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