bool Shader::load(FS::IFile& file)
{
lua_State* L = luaL_newstate();
luaL_openlibs(L);
registerFunctions(this, &m_combintions, &getRenderer(), L);
m_render_states = BGFX_STATE_DEPTH_TEST_LEQUAL;
bool errors = luaL_loadbuffer(L, (const char*)file.getBuffer(), file.size(), "") != LUA_OK;
errors = errors || lua_pcall(L, 0, 0, 0) != LUA_OK;
if (errors)
{
g_log_error.log("Renderer") << getPath().c_str() << ": " << lua_tostring(L, -1);
lua_pop(L, 1);
return false;
}
if (!generateInstances())
{
g_log_error.log("Renderer") << "Could not load instances of shader " << getPath().c_str();
return false;
}
m_size = file.size();
lua_close(L);
return true;
}
bool LuaScript::load(FS::IFile& file)
{
m_properties.clear();
m_source_code.set((const char*)file.getBuffer(), (int)file.size());
parseProperties();
m_size = file.size();
return true;
}
bool ShaderBinary::load(FS::IFile& file)
{
auto* mem = bgfx::alloc((uint32)file.size() + 1);
file.read(mem->data, file.size());
mem->data[file.size()] = '\0';
m_handle = bgfx::createShader(mem);
m_size = file.size();
return bgfx::isValid(m_handle);
}
void LuaScript::loaded(FS::IFile& file, bool success, FS::FileSystem& fs)
{
if (success)
{
m_source_code.set((const char*)file.getBuffer(), file.size());
parseProperties();
m_size = file.size();
decrementDepCount();
}
else
{
g_log_error.log("lua_script") << "Could not load script "
<< m_path.c_str();
onFailure();
}
}
bool Texture::load(FS::IFile& file)
{
PROFILE_FUNCTION();
const char* path = getPath().c_str();
size_t len = getPath().length();
bool loaded = false;
if (len > 3 && compareString(path + len - 4, ".dds") == 0)
{
loaded = loadDDS(file);
}
else if (len > 3 && compareString(path + len - 4, ".raw") == 0)
{
loaded = loadRaw(file);
}
else
{
loaded = loadTGA(file);
}
if (!loaded)
{
g_log_warning.log("Renderer") << "Error loading texture " << path;
return false;
}
m_size = file.size();
return true;
}
void Model::loaded(FS::IFile& file, bool success, FS::FileSystem& fs)
{
PROFILE_FUNCTION();
if (success)
{
FileHeader header;
file.read(&header, sizeof(header));
if (header.m_magic == FILE_MAGIC &&
header.m_version <= (uint32_t)FileVersion::LATEST &&
parseMeshes(file) && parseGeometry(file) && parseBones(file) &&
parseLODs(file))
{
m_size = file.size();
decrementDepCount();
}
else
{
g_log_warning.log("renderer") << "Error loading model "
<< m_path.c_str();
onFailure();
return;
}
}
else
{
g_log_warning.log("renderer") << "Error loading model "
<< m_path.c_str();
onFailure();
}
}
JsonSerializer::JsonSerializer(FS::IFile& file,
AccessMode access_mode,
const Path& path,
IAllocator& allocator)
: m_file(file)
, m_access_mode(access_mode)
, m_allocator(allocator)
{
m_is_error = false;
copyString(m_path, path.c_str());
m_is_first_in_block = true;
m_data = nullptr;
m_is_string_token = false;
if (m_access_mode == READ)
{
m_data_size = (int)file.size();
if (file.getBuffer() != nullptr)
{
m_data = (const char*)file.getBuffer();
m_own_data = false;
}
else
{
int size = (int)m_file.size();
char* data = (char*)m_allocator.allocate(size);
m_own_data = true;
file.read(data, m_data_size);
m_data = data;
}
m_token = m_data;
m_token_size = 0;
deserializeToken();
}
}
bool Texture::loadRaw(FS::IFile& file)
{
PROFILE_FUNCTION();
size_t size = file.size();
m_BPP = 2;
m_width = (int)sqrt(size / m_BPP);
m_height = m_width;
if (m_data_reference)
{
m_data.resize(size);
file.read(&m_data[0], size);
}
const uint16_t* src_mem = (const uint16_t*)file.getBuffer();
const bgfx::Memory* mem = bgfx::alloc(m_width * m_height * sizeof(float));
float* dst_mem = (float*)mem->data;
for (int i = 0; i < m_width * m_height; ++i)
{
dst_mem[i] = src_mem[i] / 65535.0f;
}
m_texture_handle = bgfx::createTexture2D(
m_width, m_height, 1, bgfx::TextureFormat::R32F, 0, nullptr);
bgfx::updateTexture2D(
m_texture_handle,
0,
0,
0,
m_width,
m_height,
mem);
return bgfx::isValid(m_texture_handle);
}
bool Texture::loadDDS(FS::IFile& file)
{
bgfx::TextureInfo info;
m_texture_handle = bgfx::createTexture(
bgfx::copy(file.getBuffer(), file.size()), 0, 0, &info);
m_BPP = -1;
m_width = info.width;
m_height = info.height;
return bgfx::isValid(m_texture_handle);
}
bool Clip::load(FS::IFile& file)
{
short* output = nullptr;
auto res = stb_vorbis_decode_memory(
(unsigned char*)file.getBuffer(), (int)file.size(), &m_channels, &m_sample_rate, &output);
if (res <= 0) return false;
m_data.resize(res * m_channels);
copyMemory(&m_data[0], output, res * m_channels * sizeof(m_data[0]));
free(output);
return true;
}
void Animation::loaded(FS::IFile& file, bool success, FS::FileSystem& fs)
{
if (success)
{
IAllocator& allocator = getAllocator();
allocator.deallocate(m_positions);
allocator.deallocate(m_rotations);
allocator.deallocate(m_bones);
m_positions = nullptr;
m_rotations = nullptr;
m_bones = 0;
m_frame_count = m_bone_count = 0;
Header header;
file.read(&header, sizeof(header));
if (header.magic != HEADER_MAGIC)
{
onFailure();
g_log_error.log("animation") << m_path.c_str() << " is not an animation file";
return;
}
if (header.version > 1)
{
onFailure();
g_log_error.log("animation") << "Unsupported animation version " << header.version << " (" << m_path.c_str() << ")";
return;
}
m_fps = header.fps;
file.read(&m_frame_count, sizeof(m_frame_count));
file.read(&m_bone_count, sizeof(m_bone_count));
m_positions = static_cast<Vec3*>(allocator.allocate(sizeof(Vec3) * m_frame_count * m_bone_count));
m_rotations = static_cast<Quat*>(allocator.allocate(sizeof(Quat) * m_frame_count * m_bone_count));
m_bones = static_cast<uint32_t*>(allocator.allocate(sizeof(uint32_t) * m_bone_count));
file.read(&m_positions[0], sizeof(Vec3)* m_bone_count * m_frame_count);
file.read(&m_rotations[0], sizeof(Quat)* m_bone_count * m_frame_count);
file.read(m_bones, sizeof(m_bones[0]) * m_bone_count);
m_size = file.size();
decrementDepCount();
}
else
{
onFailure();
}
}
bool Model::load(FS::IFile& file)
{
PROFILE_FUNCTION();
FileHeader header;
file.read(&header, sizeof(header));
if (header.m_magic == FILE_MAGIC
&& header.m_version <= (uint32)FileVersion::LATEST
&& parseMeshes(file)
&& parseGeometry(file)
&& parseBones(file)
&& parseLODs(file))
{
m_size = file.size();
return true;
}
g_log_warning.log("renderer") << "Error loading model " << getPath().c_str();
return false;
}
bool Model::load(FS::IFile& file)
{
PROFILE_FUNCTION();
FileHeader header;
file.read(&header, sizeof(header));
if (header.magic != FILE_MAGIC)
{
g_log_warning.log("Renderer") << "Corrupted model " << getPath().c_str();
return false;
}
if(header.version > (u32)FileVersion::LATEST)
{
g_log_warning.log("Renderer") << "Unsupported version of model " << getPath().c_str();
return false;
}
u32 global_flags = 0; // backward compatibility
if(header.version > (u32)FileVersion::WITH_FLAGS)
{
file.read(&global_flags, sizeof(global_flags));
}
bgfx::VertexDecl global_vertex_decl;
if (header.version > (u32)FileVersion::SINGLE_VERTEX_DECL && header.version <= (u32)FileVersion::MULTIPLE_VERTEX_DECLS)
{
parseVertexDeclEx(file, &global_vertex_decl);
}
if (parseMeshes(global_vertex_decl, file, (FileVersion)header.version, global_flags)
&& parseBones(file)
&& parseLODs(file))
{
m_size = file.size();
return true;
}
g_log_error.log("Renderer") << "Error loading model " << getPath().c_str();
return false;
}
void Texture::loaded(FS::IFile& file, bool success, FS::FileSystem& fs)
{
PROFILE_FUNCTION();
if (success)
{
const char* path = m_path.c_str();
size_t len = m_path.length();
bool loaded = false;
if (len > 3 && strcmp(path + len - 4, ".dds") == 0)
{
loaded = loadDDS(file);
}
else if (len > 3 && strcmp(path + len - 4, ".raw") == 0)
{
loaded = loadRaw(file);
}
else
{
loaded = loadTGA(file);
}
if (!loaded)
{
g_log_warning.log("renderer") << "Error loading texture "
<< m_path.c_str();
onFailure();
}
else
{
m_size = file.size();
decrementDepCount();
}
}
else
{
g_log_warning.log("renderer") << "Error loading texture "
<< m_path.c_str();
onFailure();
}
}
bool Animation::load(FS::IFile& file)
{
IAllocator& allocator = getAllocator();
allocator.deallocate(m_positions);
allocator.deallocate(m_rotations);
allocator.deallocate(m_bones);
m_positions = nullptr;
m_rotations = nullptr;
m_bones = nullptr;
m_frame_count = m_bone_count = 0;
Header header;
file.read(&header, sizeof(header));
if (header.magic != HEADER_MAGIC)
{
g_log_error.log("Animation") << getPath() << " is not an animation file";
return false;
}
if (header.version > 1)
{
g_log_error.log("Animation") << "Unsupported animation version " << header.version << " ("
<< getPath() << ")";
return false;
}
m_fps = header.fps;
file.read(&m_frame_count, sizeof(m_frame_count));
file.read(&m_bone_count, sizeof(m_bone_count));
m_positions = static_cast<Vec3*>(allocator.allocate(sizeof(Vec3) * m_frame_count * m_bone_count));
m_rotations = static_cast<Quat*>(allocator.allocate(sizeof(Quat) * m_frame_count * m_bone_count));
m_bones = static_cast<uint32*>(allocator.allocate(sizeof(uint32) * m_bone_count));
file.read(&m_positions[0], sizeof(Vec3)* m_bone_count * m_frame_count);
file.read(&m_rotations[0], sizeof(Quat)* m_bone_count * m_frame_count);
file.read(m_bones, sizeof(m_bones[0]) * m_bone_count);
m_size = file.size();
return true;
}
bool Material::load(FS::IFile& file)
{
PROFILE_FUNCTION();
m_render_states = BGFX_STATE_DEPTH_TEST_LEQUAL | BGFX_STATE_CULL_CW;
m_uniforms.clear();
JsonSerializer serializer(file, JsonSerializer::READ, getPath().c_str(), m_allocator);
serializer.deserializeObjectBegin();
char path[MAX_PATH_LENGTH];
char label[256];
char material_dir[MAX_PATH_LENGTH];
PathUtils::getDir(material_dir, MAX_PATH_LENGTH, getPath().c_str());
bool b_value;
while (!serializer.isObjectEnd())
{
serializer.deserializeLabel(label, 255);
if (compareString(label, "uniforms") == 0)
{
deserializeUniforms(serializer);
}
else if (compareString(label, "texture") == 0)
{
if (!deserializeTexture(serializer, material_dir))
{
return false;
}
}
else if (compareString(label, "alpha_cutout") == 0)
{
bool b;
serializer.deserialize(b, false);
enableAlphaCutout(b);
}
else if (compareString(label, "alpha_blending") == 0)
{
if (serializer.isNextBoolean())
{
bool is_alpha_blending;
serializer.deserialize(is_alpha_blending, false);
if (is_alpha_blending)
{
m_render_states |= BGFX_STATE_BLEND_ADD;
}
else
{
m_render_states &= ~BGFX_STATE_BLEND_MASK;
}
}
else
{
serializer.deserialize(label, 255, "alpha");
if (compareString(label, "alpha") == 0)
{
m_render_states |= BGFX_STATE_BLEND_ALPHA;
}
else if (compareString(label, "add") == 0)
{
m_render_states |= BGFX_STATE_BLEND_ADD;
}
else if (compareString(label, "disabled") == 0)
{
m_render_states &= ~BGFX_STATE_BLEND_MASK;
}
}
}
else if (compareString(label, "specular") == 0)
{
serializer.deserializeArrayBegin();
serializer.deserializeArrayItem(m_specular.x, 1.0f);
serializer.deserializeArrayItem(m_specular.y, 1.0f);
serializer.deserializeArrayItem(m_specular.z, 1.0f);
serializer.deserializeArrayEnd();
}
else if (compareString(label, "shininess") == 0)
{
serializer.deserialize(m_shininess, 4.0f);
}
else if (compareString(label, "shadow_receiver") == 0)
{
bool b;
serializer.deserialize(b, true);
enableShadowReceiving(b);
}
else if (compareString(label, "shader") == 0)
{
serializer.deserialize(path, MAX_PATH_LENGTH, "");
setShader(static_cast<Shader*>(
m_resource_manager.get(ResourceManager::SHADER)->load(Path(path))));
}
else if (compareString(label, "z_test") == 0)
{
serializer.deserialize(b_value, true);
enableZTest(b_value);
}
else if (compareString(label, "backface_culling") == 0)
{
serializer.deserialize(b_value, true);
enableBackfaceCulling(b_value);
}
else
{
g_log_warning.log("renderer") << "Unknown parameter " << label << " in material "
<< getPath().c_str();
}
}
serializer.deserializeObjectEnd();
if (!m_shader)
{
g_log_error.log("renderer") << "Material " << getPath().c_str() << " without a shader";
return false;
}
m_size = file.size();
return true;
}
bool PhysicsGeometry::load(FS::IFile& file)
{
Header header;
file.read(&header, sizeof(header));
if (header.m_magic != HEADER_MAGIC || header.m_version > (uint32)Versions::LAST)
{
return false;
}
auto* phy_manager = m_resource_manager.get(ResourceManager::PHYSICS);
PhysicsSystem& system = static_cast<PhysicsGeometryManager*>(phy_manager)->getSystem();
uint32 num_verts;
Array<Vec3> verts(getAllocator());
file.read(&num_verts, sizeof(num_verts));
verts.resize(num_verts);
file.read(&verts[0], sizeof(verts[0]) * verts.size());
m_is_convex = header.m_convex != 0;
if (!m_is_convex)
{
physx::PxTriangleMeshGeometry* geom =
LUMIX_NEW(getAllocator(), physx::PxTriangleMeshGeometry)();
m_geometry = geom;
uint32 num_indices;
Array<uint32> tris(getAllocator());
file.read(&num_indices, sizeof(num_indices));
tris.resize(num_indices);
file.read(&tris[0], sizeof(tris[0]) * tris.size());
physx::PxTriangleMeshDesc meshDesc;
meshDesc.points.count = num_verts;
meshDesc.points.stride = sizeof(physx::PxVec3);
meshDesc.points.data = &verts[0];
meshDesc.triangles.count = num_indices / 3;
meshDesc.triangles.stride = 3 * sizeof(physx::PxU32);
meshDesc.triangles.data = &tris[0];
OutputStream writeBuffer(getAllocator());
system.getCooking()->cookTriangleMesh(meshDesc, writeBuffer);
InputStream readBuffer(writeBuffer.data, writeBuffer.size);
geom->triangleMesh = system.getPhysics()->createTriangleMesh(readBuffer);
}
else
{
physx::PxConvexMeshGeometry* geom =
LUMIX_NEW(getAllocator(), physx::PxConvexMeshGeometry)();
m_geometry = geom;
physx::PxConvexMeshDesc meshDesc;
meshDesc.points.count = verts.size();
meshDesc.points.stride = sizeof(Vec3);
meshDesc.points.data = &verts[0];
meshDesc.flags = physx::PxConvexFlag::eCOMPUTE_CONVEX;
OutputStream writeBuffer(getAllocator());
bool status = system.getCooking()->cookConvexMesh(meshDesc, writeBuffer);
if (!status)
{
LUMIX_DELETE(getAllocator(), geom);
m_geometry = nullptr;
return false;
}
InputStream readBuffer(writeBuffer.data, writeBuffer.size);
physx::PxConvexMesh* mesh = system.getPhysics()->createConvexMesh(readBuffer);
geom->convexMesh = mesh;
}
m_size = file.size();
return true;
}
