void Evaluate::start() { QString script = arguments()[0]; QString jsonArgs; if (arguments().length()>1){ jsonArgs = arguments()[1]; } else { jsonArgs ="[]"; } QString eval_script = QString("(function(){" " for(var i=0; i<arguments.length; i++) {" " arguments[i] = JSON.parse(arguments[i]);" " var elem_id = arguments[i]['element-581e-422e-8be1-884c4e116226'];" " if (elem_id) {" " arguments[i] = Capybara.getNode(elem_id);" " };" " };" " var _result = eval(\"%1\");" " return Capybara.wrapResult(_result);" " }).apply(null, %2)").arg(script.replace("\"","\\\"").remove("\n"), jsonArgs); QObject invocation_stub; invocation_stub.setProperty("allowUnattached", false); page()->currentFrame()->addToJavaScriptWindowObject("CapybaraInvocation", &invocation_stub); QVariant result = page()->currentFrame()->evaluateJavaScript(eval_script); JsonSerializer serializer; finish(true, serializer.serialize(result)); }
void deserialize(JsonSerializer& serializer) override { char name[50]; serializer.deserialize("template_name", name, sizeof(name), ""); m_name = name; serializer.deserialize("entity", m_entity, -1); }
void JsonOut::write(const JsonSerializer &thing) { if (need_separator) { write_separator(); } thing.serialize(*this); need_separator = true; }
bool Sprite::save(JsonSerializer& serializer) { if (!isReady()) return false; serializer.beginObject(); serializer.serialize("type", type == PATCH9 ? "patch9" : "simple"); serializer.serialize("top", top); serializer.serialize("bottom", bottom); serializer.serialize("left", left); serializer.serialize("right", right); serializer.serialize("texture", m_texture ? m_texture->getPath().c_str() : ""); serializer.endObject(); return true; }
void deserialize(JsonSerializer& serializer) override { serializer.deserialize("template_name_hash", m_template_name_hash, 0); serializer.deserialize("entity", m_entity, -1); serializer.deserialize("position_x", m_position.x, 0); serializer.deserialize("position_y", m_position.y, 0); serializer.deserialize("position_z", m_position.z, 0); serializer.deserialize("rotation_x", m_rotation.x, 0); serializer.deserialize("rotation_y", m_rotation.y, 0); serializer.deserialize("rotation_z", m_rotation.z, 0); serializer.deserialize("rotation_w", m_rotation.w, 0); serializer.deserialize("size", m_size, 1); }
void serialize(JsonSerializer& serializer) override { serializer.serialize("template_name_hash", m_template_name_hash); serializer.serialize("entity", m_entity); serializer.serialize("position_x", m_position.x); serializer.serialize("position_y", m_position.y); serializer.serialize("position_z", m_position.z); serializer.serialize("rotation_x", m_rotation.x); serializer.serialize("rotation_y", m_rotation.y); serializer.serialize("rotation_z", m_rotation.z); serializer.serialize("rotation_w", m_rotation.w); serializer.serialize("size", m_size); }
void store(const Person &p, std::string &buffer) { JsonSerializer serializer; serializer.set_buffer(buffer); serializer.put_key("firstname"); serializer.put_string(p.firstname()); serializer.put_key("lastname"); serializer.put_string(p.lastname()); }
void serialize(JsonSerializer& serializer) override { serializer.serialize("template_name", m_name.c_str()); serializer.serialize("entity", m_entity); }
void JavascriptConfirmMessages::start() { JsonSerializer serializer; QByteArray json = serializer.serialize(page()->confirmMessages()); emitFinished(true, json); }
void Evaluate::start() { QVariant result = page()->currentFrame()->evaluateJavaScript(arguments()[0]); JsonSerializer serializer; emitFinished(true, serializer.serialize(result)); }
bool Material::deserializeTexture(JsonSerializer& serializer, const char* material_dir) { char path[MAX_PATH_LENGTH]; serializer.deserializeObjectBegin(); char label[256]; bool keep_data = false; uint32 flags = 0; int atlas_size = -1; while (!serializer.isObjectEnd()) { serializer.deserializeLabel(label, sizeof(label)); if (compareString(label, "source") == 0) { serializer.deserialize(path, MAX_PATH_LENGTH, ""); if (path[0] != '\0') { char texture_path[MAX_PATH_LENGTH]; if (path[0] != '/' && path[0] != '\\') { copyString(texture_path, material_dir); catString(texture_path, path); } else { copyString(texture_path, path); } m_textures[m_texture_count] = static_cast<Texture*>( m_resource_manager.get(ResourceManager::TEXTURE)->load(Path(texture_path))); addDependency(*m_textures[m_texture_count]); } } else if (compareString(label, "atlas_size") == 0) { serializer.deserialize(atlas_size, -1); } else if (compareString(label, "min_filter") == 0) { serializer.deserialize(label, sizeof(label), ""); if (compareString(label, "point") == 0) { flags |= BGFX_TEXTURE_MIN_POINT; } else if (compareString(label, "anisotropic") == 0) { flags |= BGFX_TEXTURE_MIN_ANISOTROPIC; } else { g_log_error.log("Renderer") << "Unknown texture filter \"" << label << "\" in material " << getPath().c_str(); } } else if (compareString(label, "mag_filter") == 0) { serializer.deserialize(label, sizeof(label), ""); if (compareString(label, "point") == 0) { flags |= BGFX_TEXTURE_MAG_POINT; } else if (compareString(label, "anisotropic") == 0) { flags |= BGFX_TEXTURE_MAG_ANISOTROPIC; } else { g_log_error.log("Renderer") << "Unknown texture filter \"" << label << "\" in material " << getPath().c_str(); } } else if (compareString(label, "u_clamp") == 0) { bool b; serializer.deserialize(b, false); if (b) { flags |= BGFX_TEXTURE_U_CLAMP; } } else if (compareString(label, "v_clamp") == 0) { bool b; serializer.deserialize(b, false); if (b) { flags |= BGFX_TEXTURE_V_CLAMP; } } else if (compareString(label, "w_clamp") == 0) { bool b; serializer.deserialize(b, false); if (b) { flags |= BGFX_TEXTURE_W_CLAMP; } } else if (compareString(label, "keep_data") == 0) { serializer.deserialize(keep_data, false); } else { g_log_warning.log("Renderer") << "Unknown data \"" << label << "\" in material " << getPath().c_str(); return false; } } if (m_textures[m_texture_count]) { m_textures[m_texture_count]->setAtlasSize(atlas_size); m_textures[m_texture_count]->setFlags(flags); if (keep_data) { m_textures[m_texture_count]->addDataReference(); } } serializer.deserializeObjectEnd(); ++m_texture_count; return true; }
void Material::deserializeUniforms(JsonSerializer& serializer) { serializer.deserializeArrayBegin(); clearUniforms(); while (!serializer.isArrayEnd()) { Uniform& uniform = m_uniforms.pushEmpty(); serializer.nextArrayItem(); serializer.deserializeObjectBegin(); char label[256]; auto uniform_type = bgfx::UniformType::End; while (!serializer.isObjectEnd()) { serializer.deserializeLabel(label, 255); if (compareString(label, "name") == 0) { serializer.deserialize(uniform.m_name, Uniform::MAX_NAME_LENGTH, ""); uniform.m_name_hash = crc32(uniform.m_name); } else if (compareString(label, "int_value") == 0) { uniform_type = bgfx::UniformType::Int1; uniform.m_type = Uniform::INT; serializer.deserialize(uniform.m_int, 0); } else if (compareString(label, "float_value") == 0) { uniform.m_type = Uniform::FLOAT; serializer.deserialize(uniform.m_float, 0); } else if (compareString(label, "matrix_value") == 0) { uniform_type = bgfx::UniformType::Mat4; uniform.m_type = Uniform::MATRIX; serializer.deserializeArrayBegin(); for (int i = 0; i < 16; ++i) { serializer.deserializeArrayItem(uniform.m_matrix[i], 0); ASSERT(i == 15 || !serializer.isArrayEnd()); } serializer.deserializeArrayEnd(); } else if (compareString(label, "time") == 0) { uniform.m_type = Uniform::TIME; serializer.deserialize(uniform.m_float, 0); } else { g_log_warning.log("material") << "Unknown label \"" << label << "\""; } } uniform.m_handle = bgfx::createUniform(uniform.m_name, uniform_type); serializer.deserializeObjectEnd(); } serializer.deserializeArrayEnd(); }
bool Material::save(JsonSerializer& serializer) { serializer.beginObject(); serializer.serialize("shader", m_shader ? m_shader->getPath().c_str() : ""); for (int i = 0; i < m_texture_count; ++i) { char path[MAX_PATH_LENGTH]; int flags = 0; int atlas_size = -1; if (m_textures[i]) { flags = m_textures[i]->getFlags(); path[0] = '/'; Lumix::copyString(path + 1, MAX_PATH_LENGTH - 1, m_textures[i]->getPath().c_str()); atlas_size = m_textures[i]->getAtlasSize(); } else { path[0] = '\0'; } serializer.beginObject("texture"); serializer.serialize("source", path); if (atlas_size > 0) serializer.serialize("atlas_size", atlas_size); if (flags & BGFX_TEXTURE_U_CLAMP) serializer.serialize("u_clamp", true); if (flags & BGFX_TEXTURE_V_CLAMP) serializer.serialize("v_clamp", true); if (flags & BGFX_TEXTURE_W_CLAMP) serializer.serialize("w_clamp", true); if (flags & BGFX_TEXTURE_MIN_POINT) serializer.serialize("min_filter", "point"); if (flags & BGFX_TEXTURE_MIN_ANISOTROPIC) serializer.serialize("min_filter", "anisotropic"); if (flags & BGFX_TEXTURE_MAG_POINT) serializer.serialize("mag_filter", "point"); if (flags & BGFX_TEXTURE_MAG_ANISOTROPIC) serializer.serialize("mag_filter", "anisotropic"); if (m_textures[i] && m_textures[i]->getData()) serializer.serialize("keep_data", true); serializer.endObject(); } serializer.beginArray("uniforms"); for (int i = 0; i < m_uniforms.size(); ++i) { serializer.beginObject(); serializer.serialize("name", m_uniforms[i].m_name); switch (m_uniforms[i].m_type) { case Uniform::FLOAT: serializer.serialize("float_value", m_uniforms[i].m_float); break; case Uniform::TIME: serializer.serialize("time", m_uniforms[i].m_float); break; case Uniform::INT: serializer.serialize("int_value", m_uniforms[i].m_int); break; case Uniform::MATRIX: serializer.beginArray("matrix_value"); for (int j = 0; j < 16; ++j) { serializer.serializeArrayItem(m_uniforms[i].m_matrix[j]); } serializer.endArray(); break; default: ASSERT(false); break; } serializer.endObject(); } serializer.endArray(); serializer.serialize("backface_culling", isBackfaceCulling()); serializer.serialize("alpha_cutout", isAlphaCutout()); serializer.serialize("shadow_receiver", isShadowReceiver()); serializer.serialize("shininess", m_shininess); serializer.beginArray("specular"); serializer.serializeArrayItem(m_specular.x); serializer.serializeArrayItem(m_specular.y); serializer.serializeArrayItem(m_specular.z); serializer.endArray(); serializer.serialize("z_test", isZTest()); serializer.endObject(); return true; }
void AssetLibrary::loadPackage(string name) { ifstream file(name); if (!file) { throw IOException("file could not be opened"); } auto baseName = path(name).stem(); Value package; Json::Reader jsonReader; if (!jsonReader.parse(file, package)) { throw IOException("package file could not be read: " + jsonReader.getFormattedErrorMessages()); } string prefix(baseName.string() + "."); if (package.type() == ValueType::arrayValue) { struct AssetInPackage { string uid; string objectName; Value* objectVal; }; vector<AssetInPackage> assetsInPackage; assetsInPackage.reserve(package.size()); for (auto&& asset : package) { if (asset.type() != ValueType::objectValue) { throw IOException("items in objects array must be objects"); } auto uid = asset.removeMember("uid"); if (uid.type() != ValueType::stringValue) { throw IOException("resource uid must be a string"); } auto& objectType = asset["objectName"]; if (objectType.type() != ValueType::stringValue) { throw IOException("resource has missing or invalid type"); } //normalize auto uidStr = Object::uidToString(Object::uidFromString(uid.asString())); assetsInPackage.emplace_back(AssetInPackage { uidStr, objectType.asString(), &asset }); } JsonSerializer serializer; /* simple ref resolver: each new item is mapped by uid, then subsequent items can look it up. the main limitation is the objects must appear after all of their dependencies within a file */ serializer.setRefResolver([this](Object::Uid uid, ObjectRefResolver resolve) { auto uidStr = Object::uidToString(uid); auto&& lookupNewObj = impl->assets.find(uidStr); if (lookupNewObj == impl->assets.end()) { logger.warnStream() << "failed to resolve reference for object " << uidStr; resolve(nullptr); } else { resolve(lookupNewObj->second); } }); for (auto&& asset : assetsInPackage) { Value propertiesVal = *asset.objectVal; propertiesVal.removeMember("type"); ObjectRef<> obj; ObjectRef<AssetImporter> importer; if (impl->tryGetImporter(asset.objectName, importer)) { auto importerMeta = Metadata::createMetaObject(*importer); serializer.deserializeProperties(propertiesVal, *importerMeta); obj = importer->import(); } else { obj = impl->application.instantiate(asset.objectName); auto meta = Metadata::createMetaObject(asset.objectName, *obj); serializer.deserializeProperties(propertiesVal, *meta); } impl->assets[asset.uid] = obj; } } else if (package.type() != ValueType::nullValue) { throw IOException("package data must be an array"); } }