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