示例#1
0
// ------------------------------------------------------------------------------
// Application entry point
int main (int argc, char* argv[])
{
	if (argc <= 1)	{
		printf("assimp: No command specified. Use \'assimp help\' for a detailed command list\n");
		return 0;
	}

	// assimp version
	// Display version information
	if (! strcmp(argv[1], "version")) {
		const unsigned int flags = aiGetCompileFlags();
		printf(AICMD_MSG_ABOUT,
			aiGetVersionMajor(),
			aiGetVersionMinor(),
			(flags & ASSIMP_CFLAGS_DEBUG ?			"-debug "   : ""),
			(flags & ASSIMP_CFLAGS_NOBOOST ?		"-noboost " : ""),
			(flags & ASSIMP_CFLAGS_SHARED ?			"-shared "  : ""),
			(flags & ASSIMP_CFLAGS_SINGLETHREADED ? "-st "      : ""),
			(flags & ASSIMP_CFLAGS_STLPORT ?		"-stlport " : ""),
			aiGetVersionRevision());

		return 0;
	}

	// assimp help
	// Display some basic help (--help and -h work as well 
	// because people could try them intuitively)
	if (!strcmp(argv[1], "help") || !strcmp(argv[1], "--help") || !strcmp(argv[1], "-h")) {
		printf("%s",AICMD_MSG_HELP);
		return 0;
	}

	// assimp cmpdump
	// Compare two mini model dumps (regression suite) 
	if (! strcmp(argv[1], "cmpdump")) {
		return Assimp_CompareDump (&argv[2],argc-2);
	}

	// construct global importer and exporter instances
	Assimp::Importer imp;
	imp.SetPropertyBool("GLOB_MEASURE_TIME",true);
	globalImporter = &imp;

#ifndef ASSIMP_BUILD_NO_EXPORT
	// 
	Assimp::Exporter exp;
	globalExporter = &exp;
#endif

	// assimp listext
	// List all file extensions supported by Assimp
	if (! strcmp(argv[1], "listext")) {
		aiString s;
		imp.GetExtensionList(s);

		printf("%s\n",s.data);
		return 0;
	}

#ifndef ASSIMP_BUILD_NO_EXPORT
	// assimp listexport
	// List all export file formats supported by Assimp (not the file extensions, just the format identifiers!)
	if (! strcmp(argv[1], "listexport")) {
		aiString s;
		
		for(size_t i = 0, end = exp.GetExportFormatCount(); i < end; ++i) {
			const aiExportFormatDesc* const e = exp.GetExportFormatDescription(i);
			s.Append( e->id );
			if (i!=end-1) {
				s.Append("\n");
			}
		}

		printf("%s\n",s.data);
		return 0;
	}


	// assimp exportinfo
	// stat an export format
	if (! strcmp(argv[1], "exportinfo")) {
		aiString s;

		if (argc<3) {
			printf("Expected file format id\n");
			return -11;
		}

		for(size_t i = 0, end = exp.GetExportFormatCount(); i < end; ++i) {
			const aiExportFormatDesc* const e = exp.GetExportFormatDescription(i);
			if (!strcmp(e->id,argv[2])) {
				printf("%s\n%s\n%s\n",e->id,e->fileExtension,e->description);
				return 0;
			}
		}
		
		printf("Unknown file format id: \'%s\'\n",argv[2]);
		return -12;
	}

	// assimp export
	// Export a model to a file
	if (! strcmp(argv[1], "export")) {
		return Assimp_Export (&argv[2],argc-2);
	}

#endif

	// assimp knowext
	// Check whether a particular file extension is known by us, return 0 on success
	if (! strcmp(argv[1], "knowext")) {
		if (argc<3) {
			printf("Expected file extension");
			return -10;
		}
		const bool b = imp.IsExtensionSupported(argv[2]);
		printf("File extension \'%s\'  is %sknown\n",argv[2],(b?"":"not "));
		return b?0:-1;
	}

	// assimp info
	// Print basic model statistics
	if (! strcmp(argv[1], "info")) {
		return Assimp_Info ((const char**)&argv[2],argc-2);
	}

	// assimp dump 
	// Dump a model to a file 
	if (! strcmp(argv[1], "dump")) {
		return Assimp_Dump (&argv[2],argc-2);
	}

	// assimp extract 
	// Extract an embedded texture from a file
	if (! strcmp(argv[1], "extract")) {
		return Assimp_Extract (&argv[2],argc-2);
	}

	// assimp testbatchload
	// Used by /test/other/streamload.py to load a list of files
	// using the same importer instance to check for incompatible
	// importers.
	if (! strcmp(argv[1], "testbatchload")) {
		return Assimp_TestBatchLoad (&argv[2],argc-2);
	}

	printf("Unrecognized command. Use \'assimp help\' for a detailed command list\n");
	return 1;
}
void ManageAnimation::Init(const char *filename, float xRotateCorrection, bool normalize) {
	this->fRotateXCorrection = xRotateCorrection;
	// Create an instance of the Importer class
	Assimp::Importer importer;

	unsigned int flags = aiProcess_JoinIdenticalVertices|aiProcess_Triangulate|aiProcess_FixInfacingNormals|aiProcess_ValidateDataStructure|
	                     aiProcess_GenNormals|aiProcess_LimitBoneWeights;
	// |aiProcess_OptimizeMeshes
	if (normalize)
		flags |= aiProcess_PreTransformVertices; // This flag will remove all bones.
	importer.SetPropertyBool(AI_CONFIG_PP_PTV_NORMALIZE, true); // TODO: This is only used for aiProcess_PreTransformVertices
	importer.SetPropertyInteger(AI_CONFIG_PP_LBW_MAX_WEIGHTS, 3); // The shader can only handle three weights for each vertice.
	const aiScene* scene = importer.ReadFile( filename, flags);
	if (scene == 0) {
		ErrorDialog("assimp loading %s: %s\n", filename, importer.GetErrorString());
		return;
	}

	// Number of vertices and number of indices
	int vertexSize = 0, indexSize = 0;
	if (gVerbose) {
		printf("\nScene: %s (%s)*******************\n", scene->mRootNode->mName.data, filename);
		printf("%d materials, %d meshes, %d animations, %d textures\n", scene->mNumMaterials, scene->mNumMeshes, scene->mNumAnimations, scene->mNumTextures);
	}

	//**********************************************************************
	// Count how much data is needed. All indices and vetices are saved in
	// the same buffer.
	//**********************************************************************

	fMeshData.reset(new Mesh[scene->mNumMeshes]);
	fNumMeshes = scene->mNumMeshes;
	for (unsigned int i=0; i<scene->mNumMeshes; i++) {
		aiMesh *m = scene->mMeshes[i];
		if (m->mNumBones > 0)
			this->fUsingBones = true; // True if any mesh uses bones
		aiMaterial *mat = scene->mMaterials[m->mMaterialIndex];
		aiColor3D c (0.f,0.f,0.f);
		mat->Get(AI_MATKEY_COLOR_DIFFUSE, c);
		fMeshData[i].colour = glm::vec4(c.r, c.g, c.b, 1.0f);
		indexSize += m->mNumFaces * 3; // Always 3 indices for each face (triangle).
		vertexSize += m->mNumVertices;
		if (gVerbose)
			printf("\tMesh %d ('%s'): %d faces, %d vertices\n", i, m->mName.data, m->mNumFaces, m->mNumVertices);

		// Find all animation bones in all meshes. They may have been seen in another mesh already.
		fMeshData[i].bones.resize(m->mNumBones);
		for (unsigned int j=0; j < m->mNumBones; j++) {
			aiBone *aib = m->mBones[j];
			// Add the bone to the global list of bones if it isn't already there.
			boneindexIT_t it = fBoneIndex.find(aib->mName.data);
			unsigned int jointIndex = fBoneIndex.size();
			if (it == fBoneIndex.end())
				fBoneIndex[aib->mName.data] = jointIndex;
			else
				jointIndex = it->second;

			fMeshData[i].bones[j].jointIndex = jointIndex;
			CopyaiMat(&aib->mOffsetMatrix, fMeshData[i].bones[j].offset);
		}
	}
	if (gVerbose)
		printf("Total vertices needed: %d, index count %d\n", vertexSize, indexSize);

	// Find all mesh transformations and update the bones matrix dependency on parents
	glm::mat4 meshmatrix[scene->mNumMeshes];
	FindMeshTransformations(0, meshmatrix, glm::mat4(1), scene->mRootNode);
	if (gVerbose)
		DumpNodeTree(0, scene->mRootNode);

	// Copy all vertex data into one big buffer and all index data into another buffer
	VertexDataf vertexData[vertexSize];
	unsigned short indexData[indexSize];
	int vertexOffset = 0, indexOffset = 0;
	int previousOffset = 0; // The index offset for the current mesh

	// Skinning data. Allocate even if not using bones.
	char numWeights[vertexSize];
	memset(numWeights, 0, sizeof numWeights);
	glm::vec3 weights[vertexSize];
	float joints[vertexSize*3]; // Up to 4 joints per vertex, but only three are used.
	memset(joints, 0, sizeof joints);

	//**********************************************************************
	// Traverse the meshes again, generating the vertex data
	//**********************************************************************

	for (unsigned int i=0; i<scene->mNumMeshes; i++) {
		aiMesh *m = scene->mMeshes[i];
		if (gVerbose)
			printf("Mesh %d: %d faces, %d vertices, mtl index %d\n", i, m->mNumFaces, m->mNumVertices, m->mMaterialIndex);
#if 1
		if (gVerbose) {
#if 0
			printf("Indices:\n");
			for (unsigned int face=0; face < m->mNumFaces; face++) {
				printf("%d:(", m->mFaces[face].mNumIndices);
				for (unsigned int ind=0; ind < m->mFaces[face].mNumIndices; ind++)
					printf("%d,", m->mFaces[face].mIndices[ind]);
				printf("),");
			}
			printf("\nVertices:\n");
			for (unsigned int vert=0; vert < m->mNumVertices; vert++)
				printf("%6.3f %6.3f %6.3f\n", m->mVertices[vert].x, m->mVertices[vert].y, m->mVertices[vert].z);
#endif
			printf("    Transformation matrix:\n");
			PrintMatrix(4, meshmatrix[i]);
			printf("\n");
		}
#endif

		// Copy faces, but only those that are proper triangles.
		unsigned int numTriangles = 0; // The number of found triangles.
		for (unsigned int face=0; face < m->mNumFaces; face++) {
			if (m->mFaces[face].mNumIndices != 3)
				continue; // Only allow triangles
			// m->mFaces[face].mIndices is a local index into the current mesh. Value 0 will thus
			// adress the first vertex in the current mesh. As all vertices are stored in the same buffer,
			// an offset need to be added to get the correct index of the vertex.
			indexData[indexOffset++] = m->mFaces[face].mIndices[0] + previousOffset;
			indexData[indexOffset++] = m->mFaces[face].mIndices[1] + previousOffset;
			indexData[indexOffset++] = m->mFaces[face].mIndices[2] + previousOffset;
			numTriangles++;
		}
		fMeshData[i].numFaces = numTriangles;

		// Copy all vertices
		for (unsigned int v = 0; v < m->mNumVertices; v++) {
			glm::vec4 v1(m->mVertices[v].x, m->mVertices[v].y, m->mVertices[v].z, 1);
			glm::vec4 v2 = meshmatrix[i] * v1;
			vertexData[vertexOffset].SetVertex(glm::vec3(v2));
			glm::vec4 n1(m->mNormals[v].x, m->mNormals[v].y, m->mNormals[v].z, 1);
			glm::vec4 n2 = meshmatrix[i] * glm::normalize(n1);
			vertexData[vertexOffset].SetNormal(glm::vec3(n2));
			if (m->mTextureCoords[0] != 0) {
				vertexData[vertexOffset].SetTexture(m->mTextureCoords[0][v].x, m->mTextureCoords[0][v].y);
			} else {
				vertexData[vertexOffset].SetTexture(0,0);
			}
			vertexData[vertexOffset].SetIntensity(255);
			vertexData[vertexOffset].SetAmbient(100);
			vertexOffset++;
		}

		// Every animation bone in Assimp data structures have a list of weights and vertex index.
		// We want the weights, 0-3 of them, sorted on vertices instead.
		// Iterate through all bones used in this mesh, and copy weights to respective vertex data.
		for (unsigned j=0; j < m->mNumBones; j++) {
			fMeshData[i].bones[j].offset *= glm::inverse(meshmatrix[i]);
			aiBone *aib = m->mBones[j];
			boneindexIT_t it = fBoneIndex.find(aib->mName.data);
			if (it == fBoneIndex.end())
				ErrorDialog("Mesh %d bone %s not found", i, aib->mName.data);
			if (gVerbose) {
				printf("    Offset for mesh %d %s (%d) joint %d:\n", i, aib->mName.data, j, it->second);
				PrintMatrix(4, fMeshData[i].bones[j].offset);
			}
			for (unsigned k=0; k < aib->mNumWeights; k++) {
				int v = aib->mWeights[k].mVertexId + previousOffset; // Add the local vertex number in the current mesh to the offset to get the global number
				int w = numWeights[v]++;
				// Because AI_CONFIG_PP_LBW_MAX_WEIGHTS is maximized to 3, There can't be more than 3 weights for a vertex
				// unless there is a bug in Assimp.
				if (w >= 3)
					ErrorDialog("Too many bone weights on vertice %d, bone %s, model %s", v, aib->mName.data, filename);
				weights[v][w] = aib->mWeights[k].mWeight;
				joints[v*3 + w] = it->second;
			}
		}
		previousOffset = vertexOffset;
	}

	// Now that the weights are sorted on vertices, it is possible to normalize them. The sum shall be 1.
	for (int j=0; j < vertexSize; j++)
		NormalizeWeights(weights[j], numWeights[j]);
	ASSERT(vertexOffset == vertexSize);
	ASSERT(indexOffset <= indexSize);

	// Allocated the vertex data in OpenGL. The buffer object is used with the following layout:
	// 1. The usual vertex data, and array of type VertexDataf
	// 2. Skin weights, array of glm::vec3. 3 floats for each vertex.
	// 3. Bones index, 4 bytes for each vertex (only 3 used)
	const int AREA1 = vertexSize*sizeof vertexData[0];
	const int AREA2 = vertexSize*sizeof weights[0];
	const int AREA3 = vertexSize*3*sizeof (float);
	int bufferSize = AREA1;
	if (fUsingBones) {
		// Also need space for weights and bones indices.
		bufferSize += AREA2 + AREA3;
	}
	// Allocate the buffer, random content so far
	if (!fOpenglBuffer.BindArray(bufferSize, 0)) {
		ErrorDialog("ManageAnimation::Init: Data size is mismatch with input array\n");
	}
	fOpenglBuffer.ArraySubData(0, AREA1, vertexData);
	if (this->fUsingBones) {
		glBufferSubData(GL_ARRAY_BUFFER, AREA1, AREA2, weights);
		glBufferSubData(GL_ARRAY_BUFFER, AREA1+AREA2, AREA3, joints);
	}

	glGenVertexArrays(1, &fVao);
	glBindVertexArray(fVao);
	StageOneShader::EnableVertexAttribArray(this->fUsingBones); // Will be remembered in the VAO state
	// Allocate the index data in OpenGL
	if (!fIndexBuffer.BindElementsArray(indexSize*sizeof indexData[0], indexData)) {
		ErrorDialog("ManageAnimation::Init: Data size is mismatch with input array\n");
	}
	StageOneShader::VertexAttribPointer();
	if (this->fUsingBones)
		StageOneShader::VertexAttribPointerSkinWeights(AREA1, AREA1+AREA2);
	checkError("ManageAnimation::Init");
	glBindVertexArray(0);

	if (gVerbose) {
		printf("Mesh bones for '%s':\n", filename);
		for (auto &bone : fBoneIndex) {
			printf(" %s: joint %d\n", bone.first.c_str(), bone.second);
		}
	}

	// Decode animation information
	unsigned int numMeshBones = fBoneIndex.size();
	if (numMeshBones > 0 && scene->mNumAnimations == 0)
		ErrorDialog("ManageAnimation::Init %s: Bones but no animations", filename);
	if (scene->mNumAnimations > 0) {
		if (numMeshBones == 0)
			ErrorDialog("ManageAnimation::Init %s: No mesh bones", filename);
		if (gVerbose)
			printf("Parsing %d animations\n", scene->mNumAnimations);
	}

	//**********************************************************************
	// Decode the animations
	// There may be more animated bones than used by meshes.
	//**********************************************************************
	fAnimations.reset(new Animation[scene->mNumAnimations]);
	for (unsigned int i=0; i < scene->mNumAnimations; i++) {
		aiAnimation *aia = scene->mAnimations[i];
		fAnimations[i].name = aia->mName.data;
		fAnimations[i].keysPerSecond = aia->mTicksPerSecond;
		fAnimations[i].duration = aia->mDuration;

		// Set the size of bones to the actual nutmber of bones used by the meshes, not the total number of bones
		// in the model.
		fAnimations[i].bones.reset(new AnimationBone[numMeshBones]);

		// The number of keys has to be the same for all channels. This is a limitation if it is going to be possible to
		// pre compute all matrices.
		unsigned numChannels = aia->mNumChannels;
		if (numChannels == 0)
			ErrorDialog("ManageAnimation::Init no animation channels for %s, %s", aia->mName.data, filename);
		if (numChannels != numMeshBones)
			ErrorDialog("ManageAnimation::Init %s animation %d: Can only handle when all bones are used (%d out of %d)", filename, i, numChannels, numMeshBones);
		unsigned int numKeys = aia->mChannels[0]->mNumPositionKeys;
		struct channel {
			glm::mat4 mat; // Relative transformation matrix to parent
			channel *parent;
			aiNodeAnim *node;
			unsigned joint;
#define UNUSEDCHANNEL 0xFFFF
		};
		channel channels[numChannels]; // This is the list of all bones in this animation
		// Check that there are the same number of keys for all channels, and allocate transformation matrices
		bool foundOneBone = false;
		for (unsigned int j=0; j < numChannels; j++) {
			aiNodeAnim *ain = aia->mChannels[j];
			if (ain->mNumPositionKeys != numKeys || ain->mNumRotationKeys != numKeys || ain->mNumScalingKeys != numKeys)
				ErrorDialog("ManageAnimation::Init %s Bad animation setup: Pos keys %d, rot keys %d, scaling keys %d", filename, ain->mNumPositionKeys, ain->mNumRotationKeys, ain->mNumScalingKeys);
			channels[j].node = ain;
			channels[j].parent = 0;
			boneindexIT_t it = fBoneIndex.find(ain->mNodeName.data);
			if (it == fBoneIndex.end()) {
				// Skip this channel (bone animation)
				channels[j].joint = UNUSEDCHANNEL; // Mark it as not used
				continue;
				// ErrorDialog("ManageAnimation::Init: Unknown bone %s in animation %s for %s", ain->mNodeName.data, fAnimations[i].name.c_str(), filename);
			}
			foundOneBone = true;
			unsigned int joint = it->second;
			fAnimations[i].bones[joint].frameMatrix.reset(new glm::mat4[numKeys]);
			channels[j].joint = joint;
		}
		if (!foundOneBone)
			ErrorDialog("ManageAnimation::Init %s animation %d no bones used", filename, i);

		// Find the parent for each animation node
		for (unsigned j=0; j<numChannels; j++) {
			aiNode *n = FindNode(scene->mRootNode, channels[j].node->mNodeName.data);
			if (n == 0 || n->mParent == 0)
				continue; // No parent
			n = n->mParent;
			for (unsigned p=0; p<numChannels; p++) {
				if (p == j || strcmp(n->mName.data, channels[p].node->mNodeName.data) != 0)
					continue;
				// Found it!
				channels[j].parent = &channels[p];
				break;
			}
		}

		fAnimations[i].times.reset(new double[numKeys]);
		fAnimations[i].numKeys = numKeys;
		// The first key frame doesn't always start at time 0
		double firstKeyTime = channels[0].node->mPositionKeys[0].mTime;
		for (unsigned k=0; k < numKeys; k++) {
			fAnimations[i].times[k] = channels[0].node->mPositionKeys[k].mTime - firstKeyTime;
			// printf("Animation key %d at time %.2f\n", k, fAnimations[i].times[k]);
			for (unsigned int j=0; j < numChannels; j++) {
				aiNodeAnim *ain = channels[j].node;
				glm::mat4 R;
				CopyaiQuat(R, ain->mRotationKeys[k].mValue);
				glm::mat4 T = glm::translate(glm::mat4(1), glm::vec3(ain->mPositionKeys[k].mValue.x, ain->mPositionKeys[k].mValue.y, ain->mPositionKeys[k].mValue.z));
				glm::mat4 S = glm::scale(glm::mat4(1), glm::vec3(ain->mScalingKeys[k].mValue.x, ain->mScalingKeys[k].mValue.y, ain->mScalingKeys[k].mValue.z));
				channels[j].mat = T * R * S;
				if (gVerbose) {
					printf("     Key %d animation bone %s relative\n", k, channels[j].node->mNodeName.data);
					PrintMatrix(10, channels[j].mat);
				}
			}
			// Iterate through each animation bone and compute the transformation matrix using parent matrix.
			for (unsigned int j=0; j < numChannels; j++) {
				unsigned joint = channels[j].joint;
				glm::mat4 mat(1);
				for (channel *node = &channels[j]; node; node = node->parent) {
					mat = node->mat * mat;
				}
				mat = armature * mat;
				if (joint != UNUSEDCHANNEL) {
					fAnimations[i].bones[joint].frameMatrix[k] = mat;
					if (gVerbose) {
						printf("     Key %d animation bone %s channel %d absolute\n", k, channels[j].node->mNodeName.data, j);
						PrintMatrix(10, mat);
					}
				}
			}
		}
	}
}