Implement .a3d model loader (amalgine specific format)

1 files changed, 230 insertions, 0 deletions

diff --git a/src/ModelLoader.cpp b/src/ModelLoader.cpp
new file mode 100644
index 0000000..60626f1
--- /dev/null
+++ b/src/ModelLoader.cpp
@@ -0,0 +1,230 @@
+#include "../include/ModelLoader.hpp"
+#include "../include/File.hpp"
+#include "../include/Image.hpp"
+#include <stdlib.h>
+#include <string.h>
+#include <stdio.h>
+#include <assert.h>
+#include <libgen.h>
+#include <string>
+
+namespace amalgine {
+    class ModelLoaderInternal {
+    public:
+        ModelLoaderInternal(const char *data, size_t size) : data(data), size(size), offset(0) {}
+
+        template <typename T>
+        bool extract(T *result) {
+            if(size - offset >= sizeof(T)) {
+                // This is fine, because all data in .a3d files are aligned correctly.
+                // However this could be incorrect if the file is not an .a3d file, in which case this would crash on ARM processors for example..
+                // TODO: Use memcpy on ARM (and other platforms that dont support unaligned memory access)
+                *result = *(T*)(data + offset);
+                offset += sizeof(T);
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        template <typename T>
+        bool extract_list(T *result, size_t num_items) {
+            const size_t bytes_to_extract = sizeof(T) * num_items;
+            if(size - offset >= bytes_to_extract) {
+                memcpy(result, data + offset, bytes_to_extract);
+                offset += bytes_to_extract;
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        std::string extract_null_terminated_string() {
+            std::string result;
+            const char *p = data + offset;
+            while(true) {
+                char c = *p++;
+                if(c == '\0')
+                    break;
+                else
+                    result += c;
+            }
+            offset += p - (data + offset);
+            return result;
+        }
+
+        bool skip(size_t num_bytes) {
+            if(size - offset >= num_bytes) {
+                offset += num_bytes;
+                return true;
+            } else {
+                return false;
+            }
+        }
+
+        bool empty() const { return offset == size; }
+    private:
+        const char *data;
+        const size_t size;
+        size_t offset;
+    };
+
+    struct Face {
+        unsigned int index[3];
+    };
+
+    // TODO: Check bounds of indices and size of data before allocating
+    static bool model_loader_version_1(ModelLoaderInternal &model_loader, std::vector<Triangle3D> &triangles, std::vector<vec2f> &texture_coords, Image **image, const std::string &dir_path) {
+        // TODO: Remove these temporary variables when amalgine has been modified to use indices instead of
+        // data directly in shaders
+        std::vector<Triangle3D> temp_vertices;
+        std::vector<vec2f> temp_texcoords;
+        std::vector<Face> indices;
+        while(!model_loader.empty()) {
+            // TODO: Verify num_vertices isn't too large?
+            unsigned int num_vertices;
+            if(!model_loader.extract<unsigned int>(&num_vertices) || num_vertices == 0) {
+                fprintf(stderr, "Error: failed to extract num_vertices\n");
+                return false;
+            }
+            
+            unsigned int num_triangles = num_vertices / 3;
+            temp_vertices.resize(num_triangles);
+            if(!model_loader.extract_list(&temp_vertices[0], num_triangles)) {
+                fprintf(stderr, "Error: failed to extract vertices\n");
+                return false;
+            }
+
+            if(!model_loader.skip(num_vertices * sizeof(vec3f))) {
+                fprintf(stderr, "Error: failed to extract normals\n");
+                return false;
+            }
+
+            unsigned int has_texcoords;
+            if(!model_loader.extract<unsigned int>(&has_texcoords) || has_texcoords > 1) {
+                fprintf(stderr, "Error: failed to extract has_texcoords\n");
+                return false;
+            }
+            
+            if(has_texcoords) {
+                temp_texcoords.resize(num_vertices);
+                if(!model_loader.extract_list(&temp_texcoords[0], num_vertices)) {
+                    fprintf(stderr, "Error: failed to extract texture coordinates\n");
+                    return false;
+                }
+            }
+            
+            unsigned int num_faces;
+            if(!model_loader.extract<unsigned int>(&num_faces)) {
+                fprintf(stderr, "Error: failed to extract num_faces\n");
+                return false;
+            }
+            
+            indices.resize(num_faces);
+            if(!model_loader.extract_list(&indices[0], num_faces)) {
+                fprintf(stderr, "Error: failed to extract face indices\n");
+                return false;
+            }
+
+            unsigned int triangles_offset = triangles.size();
+            triangles.resize(triangles.size() + indices.size());
+            const Vertex3D *temp_vertices_begin = &temp_vertices[0].p1;
+            unsigned int max_vertex_index = (unsigned int)(temp_vertices.size() - 1) * 3;
+            for(unsigned int i = 0; i < indices.size(); ++i) {
+                triangles[triangles_offset + i].p1 = temp_vertices_begin[std::min(indices[i].index[0], max_vertex_index)];
+                triangles[triangles_offset + i].p2 = temp_vertices_begin[std::min(indices[i].index[1], max_vertex_index)];
+                triangles[triangles_offset + i].p3 = temp_vertices_begin[std::min(indices[i].index[2], max_vertex_index)];
+            }
+
+            unsigned int texcoords_offset = texture_coords.size();
+            texture_coords.resize(texture_coords.size() + indices.size() * 3);
+            if(has_texcoords) {
+                unsigned int max_texcoord_index = (unsigned int)temp_texcoords.size() - 1;
+                for(unsigned int i = 0; i < indices.size(); ++i) {
+                    texture_coords[texcoords_offset + 0] = temp_texcoords[std::min(indices[i].index[0], max_texcoord_index)];
+                    texture_coords[texcoords_offset + 1] = temp_texcoords[std::min(indices[i].index[1], max_texcoord_index)];
+                    texture_coords[texcoords_offset + 2] = temp_texcoords[std::min(indices[i].index[2], max_texcoord_index)];
+                    texcoords_offset += 3;
+                }
+            } else {
+                for(unsigned int i = 0; i < indices.size(); ++i) {
+                    // TODO: is this needed even with the resize above? or use memset?
+                    texture_coords[texcoords_offset + i + 0] = { 0.0f, 0.0f };
+                    texture_coords[texcoords_offset + i + 1] = { 0.0f, 0.0f };
+                    texture_coords[texcoords_offset + i + 2] = { 0.0f, 0.0f };
+                }
+            }
+
+            unsigned int has_materials;
+            if(!model_loader.extract<unsigned int>(&has_materials) || has_materials > 1) {
+                fprintf(stderr, "Error: failed to extract has_materials\n");
+                return false;
+            }
+            
+            if(has_materials) {
+                for(unsigned int i = 0; i < 3; ++i) {
+                    unsigned int num_textures;
+                    if(!model_loader.extract<unsigned int>(&num_textures)) {
+                        fprintf(stderr, "Error: failed to extract num_textures\n");
+                        return false;
+                    }
+                    
+                    for(unsigned int j = 0; j < num_textures; ++j) {
+                        std::string texture_name = model_loader.extract_null_terminated_string();
+                        fprintf(stderr, "texture name: %s\n", texture_name.c_str());
+                        std::string texture_path = dir_path + "/" + texture_name;
+                        assert(!*image); // TODO: Support multiple images
+                        Result<Image*> image_result = Image::loadFromFile(texture_path.c_str());
+                        if(!image_result) {
+                            fprintf(stderr, "%s\n", image_result.getErrorMsg().c_str());
+                            return false;
+                        }
+                        *image = image_result.unwrap();
+                    }
+                }
+            }
+        }
+        return true;
+    }
+
+    // TODO: Instead of reading all file data to a buffer and then copying it, maybe read from file
+    // directly into data structures?
+    bool ModelLoader::load_from_file(const char *filepath, std::vector<Triangle3D> &triangles, std::vector<vec2f> &texture_coords, Image **image) {
+        triangles.clear();
+        texture_coords.clear();
+        *image = nullptr;
+        bool result = true;
+
+        size_t file_size;
+        char *file_data = file_get_content(filepath, &file_size);
+        if(!file_data)
+            return false;
+
+        std::string dir_path = filepath;
+        dirname(&dir_path[0]);
+        const int dir_path_size = strlen(dir_path.c_str());
+        dir_path.resize(dir_path_size);
+
+        ModelLoaderInternal model_loader(file_data, file_size);
+
+        unsigned int magic_number;
+        unsigned int version = 0;
+
+        if(!model_loader.extract<unsigned int>(&magic_number) || magic_number != 0x036144AF) {
+            fprintf(stderr, "Error: file %s is not an .a3d file (magic number not found)\n", filepath);
+            result = false;
+            goto cleanup;
+        }
+        
+        if(model_loader.extract<unsigned int>(&version) && version == 1) {
+            result = model_loader_version_1(model_loader, triangles, texture_coords, image, dir_path);
+        } else {
+            fprintf(stderr, "Error: version not supported: %u\n", version);
+            result = false;
+        }
+
+        cleanup:
+        free(file_data);
+        return result;
+    }
+}
\ No newline at end of file