471 lines
9.6 KiB
D
471 lines
9.6 KiB
D
module dlib.assets;
|
|
|
|
import includes;
|
|
import dlib.aliases;
|
|
import dlib.util;
|
|
import dlib.alloc;
|
|
|
|
import std.file;
|
|
import std.path;
|
|
import std.format;
|
|
import std.stdio;
|
|
import std.exception;
|
|
|
|
__gshared ImageData DEFAULT_IMAGE = GenerateDefaultTexture(32, 32);
|
|
__gshared Material DEFAULT_MATERIAL = GenerateDefaultMaterial();
|
|
|
|
// TODO:
|
|
// Alignment?
|
|
|
|
/*************************
|
|
****** FILE PACKER ******
|
|
*************************/
|
|
|
|
/*************************
|
|
****** FILE PACKER ******
|
|
*************************/
|
|
|
|
/************************
|
|
*** ASSET STRUCTURES ***
|
|
************************/
|
|
|
|
struct ImageData
|
|
{
|
|
u8[] data;
|
|
u32 w;
|
|
u32 h;
|
|
u32 ch;
|
|
}
|
|
|
|
struct ModelData
|
|
{
|
|
Model model;
|
|
ImageData[] tex;
|
|
}
|
|
|
|
/************************
|
|
*** ASSET STRUCTURES ***
|
|
************************/
|
|
|
|
/**************************
|
|
***** GFX STRUCTURES *****
|
|
**************************/
|
|
|
|
enum MaterialMapIndex
|
|
{
|
|
Albedo,
|
|
Normal,
|
|
Metallic,
|
|
Roughness,
|
|
Occlusion,
|
|
Emission,
|
|
Height,
|
|
Cubemap,
|
|
Irradiance,
|
|
Prefilter,
|
|
BRDF,
|
|
|
|
Max,
|
|
}
|
|
|
|
alias MMI = MaterialMapIndex;
|
|
|
|
struct MaterialMap
|
|
{
|
|
u32 tex_id;
|
|
Vec4 col;
|
|
f32 value;
|
|
}
|
|
|
|
struct Material
|
|
{
|
|
u32 pipeline_id;
|
|
MaterialMap[MMI.max] maps;
|
|
Vec4 params;
|
|
}
|
|
|
|
struct Vertex
|
|
{
|
|
Vec4 color;
|
|
Vec4 tangent;
|
|
Vec3 pos;
|
|
Vec3 normal;
|
|
Vec2 uv;
|
|
Vec2 uv2;
|
|
}
|
|
|
|
struct Mesh
|
|
{
|
|
Vertex[] vtx;
|
|
u32 idx;
|
|
u32 mat_id;
|
|
}
|
|
|
|
struct Model
|
|
{
|
|
Mat4 transform;
|
|
|
|
Mesh[] meshes;
|
|
Material[] mats;
|
|
|
|
// TODO: bones/animations
|
|
}
|
|
|
|
/**************************
|
|
***** GFX STRUCTURES *****
|
|
**************************/
|
|
|
|
__gshared string g_BASE_ASSETS_DIR;
|
|
|
|
static u32
|
|
MagicValue(string str)
|
|
{
|
|
assert(str.length == 4, "Magic value must 4 characters");
|
|
return cast(u32)(cast(u32)(str[0] << 24) | cast(u32)(str[1] << 16) | cast(u32)(str[2] << 8) | cast(u32)(str[3] << 0));
|
|
}
|
|
|
|
void
|
|
SetBaseAssetsDir(string dir)
|
|
{
|
|
if(!isDir(dir))
|
|
{
|
|
assert(false, "Unable to find assets directory");
|
|
}
|
|
|
|
g_BASE_ASSETS_DIR = dir;
|
|
}
|
|
|
|
void
|
|
U32ColToVec4(u32 col, Vec4* vec)
|
|
{
|
|
if(!col)
|
|
{
|
|
vec.rgb = 0.0;
|
|
vec.a = 1.0;
|
|
}
|
|
else
|
|
{
|
|
vec.r = cast(f32)((col >> 0)&0xFF) / 255;
|
|
vec.g = cast(f32)((col >> 8)&0xFF) / 255;
|
|
vec.b = cast(f32)((col >> 16)&0xFF) / 255;
|
|
vec.a = cast(f32)((col >> 24)&0xFF) / 255;
|
|
}
|
|
}
|
|
|
|
// TODO: make better
|
|
u8[]
|
|
OpenFile(string file_name)
|
|
{
|
|
File f;
|
|
u8[] data;
|
|
|
|
try
|
|
{
|
|
f = File(file_name, "rb");
|
|
data = Alloc!(u8)(f.size());
|
|
f.rawRead(data);
|
|
}
|
|
catch(Exception e)
|
|
{
|
|
data = null;
|
|
}
|
|
|
|
f.close();
|
|
|
|
return data;
|
|
}
|
|
|
|
extern (C) cgltf_result
|
|
GLTFLoadCallback(cgltf_memory_options* memory_opts, cgltf_file_options* file_opts, const(char)* path, cgltf_size* size, void** data)
|
|
{
|
|
u8[] file_data = OpenFile(ConvToStr(path[0 .. strlen(path)]));
|
|
|
|
if(file_data == null) return cgltf_result_io_error;
|
|
|
|
*size = cast(cgltf_size)file_data.length;
|
|
*data = file_data.ptr;
|
|
|
|
return cgltf_result_success;
|
|
}
|
|
|
|
extern (C) void
|
|
GLTFFreeCallback(cgltf_memory_options* memory_opts, cgltf_file_options* file_opts, void* data, cgltf_size size)
|
|
{
|
|
Free(data);
|
|
}
|
|
|
|
ImageData
|
|
LoadImage(void* data, i32 size)
|
|
{
|
|
ImageData image;
|
|
|
|
i32 w, h, has_ch;
|
|
u8* image_bytes = stbi_load_from_memory(cast(const(u8)*)data, size, &w, &h, &has_ch, 4);
|
|
if(w <= 0 || h <= 0 || has_ch <= 0)
|
|
{
|
|
Logf("Failed to load image data");
|
|
}
|
|
else
|
|
{
|
|
image.data = image_bytes[0 .. w*h*has_ch];
|
|
image.w = w;
|
|
image.h = h;
|
|
image.ch = has_ch;
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
void
|
|
UnloadImage(ImageData* image)
|
|
{
|
|
stbi_image_free(image.data.ptr);
|
|
}
|
|
|
|
ImageData
|
|
LoadImage(cgltf_image* asset_image, string tex_path)
|
|
{
|
|
ImageData image;
|
|
|
|
if(asset_image)
|
|
{
|
|
if(asset_image.uri != null)
|
|
{
|
|
if(strlen(asset_image.uri) > 5 && ConvToStr(asset_image.uri[0 .. 5]) == "data:")
|
|
{
|
|
u32 i;
|
|
for(; asset_image.uri[i] != ',' && asset_image.uri[i] != 0; i += 1) {}
|
|
|
|
if(asset_image.uri[i] == 0)
|
|
{
|
|
Logf("gltf data URI for is not a valid image");
|
|
}
|
|
else
|
|
{
|
|
u64 base_64_size = strlen(asset_image.uri + i + 1);
|
|
for(; asset_image.uri[i + base_64_size] == '='; base_64_size -= 1) {}
|
|
|
|
u64 bit_count = base_64_size*6 - (base_64_size*6) % 8;
|
|
i32 out_size = cast(i32)(bit_count/8);
|
|
|
|
void* data;
|
|
cgltf_options options;
|
|
options.file.read = &GLTFLoadCallback;
|
|
options.file.release = &GLTFFreeCallback;
|
|
|
|
cgltf_result result = cgltf_load_buffer_base64(&options, out_size, asset_image.uri + i + 1, &data);
|
|
if(result == cgltf_result_success)
|
|
{
|
|
image = LoadImage(data, out_size);
|
|
cgltf_free(cast(cgltf_data*)data);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
char[512] buf;
|
|
char[] file_path = buf.sformat("%s%s%s", tex_path, dirSeparator, cast(char*)asset_image.uri);
|
|
u8[] image_file = OpenFile(ConvToStr(file_path));
|
|
|
|
image = LoadImage(image_file.ptr, cast(i32)image_file.length);
|
|
|
|
Free(image_file);
|
|
}
|
|
}
|
|
else if(asset_image.buffer_view != null && asset_image.buffer_view.buffer.data != null)
|
|
{
|
|
u8[] data = Alloc!(u8)(asset_image.buffer_view.size);
|
|
|
|
i32 offset = cast(i32)(asset_image.buffer_view.offset);
|
|
i32 stride = cast(i32)(asset_image.buffer_view.stride ? asset_image.buffer_view.stride : 1);
|
|
|
|
u64 len = asset_image.buffer_view.size - (asset_image.buffer_view.size % stride);
|
|
data[0 .. len] = (cast(u8*)(asset_image.buffer_view.buffer.data))[offset .. offset+len];
|
|
|
|
string mime_type = ConvToStr(asset_image.mime_type[0 .. strlen(asset_image.mime_type)]);
|
|
|
|
const string[] accepted_types = ["image\\/png", "image/png", "image\\/jpeg", "image/jpeg", "image\\/tga", "image/tga", "image\\/bmp", "image/bmp"];
|
|
bool accepted;
|
|
static foreach(type; accepted_types)
|
|
{
|
|
if(type == mime_type)
|
|
{
|
|
accepted = true;
|
|
goto PostTypeCheck;
|
|
}
|
|
}
|
|
|
|
PostTypeCheck:
|
|
u8[] image_data;
|
|
if(accepted)
|
|
{
|
|
image = LoadImage(data.ptr, cast(i32)data.length);
|
|
}
|
|
else
|
|
{
|
|
Logf("Unknown image type [%s], unable to load", mime_type);
|
|
}
|
|
|
|
Free(data);
|
|
}
|
|
}
|
|
|
|
if(image.data == null)
|
|
{
|
|
Logf("Failed to load GLTF image data/file");
|
|
image = DEFAULT_IMAGE;
|
|
}
|
|
|
|
return image;
|
|
}
|
|
|
|
ModelData
|
|
LoadGLTF(Arena* arena, string file_name)
|
|
{
|
|
ModelData m_data;
|
|
Model* model = &m_data.model;
|
|
|
|
u8[] file_data = OpenFile(file_name);
|
|
assert(file_data != null);
|
|
|
|
cgltf_options opts;
|
|
cgltf_data* data;
|
|
|
|
opts.file.read = &GLTFLoadCallback;
|
|
opts.file.release = &GLTFFreeCallback;
|
|
|
|
cgltf_result result = cgltf_parse(&opts, file_data.ptr, file_data.length, &data);
|
|
|
|
if(result == cgltf_result_success)
|
|
{
|
|
result = cgltf_load_buffers(&opts, data, file_name.ptr);
|
|
if(result != cgltf_result_success)
|
|
{
|
|
Logf("%s Failure: Unable to load buffers", __FUNCTION__);
|
|
}
|
|
|
|
u64 primitive_count;
|
|
|
|
for(u64 i = 0; i < data.nodes_count; i += 1)
|
|
{
|
|
cgltf_node* node = &data.nodes[i];
|
|
|
|
if(node.mesh == null) continue;
|
|
|
|
for(u64 j = 0; j < node.mesh.primitives_count; j += 1)
|
|
{
|
|
if(node.mesh.primitives[j].type == cgltf_primitive_type_triangles)
|
|
{
|
|
primitive_count += 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
model.meshes = Alloc!(Mesh)(primitive_count);
|
|
model.mats = Alloc!(Material)(data.materials_count+1);
|
|
m_data.tex = Alloc!(ImageData)(data.textures_count+1);
|
|
|
|
model.mats[0] = DEFAULT_MATERIAL;
|
|
|
|
u32 tex_idx;
|
|
string file_path = GetFilePath(file_name);
|
|
for(u64 i = 0; i < data.materials_count; i += 1)
|
|
{
|
|
u64 mat_idx = i+1;
|
|
|
|
model.mats[mat_idx] = DEFAULT_MATERIAL;
|
|
|
|
if(data.materials[i].has_pbr_metallic_roughness)
|
|
{
|
|
auto pbr_mr = &data.materials[i].pbr_metallic_roughness;
|
|
if(pbr_mr.base_color_texture.texture)
|
|
{
|
|
m_data.tex[tex_idx] = LoadImage(pbr_mr.base_color_texture.texture.image, file_path);
|
|
model.mats[mat_idx].maps[MMI.Albedo].tex_id = tex_idx++;
|
|
}
|
|
|
|
model.mats[mat_idx].maps[MMI.Albedo].col.v = pbr_mr.base_color_factor;
|
|
|
|
if(pbr_mr.metallic_roughness_texture.texture)
|
|
{
|
|
m_data.tex[tex_idx] = LoadImage(pbr_mr.base_color_texture.texture.image, file_path);
|
|
model.mats[mat_idx].maps[MMI.Metallic].tex_id = tex_idx;
|
|
model.mats[mat_idx].maps[MMI.Roughness].tex_id = tex_idx;
|
|
tex_idx += 1;
|
|
|
|
model.mats[mat_idx].maps[MMI.Metallic].value = pbr_mr.metallic_factor;
|
|
model.mats[mat_idx].maps[MMI.Roughness].value = pbr_mr.roughness_factor;
|
|
}
|
|
|
|
if(data.materials[i].normal_texture.texture)
|
|
{
|
|
m_data.tex[tex_idx] = LoadImage(data.materials[i].normal_texture.texture.image, file_path);
|
|
model.mats[mat_idx].maps[MMI.Normal].tex_id = tex_idx++;
|
|
}
|
|
|
|
if(data.materials[i].occlusion_texture.texture)
|
|
{
|
|
m_data.tex[tex_idx] = LoadImage(data.materials[i].occlusion_texture.texture.image, file_path);
|
|
model.mats[mat_idx].maps[MMI.Occlusion].tex_id = tex_idx++;
|
|
}
|
|
|
|
if(data.materials[i].emissive_texture.texture)
|
|
{
|
|
m_data.tex[tex_idx] = LoadImage(data.materials[i].emissive_texture.texture.image, file_path);
|
|
model.mats[mat_idx].maps[MMI.Emission].tex_id = tex_idx++;
|
|
|
|
model.mats[mat_idx].maps[MMI.Emission].col.v[0 .. 3] = data.materials[i].emissive_factor;
|
|
model.mats[mat_idx].maps[MMI.Emission].col.v.a = 1.0;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
}
|
|
|
|
return m_data;
|
|
}
|
|
|
|
|
|
static ImageData
|
|
GenerateDefaultTexture(u32 x, u32 y)
|
|
{
|
|
ImageData data = {
|
|
w: x,
|
|
h: y,
|
|
ch: 4,
|
|
};
|
|
|
|
u64 tex_size = x*y*4;
|
|
u8[] placeholder_tex = new u8[tex_size];
|
|
|
|
u8[4] magenta = [255, 0, 255, 255];
|
|
u8[4] black = [0, 0, 0, 255];
|
|
u64 half = tex_size/2;
|
|
for(u64 i = 0; i < tex_size; i += 32)
|
|
{
|
|
bool swap = i <= half;
|
|
for(u64 j = 0; j < 16; j += 4)
|
|
{
|
|
placeholder_tex[i+j .. i+j+4] = !swap ? magenta[0 .. $] : black[0 .. $];
|
|
placeholder_tex[i+j+16 .. i+j+16+4] = !swap ? black[0 .. $] : magenta[0 .. $];
|
|
}
|
|
}
|
|
|
|
data.data = placeholder_tex;
|
|
|
|
return data;
|
|
}
|
|
|
|
static Material
|
|
GenerateDefaultMaterial()
|
|
{
|
|
Material mat;
|
|
|
|
mat.maps[MMI.Albedo].col = Vec4(1.0);
|
|
mat.maps[MMI.Metallic].col = Vec4(1.0);
|
|
|
|
return mat;
|
|
}
|
|
|