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; }