5 #include <gmath/gmath.h>
6 #include <assimp/cimport.h>
7 #include <assimp/postprocess.h>
8 #include <assimp/scene.h>
9 #include <assimp/mesh.h>
10 #include <assimp/material.h>
11 #include <assimp/anim.h>
12 #include <assimp/vector3.h>
13 #include <assimp/matrix4x4.h>
14 #include <assimp/quaternion.h>
20 static bool load_material(Scene *scn, Material *mat, const aiMaterial *aimat);
21 static SceneNode *load_node(Scene *scn, const aiScene *aiscn, unsigned int flags, const aiNode *ainode);
22 static Mesh *load_mesh(Scene *scn, const aiScene *aiscn, unsigned int flags, const aiMesh *aimesh);
23 /*static const char *mprop_semantic(int x);
24 static int count_textures(const aiMaterial *aimat);*/
25 static int assimp_textype(aiTextureType type);
26 static const char *assimp_textypestr(aiTextureType type);
28 static Mat4 assimp_matrix(const aiMatrix4x4 &aim);
30 /*static Vec3 assimp_vector(const aiVector3D &v);
31 static Quat assimp_quat(const aiQuaternion &q);
32 static long assimp_time(const aiAnimation *anim, double aitime);
33 static void print_hierarchy(const aiNode *node);
38 std::map<std::string, SceneNode*> node_by_name;
39 std::map<aiMesh*, Mesh*> mesh_by_aimesh;
42 #define LD_STAGE_MASK 0xf000
44 bool Scene::load(const char *fname, unsigned int flags)
46 if((flags & LD_STAGE_MASK) == 0) {
47 // not passing either of the stage specifiers, means do the whole job
48 flags |= LD_STAGE_MASK;
51 // first perform I/O and all operations not requiring access to an OpenGL context
52 if(flags & SCNLOAD_STAGE_IO) {
53 unsigned int ppflags = aiProcess_CalcTangentSpace |
54 aiProcess_GenNormals |
55 aiProcess_JoinIdenticalVertices |
56 aiProcess_Triangulate |
57 aiProcess_SortByPType |
58 aiProcess_GenUVCoords |
59 //aiProcess_PreTransformVertices |
60 aiProcess_TransformUVCoords;
62 if(flags & SCNLOAD_FLIPTEX) {
63 ppflags |= aiProcess_FlipUVs;
66 info_log("Loading scene file: %s\n", fname);
68 const aiScene *aiscn = aiImportFile(fname, ppflags);
70 error_log("failed to load scene file: %s\n", fname);
74 // assimp adds its own root node, which might have transformations
75 Vec3 root_pos, root_scaling(1.0, 1.0, 1.0);
78 if(aiscn->mRootNode) {
79 Mat4 root_matrix = assimp_matrix(aiscn->mRootNode->mTransformation);
80 root_pos = root_matrix.get_translation();
81 root_rot = root_matrix.get_rotation();
82 root_scaling = root_matrix.get_scaling();
86 nodes = new SceneNode;
88 nodes->set_name("root");
89 nodes->set_position(root_pos);
90 nodes->set_rotation(root_rot);
91 nodes->set_scaling(root_scaling);
94 LoaderData *ldata = new LoaderData;
96 loader_data = (void*)ldata;
99 /* then, assuming we have successfully loaded everything, proceed to construct
100 * all the engine objects, which require access to the OpenGL context
102 if(flags & SCNLOAD_STAGE_GL) {
104 error_log("second stage scene loader failed to find valid I/O data\n");
108 LoaderData *ldata = (LoaderData*)loader_data;
109 const aiScene *aiscn = ldata->aiscn;
112 for(unsigned int i=0; i<aiscn->mNumMeshes; i++) {
113 aiMesh *aimesh = aiscn->mMeshes[i];
116 switch(aimesh->mPrimitiveTypes) {
117 case aiPrimitiveType_TRIANGLE:
118 if((mesh = load_mesh(this, aiscn, flags, aimesh))) {
119 ldata->mesh_by_aimesh[aimesh] = mesh;
120 meshes.push_back(mesh);
125 error_log("unsupported primitive type: %u\n", aimesh->mPrimitiveTypes);
130 // load all the nodes recursively
131 for(unsigned int i=0; i<aiscn->mRootNode->mNumChildren; i++) {
132 SceneNode *node = load_node(this, aiscn, flags, aiscn->mRootNode->mChildren[i]);
134 nodes->add_child(node);
138 aiReleaseImport(aiscn);
141 info_log("loaded scene file: %s, %d meshes\n", fname, (int)meshes.size());
147 static bool load_material(Scene *scn, Material *mat, const aiMaterial *aimat)
151 float shin, shin_str;
153 if(aiGetMaterialString(aimat, AI_MATKEY_NAME, &name) == 0) {
154 mat->name = name.data;
156 mat->name = "unknown";
158 //info_log("load_material: %s\n", mat->name.c_str());
160 if(aiGetMaterialColor(aimat, AI_MATKEY_COLOR_DIFFUSE, &aicol) == 0) {
161 mat->diffuse = Vec3(aicol[0], aicol[1], aicol[2]);
163 if(aiGetMaterialColor(aimat, AI_MATKEY_COLOR_SPECULAR, &aicol) == 0) {
164 mat->specular = Vec3(aicol[0], aicol[1], aicol[2]);
167 unsigned int count = 1;
168 if(aiGetMaterialFloatArray(aimat, AI_MATKEY_SHININESS_STRENGTH, &shin_str, &count) != 0) {
171 if(aiGetMaterialFloatArray(aimat, AI_MATKEY_SHININESS, &shin, &count) == 0) {
172 // XXX can't remember how I came up with this...
173 mat->shininess = shin * shin_str * 0.0001 * 128.0;
178 const int num_tex_types = aiTextureType_UNKNOWN + 1;
179 for(int i=0; i<num_tex_types; i++) {
180 aiTextureType aitype = (aiTextureType)i;
181 int count = aiGetMaterialTextureCount(aimat, aitype);
183 for(int j=0; j<count; j++) {
185 if(aiGetMaterialTexture(aimat, aitype, j, &aipath) != 0) {
189 char *fname = (char*)alloca(strlen(aipath.data) + 1);
191 char *sptr = aipath.data;
193 *dptr++ = *sptr == '\\' ? '/' : *sptr;
196 int textype = assimp_textype(aitype);
197 info_log("loading %s texture: %s\n", assimp_textypestr(aitype), fname);
199 Texture *tex = scn->texset->get_texture(fname, TEX_2D);
201 mat->textures.push_back(tex);
203 if(textype != MTL_TEX_UNKNOWN && !mat->stdtex[textype]) {
204 mat->stdtex[textype] = tex;
212 static SceneNode *load_node(Scene *scn, const aiScene *aiscn, unsigned int flags, const aiNode *ainode)
214 LoaderData *ldata = (LoaderData*)scn->loader_data;
216 SceneNode *node = new SceneNode;
217 node->set_name(ainode->mName.data);
220 Mat4 matrix = assimp_matrix(ainode->mTransformation);
221 Vec3 pos = matrix.get_translation();
222 Quat rot = matrix.get_rotation();
223 Vec3 scale = matrix.get_scaling();
225 node->set_position(pos);
226 node->set_rotation(rot);
227 node->set_scaling(scale);
228 node->dbg_xform = matrix;
231 for(unsigned int i=0; i<ainode->mNumMeshes; i++) {
232 aiMesh *aimesh = aiscn->mMeshes[ainode->mMeshes[i]];
234 Mesh *mesh = ldata->mesh_by_aimesh[aimesh];
236 ObjMesh *obj = new ObjMesh;
237 obj->set_name(mesh->get_name());
239 // also grab the material of this mesh
240 load_material(scn, &obj->mtl, aiscn->mMaterials[aimesh->mMaterialIndex]);
242 node->add_object(obj);
243 scn->objects.push_back(obj);
247 /* recurse to all children */
248 for(unsigned int i=0; i<ainode->mNumChildren; i++) {
249 SceneNode *child = load_node(scn, aiscn, flags, ainode->mChildren[i]);
251 node->add_child(child);
255 ldata->node_by_name[node->get_name()] = node;
259 static Mesh *load_mesh(Scene *scn, const aiScene *aiscn, unsigned int flags, const aiMesh *aimesh)
261 Mesh *mesh = new Mesh;
262 mesh->set_name(aimesh->mName.data);
264 int num_verts = aimesh->mNumVertices;
265 int num_faces = aimesh->mNumFaces;
267 mesh->set_attrib_data(MESH_ATTR_VERTEX, 3, num_verts, (float*)aimesh->mVertices);
269 if(aimesh->mNormals) {
270 mesh->set_attrib_data(MESH_ATTR_NORMAL, 3, num_verts, (float*)aimesh->mNormals);
272 if(aimesh->mTangents) {
273 mesh->set_attrib_data(MESH_ATTR_TANGENT, 3, num_verts, (float*)aimesh->mTangents);
275 if(aimesh->mTextureCoords[0]) {
276 mesh->set_attrib_data(MESH_ATTR_TEXCOORD, 3, num_verts, (float*)aimesh->mTextureCoords[0]);
278 if(aimesh->mTextureCoords[1]) {
279 mesh->set_attrib_data(MESH_ATTR_TEXCOORD2, 3, num_verts, (float*)aimesh->mTextureCoords[1]);
282 if(flags & SCNLOAD_FLIPYZ) {
283 Vec3 *vptr = (Vec3*)mesh->get_attrib_data(MESH_ATTR_VERTEX);
284 for(int i=0; i<num_verts; i++) {
289 Vec3 *nptr = (Vec3*)mesh->get_attrib_data(MESH_ATTR_NORMAL);
290 for(int i=0; i<num_verts; i++) {
295 Vec3 *tptr = (Vec3*)mesh->get_attrib_data(MESH_ATTR_TANGENT);
296 for(int i=0; i<num_verts; i++) {
302 unsigned int *iptr = mesh->set_index_data(num_faces * 3);
303 for(int i=0; i<num_faces; i++) {
304 iptr[0] = aimesh->mFaces[i].mIndices[0];
305 iptr[1] = aimesh->mFaces[i].mIndices[flags & SCNLOAD_FLIPYZ ? 2 : 1];
306 iptr[2] = aimesh->mFaces[i].mIndices[flags & SCNLOAD_FLIPYZ ? 1 : 2];
312 static int assimp_textype(aiTextureType type)
315 case aiTextureType_DIFFUSE:
316 return MTL_TEX_DIFFUSE;
317 case aiTextureType_SPECULAR:
318 return MTL_TEX_SPECULAR;
319 case aiTextureType_NORMALS:
320 return MTL_TEX_NORMALMAP;
321 case aiTextureType_LIGHTMAP:
322 case aiTextureType_EMISSIVE:
323 return MTL_TEX_LIGHTMAP;
324 case aiTextureType_REFLECTION:
325 return MTL_TEX_ENVMAP;
329 return MTL_TEX_UNKNOWN;
332 static const char *assimp_textypestr(aiTextureType type)
335 case aiTextureType_DIFFUSE:
337 case aiTextureType_SPECULAR:
339 case aiTextureType_NORMALS:
341 case aiTextureType_LIGHTMAP:
342 case aiTextureType_EMISSIVE:
344 case aiTextureType_REFLECTION:
352 static Mat4 assimp_matrix(const aiMatrix4x4 &aim)
355 memcpy(m[0], &aim, 16 * sizeof(float));