Model loading

Author: Pilzschaf

.gitignore

@@ -31,6 +31,7 @@
 *.out
 *.app
 opengl_tutorial
+tools/modelexporter
 
 # Dolphin
 .directory

main.cpp

@@ -1,5 +1,7 @@
 #include <iostream>
 #include <cmath>
+#include <vector>
+#include <fstream>
 #define GLEW_STATIC
 #include <GL/glew.h>
 #define SDL_MAIN_HANDLED
@@ -77,24 +79,40 @@ int main(int argc, char** argv) {
 	glDebugMessageCallback(openGLDebugCallback, 0);
 	#endif
 
-	Vertex vertices[] = {
-		Vertex{-0.5f, -0.5f, -0.0f,
-		1.0f, 0.0f, 0.0f, 1.0f},
-		Vertex{0.5f, -0.5f, -0.0f,
-		0.0, 1.0f, 0.0f, 1.0f},
-		Vertex{0.0f, 0.5f, -0.0f,
-		0.0f, 0.0f, 1.0f, 1.0f}
-	};
-	uint32 numVertices = 3;
+	std::vector<Vertex> vertices;
+	uint64 numVertices = 0;
+	
+	std::vector<uint32> indices;
+	uint64 numIndices = 0;
 
-	uint32 indices[] = {
-		0, 1, 2
-	};
-	uint32 numIndices = 3;
+	std::ifstream input = std::ifstream("models/monkey.bmf", std::ios::in | std::ios::binary);
+	if(!input.is_open()) {
+		std::cout << "Error reading model file" << std::endl;
+		return 1;
+	}
+	input.read((char*)&numVertices, sizeof(uint64));
+	input.read((char*)&numIndices, sizeof(uint64));
+
+	for(uint64 i = 0; i < numVertices; i++) {
+		Vertex vertex;
+		input.read((char*)&vertex.x, sizeof(float));
+		input.read((char*)&vertex.y, sizeof(float));
+		input.read((char*)&vertex.z, sizeof(float));
+		vertex.r = 1.0f;
+		vertex.g = 1.0f;
+		vertex.b = 1.0f;
+		vertex.a = 1.0f;
+		vertices.push_back(vertex);
+	}
+	for(uint64 i = 0; i < numIndices; i++) {
+		uint32 index;
+		input.read((char*)&index, sizeof(uint32));
+		indices.push_back(index);
+	}
 
-	IndexBuffer indexBuffer(indices, numIndices, sizeof(indices[0]));
+	IndexBuffer indexBuffer(indices.data(), numIndices, sizeof(indices[0]));
 
-	VertexBuffer vertexBuffer(vertices, numVertices);
+	VertexBuffer vertexBuffer(vertices.data(), numVertices);
 	vertexBuffer.unbind();
 
 	Shader shader("shaders/basic.vs", "shaders/basic.fs");

models/cube.bmf

@@ -0,0 +1,95 @@
+#include <iostream>
+#include <vector>
+#include <cassert>
+#include <string>
+#include <fstream>
+#include <assimp/Importer.hpp>
+#include <assimp/scene.h>
+#include <assimp/postprocess.h>
+
+struct Position {
+    float x, y, z;
+};
+
+std::vector<Position> positions;
+std::vector<uint32_t> indices;
+
+void processMesh(aiMesh* mesh, const aiScene* scene) {
+    for(unsigned int i = 0; i < mesh->mNumVertices; i++) {
+        Position vertex;
+        vertex.x = mesh->mVertices[i].x;
+        vertex.y = mesh->mVertices[i].y;
+        vertex.z = mesh->mVertices[i].z;
+        positions.push_back(vertex);
+    }
+
+    for(unsigned int i = 0; i < mesh->mNumFaces; i++) {
+        aiFace face = mesh->mFaces[i];
+        assert(face.mNumIndices == 3);
+        for(unsigned int j = 0; j < face.mNumIndices; j++) {
+            indices.push_back(face.mIndices[j]);
+        }
+    }
+}
+
+void processNode(aiNode* node, const aiScene* scene) {
+
+    for(unsigned int i = 0; i < node->mNumMeshes; i++) {
+        aiMesh* mesh = scene->mMeshes[node->mMeshes[i]];
+        processMesh(mesh, scene);
+    }
+
+    for(unsigned int i = 0; i < node->mNumChildren; i++) {
+        processNode(node->mChildren[i], scene);
+    }
+}
+
+char* getFilename(char* filename) {
+    int len = strlen(filename);
+    char* lastSlash = filename;
+    for(int i = 0; i < len; i++) {
+        if(filename[i] == '/' || filename[i] == '\\') {
+            lastSlash = filename+i+1;
+        }
+    }
+    return lastSlash;
+}
+
+int main(int argc, char** argv) {
+    if(argc <= 0) {
+        return 1;
+    }
+    if(argc < 2) {
+        std::cout << "Usage: " << argv[0] << " <modelfilename>" << std::endl;
+        return 1;
+    }
+
+    Assimp::Importer importer;
+    const aiScene* scene = importer.ReadFile(argv[argc-1], aiProcess_Triangulate | aiProcess_OptimizeMeshes | aiProcess_OptimizeGraph | aiProcess_JoinIdenticalVertices | aiProcess_ImproveCacheLocality);
+    if(!scene || scene->mFlags & AI_SCENE_FLAGS_INCOMPLETE, !scene->mRootNode) {
+        std::cout << "Error while loading model with assimp: " << importer.GetErrorString() << std::endl;
+        return 1;
+    }
+
+    processNode(scene->mRootNode, scene);
+
+    std::string filename = std::string(getFilename(argv[argc-1]));
+    std::string filenameWithoutExtension = filename.substr(0, filename.find_last_of('.'));
+    std::string outputFilename = filenameWithoutExtension + ".bmf";
+
+    std::ofstream output(outputFilename, std::ios::out | std::ios::binary);
+    std::cout << "Writing bmf file..." << std::endl;
+    uint64_t numVertices = positions.size();
+    uint64_t numIndices = indices.size();
+    output.write((char*)&numVertices, sizeof(uint64_t));
+    output.write((char*)&numIndices, sizeof(uint64_t));
+    for(uint64_t i = 0; i < numVertices; i++) {
+        output.write((char*)&positions[i].x, sizeof(float));
+        output.write((char*)&positions[i].y, sizeof(float));
+        output.write((char*)&positions[i].z, sizeof(float));
+    }
+    for(uint64_t i = 0; i < numIndices; i++) {
+        output.write((char*)&indices[i], sizeof(uint32_t));
+    }
+    output.close();
+}