xloadercharacter.cpp

X文件读取插件

			XCKObjectsHashTableIt it=m_MaterialHashTable.Find(MaterialName);
			Material = (it==m_MaterialHashTable.End()) ? NULL : (CKMaterial*)*it;
			if (Material) {
				if (Material->GetDiffuse() != VirtoolsMat.m_Diffuse) Material = NULL;
				else
				if (Material->GetSpecular() != VirtoolsMat.m_Specular) Material = NULL;
				else
				if (Material->GetEmissive() != VirtoolsMat.m_Emissive) Material = NULL;
				else
				if (Material->GetPower() != VirtoolsMat.m_SpecularPower) Material = NULL;
				else 
				if (TextureFileName!="") {
					CKTexture* tex = Material->GetTexture();
					if (tex) {
						if (TextureFileName!=tex->GetSlotFileName(0)) {
							Material = NULL;
						}
					} else Material = NULL;
				}
			}		
		
			if (!Material) {
				// And finally create the material 
				Material = m_VirtoolsExport->AddMaterial(&VirtoolsMat,MaterialName.Str());
				m_MaterialHashTable.Insert(MaterialName,Material);
			}
			SAFERELEASE(CurData);
		}
	}
	return Material;
}

/*********************************************************
Loads a mesh vertices colors
**********************************************************/
HRESULT CKXReader::LoadMeshVertexColors(LPDIRECTXFILEDATA CurData,VirtoolsTransitionMesh* m)
{
	HRESULT hr;
	DWORD*				nVertexColors = 0;
	DWORD*				vertexColors = 0;
	DWORD Size;

	if (FAILED( hr = CurData->GetData("nVertexColors",&Size, (void **)&nVertexColors))) return hr;
	if (FAILED( hr = CurData->GetData("vertexColors",&Size, (void **)&vertexColors))) return hr;
	
	m->m_PrelitMesh = TRUE;

	m->m_VertexColors.Resize(m->m_Vertices.Size());
	for (DWORD i = 0; i < *nVertexColors; ++i) {
		DWORD Index = *vertexColors++;
		VxColor* col = (VxColor*)vertexColors;
		m->m_VertexColors[Index] = *col;
		vertexColors += 4;
	}

	return hr;
}

/*********************************************************
Loads a mesh vertices texture coordinates
**********************************************************/
HRESULT CKXReader::LoadMeshTextureCoords(LPDIRECTXFILEDATA CurData,VirtoolsTransitionMesh* m)
{
	HRESULT hr;
	DWORD*				nTextureCoords = 0;
	VxUV*				textureCoords = 0;
	DWORD Size;

	if (FAILED( hr = CurData->GetData("nTextureCoords",&Size, (void **)&nTextureCoords))) return hr;
	if (FAILED( hr = CurData->GetData("textureCoords",&Size, (void **)&textureCoords))) return hr;

	for (DWORD i = 0; i < *nTextureCoords; ++i,textureCoords++) {
		m->AddUv(*textureCoords);
	}

	return hr;
}

/*********************************************************
Loads a mesh vertices normals
**********************************************************/
HRESULT CKXReader::LoadMeshNormals(LPDIRECTXFILEDATA CurData,VirtoolsTransitionMesh* m)
{
	HRESULT hr;
	DWORD*			nNormals = 0;
	VxVector*		normals = 0;
	DWORD*			nFaceNormals = 0;
	DWORD*			faceNormals = 0;
	DWORD Size;

	if (FAILED( hr = CurData->GetData("nNormals",&Size, (void **)&nNormals))) return hr;
	if (FAILED( hr = CurData->GetData("normals",&Size, (void **)&normals))) return hr;
	if (FAILED( hr = CurData->GetData("nFaceNormals",&Size, (void **)&nFaceNormals))) return hr;
	if (FAILED( hr = CurData->GetData("faceNormals",&Size, (void **)&faceNormals))) return hr;

	for (DWORD i = 0; i < *nNormals; ++i,normals++) {
		m->AddNormal(*normals);
	}

	for (i = 0; i < *nFaceNormals; ++i) {
		int count = *faceNormals++;
		m->AddNormalFace((int *)faceNormals,count);
		faceNormals += count;
	}

	return hr;
}


/*********************************************************
Loads a mesh face materials
**********************************************************/
HRESULT CKXReader::LoadMeshMaterials(LPDIRECTXFILEDATA CurData,VirtoolsTransitionMesh* m)
{
	HRESULT hr;
	DWORD*				nMaterials = 0;
	DWORD*				nFaceIndexes = 0;
	DWORD*				FaceIndexes = 0;
	DWORD				Size;
	XArray<CKMaterial*> materials;

	if (FAILED( hr = CurData->GetData("nMaterials",&Size, (void **)&nMaterials))) return hr;
	if (FAILED( hr = CurData->GetData("nFaceIndexes",&Size, (void **)&nFaceIndexes))) return hr;
	if (FAILED( hr = CurData->GetData("FaceIndexes",&Size, (void **)&nFaceIndexes))) return hr;

	LPDIRECTXFILEOBJECT	NextObject = NULL;
		
	// Enumerate child objects. (We're expecting to find material objects
	while (SUCCEEDED(CurData->GetNextObject(&NextObject)))  {
		// ok found a material we add it to our temp list 
		materials.PushBack(LoadMaterial(NextObject));
		SAFERELEASE(NextObject);
	}

	if (*nMaterials == 1) {
		// If only one material we can apply it to all faces
		for (int i=0;i<m->m_Faces.Size();++i)
			m->SetFaceMaterial(i,materials[0]);
	} else 
	for (DWORD i = 0; i < *nFaceIndexes; ++i,++FaceIndexes) {
		m->SetFaceMaterial(i,materials[*FaceIndexes]);
	}

	return hr;
}

/*******************************************
Loads bone information 
If a skin does not yet exist on the parent entity we 
create it, otherwise we had the bone information
and set the weights on the concerned vertices
*******************************************/
HRESULT CKXReader::LoadSkinBone(LPDIRECTXFILEDATA CurData,VirtoolsTransitionMesh* m,CK3dEntity* Parent)
{
	HRESULT hr = S_OK;
	char**			transformNodeName = NULL;
	DWORD*			nWeights = 0;
	DWORD*			vertexIndices = 0;
	float*			weights = 0;
	VxMatrix*		matrixOffset;
	DWORD			Size;

	if (!Parent) return S_OK;
	if (FAILED( hr = CurData->GetData("transformNodeName",&Size, (void **)&transformNodeName))) return hr;
	if (FAILED( hr = CurData->GetData("nWeights",&Size, (void **)&nWeights)))					return hr;
	if (FAILED( hr = CurData->GetData("vertexIndices",&Size, (void **)&vertexIndices)))			return hr;
	if (FAILED( hr = CurData->GetData("weights",&Size, (void **)&weights)))						return hr;
	if (FAILED( hr = CurData->GetData("matrixOffset",&Size, (void **)&matrixOffset)))			return hr;

	CKSkin* Skin = Parent->GetSkin();
	if (!Skin) {
		Skin = Parent->CreateSkin();

		// Inital Matrix
		Skin->SetObjectInitMatrix(Parent->GetWorldMatrix());

		// The correct number of vertices has not yet been set on the skin, 
		// we set it and update the vertex original position by the way...
		int VCount = m->m_VirtoolsVertices.Size();
		Skin->SetVertexCount(VCount);
		for (int i=0; i<VCount; ++i) {
			CKSkinVertexData* VData = Skin->GetVertexData(i);
			VData->SetInitialPos(m->m_VirtoolsVertices[i].Pos);
		}
	}
	
	//-- Find the Frame that represent the bone
	XCKObjectsHashTableIt it=m_FrameHashTable.Find(XString(*transformNodeName));
	CK3dEntity* Bone = (it==m_FrameHashTable.End()) ? NULL : (CK3dEntity*)*it;

	//-- Not found
	if (!Bone) return hr;
	//-- no vertices are influcenced by this bone 
	if (!*nWeights) return hr;
			
	int BoneIndex = Skin->GetBoneCount();
	
	//-- Add this bone to the skin
	Skin->SetBoneCount(BoneIndex+1);
	CKSkinBoneData* BoneData = Skin->GetBoneData(BoneIndex);
	BoneData->SetBone(Bone);
	BoneData->SetBoneInitialInverseMatrix(Bone->GetInverseWorldMatrix());

	
	// We are not sure that the virtools mesh contains the same number 
	// of vertices than the .X Mesh, but we can have the table of 
	// generated vertices for a given vertex in the .X Mesh...
	for (DWORD i = 0; i< *nWeights; ++i,++vertexIndices,++weights) {
		const IntArray& newindices = m->GetGeneratedIndices((int)*vertexIndices);
		for (int* vi =  newindices.Begin(); vi < newindices.End(); ++vi) {
			// Need to add a bone on this vertex
			CKSkinVertexData* VData = Skin->GetVertexData(*vi);
			int VBoneCount = VData->GetBoneCount();

			// Add the bone (with its weight) to this vertex
			VData->SetBoneCount(VBoneCount+1);
			VData->SetBone(VBoneCount,BoneIndex);
			VData->SetWeight(VBoneCount,*weights);
		}
	}
	return hr;
}



/*********************************************
 Loads a Mesh representation
*********************************************/
HRESULT CKXReader::LoadMesh(LPDIRECTXFILEOBJECT CurObject,CK3dEntity* Parent)
{
	HRESULT hr = S_OK;
	if (m_LoadFlags & CK_LOAD_GEOMETRY) {

		// Reference or data ? 
		LPDIRECTXFILEDATA CurData = NULL;
		LPDIRECTXFILEDATAREFERENCE CurDataRef = NULL;
		XString MeshName = GetFileObjectName(CurObject);

		if (SUCCEEDED(CurObject->QueryInterface(IID_IDirectXFileDataReference,(LPVOID *)&CurDataRef))) {
			// REFERENCE : we find the mesh from its name and set
			// it to the Parent entity
			if (SUCCEEDED(CurDataRef->Resolve(&CurData))) {
				
				MeshName = GetFileObjectName(CurData);
				XCKObjectsHashTableIt it=m_MeshHashTable.Find(MeshName);
				CKMesh* mesh = (it==m_MeshHashTable.End()) ? NULL : (CKMesh*)*it;
				Parent->SetCurrentMesh(mesh);

				SAFERELEASE(CurData);
			}

			SAFERELEASE(CurDataRef);
		}  else 
		if (SUCCEEDED(CurObject->QueryInterface(IID_IDirectXFileData,(LPVOID *)&CurData))) {
			// DATA : we have to create a mesh 
			DWORD Size;

			// Mesh Data
			DWORD*				nVertices = 0;
			VxVector*			vertices = 0;
			DWORD*				nFaces = 0;
			DWORD**				faces = 0;
			BOOL				Generated = FALSE;
			
			// Load vertex and faces data (if some of them are not here we fail...)
			if (FAILED(hr = CurData->GetData("nVertices",&Size, (void **)&nVertices))) RELEASEEXIT(hr,CurData);
			if (FAILED(hr = CurData->GetData("vertices",&Size, (void **)&vertices)))  RELEASEEXIT(hr,CurData);
			if (FAILED(hr = CurData->GetData("nFaces",&Size, (void **)&nFaces)))    RELEASEEXIT(hr,CurData);
			if (FAILED(hr = CurData->GetData("faces",&Size, (void **)&faces)))	  RELEASEEXIT(hr,CurData);

			VirtoolsTransitionMesh TransitionMesh(m_VirtoolsExport); 

			//------- Add Vertices position
			for (DWORD i=0;i<*nVertices;++i,++vertices) 
				TransitionMesh.AddPosition(*vertices);

			//------- Add faces
			for (i=0;i<*nFaces;++i)  {
				int count = (int)*faces++;
				TransitionMesh.AddFace((int *)faces,count,NULL);
				faces += count;
			}
			
			LPDIRECTXFILEDATA	NextData = NULL;
			LPDIRECTXFILEOBJECT	NextObject = NULL;
			
			// Enumerate child objects. (We're expecting to find texture coords, vertex colors or material list
			while (SUCCEEDED(CurData->GetNextObject(&NextObject)))  {
				// Query the child for it's FileData
				if SUCCEEDED(NextObject->QueryInterface(IID_IDirectXFileData,(LPVOID *)&NextData)) {
					const GUID* DataType = NULL;

					if (SUCCEEDED(NextData->GetType(&DataType))) {
						if (TID_D3DRMMeshFaceWraps == *DataType) {
							// Not supported for the moment, Skip... 
						} else 
						if (TID_D3DRMMeshVertexColors == *DataType) {
							//****** Load vertex Colors
							LoadMeshVertexColors(NextData,&TransitionMesh);
						} else 
						if (TID_D3DRMMeshTextureCoords == *DataType) {
							//****** Load texture coordinates
							LoadMeshTextureCoords(NextData,&TransitionMesh);
						} else 
						if (TID_D3DRMMeshMaterialList == *DataType) {
							//****** Load material list
							LoadMeshMaterials(NextData,&TransitionMesh);
						} else