aboutsummaryrefslogtreecommitdiff
path: root/src/ModelLoader.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/ModelLoader.cpp')
-rw-r--r--src/ModelLoader.cpp230
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