cinnaboot
/
libTangerine
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

reorganize asset.cpp

render_group_fix
cinnaboot 5 years ago
parent
4019d1cded
commit
baf65e6dab
1 changed files with 145 additions and 126 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 271
      src/asset.cpp

271
src/asset.cpp
Unescape View File

@ -8,54 +8,20 @@
#include "asset.h" #include "asset.h"
#include "dumbLog.h" #include "dumbLog.h"
const char*
getTargetStr(int target)
{
switch (target) {
case 34962: return "GL_ARRAY_BUFFER";
case 34963: return "GL_ELEMENT_ARRAY_BUFFER";
default: return "UNKNOWN";
}
}
const char* // forward declarations
getElementType(int type) void dumpNodes(tinygltf::Model t_mdl);
{ model* initModel(model_assets* assets,
switch (type) { memory_arena* arena,
case 2: return "TINYGLTF_TYPE_VEC2"; tinygltf::Model t_mdl,
case 3: return "TINYGLTF_TYPE_VEC3"; const char* filename);
case 4: return "TINYGLTF_TYPE_VEC4"; bool parseMeshNode(mesh& m,
case 65: return "TINYGLTF_TYPE_SCALAR"; memory_arena* arena,
default: return "UNKNOWN"; const tinygltf::Node& node,
} const tinygltf::Model& t_mdl);
}
const char*
getComponentType(int componentType)
{
switch (componentType) {
case 5123: return "TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT";
case 5124: return "TINYGLTF_COMPONENT_TYPE_INT";
case 5125: return "TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT";
case 5126: return "TINYGLTF_COMPONENT_TYPE_FLOAT";
case 5130: return "TINYGLTF_COMPONENT_TYPE_DOUBLE";
default: return "UNKOWN"; }
}
const char* // interface
getDrawMode(int drawMode)
{
switch (drawMode) {
case 0: return "TINYGLTF_MODE_POINTS";
case 1: return "TINYGLTF_MODE_LINE";
case 2: return "TINYGLTF_MODE_LINE_LOOP";
case 3: return "TINYGLTF_MODE_LINE_STRIP";
case 4: return "TINYGLTF_MODE_TRIANGLES";
case 5: return "TINYGLTF_MODE_TRIANGLE_STRIP";
case 6: return "TINYGLTF_MODE_TRIANGLE_FAN";
default: return "UNKOWN MODE";
}
}
model_assets* model_assets*
assetInitBlock(memory_arena* arena, uint asset_count) assetInitBlock(memory_arena* arena, uint asset_count)
@ -69,26 +35,60 @@ assetInitBlock(memory_arena* arena, uint asset_count)
return assets; return assets;
} }
void model*
dumpBuffer(tinygltf::Model model, tinygltf::Accessor acc) assetLoadFromFile(model_assets* assets,
memory_arena* arena,
const char* filename)
{ {
size_t bv_idx = acc.bufferView; tinygltf::Model t_mdl;
assert(bv_idx >= 0 && bv_idx < model.bufferViews.size()); tinygltf::TinyGLTF gltf_ctx;
tinygltf::BufferView bv = model.bufferViews[bv_idx]; std::string err;
std::string warn;
LOG(Debug) << "-----------------------\n"; LOG(Info) << "Loading model: " << filename << "\n";
LOG(Debug) << "buf idx: " << bv_idx << "\n";
LOG(Debug) << "buf target: " << getTargetStr(bv.target) << "\n"; if (!gltf_ctx.LoadASCIIFromFile(&t_mdl, &err, &warn, filename)) {
LOG(Debug) << "buf len: " << bv.byteLength << "\n"; LOG(Error) << "Error loading file: " << filename
LOG(Debug) << "buf offset: " << bv.byteOffset << "\n"; << " , msg: " << err << "\n";
LOG(Debug) << "buf stride: " << bv.byteStride << "\n"; return nullptr;
LOG(Debug) << "acc component type: " }
<< getComponentType(acc.componentType) << "\n";
LOG(Debug) << "acc element type: " // NOTE: assume we're working with a single buffer
<< getElementType(acc.type) << "\n"; assert(t_mdl.buffers.size() == 1);
model* mdl = initModel(assets, arena, t_mdl, filename);
// FIXME: also need to dump textures/materials
#if 0
dumpNodes(t_mdl);
#endif
uint mesh_idx = 0;
for (tinygltf::Node node : t_mdl.nodes) {
if (node.mesh >= 0) {
if (!parseMeshNode(mdl->meshes[mesh_idx++], arena, node, t_mdl)) {
LOG(Error) << "Error parsing node\n";
return nullptr;
}
}
}
return mdl;
}
model*
assetGetCached(model_assets* assets, uint64_t path_hash)
{
for (uint i = 0; i < assets->count; i++) {
if (assets->models[i].filepath_hash == path_hash)
return &assets->models[i];
}
LOG(Debug) << "asset not cached: " << path_hash << "\n";
return nullptr;
} }
// internal
model* model*
initModel(model_assets* assets, initModel(model_assets* assets,
memory_arena* arena, memory_arena* arena,
@ -112,35 +112,6 @@ initModel(model_assets* assets,
return mdl; return mdl;
} }
void
dumpNodes(tinygltf::Model t_mdl)
{
for (tinygltf::Node node : t_mdl.nodes) {
LOG(Debug) << "##################\n";
LOG(Debug) << "node name: " << node.name << "\n";
LOG(Debug) << "node mesh idx: " << node.mesh << "\n";
if (node.mesh >= 0) {
tinygltf::Mesh t_mesh = t_mdl.meshes[node.mesh];
LOG(Debug) << "node mesh name: " << t_mesh.name << "\n";
// NOTE: assume only 1 primitive object per mesh
assert(t_mdl.meshes[node.mesh].primitives.size() == 1);
tinygltf::Primitive prim = t_mesh.primitives[0];
LOG(Debug) << "node draw mode: " << getDrawMode(prim.mode) << "\n";
for (auto& att : prim.attributes) {
LOG(Debug) << "dumping buffer: " << att.first << "\n";
dumpBuffer(t_mdl, t_mdl.accessors[att.second]);
}
LOG(Debug) << "dumping index buffer\n";
dumpBuffer(t_mdl, t_mdl.accessors[prim.indices]);
} else {
LOG(Debug) << "Not a mesh node\n";
}
}
}
bool bool
copyBuffer(uint8_t*& buffer_ref, copyBuffer(uint8_t*& buffer_ref,
memory_arena* arena, memory_arena* arena,
@ -170,6 +141,7 @@ copyBuffer(uint8_t*& buffer_ref,
return buffer_ref != nullptr; return buffer_ref != nullptr;
} }
// FIXME: need to implement tree structure for blender models to work properly
glm::mat4* glm::mat4*
parseNodeTransform(memory_arena* arena, const tinygltf::Node* node) parseNodeTransform(memory_arena* arena, const tinygltf::Node* node)
{ {
@ -251,54 +223,101 @@ parseMeshNode(mesh& m,
return false; return false;
} }
model* const char*
assetLoadFromFile(model_assets* assets, getTargetStr(int target)
memory_arena* arena,
const char* filename)
{ {
tinygltf::Model t_mdl; switch (target) {
tinygltf::TinyGLTF gltf_ctx; case 34962: return "GL_ARRAY_BUFFER";
std::string err; case 34963: return "GL_ELEMENT_ARRAY_BUFFER";
std::string warn; default: return "UNKNOWN";
}
}
LOG(Info) << "Loading model: " << filename << "\n"; const char*
getElementType(int type)
{
switch (type) {
case 2: return "TINYGLTF_TYPE_VEC2";
case 3: return "TINYGLTF_TYPE_VEC3";
case 4: return "TINYGLTF_TYPE_VEC4";
case 65: return "TINYGLTF_TYPE_SCALAR";
default: return "UNKNOWN";
}
}
if (!gltf_ctx.LoadASCIIFromFile(&t_mdl, &err, &warn, filename)) { const char*
LOG(Error) << "Error loading file: " << filename getComponentType(int componentType)
<< " , msg: " << err << "\n"; {
return nullptr; switch (componentType) {
case 5123: return "TINYGLTF_COMPONENT_TYPE_UNSIGNED_SHORT";
case 5124: return "TINYGLTF_COMPONENT_TYPE_INT";
case 5125: return "TINYGLTF_COMPONENT_TYPE_UNSIGNED_INT";
case 5126: return "TINYGLTF_COMPONENT_TYPE_FLOAT";
case 5130: return "TINYGLTF_COMPONENT_TYPE_DOUBLE";
default: return "UNKOWN"; }
}
const char*
getDrawMode(int drawMode)
{
switch (drawMode) {
case 0: return "TINYGLTF_MODE_POINTS";
case 1: return "TINYGLTF_MODE_LINE";
case 2: return "TINYGLTF_MODE_LINE_LOOP";
case 3: return "TINYGLTF_MODE_LINE_STRIP";
case 4: return "TINYGLTF_MODE_TRIANGLES";
case 5: return "TINYGLTF_MODE_TRIANGLE_STRIP";
case 6: return "TINYGLTF_MODE_TRIANGLE_FAN";
default: return "UNKOWN MODE";
} }
}
// NOTE: assume we're working with a single buffer void
assert(t_mdl.buffers.size() == 1); dumpBuffer(tinygltf::Model model, tinygltf::Accessor acc)
model* mdl = initModel(assets, arena, t_mdl, filename); {
// FIXME: also need to get each node xform size_t bv_idx = acc.bufferView;
// FIXME: also need to dump textures/materials assert(bv_idx >= 0 && bv_idx < model.bufferViews.size());
//dumpNodes(t_mdl); tinygltf::BufferView bv = model.bufferViews[bv_idx];
uint mesh_idx = 0; LOG(Debug) << "-----------------------\n";
LOG(Debug) << "buf idx: " << bv_idx << "\n";
LOG(Debug) << "buf target: " << getTargetStr(bv.target) << "\n";
LOG(Debug) << "buf len: " << bv.byteLength << "\n";
LOG(Debug) << "buf offset: " << bv.byteOffset << "\n";
LOG(Debug) << "buf stride: " << bv.byteStride << "\n";
LOG(Debug) << "acc component type: "
<< getComponentType(acc.componentType) << "\n";
LOG(Debug) << "acc element type: "
<< getElementType(acc.type) << "\n";
}
void
dumpNodes(tinygltf::Model t_mdl)
{
for (tinygltf::Node node : t_mdl.nodes) { for (tinygltf::Node node : t_mdl.nodes) {
LOG(Debug) << "##################\n";
LOG(Debug) << "node name: " << node.name << "\n";
LOG(Debug) << "node mesh idx: " << node.mesh << "\n";
if (node.mesh >= 0) { if (node.mesh >= 0) {
if (!parseMeshNode(mdl->meshes[mesh_idx++], arena, node, t_mdl)) { tinygltf::Mesh t_mesh = t_mdl.meshes[node.mesh];
LOG(Error) << "Error parsing node\n"; LOG(Debug) << "node mesh name: " << t_mesh.name << "\n";
return nullptr; // NOTE: assume only 1 primitive object per mesh
assert(t_mdl.meshes[node.mesh].primitives.size() == 1);
tinygltf::Primitive prim = t_mesh.primitives[0];
LOG(Debug) << "node draw mode: " << getDrawMode(prim.mode) << "\n";
for (auto& att : prim.attributes) {
LOG(Debug) << "dumping buffer: " << att.first << "\n";
dumpBuffer(t_mdl, t_mdl.accessors[att.second]);
} }
LOG(Debug) << "dumping index buffer\n";
dumpBuffer(t_mdl, t_mdl.accessors[prim.indices]);
} else {
LOG(Debug) << "Not a mesh node\n";
} }
} }
return mdl;
} }
// FIXME: reorganize asset.cpp, put interface at the top
model*
assetGetCached(model_assets* assets, uint64_t path_hash)
{
for (uint i = 0; i < assets->count; i++) {
if (assets->models[i].filepath_hash == path_hash)
return &assets->models[i];
}
LOG(Debug) << "asset not cached: " << path_hash << "\n";
return nullptr;
}

Write Preview
Loading…
Cancel
Save