History

Added first draft of DataView scriptable objects

Atlante45 committed 12 years ago

Commit 2e480761 parent 13fe8b54 files · +394 −0Browse files

Showing the changes to libraries/script-engine/src/DataViewPrototype.cpp (1 of 4 files). Show all

Unified · Split

libraries/script-engine/src/DataViewPrototype.cpp+209−0
@@ -0,0 +1,209 @@
1+//
2+// DataViewPrototype.cpp
3+//
4+//
5+// Created by Clement on 7/8/14.
6+// Copyright 2014 High Fidelity, Inc.
7+//
8+// Distributed under the Apache License, Version 2.0.
9+// See the accompanying file LICENSE or http://www.apache.org/licenses/LICENSE-2.0.html
10+//
11+#include <QDebug>
12+
13+#include <glm/glm.hpp>
14+
15+#include "DataViewClass.h"
16+
17+#include "DataViewPrototype.h"
18+
19+Q_DECLARE_METATYPE(QByteArray*)
20+
21+DataViewPrototype::DataViewPrototype(QObject* parent) : QObject(parent) {
22+}
23+
24+QByteArray* DataViewPrototype::thisArrayBuffer() const {
25+ QScriptValue bufferObject = thisObject().data().property(BUFFER_PROPERTY_NAME);
26+ return qscriptvalue_cast<QByteArray*>(bufferObject.data());
27+}
28+
29+bool DataViewPrototype::realOffset(quint32& offset, size_t size) const {
30+ quint32 viewOffset = thisObject().data().property(BYTE_OFFSET_PROPERTY_NAME).toInt32();
31+ quint32 viewLength = thisObject().data().property(BYTE_LENGTH_PROPERTY_NAME).toInt32();
32+ qDebug() << "View Offset: " << viewOffset << ", View Lenght: " << viewLength;
33+ qDebug() << "Offset: " << offset << ", Size: " << size;
34+ offset += viewOffset;
35+ qDebug() << "New offset: " << offset << ", bool: " << ((offset + size) <= viewOffset + viewLength);
36+ return (offset + size) <= viewOffset + viewLength;
37+}
38+
39+///////////////// GETTERS ////////////////////////////
40+
41+qint8 DataViewPrototype::getInt8(quint32 byteOffset) {
42+ if (realOffset(byteOffset, sizeof(qint8))) {
43+ qDebug() << "Value: " << (qint8)thisArrayBuffer()->at(byteOffset);
44+
45+ return (qint8)thisArrayBuffer()->at(byteOffset);
46+ }
47+ qDebug() << "42 powaaaa!!!";
48+ return 42;
49+}
50+
51+quint8 DataViewPrototype::getUint8(quint32 byteOffset) {
52+ if (realOffset(byteOffset, sizeof(quint8))) { return thisArrayBuffer()->at(byteOffset);
53+ }
54+ return 42;
55+}
56+
57+qint16 DataViewPrototype::getInt16(quint32 byteOffset, bool littleEndian) {
58+ if (realOffset(byteOffset, sizeof(qint16))) {
59+ QDataStream stream(*thisArrayBuffer());
60+ stream.setByteOrder((littleEndian) ? QDataStream::LittleEndian : QDataStream::BigEndian);
61+ stream.skipRawData(byteOffset);
62+
63+ qint16 result;
64+ stream >> result;
65+ return result;
66+ }
67+ return 42;
68+}
69+
70+quint16 DataViewPrototype::getUint16(quint32 byteOffset, bool littleEndian) {
71+ if (realOffset(byteOffset, sizeof(quint16))) {
72+ QDataStream stream(*thisArrayBuffer());
73+ stream.setByteOrder((littleEndian) ? QDataStream::LittleEndian : QDataStream::BigEndian);
74+ stream.skipRawData(byteOffset);
75+
76+ qint16 result;
77+ stream >> result;
78+ return result;
79+ }
80+ return 42;
81+}
82+
83+qint32 DataViewPrototype::getInt32(quint32 byteOffset, bool littleEndian) {
84+ if (realOffset(byteOffset, sizeof(qint32))) {
85+ QDataStream stream(*thisArrayBuffer());
86+ stream.setByteOrder((littleEndian) ? QDataStream::LittleEndian : QDataStream::BigEndian);
87+ stream.skipRawData(byteOffset);
88+
89+ qint16 result;
90+ stream >> result;
91+ return result;
92+ }
93+ return 42;
94+}
95+
96+quint32 DataViewPrototype::getUint32(quint32 byteOffset, bool littleEndian) {
97+ if (realOffset(byteOffset, sizeof(quint32))) {
98+ QDataStream stream(*thisArrayBuffer());
99+ stream.setByteOrder((littleEndian) ? QDataStream::LittleEndian : QDataStream::BigEndian);
100+ stream.skipRawData(byteOffset);
101+
102+ qint16 result;
103+ stream >> result;
104+ return result;
105+ }
106+ return 42;
107+}
108+
109+float DataViewPrototype::getFloat32(quint32 byteOffset, bool littleEndian) {
110+ if (realOffset(byteOffset, sizeof(float))) {
111+ QDataStream stream(*thisArrayBuffer());
112+ stream.setByteOrder((littleEndian) ? QDataStream::LittleEndian : QDataStream::BigEndian);
113+ stream.skipRawData(byteOffset);
114+
115+ qint16 result;
116+ stream >> result;
117+ return result;
118+ }
119+ return 42;
120+}
121+
122+double DataViewPrototype::getFloat64(quint32 byteOffset, bool littleEndian) {
123+ if (realOffset(byteOffset, sizeof(double))) {
124+ QDataStream stream(*thisArrayBuffer());
125+ stream.setByteOrder((littleEndian) ? QDataStream::LittleEndian : QDataStream::BigEndian);
126+ stream.skipRawData(byteOffset);
127+
128+ qint16 result;
129+ stream >> result;
130+ return result;
131+ }
132+ return 42;
133+}
134+
135+///////////////// SETTERS ////////////////////////////
136+
137+void DataViewPrototype::setInt8(quint32 byteOffset, qint8 value) {
138+ if (realOffset(byteOffset, sizeof(qint8))) {
139+ QDataStream stream(thisArrayBuffer(), QIODevice::ReadWrite);
140+ stream.skipRawData(byteOffset);
141+
142+ stream << value;
143+ }
144+}
145+
146+void DataViewPrototype::setUint8(quint32 byteOffset, quint8 value) {
147+ if (realOffset(byteOffset, sizeof(quint8))) {
148+ QDataStream stream(thisArrayBuffer(), QIODevice::ReadWrite);
149+ stream.skipRawData(byteOffset);
150+
151+ stream << value;
152+ }
153+}
154+
155+void DataViewPrototype::setInt16(quint32 byteOffset, qint16 value, bool littleEndian) {
156+ if (realOffset(byteOffset, sizeof(qint16))) {
157+ QDataStream stream(thisArrayBuffer(), QIODevice::ReadWrite);
158+ stream.skipRawData(byteOffset);
159+
160+ stream << value;
161+ }
162+}
163+
164+void DataViewPrototype::setUint16(quint32 byteOffset, quint16 value, bool littleEndian) {
165+ if (realOffset(byteOffset, sizeof(quint16))) {
166+ QDataStream stream(thisArrayBuffer(), QIODevice::ReadWrite);
167+ stream.skipRawData(byteOffset);
168+
169+ stream << value;
170+ }
171+}
172+
173+void DataViewPrototype::setInt32(quint32 byteOffset, quint32 value, bool littleEndian) {
174+ if (realOffset(byteOffset, sizeof(qint32))) {
175+ QDataStream stream(thisArrayBuffer(), QIODevice::ReadWrite);
176+ stream.skipRawData(byteOffset);
177+
178+ stream << value;
179+ }
180+}
181+
182+void DataViewPrototype::setUint32(quint32 byteOffset, quint32 value, bool littleEndian) {
183+ if (realOffset(byteOffset, sizeof(quint32))) {
184+ QDataStream stream(thisArrayBuffer(), QIODevice::ReadWrite);
185+ stream.skipRawData(byteOffset);
186+
187+ stream << value;
188+ }
189+}
190+
191+void DataViewPrototype::setFloat32(quint32 byteOffset, float value, bool littleEndian) {
192+ if (realOffset(byteOffset, sizeof(float))) {
193+ QDataStream stream(thisArrayBuffer(), QIODevice::ReadWrite);
194+ stream.skipRawData(byteOffset);
195+
196+ stream << value;
197+ }
198+}
199+
200+void DataViewPrototype::setFloat64(quint32 byteOffset, double value, bool littleEndian) {
201+ if (realOffset(byteOffset, sizeof(double))) {
202+ QDataStream stream(thisArrayBuffer(), QIODevice::ReadWrite);
203+ stream.skipRawData(byteOffset);
204+
205+ stream << value;
206+ }
207+}
208+
209+