desc_0a::desc_0a(Decoder *parent, dvbpsi_descriptor_t *p_descriptor)
: Descriptor(parent, DESC_NAME, p_descriptor)
{
if (!desc_check_tag(getTag(), DESC_TAG)) return;
dvbpsi_iso639_dr_t* dr = dvbpsi_DecodeISO639Dr(p_descriptor);
if (desc_dr_failed(dr)) return;
Array languages;
for (int i = 0; i < dr->i_code_count; ++i) {
Object entry;
char lang[4] = { 0 };
for (unsigned int j = 0; j < 3; j++) lang[j] = dr->code[i].iso_639_code[j];
entry.set("language", std::string(lang));
entry.set("audioType", dr->code[i].i_audio_type);
languages.push(entry);
}
set("ISO639Lang", languages);
dPrintf("%s", toJson().c_str());
setValid(true);
}
void testIndexedAccess() {
Object object;
Vector3d vector(1, 2, 3);
double value = 4.5;
object.set(1, vector);
object.set("2", value);
TS_ASSERT_EQUALS(object.get<Vector3d>("1"), vector);
TS_ASSERT_EQUALS(object.get<double>(2), value);
}
inline AtomType operator()( PairType const & arg ) const
{
static const StringType str1("k");
static const StringType str2("v");
Object obj;
obj.set(str1, nativeToAtom(arg.first) );
obj.set(str2, nativeToAtom(arg.second) );
return obj;
}
void testProperty() {
Object object;
object.set("a", 1.0);
object.set("b", Interval(2, 5));
TS_ASSERT(object.has("a"));
TS_ASSERT(object.has("b"));
TS_ASSERT(!object.has("c"));
TS_ASSERT_EQUALS(object.get<double>("a"), 1.0);
TS_ASSERT_EQUALS(object.get<Interval>("b").upperBound(), 5.0);
TS_ASSERT_THROWS(object.get<int>("c"), ObjectGetValueError);
}
void testTransformation() {
Object object;
object.set("vector", Vector3d(1, 2, 3));
Object translated = object.translated(Vector3d::Ones());
TS_ASSERT(translated.has("vector"));
TS_ASSERT((Vector3d(2, 3, 4) - translated.get<Vector3d>("vector")).isZero());
}
void MultiSwitch::notParsed(Object& out) const {
if (hasDefault_) {
out.set(default_);
} else {
Argument::notParsed(out);
}
}
void UndoRedo::_process_operation_list(List<Operation>::Element *E) {
for (;E;E=E->next()) {
Operation &op=E->get();
Object *obj = ObjectDB::get_instance(op.object);
if (!obj) {
//corruption
clear_history();
ERR_FAIL_COND(!obj);
}
switch(op.type) {
case Operation::TYPE_METHOD: {
obj->call(op.name,VARIANT_ARGS_FROM_ARRAY(op.args));
} break;
case Operation::TYPE_PROPERTY: {
obj->set(op.name,op.args[0]);
} break;
case Operation::TYPE_REFERENCE: {
//do nothing
} break;
}
}
}
void Window::load() {
// Generate light source:
Matrix4 temp;
temp.identity();
setMatrix(temp);
glEnable(GL_LIGHTING);
camera.set(e, d, up);
object.move(0, 1, 0);
cameraObject.set(initial.get(0),initial.get(1),initial.get(2));
bCurve.setPoints(initial, Vector4(-2, 8, -4, 0), Vector4(2, 8, 4, 0), endV);
for (int i = 0; i < 100; i++) {
points[i] = bCurve.evalBCurve((double)i / 100);
}
belzCamera.set(points[0], belzD, belzUp);
loadTextures();
loadCharacter();
Vector4 points[49];
for (int i = 0; i < 7; i++) {
for (int j = 0; j < 7; j++) {
int k = i * 7 + j;
points[k] = Vector4((double)i*2 - 6, (double)10, (double)j*2 - 6, 0);
}
}
plane.definePoints(points);
}
void MultiSwitch::parse(Object& out,
std::vector<std::list<std::string>>& output,
std::vector<std::list<std::string>>& input) const {
out.set(default_ + input.size());
output = input;
input.clear();
}
void ScriptDebuggerRemote::_set_object_property(ObjectID p_id, const String &p_property, const Variant &p_value) {
Object *obj = ObjectDB::get_instance(p_id);
if (!obj)
return;
obj->set(p_property, p_value);
}
void runtest() {
int err = 0;
string test_case = "(Test reset types char - uchar)";
print(test_case + "\n");
Object o;
unsigned char uch = 'd';
o.set("v1", 'a');
o.set("v2", 'b');
o.set("v2", 'c');
o.set("v2", uch);
if (o.get("v2", uch) != (unsigned char)'d') {
err++;
cout << "error get v2 expect 'd', got '" << o.get("v2", uch) << "\n";
}
o.set("v2", 'n');
if (o.get("v1") != (char)'a') {
err++;
cout << "error get v1 expect 'a', got '" << o.get("v1") << "\n";
}
if (o.get("v2") != (char)'n') {
err++;
cout << "error get v2 expect 'n', got '" << o.get("v1") << "\n";
}
print_status(err);
//=================
err = 0;
test_case = "(Test reset types char - short)";
print(test_case + "\n");
short n = 1001;
o.set("v1", n);
if (o.get("v1", n) != (short)1001) {
err++;
cout << "error get v1 expect 1001, got " << o.get("v1", n) << "\n";
}
o.set("v1", 'N');
if (o.get("v1") != 'N') {
err++;
cout << "error get v1 expect N, got " << o.get("v1") << "\n";
}
print_status(err);
}
inline AtomType operator()( MapType const & arg ) const
{
Object obj;
typedef typename MapType::const_iterator IT;
IT it = arg.begin();
for( ; arg.end() != it; ++it ) {
obj.set( nativeToAtom((*it).first),
nativeToAtom((*it).second) );
}
return obj;
}
void testSerialization() {
Object object;
object.set("value", 1.0);
object.set("vector", Vector3d(1, 2, 3));
Object component;
component.set("axis", Axis3d(Vector3d::Zero(), Vector3d(4, 5, 6)));
component.set("facet", Triangle3d(Matrix3d::Ones()));
object.set("component", component);
Serialization<Object> serialization;
std::string serialized = serialization(object);
Deserialization<Object> deserialization;
Object deserialized = deserialization(serialized);
TS_ASSERT_EQUALS(deserialized.get<double>("value"), 1.0);
TS_ASSERT_EQUALS(deserialized.get<Vector3d>("vector"), Vector3d(1, 2, 3));
Axis3d axis = deserialized.get<Object>("component").get<Axis3d>("axis");
TS_ASSERT_EQUALS(axis.origin(), Vector3d::Zero());
TS_ASSERT((axis.direction() - Vector3d(4, 5, 6).normalized()).isZero());
Triangle3d facet = deserialized.get<Object>("component").get<Triangle3d>("facet");
TS_ASSERT_EQUALS(facet.vertices(), Matrix3d::Ones());
}
void ScriptDebuggerRemote::_set_object_property(ObjectID p_id, const String &p_property, const Variant &p_value) {
Object *obj = ObjectDB::get_instance(p_id);
if (!obj)
return;
String prop_name = p_property;
if (p_property.begins_with("Members/"))
prop_name = p_property.substr(8, p_property.length());
obj->set(prop_name, p_value);
}
void testAutomaticConversion() {
CustomType original;
original.value = M_PI;
original.vector = Vector3d::Random();
Object object;
object.set("custom", original);
TS_ASSERT_EQUALS(object.get<Object>("custom").get<double>("value"), original.value);
TS_ASSERT_EQUALS(object.get<Object>("custom").get<Vector3d>("vector"), original.vector);
CustomType reconstructed = object.get<CustomType>("custom");
TS_ASSERT_EQUALS(reconstructed.value, original.value);
TS_ASSERT_EQUALS(reconstructed.vector, original.vector);
}
void ScriptDebuggerRemote::_set_object_property(ObjectID p_id, const String &p_property, const Variant &p_value) {
Object *obj = ObjectDB::get_instance(p_id);
if (!obj)
return;
String prop_name = p_property;
if (p_property.begins_with("Members/")) {
Vector<String> ss = p_property.split("/");
prop_name = ss[ss.size() - 1];
}
obj->set(prop_name, p_value);
}
void UndoRedo::_process_operation_list(List<Operation>::Element *E) {
for (;E;E=E->next()) {
Operation &op=E->get();
Object *obj = ObjectDB::get_instance(op.object);
if (!obj) {
//corruption
clear_history();
ERR_FAIL_COND(!obj);
}
switch(op.type) {
case Operation::TYPE_METHOD: {
obj->call(op.name,VARIANT_ARGS_FROM_ARRAY(op.args));
#ifdef TOOLS_ENABLED
Resource* res = obj->cast_to<Resource>();
if (res)
res->set_edited(true);
#endif
if (method_callback) {
method_callback(method_callbck_ud,obj,op.name,VARIANT_ARGS_FROM_ARRAY(op.args));
}
} break;
case Operation::TYPE_PROPERTY: {
obj->set(op.name,op.args[0]);
#ifdef TOOLS_ENABLED
Resource* res = obj->cast_to<Resource>();
if (res)
res->set_edited(true);
#endif
if (property_callback) {
property_callback(prop_callback_ud,obj,op.name,op.args[0]);
}
} break;
case Operation::TYPE_REFERENCE: {
//do nothing
} break;
}
}
}
bool Tween::_apply_tween_value(InterpolateData& p_data, Variant& value) {
Object *object = ObjectDB::get_instance(p_data.id);
ERR_FAIL_COND_V(object == NULL, false);
switch(p_data.type) {
case INTER_PROPERTY:
case FOLLOW_PROPERTY:
case TARGETING_PROPERTY:
{
bool valid = false;
object->set(p_data.key,value, &valid);
return valid;
}
case INTER_METHOD:
case FOLLOW_METHOD:
case TARGETING_METHOD:
{
Variant::CallError error;
if (value.get_type() != Variant::NIL) {
Variant *arg[1] = { &value };
object->call(p_data.key, (const Variant **) arg, 1, error);
} else {
object->call(p_data.key, NULL, 0, error);
}
if(error.error == Variant::CallError::CALL_OK)
return true;
return false;
}
case INTER_CALLBACK:
break;
};
return true;
}
//----------------------------------------------------------------------------
// Callback method called by GLUT when users press specific keys on the keyboard
void Window::keyboardCallback(unsigned char key, int xn, int yn) {
glMatrixMode(GL_PROJECTION);
Matrix4 temp;
switch (key) {
case'q':
person.rotateY(5);
temp.makeRotateY(5);
ahead = temp * ahead;
side = temp * side;
camera.rotateDirectionY(5);
break;
case'Q':
person.rotateY(5);
break;
case'e':
person.rotateY(-5);
temp.makeRotateY(-5);
ahead = temp * ahead;
side = temp * side;
camera.rotateDirectionY(-5);
break;
case'E':
person.rotateY(-5);
break;
case 'z':
camera.moveUp(1);
break;
case 'Z':
camera.moveDown(1);
break;
case 'w':
walk = true;
person.move(ahead.get(0), ahead.get(1), ahead.get(2));
camera.move(Vector3(ahead.get(0),ahead.get(1),ahead.get(2)),1);
break;
case's':
walk = true;
person.move(-ahead.get(0), -ahead.get(1), -ahead.get(2));
camera.move(Vector3(-ahead.get(0), -ahead.get(1), -ahead.get(2)), 1);
break;
case 'a':
person.move(side.get(0), side.get(1), side.get(2));
camera.move(Vector3(side.get(0), side.get(1), side.get(2)), 1);
break;
case 'd':
person.move(-side.get(0), -side.get(1), -side.get(2));
camera.move(Vector3(-side.get(0), -side.get(1), -side.get(2)), 1);
break;
case 'i':
camera.moveForward(1);
break;
case'k':
camera.moveBackward(1);
break;
case 'j':
camera.moveLeft(1);
break;
case 'l':
camera.moveRight(1);
break;
case 'r':
t = 0;
cameraObject.set(initial.get(0), initial.get(1), initial.get(2));
object.reset();
object.move(0, 1, 0);
belzCamera.set(points[0], belzD, belzUp);
person.reset();
camera.set(e, d, up);
ahead = Vector4(0, 0, -1, 0);
side = Vector4(-1, 0, 0, 0);
break;
case 'p':
cam = !cam;
break;
case'o':
altCam = !altCam;
break;
case'+':
t++;
if (t == 100)
t = 99;
break;
case'-':
t--;
if (t == 0)
t = 1;
break;
case'.':
automatic = !automatic;
break;
case'/':
light = !light;
break;
}
glMatrixMode(GL_MODELVIEW);
}
//----------------------------------------------------------------------------
// Callback method called by GLUT when window readraw is necessary or when glutPostRedisplay() was called.
void Window::displayCallback()
{
glEnable(GL_LIGHT0);
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // clear color and depth buffers
glColor3f(0, 0, 1);
//Setting moving camera
Matrix4 glmatrix;
if (cam) {
if (t == 99) {
back = true;
}
if (t == 0)
back = false;
Vector3 upd = belzCamera.upd;
belzCamera.set(points[t], Vector3(0,0,0), upd);
std::cout << t << std::endl;
}
if (altCam) {
glmatrix = belzCamera.getInverse();
}
else {
glmatrix = camera.getInverse();
}
//Drawing Light Source
Matrix4 temp;
temp.makeTranslate(position[0], position[1], position[2]);
setMatrix(glmatrix, temp);
glColor3f(1, 1, 0);
glutSolidSphere(.5, 100, 100);
setMatrix(glmatrix);
glLightfv(GL_LIGHT0, GL_POSITION, position);
//glLightfv(GL_LIGHT0, GL_AMBIENT, ambient);
/*
//Seting main objects
glColor3d(1, 0, 0);
setMatrix(glmatrix, object.getMatrix());
glutSolidCube(2);
temp.makeTranslate(3, 1.5, 0);
setMatrix(glmatrix, temp);
glColor3d(1, 0, 1);
glutSolidCube(3);
temp.makeTranslate(0, 1.5, 3);
setMatrix(glmatrix, temp);
glColor3d(0, 1, 1);
glutSolidCube(3);
temp.makeTranslate(0, 1.5, -3);
setMatrix(glmatrix, temp);
glColor3d(1, 1, 0);
glutSolidCube(3);
temp.makeTranslate(-3, 1.5, 0);
setMatrix(glmatrix, temp);
glColor3d(1, 1, 1);
glutSolidCube(3);
//Setting Floor
setMatrix(glmatrix);
glBegin(GL_QUADS);
glNormal3d(0, 1, 0);
glColor3d(0.5, 0.6, 0.7);
glVertex3d(-10, 0, -10);
glVertex3d(-10, 0, 10);
glVertex3d(10, 0, 10);
glVertex3d(10, 0, -10);
glEnd();*/
setMatrix(glmatrix);
if (light) {
Globals::shader->bind();
}
else
Globals::shader->unbind();
glutSolidTeapot(5);
plane.animate();
plane.draw();
Globals::shader->unbind();
//Drawing Bezier Curve
glBegin(GL_LINE_STRIP);
for (int i = 0; i < 99; i++) {
Vector3 current = points[i];
Vector3 next = points[i + 1];
glLineWidth(2.5);
glColor3f(1.0, 1.0, 0.0);
glVertex3d(current.getX(), current.getY(), current.getZ());
glVertex3d(next.getX(), next.getY(), next.getZ());
}
glEnd();
//Drawing Head
glActiveTexture(GL_TEXTURE0);
temp = glmatrix;
control.set(person.getMatrix());
character.draw(temp, light);
//Drawing Camera
setMatrix(glmatrix, cameraObject.getMatrix());
glColor3f(0, 1, 1);
glutSolidSphere(.5,100,100);
if (cam) {
Vector3 current;
current = points[t];
cameraObject.set(current.getX(), current.getY(), current.getZ());
if (automatic) {
if (!back) {
t++;
}
else {
t--;
}
}
}
glFlush();
glutSwapBuffers();
}
void DiskInfoRequestHandler::handleRequest(HTTPServerRequest& request,
HTTPServerResponse& response) {
Application& app = Application::instance();
app.logger().information("Start processing request from: "+request.clientAddress().toString());
Timestamp start;
SharedPtr<HDDExplorer> explorer = hddExplorerCache.get(0);
if(explorer.isNull()){
explorer = new HDDExplorer;
hddExplorerCache.add(0, explorer);
}
Object responseObject;
if((*explorer).isSuccessfullyDiscovered() && (*explorer).getAvailableHDDs().size()>0){
responseObject.set("found", true);
vector<string> hdds = (*explorer).getAvailableHDDs();
Array disks;
for(vector<string>::iterator iter = hdds.begin(); iter!=hdds.end(); iter++){
string hddPath = *iter;
SharedPtr<DiskInfo> info = smartInfoCache.get(hddPath);
if(info.isNull()){
info = new DiskInfo(hddPath);
smartInfoCache.add(hddPath, info);
}
Object jsonObject = (*info).toJSONObject();
disks.add(jsonObject);
}
responseObject.set("disks", disks);
} else {
responseObject.set("found", false);
}
response.setContentType("application/javascript; charset=utf-8");
HTMLForm form(request);
string callbackFunc = "callback";
if(form.has("callback") && !form.get("callback").empty()){
callbackFunc = form.get("callback");
}
std::stringstream ostr;
ostr<<callbackFunc<<"("; //send callback for JSONP
responseObject.stringify(ostr);
ostr<<")";
string serialized = ostr.str();
response.sendBuffer(serialized.c_str(), serialized.size());//connection keep-alive. We need to
//know content-length
Timestamp end;
string secs = NumberFormatter::format((end-start)/1000)+" msecs";
app.logger().information("Request from: "+request.clientAddress().toString()+
" succesfully processed in "+secs);
}
Error decode_variant(Variant &r_variant, const uint8_t *p_buffer, int p_len, int *r_len, bool p_allow_objects) {
const uint8_t *buf = p_buffer;
int len = p_len;
if (len < 4) {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
}
uint32_t type = decode_uint32(buf);
ERR_FAIL_COND_V((type & ENCODE_MASK) >= Variant::VARIANT_MAX, ERR_INVALID_DATA);
buf += 4;
len -= 4;
if (r_len)
*r_len = 4;
switch (type & ENCODE_MASK) {
case Variant::NIL: {
r_variant = Variant();
} break;
case Variant::BOOL: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
bool val = decode_uint32(buf);
r_variant = val;
if (r_len)
(*r_len) += 4;
} break;
case Variant::INT: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
if (type & ENCODE_FLAG_64) {
int64_t val = decode_uint64(buf);
r_variant = val;
if (r_len)
(*r_len) += 8;
} else {
int32_t val = decode_uint32(buf);
r_variant = val;
if (r_len)
(*r_len) += 4;
}
} break;
case Variant::REAL: {
ERR_FAIL_COND_V(len < (int)4, ERR_INVALID_DATA);
if (type & ENCODE_FLAG_64) {
double val = decode_double(buf);
r_variant = val;
if (r_len)
(*r_len) += 8;
} else {
float val = decode_float(buf);
r_variant = val;
if (r_len)
(*r_len) += 4;
}
} break;
case Variant::STRING: {
String str;
Error err = _decode_string(buf, len, r_len, str);
if (err)
return err;
r_variant = str;
} break;
// math types
case Variant::VECTOR2: {
ERR_FAIL_COND_V(len < (int)4 * 2, ERR_INVALID_DATA);
Vector2 val;
val.x = decode_float(&buf[0]);
val.y = decode_float(&buf[4]);
r_variant = val;
if (r_len)
(*r_len) += 4 * 2;
} break; // 5
case Variant::RECT2: {
ERR_FAIL_COND_V(len < (int)4 * 4, ERR_INVALID_DATA);
Rect2 val;
val.position.x = decode_float(&buf[0]);
val.position.y = decode_float(&buf[4]);
val.size.x = decode_float(&buf[8]);
val.size.y = decode_float(&buf[12]);
r_variant = val;
if (r_len)
(*r_len) += 4 * 4;
} break;
case Variant::VECTOR3: {
ERR_FAIL_COND_V(len < (int)4 * 3, ERR_INVALID_DATA);
Vector3 val;
val.x = decode_float(&buf[0]);
val.y = decode_float(&buf[4]);
val.z = decode_float(&buf[8]);
r_variant = val;
if (r_len)
(*r_len) += 4 * 3;
} break;
case Variant::TRANSFORM2D: {
ERR_FAIL_COND_V(len < (int)4 * 6, ERR_INVALID_DATA);
Transform2D val;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 2; j++) {
val.elements[i][j] = decode_float(&buf[(i * 2 + j) * 4]);
}
}
r_variant = val;
if (r_len)
(*r_len) += 4 * 6;
} break;
case Variant::PLANE: {
ERR_FAIL_COND_V(len < (int)4 * 4, ERR_INVALID_DATA);
Plane val;
val.normal.x = decode_float(&buf[0]);
val.normal.y = decode_float(&buf[4]);
val.normal.z = decode_float(&buf[8]);
val.d = decode_float(&buf[12]);
r_variant = val;
if (r_len)
(*r_len) += 4 * 4;
} break;
case Variant::QUAT: {
ERR_FAIL_COND_V(len < (int)4 * 4, ERR_INVALID_DATA);
Quat val;
val.x = decode_float(&buf[0]);
val.y = decode_float(&buf[4]);
val.z = decode_float(&buf[8]);
val.w = decode_float(&buf[12]);
r_variant = val;
if (r_len)
(*r_len) += 4 * 4;
} break;
case Variant::RECT3: {
ERR_FAIL_COND_V(len < (int)4 * 6, ERR_INVALID_DATA);
Rect3 val;
val.position.x = decode_float(&buf[0]);
val.position.y = decode_float(&buf[4]);
val.position.z = decode_float(&buf[8]);
val.size.x = decode_float(&buf[12]);
val.size.y = decode_float(&buf[16]);
val.size.z = decode_float(&buf[20]);
r_variant = val;
if (r_len)
(*r_len) += 4 * 6;
} break;
case Variant::BASIS: {
ERR_FAIL_COND_V(len < (int)4 * 9, ERR_INVALID_DATA);
Basis val;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
val.elements[i][j] = decode_float(&buf[(i * 3 + j) * 4]);
}
}
r_variant = val;
if (r_len)
(*r_len) += 4 * 9;
} break;
case Variant::TRANSFORM: {
ERR_FAIL_COND_V(len < (int)4 * 12, ERR_INVALID_DATA);
Transform val;
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
val.basis.elements[i][j] = decode_float(&buf[(i * 3 + j) * 4]);
}
}
val.origin[0] = decode_float(&buf[36]);
val.origin[1] = decode_float(&buf[40]);
val.origin[2] = decode_float(&buf[44]);
r_variant = val;
if (r_len)
(*r_len) += 4 * 12;
} break;
// misc types
case Variant::COLOR: {
ERR_FAIL_COND_V(len < (int)4 * 4, ERR_INVALID_DATA);
Color val;
val.r = decode_float(&buf[0]);
val.g = decode_float(&buf[4]);
val.b = decode_float(&buf[8]);
val.a = decode_float(&buf[12]);
r_variant = val;
if (r_len)
(*r_len) += 4 * 4;
} break;
case Variant::NODE_PATH: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
uint32_t strlen = decode_uint32(buf);
if (strlen & 0x80000000) {
//new format
ERR_FAIL_COND_V(len < 12, ERR_INVALID_DATA);
Vector<StringName> names;
Vector<StringName> subnames;
StringName prop;
uint32_t namecount = strlen &= 0x7FFFFFFF;
uint32_t subnamecount = decode_uint32(buf + 4);
uint32_t flags = decode_uint32(buf + 8);
len -= 12;
buf += 12;
uint32_t total = namecount + subnamecount;
if (flags & 2)
total++;
if (r_len)
(*r_len) += 12;
for (uint32_t i = 0; i < total; i++) {
ERR_FAIL_COND_V((int)len < 4, ERR_INVALID_DATA);
strlen = decode_uint32(buf);
int pad = 0;
if (strlen % 4)
pad += 4 - strlen % 4;
buf += 4;
len -= 4;
ERR_FAIL_COND_V((int)strlen + pad > len, ERR_INVALID_DATA);
String str;
str.parse_utf8((const char *)buf, strlen);
if (i < namecount)
names.push_back(str);
else if (i < namecount + subnamecount)
subnames.push_back(str);
else
prop = str;
buf += strlen + pad;
len -= strlen + pad;
if (r_len)
(*r_len) += 4 + strlen + pad;
}
r_variant = NodePath(names, subnames, flags & 1, prop);
} else {
//old format, just a string
buf += 4;
len -= 4;
ERR_FAIL_COND_V((int)strlen > len, ERR_INVALID_DATA);
String str;
str.parse_utf8((const char *)buf, strlen);
r_variant = NodePath(str);
if (r_len)
(*r_len) += 4 + strlen;
}
} break;
/*case Variant::RESOURCE: {
ERR_EXPLAIN("Can't marshallize resources");
ERR_FAIL_V(ERR_INVALID_DATA); //no, i'm sorry, no go
} break;*/
case Variant::_RID: {
r_variant = RID();
} break;
case Variant::OBJECT: {
if (type & ENCODE_FLAG_OBJECT_AS_ID) {
//this _is_ allowed
ObjectID val = decode_uint64(buf);
if (r_len)
(*r_len) += 8;
if (val == 0) {
r_variant = (Object *)NULL;
} else {
Ref<EncodedObjectAsID> obj_as_id;
obj_as_id.instance();
obj_as_id->set_object_id(val);
r_variant = obj_as_id;
}
} else {
ERR_FAIL_COND_V(!p_allow_objects, ERR_UNAUTHORIZED);
String str;
Error err = _decode_string(buf, len, r_len, str);
if (err)
return err;
if (str == String()) {
r_variant = (Object *)NULL;
} else {
Object *obj = ClassDB::instance(str);
ERR_FAIL_COND_V(!obj, ERR_UNAVAILABLE);
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
int32_t count = decode_uint32(buf);
buf += 4;
len -= 4;
if (r_len) {
(*r_len) += 4;
}
for (int i = 0; i < count; i++) {
str = String();
err = _decode_string(buf, len, r_len, str);
if (err)
return err;
Variant value;
int used;
err = decode_variant(value, buf, len, &used, p_allow_objects);
if (err)
return err;
buf += used;
len -= used;
if (r_len) {
(*r_len) += used;
}
obj->set(str, value);
}
if (Object::cast_to<Reference>(obj)) {
REF ref = REF(Object::cast_to<Reference>(obj));
r_variant = ref;
} else {
r_variant = obj;
}
}
}
} break;
case Variant::DICTIONARY: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
uint32_t count = decode_uint32(buf);
// bool shared = count&0x80000000;
count &= 0x7FFFFFFF;
buf += 4;
len -= 4;
if (r_len) {
(*r_len) += 4;
}
Dictionary d;
for (uint32_t i = 0; i < count; i++) {
Variant key, value;
int used;
Error err = decode_variant(key, buf, len, &used, p_allow_objects);
ERR_FAIL_COND_V(err, err);
buf += used;
len -= used;
if (r_len) {
(*r_len) += used;
}
err = decode_variant(value, buf, len, &used, p_allow_objects);
ERR_FAIL_COND_V(err, err);
buf += used;
len -= used;
if (r_len) {
(*r_len) += used;
}
d[key] = value;
}
r_variant = d;
} break;
case Variant::ARRAY: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
uint32_t count = decode_uint32(buf);
// bool shared = count&0x80000000;
count &= 0x7FFFFFFF;
buf += 4;
len -= 4;
if (r_len) {
(*r_len) += 4;
}
Array varr;
for (uint32_t i = 0; i < count; i++) {
int used = 0;
Variant v;
Error err = decode_variant(v, buf, len, &used, p_allow_objects);
ERR_FAIL_COND_V(err, err);
buf += used;
len -= used;
varr.push_back(v);
if (r_len) {
(*r_len) += used;
}
}
r_variant = varr;
} break;
// arrays
case Variant::POOL_BYTE_ARRAY: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
uint32_t count = decode_uint32(buf);
buf += 4;
len -= 4;
ERR_FAIL_COND_V((int)count > len, ERR_INVALID_DATA);
PoolVector<uint8_t> data;
if (count) {
data.resize(count);
PoolVector<uint8_t>::Write w = data.write();
for (uint32_t i = 0; i < count; i++) {
w[i] = buf[i];
}
w = PoolVector<uint8_t>::Write();
}
r_variant = data;
if (r_len) {
if (count % 4)
(*r_len) += 4 - count % 4;
(*r_len) += 4 + count;
}
} break;
case Variant::POOL_INT_ARRAY: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
uint32_t count = decode_uint32(buf);
buf += 4;
len -= 4;
ERR_FAIL_COND_V((int)count * 4 > len, ERR_INVALID_DATA);
PoolVector<int> data;
if (count) {
//const int*rbuf=(const int*)buf;
data.resize(count);
PoolVector<int>::Write w = data.write();
for (uint32_t i = 0; i < count; i++) {
w[i] = decode_uint32(&buf[i * 4]);
}
w = PoolVector<int>::Write();
}
r_variant = Variant(data);
if (r_len) {
(*r_len) += 4 + count * sizeof(int);
}
} break;
case Variant::POOL_REAL_ARRAY: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
uint32_t count = decode_uint32(buf);
buf += 4;
len -= 4;
ERR_FAIL_COND_V((int)count * 4 > len, ERR_INVALID_DATA);
PoolVector<float> data;
if (count) {
//const float*rbuf=(const float*)buf;
data.resize(count);
PoolVector<float>::Write w = data.write();
for (uint32_t i = 0; i < count; i++) {
w[i] = decode_float(&buf[i * 4]);
}
w = PoolVector<float>::Write();
}
r_variant = data;
if (r_len) {
(*r_len) += 4 + count * sizeof(float);
}
} break;
case Variant::POOL_STRING_ARRAY: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
uint32_t count = decode_uint32(buf);
PoolVector<String> strings;
buf += 4;
len -= 4;
if (r_len)
(*r_len) += 4;
//printf("string count: %i\n",count);
for (int i = 0; i < (int)count; i++) {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
uint32_t strlen = decode_uint32(buf);
buf += 4;
len -= 4;
ERR_FAIL_COND_V((int)strlen > len, ERR_INVALID_DATA);
//printf("loaded string: %s\n",(const char*)buf);
String str;
str.parse_utf8((const char *)buf, strlen);
strings.push_back(str);
buf += strlen;
len -= strlen;
if (r_len)
(*r_len) += 4 + strlen;
if (strlen % 4) {
int pad = 4 - (strlen % 4);
buf += pad;
len -= pad;
if (r_len) {
(*r_len) += pad;
}
}
}
r_variant = strings;
} break;
case Variant::POOL_VECTOR2_ARRAY: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
uint32_t count = decode_uint32(buf);
buf += 4;
len -= 4;
ERR_FAIL_COND_V((int)count * 4 * 2 > len, ERR_INVALID_DATA);
PoolVector<Vector2> varray;
if (r_len) {
(*r_len) += 4;
}
if (count) {
varray.resize(count);
PoolVector<Vector2>::Write w = varray.write();
for (int i = 0; i < (int)count; i++) {
w[i].x = decode_float(buf + i * 4 * 2 + 4 * 0);
w[i].y = decode_float(buf + i * 4 * 2 + 4 * 1);
}
int adv = 4 * 2 * count;
if (r_len)
(*r_len) += adv;
len -= adv;
buf += adv;
}
r_variant = varray;
} break;
case Variant::POOL_VECTOR3_ARRAY: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
uint32_t count = decode_uint32(buf);
buf += 4;
len -= 4;
ERR_FAIL_COND_V((int)count * 4 * 3 > len, ERR_INVALID_DATA);
PoolVector<Vector3> varray;
if (r_len) {
(*r_len) += 4;
}
if (count) {
varray.resize(count);
PoolVector<Vector3>::Write w = varray.write();
for (int i = 0; i < (int)count; i++) {
w[i].x = decode_float(buf + i * 4 * 3 + 4 * 0);
w[i].y = decode_float(buf + i * 4 * 3 + 4 * 1);
w[i].z = decode_float(buf + i * 4 * 3 + 4 * 2);
}
int adv = 4 * 3 * count;
if (r_len)
(*r_len) += adv;
len -= adv;
buf += adv;
}
r_variant = varray;
} break;
case Variant::POOL_COLOR_ARRAY: {
ERR_FAIL_COND_V(len < 4, ERR_INVALID_DATA);
uint32_t count = decode_uint32(buf);
buf += 4;
len -= 4;
ERR_FAIL_COND_V((int)count * 4 * 4 > len, ERR_INVALID_DATA);
PoolVector<Color> carray;
if (r_len) {
(*r_len) += 4;
}
if (count) {
carray.resize(count);
PoolVector<Color>::Write w = carray.write();
for (int i = 0; i < (int)count; i++) {
w[i].r = decode_float(buf + i * 4 * 4 + 4 * 0);
w[i].g = decode_float(buf + i * 4 * 4 + 4 * 1);
w[i].b = decode_float(buf + i * 4 * 4 + 4 * 2);
w[i].a = decode_float(buf + i * 4 * 4 + 4 * 3);
}
int adv = 4 * 4 * count;
if (r_len)
(*r_len) += adv;
len -= adv;
buf += adv;
}
r_variant = carray;
} break;
default: { ERR_FAIL_V(ERR_BUG); }
}
return OK;
}
void UndoRedo::_process_operation_list(List<Operation>::Element *E) {
for (; E; E = E->next()) {
Operation &op = E->get();
Object *obj = ObjectDB::get_instance(op.object);
if (!obj) {
//corruption
clear_history();
ERR_FAIL_COND(!obj);
}
switch (op.type) {
case Operation::TYPE_METHOD: {
Vector<const Variant *> argptrs;
argptrs.resize(VARIANT_ARG_MAX);
int argc = 0;
for (int i = 0; i < VARIANT_ARG_MAX; i++) {
if (op.args[i].get_type() == Variant::NIL) {
break;
}
argptrs.write[i] = &op.args[i];
argc++;
}
argptrs.resize(argc);
Variant::CallError ce;
obj->call(op.name, (const Variant **)argptrs.ptr(), argc, ce);
if (ce.error != Variant::CallError::CALL_OK) {
ERR_PRINTS("Error calling method from signal '" + String(op.name) + "': " + Variant::get_call_error_text(obj, op.name, (const Variant **)argptrs.ptr(), argc, ce));
}
#ifdef TOOLS_ENABLED
Resource *res = Object::cast_to<Resource>(obj);
if (res)
res->set_edited(true);
#endif
if (method_callback) {
method_callback(method_callbck_ud, obj, op.name, VARIANT_ARGS_FROM_ARRAY(op.args));
}
} break;
case Operation::TYPE_PROPERTY: {
obj->set(op.name, op.args[0]);
#ifdef TOOLS_ENABLED
Resource *res = Object::cast_to<Resource>(obj);
if (res)
res->set_edited(true);
#endif
if (property_callback) {
property_callback(prop_callback_ud, obj, op.name, op.args[0]);
}
} break;
case Operation::TYPE_REFERENCE: {
//do nothing
} break;
}
}
}
int main()
{
// SFML window that will host our OpenGL magic
sf::Window window(sf::VideoMode(1920, 1080), "OpenGL", sf::Style::Default, sf::ContextSettings(32));
window.setVerticalSyncEnabled(true);
window.setMouseCursorVisible(false);
sf::View view;
sf::Mouse::setPosition(sf::Vector2i(window.getSize().x / 2, window.getSize().y / 2), window);
glewInit();
Player player;
programInit(shaderMap, modelMap, textureMap, normalMap);
initPresetSystem(shaderMap, modelMap, textureMap, normalMap, presetMap);
Editor editor(modelMap, shaderMap, textureMap, normalMap, presetMap);
GLInit();
// ---------------------- MODELS -------------------------------
Model sphereModel, unitSquareModel;
generateSphere(&sphereModel, 50); sphereModel.upload();
myLoadObj("Models/unitSquare.obj", &unitSquareModel); unitSquareModel.upload();
loadNoise();
// Add terrain information to earth
cv::Mat earthBumpMap = cv::imread("Textures/earthBumpMap.jpg");
earthBumpMap.convertTo(earthBumpMap, CV_32F);
int height = earthBumpMap.rows;
int width = earthBumpMap.cols;
std::cout << "Dims: " << height << ", " << width << std::endl;
std::cout << "Dims: " << *earthBumpMap.row(height-1).col(5).ptr<float>() << std::endl;
// ---------------------- OBJECTS -------------------------------
// Initiation of all objects in the program
// ShaderParameters = (ambientCoeff, diffuseCoeff, specularCoeff, specularExponent)
cv::Vec4f standardShaderParameters(0.2f, 0.5f, 0.8f, 10);
Object squareNormalMap, squareSpecularityMap;
GLuint earthNormalMap, earthSpecularityMap, earthTextureDay, earthTextureNight;
GLuint normalMapShader, specularityMapShader;
shaderInit(&phongNoTex, "Shaders/phongNoTex.vert", "Shaders/phongNoTex.frag");
shaderInit(&normalMapShader, "Shaders/normalMap.vert", "Shaders/normalMap.frag");
shaderInit(&specularityMapShader, "Shaders/specularityMap.vert", "Shaders/specularityMap.frag");
LoadTGATextureSimple("Textures/earthTextureDay.tga", &earthTextureDay);
LoadTGATextureSimple("Textures/earthTextureNight.tga", &earthTextureNight);
LoadTGATextureSimple("Textures/earthNormalMap.tga", &earthNormalMap);
LoadTGATextureSimple("Textures/earthSpecularityMap.tga", &earthSpecularityMap);
//squareNormalMap.init(&unitSquareModel, phongNoTex, standardShaderParameters, 0, 0, 0, earthNormalMap);
squareNormalMap.init(&unitSquareModel, normalMapShader, standardShaderParameters, 0, 0, 0, earthNormalMap);
squareSpecularityMap.init(&unitSquareModel, specularityMapShader, standardShaderParameters, earthTextureDay, earthTextureNight, earthSpecularityMap, earthNormalMap);
squareNormalMap.set(cv::Vec3f(100,0,0), cv::Vec3f(50,50,100), cv::Vec3f(0, pi/2, -pi/2), cv::Vec3f(0,0,0), 1);
squareSpecularityMap.set(cv::Vec3f(100,0,0), cv::Vec3f(50,50,100), cv::Vec3f(0, pi/2, -pi/2), cv::Vec3f(0,0,0), 1);
// ---------------------- SKYSPHERE -------------------------------
Object skysphere;
GLuint skysphereTexture, skyboxShader;
LoadTGATextureSimple("Textures/spaceBox6.tga", &skysphereTexture);
shaderInit(&skyboxShader, "Shaders/skybox.vert", "Shaders/skybox.frag");
skysphere.init(&sphereModel, skyboxShader, standardShaderParameters, skysphereTexture);
skysphere.set(player.position, cv::Vec3f(1,1,1), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1);
int item;
// SFML built-in clock
sf::Clock clock;
states[RUNNING] = true;
states[EDITOR] = true;
states[STARTUP] = true;
/*
bool running = true;
bool runningEditor = true;
bool startup = true;
bool selectObject = false;
bool cooldown = false;
*/
Object* currentObject = NULL;
Object* playerObject = NULL;
while (states[RUNNING])
{
dt = clock.getElapsedTime().asSeconds();
if(states[EDITOR])
{
window.setVisible(false);
if(states[SELECTOBJECT])
{
solsystem.getObjects(&allObjects);
currentObject = getSelectedObject(&allObjects, &player);
allObjects.clear();
}
editor.edit(solsystem, states, currentObject);
states[STARTUP] = false;
sf::Mouse::setPosition(sf::Vector2i(window.getSize().x / 2, window.getSize().y / 2), window);
clock.restart();
window.setActive();
states[SELECTOBJECT] = false;
currentObject = NULL;
states[EDITOR] = false;
window.setVisible(true);
}
else
{
clock.restart();
if (playerObject != NULL)
{
std::cout << player.position << std::endl;
player.move(playerObject->position);
//player.position = playerObject->position;
std::cout << playerObject->position << std::endl;
}
handleEvents(&window, states, &item, playerObject, &player, dt);
player.lookAtUpdate(dt);
// Plocka ut all planeters positioner
std::list<Object*> allObjects;
solsystem.getObjects(&allObjects);
std::vector<cv::Vec3f> positionVector;
std::vector<cv::Vec3f> radiusVector;
std::list<Object*>::iterator i = allObjects.begin();
for (i++ ; i != allObjects.end(); ++i)
{
positionVector.push_back((*i)->position);
radiusVector.push_back((*i)->scale);
//std::cout << "Scale: " << (*i)->scale << std::endl;
}
int numberOfPlanets = positionVector.size();
GLfloat* positions = makeArray(positionVector);
GLfloat* radius = makeArray(radiusVector);
///////////////////////////////// SKYBOX /////////////////////////////////////////
window.setActive();
//drawSkybox(&player, &skyboxModel, skyboxShader, skyboxTexture);
glDisable(GL_DEPTH_TEST);
//skybox.set(player.position, cv::Vec3f(5,5,5), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1);
//skybox.draw(&player);
skysphere.set(player.position, cv::Vec3f(5,5,5), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1);
skysphere.draw(&player, 0, dt);
glEnable(GL_DEPTH_TEST);
///////////////////////////////// ALX /////////////////////////////////////////
if (states[NORMALMAP])
{
squareNormalMap.draw(&player, dt, numberOfPlanets, positions, radius);
}
if (states[SPECULARITYMAP])
{
squareSpecularityMap.draw(&player, dt, numberOfPlanets, positions, radius);
}
///////////////////////////////// ALX /////////////////////////////////////////
if(!states[COOLDOWN] && item == 1)
{
Object* newItem = presetMap["Earth"]->clone();
newItem->set(player.position, cv::Vec3f(0.25,0.25,0.25), cv::Vec3f(0,0,0), 10*player.getLookAtDirection(), 1);
solsystem.addItem(newItem);
std::cout << 10*normalize(player.position - player.lookAtVector) << std::endl;
states[COOLDOWN] = true;
}
item = 0;
if(states[ENABLEGRAVITY] && playerObject == NULL)
{
playerObject = presetMap["Earth"]->clone();
playerObject->set(player.position, cv::Vec3f(1.25,1.25,1.25), cv::Vec3f(0,0,0), cv::Vec3f(0,0,0), 1);
solsystem.addPlayerItem(playerObject);
states[ENABLEGRAVITY] = false;
}
if(states[DISABLEGRAVITY] && playerObject != NULL)
{
solsystem.removePlayerItem();
playerObject = NULL;
states[DISABLEGRAVITY] = false;
}
solsystem.update(physEngine, dt*0.5);
solsystem.draw(&player, accTime);
accTime += dt;
window.display();
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
}
cv::waitKey(0);
}
// release resources...
glDeleteVertexArrays(1, &sphereModel.VAO);
//glDeleteVertexArrays(1, &skyboxModel.VAO);
//glDeleteVertexArrays(1, &unitSquareModel.VAO);
//glDeleteVertexArrays(1, &groundModel.VAO);
return 0;
}
void MessageQueue::flush() {
if (buffer_end > buffer_max_used) {
buffer_max_used=buffer_end;
//statistics();
}
uint32_t read_pos=0;
//using reverse locking strategy
_THREAD_SAFE_LOCK_
while (read_pos<buffer_end) {
_THREAD_SAFE_UNLOCK_
//lock on each interation, so a call can re-add itself to the message queue
Message *message = (Message*)&buffer[ read_pos ];
Object *target = ObjectDB::get_instance(message->instance_ID);
if (target!=NULL) {
switch(message->type&FLAG_MASK) {
case TYPE_CALL: {
Variant *args= (Variant*)(message+1);
// messages don't expect a return value
_call_function(target,message->target,args,message->args,message->type&FLAG_SHOW_ERROR);
for(int i=0;i<message->args;i++) {
args[i].~Variant();
}
} break;
case TYPE_NOTIFICATION: {
// messages don't expect a return value
target->notification(message->notification);
} break;
case TYPE_SET: {
Variant *arg= (Variant*)(message+1);
// messages don't expect a return value
target->set(message->target,*arg);
arg->~Variant();
} break;
}
}
uint32_t advance = sizeof(Message);
if ((message->type&FLAG_MASK)!=TYPE_NOTIFICATION)
advance+=sizeof(Variant)*message->args;
message->~Message();
_THREAD_SAFE_LOCK_
read_pos+=advance;
}
buffer_end=0; // reset buffer
_THREAD_SAFE_UNLOCK_
}
Object operator()(const CustomType& argument) const {
Object result;
result.set("value", argument.value);
result.set("vector", argument.vector);
return result;
}
