void compile(const char* path, CompileOptions& compileOptions) { TempAllocator1024 ta; DynamicString scriptSource(ta); DynamicString scriptBinary(ta); compileOptions.getAbsolutePath(path, scriptSource); compileOptions.getTemporaryPath("lua.bin", scriptBinary); StringStream arguments(ta); arguments << " " << LUAJIT_FLAGS; arguments << " " << scriptSource.getCStr(); arguments << " " << scriptBinary.getCStr(); StringStream output(ta); int exitCode = OsFn::executeProcess(LUAJIT_EXE, StringStreamFn::getCStr(arguments), output); RESOURCE_COMPILER_ASSERT(exitCode == 0 , compileOptions , "Failed to compile lua script:\n%s" , StringStreamFn::getCStr(output) ); Buffer blob = compileOptions.readTemporary(scriptBinary.getCStr()); compileOptions.deleteFile(scriptBinary.getCStr()); ScriptResource scriptResource; scriptResource.version = RESOURCE_VERSION_SCRIPT; scriptResource.size = ArrayFn::getCount(blob); compileOptions.write(scriptResource.version); compileOptions.write(scriptResource.size); compileOptions.write(blob); }
void compile(const char* path, CompileOptions& opts) { TempAllocator1024 ta; DynamicString luasrc(ta); DynamicString luabin(ta); opts.get_absolute_path(path, luasrc); opts.get_temporary_path("lua.bin", luabin); StringStream args(ta); args << " " << LUAJIT_FLAGS; args << " " << luasrc.c_str(); args << " " << luabin.c_str(); StringStream output(ta); int exitcode = os::execute_process(LUAJIT_EXE, string_stream::c_str(args), output); RESOURCE_COMPILER_ASSERT(exitcode == 0 , opts , "Failed to compile lua:\n%s" , string_stream::c_str(output) ); Buffer blob = opts.read_temporary(luabin.c_str()); opts.delete_file(luabin.c_str()); LuaResource lr; lr.version = RESOURCE_VERSION_SCRIPT; lr.size = array::size(blob); opts.write(lr.version); opts.write(lr.size); opts.write(blob); }
u32 filter_to_mask(StringId32 filter) { RESOURCE_COMPILER_ASSERT(map::has(_filter_map, filter) , _opts , "Filter not found" ); return map::get(_filter_map, filter, 0u); }
u32 new_filter_mask() { RESOURCE_COMPILER_ASSERT(_filter != 0x80000000u , _opts , "Too many collision filters" ); const u32 f = _filter; _filter = _filter << 1; return f; }
void compile(const char* path, CompileOptions& opts) { Buffer buf = opts.read(path); TempAllocator1024 ta; JsonObject boot(ta); sjson::parse(buf, boot); const char* boot_script_json = boot["boot_script"]; const char* boot_package_json = boot["boot_package"]; RESOURCE_COMPILER_ASSERT(boot_script_json != NULL, opts, "'boot_script' must be specified."); RESOURCE_COMPILER_ASSERT(boot_package_json != NULL, opts, "'boot_package' must be specified."); DynamicString boot_script(ta); DynamicString boot_package(ta); sjson::parse_string(boot_script_json, boot_script); sjson::parse_string(boot_package_json, boot_package); RESOURCE_COMPILER_ASSERT_RESOURCE_EXISTS(RESOURCE_EXTENSION_SCRIPT, boot_script.c_str(), opts); RESOURCE_COMPILER_ASSERT_RESOURCE_EXISTS(RESOURCE_EXTENSION_PACKAGE, boot_package.c_str(), opts); opts.write(buf); }
Buffer compile_joint(const char* json, CompileOptions& opts) { TempAllocator4096 ta; JsonObject obj(ta); sjson::parse(json, obj); DynamicString type(ta); sjson::parse_string(obj["type"], type); JointType::Enum jt = joint_type_to_enum(type.c_str()); RESOURCE_COMPILER_ASSERT(jt != JointType::COUNT , opts , "Unknown joint type: '%s'" , type.c_str() ); JointDesc jd; jd.type = jt; jd.anchor_0 = sjson::parse_vector3(obj["anchor_0"]); jd.anchor_1 = sjson::parse_vector3(obj["anchor_1"]); switch (jd.type) { case JointType::HINGE: { jd.hinge.use_motor = sjson::parse_bool (obj["use_motor"]); jd.hinge.target_velocity = sjson::parse_float(obj["target_velocity"]); jd.hinge.max_motor_impulse = sjson::parse_float(obj["max_motor_impulse"]); jd.hinge.lower_limit = sjson::parse_float(obj["lower_limit"]); jd.hinge.upper_limit = sjson::parse_float(obj["upper_limit"]); jd.hinge.bounciness = sjson::parse_float(obj["bounciness"]); break; } } Buffer buf(default_allocator()); array::push(buf, (char*)&jd, sizeof(jd)); return buf; }
Buffer compile_collider(const char* json, CompileOptions& opts) { TempAllocator4096 ta; JsonObject obj(ta); sjson::parse(json, obj); DynamicString type(ta); sjson::parse_string(obj["shape"], type); ColliderType::Enum st = shape_type_to_enum(type.c_str()); RESOURCE_COMPILER_ASSERT(st != ColliderType::COUNT , opts , "Unknown shape type: '%s'" , type.c_str() ); ColliderDesc cd; cd.type = st; cd.shape_class = sjson::parse_string_id(obj["class"]); cd.material = sjson::parse_string_id(obj["material"]); cd.local_tm = MATRIX4X4_IDENTITY; cd.size = 0; DynamicString scene(ta); DynamicString name(ta); sjson::parse_string(obj["scene"], scene); sjson::parse_string(obj["name"], name); RESOURCE_COMPILER_ASSERT_RESOURCE_EXISTS(RESOURCE_EXTENSION_MESH, scene.c_str(), opts); scene += "." RESOURCE_EXTENSION_MESH; Buffer file = opts.read(scene.c_str()); JsonObject json_mesh(ta); JsonObject geometries(ta); JsonObject nodes(ta); JsonObject node(ta); sjson::parse(file, json_mesh); sjson::parse(json_mesh["geometries"], geometries); sjson::parse(json_mesh["nodes"], nodes); sjson::parse(nodes[name.c_str()], node); const char* mesh = geometries[name.c_str()]; Matrix4x4 matrix_local = sjson::parse_matrix4x4(node["matrix_local"]); cd.local_tm = matrix_local; Array<Vector3> mesh_data(default_allocator()); switch (cd.type) { case ColliderType::SPHERE: compile_sphere(mesh, cd); break; case ColliderType::CAPSULE: compile_capsule(mesh, cd); break; case ColliderType::BOX: compile_box(mesh, cd); break; case ColliderType::CONVEX_HULL: compile_convex_hull(mesh, mesh_data); break; case ColliderType::MESH: case ColliderType::HEIGHTFIELD: { RESOURCE_COMPILER_ASSERT(false, opts, "Not implemented yet"); break; } } cd.size = sizeof(Vector3)*array::size(mesh_data); Buffer buf(default_allocator()); array::push(buf, (char*)&cd, sizeof(cd)); if (array::size(mesh_data)) array::push(buf, (char*)array::begin(mesh_data), sizeof(Vector3)*array::size(mesh_data)); return buf; }
static void parse_uniforms(const char* json, Array<UniformData>& uniforms, Array<char>& names, Array<char>& dynamic, CompileOptions& opts) { TempAllocator4096 ta; JsonObject object(ta); sjson::parse(json, object); auto begin = json_object::begin(object); auto end = json_object::end(object); for (; begin != end; ++begin) { const FixedString key = begin->pair.first; const char* value = begin->pair.second; UniformHandle uh; uh.uniform_handle = 0; JsonObject uniform(ta); sjson::parse_object(value, uniform); DynamicString type(ta); sjson::parse_string(uniform["type"], type); const UniformType::Enum ut = name_to_uniform_type(type.c_str()); RESOURCE_COMPILER_ASSERT(ut != UniformType::COUNT , opts , "Unknown uniform type: '%s'" , type.c_str() ); const u32 name_offset = array::size(names); array::push(names, key.data(), key.length()); array::push_back(names, '\0'); UniformData ud; ud.type = ut; ud.name = StringId32(key.data(), key.length()); ud.name_offset = name_offset; ud.data_offset = reserve_dynamic_data(uh, dynamic); switch (ud.type) { case UniformType::FLOAT: reserve_dynamic_data(sjson::parse_float(uniform["value"]), dynamic); break; case UniformType::VECTOR2: reserve_dynamic_data(sjson::parse_vector2(uniform["value"]), dynamic); break; case UniformType::VECTOR3: reserve_dynamic_data(sjson::parse_vector3(uniform["value"]), dynamic); break; case UniformType::VECTOR4: reserve_dynamic_data(sjson::parse_vector4(uniform["value"]), dynamic); break; default: CE_FATAL("Unknown uniform type"); break; } array::push_back(uniforms, ud); } }