polymech/deargui-vpl
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
master
deargui-vpl/ref/virtools/Samples/Plugins/x Loader/XloaderCharacter.cpp

958 lines
31 KiB
C++
Raw Permalink Blame History

/*************************************************************************/
/* File : XLoader.cpp */
/* */
/* DirectX .X files loader */
/* */
/* Virtools SDK */
/* Copyright (c) Virtools 2000, All Rights Reserved. */
/*************************************************************************/
#include "XLoader.h"
#include "InitGuid.h"
char *RemoveX3DS(char *name);
/* {3CF169CE-FF7C-44ab-93C0-F78F62D172E2} */
DEFINE_GUID(TID_XSkinMeshHeader,
0x3CF169CE, 0xFF7C, 0x44ab, 0x93, 0xc0, 0xF7, 0x8F, 0x62, 0xD1, 0x72, 0xE2);
/* {6F0D123B-BAD2-4167-A0D0-80224F25FABB} */
DEFINE_GUID(TID_SkinWeights,
0x6F0D123B, 0xBAD2, 0x4167, 0xA0, 0xD0, 0x80, 0x22, 0x4F, 0x25, 0xFA, 0xBB);
#ifdef CK_LIB
#define CKGetPluginInfoCount CKGet_XLoader_PluginInfoCount
#define CKGetPluginInfo CKGet_XLoader_PluginInfo
#define CKGetReader CKGet_XLoader_Reader
#else
#define CKGetPluginInfoCount CKGetPluginInfoCount
#define CKGetPluginInfo CKGetPluginInfo
#define CKGetReader CKGetReader
#endif
//********************************************************************************
//********************************************************************************
//*************** PLUGIN DECLARATION ********************************************
//********************************************************************************
//********************************************************************************
#define X_PLUGIN_VERSION 0x0000001
#define X_READER_GUID CKGUID(0x31011515,0x71af1e3f)
CKPluginInfo g_PluginInfos;
/*************************************************
Returns the number of plugins in this DLL (1)
**************************************************/
int CKGetPluginInfoCount() {
if (VxGetOs() == VXOS_WINNT4) return 0;
return 1;
}
/*************************************************
Returns info about this plugin
**************************************************/
CKPluginInfo* CKGetPluginInfo(int index)
{
// Not Valid under Win NT 4
if (VxGetOs() == VXOS_WINNT4) return 0;
g_PluginInfos.m_GUID=X_READER_GUID;
g_PluginInfos.m_Extension="X";
g_PluginInfos.m_Description="Microsoft DirectX";
g_PluginInfos.m_Author="Virtools";
g_PluginInfos.m_Summary="DirectX File Reader";
g_PluginInfos.m_Version=X_PLUGIN_VERSION;
g_PluginInfos.m_InitInstanceFct=NULL; //
g_PluginInfos.m_Type=CKPLUGIN_MODEL_READER; // Plugin Type
return &g_PluginInfos;
}
CKDataReader* CKGetReader(int index)
{
return new CKXReader();
}
//********************************************************************************
//********************************************************************************
//************* READER IMPLEMENTATION ********************************************
//********************************************************************************
//********************************************************************************
CKPluginInfo* CKXReader::GetReaderInfo() {
return &g_PluginInfos;
}
//------- Returns the name of a LPDIRECTXFILEOBJECT
XString GetFileObjectName(LPDIRECTXFILEOBJECT obj)
{
if (!obj) return XString("");
DWORD NameSize = 0;
if (FAILED(obj->GetName(NULL,&NameSize)))
return XString("");
if (!NameSize)
return XString("");
NameSize++;
XString Temp(NameSize);
if (FAILED(obj->GetName(Temp.Str(),&NameSize)))
return XString("");
return Temp;
}
/*************************************************************
Main Loading function
*************************************************************/
CKERROR CKXReader::Load(CKContext* context,CKSTRING FileName,CKObjectArray *array,CKDWORD LoadFlags,CKCharacter *carac)
{
if(!array) return CKERR_INVALIDPARAMETER;
if(!FileName) return CKERR_INVALIDPARAMETER;
HRESULT hr = S_OK;
m_Context = context;
m_LoadFlags = LoadFlags;
m_Character = carac;
m_FileName = FileName;
m_AnimationLength = 0;
// Create the XFile object
if (DXFILE_OK != DirectXFileCreate(&m_XFile)) return CKERR_NOTIMPLEMENTED;
// Create the XFile enumerator
if (FAILED(m_XFile->CreateEnumObject(FileName,DXFILELOAD_FROMFILE,&m_XFileEnumerator))) {
CleanUp();
return CKERR_INVALIDFILE;
}
// Create the exporter object
m_VirtoolsExport = new Export2Virtools(context, FALSE);
// Register templates for d3drm and patch extensions.
if( FAILED( hr = m_XFile->RegisterTemplates( (VOID*)D3DRM_XTEMPLATES,
D3DRM_XTEMPLATE_BYTES ) ) )
{
CleanUp();
return CKERR_INVALIDFILE;
}
m_CreationOptions = CK_OBJECTCREATION_NONAMECHECK;
if (LoadFlags & (CK_LOAD_AS_DYNAMIC_OBJECT))
m_CreationOptions = CK_OBJECTCREATION_OPTIONS(m_CreationOptions|CK_OBJECTCREATION_DYNAMIC);
m_VirtoolsExport->SetObjectsCreationOptions(m_CreationOptions);
m_3dObjectsClass = m_Character ? CKCID_BODYPART : ((m_LoadFlags & CK_LOAD_ASCHARACTER)!=0) ? CKCID_BODYPART : CKCID_3DOBJECT;
LPDIRECTXFILEDATA pXData = NULL;
// Enumerate top level objects.
// Top level objects are always data object.
while (SUCCEEDED(m_XFileEnumerator->GetNextDataObject(&pXData)))
{
HRESULT hr = LoadFileData(pXData,NULL);
SAFERELEASE(pXData);
}
if (FAILED(hr)) {
CleanUp();
return CKERR_INVALIDFILE;
}
//We set the skinning information now that we are sure all bones are loaded
int i;
for(i=0;i<m_BonesName.Size();i++)
{
XCKObjectsHashTableIt it = m_FrameHashTable.Find(m_BonesName[i]);
CK3dEntity* Bone = (it==m_FrameHashTable.End()) ? NULL : (CK3dEntity*)*it;
CKSkinBoneData* BoneData = (m_Skins[i])->GetBoneData(m_BonesIndex[i]);
BoneData->SetBone(Bone);
BoneData->SetBoneInitialInverseMatrix(Bone->GetInverseWorldMatrix());
}
m_BonesName.Clear();
m_BonesIndex.Clear();
m_Skins.Clear();
if (m_VirtoolsExport->GetGlobalAnimation())
m_VirtoolsExport->GetGlobalAnimation()->SetLength(m_AnimationLength);
//---- There are some meshes without a frame
if (m_MeshHashTable.Size() && !m_FrameHashTable.Size()) {
XCKObjectsHashTableIt Begin = m_MeshHashTable.Begin();
XCKObjectsHashTableIt End = m_MeshHashTable.End();
for (;Begin!=End;++Begin) {
CKMesh* m = (CKMesh*)*Begin;
CK3dEntity* NewFrame = NULL;
if (CharacterMode())
NewFrame = (CK3dEntity*)m_VirtoolsExport->AddCharacterBodyPart((char *)m->GetName());
else
NewFrame = (CK3dEntity*)m_VirtoolsExport->Add3dObject((char *)m->GetName());
NewFrame->SetCurrentMesh(m);
}
}
//--- No character was given
//--- but one should be created...
if (!m_Character) {
if ((m_LoadFlags & CK_LOAD_ASCHARACTER)) {
CKPathSplitter Splitter(FileName);
m_VirtoolsExport->CreateCharacter(Splitter.GetName());
}
}
BOOL AnimationOnly = FALSE;
//--- Only animations were asked...
if ((m_LoadFlags & CK_LOAD_ANIMATION) && !(m_LoadFlags & CK_LOAD_GEOMETRY)) {
// we are loading animations and need to find the entities
// to which they apply
m_VirtoolsExport->ResolveAnimationsTargets(m_Character);
AnimationOnly = TRUE;
}
//-- Generate the list of objects in the array
m_VirtoolsExport->GenerateObjects(array,AnimationOnly);
return CK_OK;
}
#define RELEASEEXIT(ErrorCode,ToRelease) {\
SAFERELEASE(ToRelease);\
return ErrorCode;\
}\
/*********************************************
Loads a 3DEntity transformation Matrix
*********************************************/
HRESULT CKXReader::LoadTransformationMatrix(LPDIRECTXFILEDATA CurData,CK3dEntity* Parent)
{
VxMatrix* Mat;
DWORD Size = 0;
HRESULT hr = CurData->GetData(NULL, &Size, (void **)&Mat);
if (SUCCEEDED(hr) && Parent) {
Parent->SetLocalMatrix(*Mat,TRUE);
}
return hr;
}
/***************************************************************
Loads a material (reference or data) and returns a pointer
to the created CKMaterial
**************************************************************/
CKMaterial* CKXReader::LoadMaterial(LPDIRECTXFILEOBJECT CurObject)
{
HRESULT hr = S_OK;
CKMaterial* Material = NULL;
if (m_LoadFlags & CK_LOAD_GEOMETRY) {
LPDIRECTXFILEDATA CurData = NULL;
LPDIRECTXFILEDATAREFERENCE CurDataRef = NULL;
XString MaterialName = GetFileObjectName(CurObject);
// Reference or data ?
if (SUCCEEDED(CurObject->QueryInterface(IID_IDirectXFileDataReference,(LPVOID *)&CurDataRef))) {
// REFERENCE : we find the material from its name and return it
if (SUCCEEDED(CurDataRef->Resolve(&CurData))) {
MaterialName = GetFileObjectName(CurData);
XCKObjectsHashTableIt it=m_MaterialHashTable.Find(MaterialName);
Material = (it==m_MaterialHashTable.End()) ? NULL : (CKMaterial*)*it;
SAFERELEASE(CurData);
}
SAFERELEASE(CurDataRef);
} else
if (SUCCEEDED(CurObject->QueryInterface(IID_IDirectXFileData,(LPVOID *)&CurData))) {
// DATA : we have to create a material
VxColor* Diffuse = 0;
float* Power = 0;
VxColor* Specular = 0;
VxColor* Emissive = 0;
DWORD Size = 0;
//-- Load material data (if some of them are not here we fail...)
if (FAILED(hr = CurData->GetData("faceColor",&Size, (void **)&Diffuse))) RELEASEEXIT(NULL,CurData);
if (FAILED(hr = CurData->GetData("power",&Size, (void **)&Power))) RELEASEEXIT(NULL,CurData);
if (FAILED(hr = CurData->GetData("specularColor",&Size, (void **)&Specular))) RELEASEEXIT(NULL,CurData);
if (FAILED(hr = CurData->GetData("emissiveColor",&Size, (void **)&Emissive))) RELEASEEXIT(NULL,CurData);
//-- Copy the loaded material settings into a VirtoolsMat
VirtoolsMaterial VirtoolsMat;
XString TextureFileName;
VirtoolsMat.m_Specular.a = 0;
VirtoolsMat.m_Emissive.a = 0;
VirtoolsMat.m_Diffuse = *Diffuse;
memcpy(&VirtoolsMat.m_Specular,Specular,3*sizeof(float));
memcpy(&VirtoolsMat.m_Emissive,Emissive,3*sizeof(float));
VirtoolsMat.m_SpecularPower = *Power;
//-- Transparent Material
if (VirtoolsMat.m_Diffuse.a < 1.0f) {
VirtoolsMat.m_AlphaBlending = TRUE;
VirtoolsMat.m_SrcBlendFactor = VXBLEND_SRCALPHA;
VirtoolsMat.m_DstBlendFactor = VXBLEND_INVSRCALPHA;
VirtoolsMat.m_ZWriteEnable = FALSE;
}
//------- Is There a texture ? -------------
LPDIRECTXFILEOBJECT NextObject = NULL;
LPDIRECTXFILEDATA NextData = NULL;
if (SUCCEEDED(CurData->GetNextObject(&NextObject))) {
if SUCCEEDED(NextObject->QueryInterface(IID_IDirectXFileData,(LPVOID *)&NextData)) {
const GUID* DataType = NULL;
if (SUCCEEDED(NextData->GetType(&DataType))) {
if (TID_D3DRMTextureFilename == *DataType) {
char** String = NULL;
DWORD DataSize;
if (SUCCEEDED(NextData->GetData("filename",&DataSize,(void**)&String))) {
// Yes ! there is a texture : try to load it...
if (String && *String) {
TextureFileName = *String;
VirtoolsMat.m_Texture = m_VirtoolsExport->AddTexture(*String,*String);
}
}
}
}
SAFERELEASE(NextData);
}
SAFERELEASE(NextObject);
}
// Rename the material if necessary
if (MaterialName=="") MaterialName = GetUnnamed();
// If a material with this name already exists we
// compare the existing one parameters
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 (DWORD 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;
//-- 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);
if (!Bone)
{
//Bone may not have been loaded yet
m_BonesName.PushBack(XString(*transformNodeName));
m_BonesIndex.PushBack(BoneIndex);
m_Skins.PushBack(Skin);
}
else
{
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 (DWORD 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
if (TID_D3DRMMeshNormals == *DataType) {
//****** Load material list
LoadMeshNormals(NextData,&TransitionMesh);
} else
if (TID_SkinWeights == *DataType) {
//----- To load the skin data we need to
//----- have the appropriate number of
//----- virtools vertices computed
if (!Generated) {
TransitionMesh.GenerateVirtoolsData();
Generated = TRUE;
}
//****** Load bone info
LoadSkinBone(NextData,&TransitionMesh,Parent);
} else
if (TID_XSkinMeshHeader == *DataType) {
// No need to load this
}
}
SAFERELEASE(NextData);
}
SAFERELEASE(NextObject);
}
// Rename the mesh if necessary
if (MeshName=="")
if (Parent) {
MeshName = Parent->GetName();
MeshName << "_Mesh";
} else {
MeshName << GetUnnamed();
}
if (!Generated)
TransitionMesh.GenerateVirtoolsData();
// And finally create the mesh
CKMesh* Mesh = m_VirtoolsExport->AddMesh(&TransitionMesh,MeshName.CStr());
m_MeshHashTable.Insert(MeshName,Mesh);
if (Parent) {
if (Parent->GetMeshCount()) {
// A mesh has already been set on this entity
// we need to create a new frame to hold this one
CK3dEntity* NewFrame = NULL;
if (CharacterMode())
NewFrame = (CK3dEntity*)m_VirtoolsExport->AddCharacterBodyPart(MeshName.CStr());
else
NewFrame = (CK3dEntity*)m_VirtoolsExport->Add3dObject(MeshName.CStr());
NewFrame->SetParent(Parent,FALSE);
NewFrame->SetCurrentMesh(Mesh);
} else {
Parent->SetCurrentMesh(Mesh);
}
}
SAFERELEASE(CurData);
}
}
return hr;
}
/***************************************************
Loads an animation Set (group of sub animations)
****************************************************/
HRESULT CKXReader::LoadAnimationSet(LPDIRECTXFILEDATA CurData)
{
HRESULT hr = S_OK;
XString AnimationName = GetFileObjectName(CurData);
if (AnimationName=="") {
CKPathSplitter Splitter(m_FileName.Str());
AnimationName = Splitter.GetName();
}
m_VirtoolsExport->CreateGlobalAnimation(AnimationName.Str());
LPDIRECTXFILEDATA NextData = NULL;
LPDIRECTXFILEOBJECT NextObject = NULL;
// Enumerate child objects. (We're expecting to find animations
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_D3DRMAnimation == *DataType) {
hr = LoadAnimation(NextData);
}
}
SAFERELEASE(NextData);
}
SAFERELEASE(NextObject);
}
return hr;
}
/**************************************************************
+ Adds a list of position keys to the animation
+ Only linear animation are supported in .x files so we directly
use the CKObjectAnimation AddPosition method instead of using CKAnimController
******************************************************************/
void CKXReader::LoadAnimationPositionKey(CKObjectAnimation* anim,DWORD KeyCount,DWORD* keys)
{
XFileVectorKey* vkeys = (XFileVectorKey*)keys;
for (DWORD i = 0; i< KeyCount; ++i,++vkeys) {
m_AnimationLength = max (m_AnimationLength,(float)vkeys->Time);
anim->AddPositionKey((float)vkeys->Time,&vkeys->Key);
}
}
/**************************************************************
+ Adds a list of rotation keys to the animation
+ Only linear animation are supported in .x files so we directly
use the CKObjectAnimation AddRtoationKey method instead of using CKAnimController
+ Warning .X file store quaternions in this order : w,x,y,z
******************************************************************/
void CKXReader::LoadAnimationRotationKey(CKObjectAnimation* anim,DWORD KeyCount,DWORD* keys)
{
XFileRotateKey* rkeys = (XFileRotateKey*)keys;
for (DWORD i = 0; i< KeyCount; ++i,++rkeys) {
m_AnimationLength = max (m_AnimationLength,(float)rkeys->Time);
VxQuaternion quat(rkeys->x,rkeys->y,rkeys->z,rkeys->w);
anim->AddRotationKey((float)rkeys->Time,&quat);
}
}
/**************************************************************
+ Adds a list of scale keys to the animation
+ Only linear animation are supported in .x files so we directly
use the CKObjectAnimation AddScaleKey method instead of using CKAnimController
******************************************************************/
void CKXReader::LoadAnimationScaleKey(CKObjectAnimation* anim,DWORD KeyCount,DWORD* keys)
{
XFileVectorKey* vkeys = (XFileVectorKey*)keys;
for (DWORD i = 0; i< KeyCount; ++i,++vkeys) {
m_AnimationLength = max (m_AnimationLength,(float)vkeys->Time);
anim->AddScaleKey((float)vkeys->Time,&vkeys->Key);
}
}
/**************************************************************
+ Adds a list of matrix keys to the animation
+ Matrix keys need to be converted to standard PRS keys
*****************************************************************/
void CKXReader::LoadAnimationMatrixKey(CKObjectAnimation* anim,DWORD KeyCount,DWORD* keys)
{
XFileMatrixKey* mkeys = (XFileMatrixKey*)keys;
for (DWORD i = 0; i< KeyCount; ++i,++mkeys) {
m_AnimationLength = max (m_AnimationLength,(float)mkeys->Time);
float time = (float)mkeys->Time;
VxMatrix Mat = mkeys->Key;
VxQuaternion q,qs;
VxVector p,s;
Vx3DDecomposeMatrixTotal(Mat,q,p,s,qs);
anim->AddRotationKey(time,&q);
anim->AddScaleKey(time,&s);
anim->AddPositionKey(time,&p);
// Matrix (especially coming from bipeds) may contain some shearing)
anim->AddScaleAxisKey(time,&qs);
}
}
/*********************************************************
***********************************************************/
HRESULT CKXReader::LoadAnimation(LPDIRECTXFILEDATA CurData)
{
LPDIRECTXFILEDATA NextData = NULL;
LPDIRECTXFILEDATAREFERENCE NextDataRef = NULL;
LPDIRECTXFILEOBJECT NextObject = NULL;
XString EntityName="";
CK3dEntity* Entity = NULL;
CKObjectAnimation* Animation = (CKObjectAnimation*)m_Context->CreateObject(CKCID_OBJECTANIMATION,NULL,m_CreationOptions);
// Enumerate child objects. (We're expecting to find animation keys and a reference
// to the animated frame
while (SUCCEEDED(CurData->GetNextObject(&NextObject))) {
// Query the child for it's FileData
if SUCCEEDED(NextObject->QueryInterface(IID_IDirectXFileData,(LPVOID *)&NextData)) {
const GUID* DataType = NULL;
// Enemerate animation keys
if (SUCCEEDED(NextData->GetType(&DataType))) {
if (TID_D3DRMAnimationKey == *DataType) {
DWORD* keyType = NULL;
DWORD* nKeys = NULL;
DWORD* keys = NULL;
DWORD Size;
NextData->GetData("keyType",&Size, (void **)&keyType);
NextData->GetData("nKeys",&Size, (void **)&nKeys);
NextData->GetData("keys",&Size, (void **)&keys);
if (*nKeys) {
switch (*keyType) {
case 0:LoadAnimationRotationKey(Animation,*nKeys,keys); break;
case 1:LoadAnimationScaleKey(Animation,*nKeys,keys); break;
case 2:LoadAnimationPositionKey(Animation,*nKeys,keys); break;
case 4:LoadAnimationMatrixKey(Animation,*nKeys,keys); break;
}
}
}
}
SAFERELEASE(NextData);
} else
if SUCCEEDED(NextObject->QueryInterface(IID_IDirectXFileDataReference,(LPVOID *)&NextDataRef)) {
//--- Get the reference to the target frame
if (SUCCEEDED(NextDataRef->Resolve(&NextData))) {
EntityName = GetFileObjectName(NextData);
XCKObjectsHashTableIt it=m_FrameHashTable.Find(EntityName);
Entity = (it==m_FrameHashTable.End()) ? NULL : (CK3dEntity*)*it;
SAFERELEASE(NextData);
}
SAFERELEASE(NextDataRef);
}
SAFERELEASE(NextObject);
}
//----------------------
//-- Set the target entity and add to exporter
Animation->SetName(EntityName.Str());
Animation->Set3dEntity(Entity);
m_VirtoolsExport->AddObjectAnimation(Animation);
return S_OK;
}
/*********************************************
Loads top level file data (frame , mesh,material,animation sets,etc..)
*********************************************/
HRESULT CKXReader::LoadFileData(LPDIRECTXFILEDATA CurData,CK3dEntity* Parent)
{
HRESULT hr = S_OK;
const GUID* DataType;
// Get the type of the object
hr = CurData->GetType(&DataType);
if (FAILED(hr)) return hr;
if (TID_D3DRMMaterial == *DataType) {
if (m_LoadFlags & CK_LOAD_GEOMETRY) {
LoadMaterial(CurData);
}
} else
if (TID_D3DRMMesh == *DataType) {
if (m_LoadFlags & CK_LOAD_GEOMETRY) {
hr = LoadMesh(CurData,Parent);
}
} else
if (TID_D3DRMFrameTransformMatrix == *DataType) {
if (m_LoadFlags & CK_LOAD_GEOMETRY) {
hr = LoadTransformationMatrix(CurData,Parent);
}
} else
if (TID_D3DRMAnimationSet == *DataType) {
hr = LoadAnimationSet(CurData);
} else
if (TID_D3DRMAnimation == *DataType) {
hr = LoadAnimation(CurData);
} else
if (TID_D3DRMFrame == *DataType) {
//------ A child frame -------
LPDIRECTXFILEDATA NextData = NULL;
LPDIRECTXFILEOBJECT NextObject = NULL;
CK3dEntity* NewFrame = NULL;
if (m_LoadFlags & CK_LOAD_GEOMETRY) {
XString FrameName = GetFileObjectName(CurData);
if (CharacterMode())
NewFrame = (CK3dEntity*)m_VirtoolsExport->AddCharacterBodyPart(FrameName.Str());
else
NewFrame = (CK3dEntity*)m_VirtoolsExport->Add3dObject(FrameName.Str());
m_FrameHashTable.Insert(FrameName,NewFrame);
NewFrame->SetParent(Parent);
}
// Enumerate child objects.
while (SUCCEEDED(CurData->GetNextObject(&NextObject))) {
// Query the child for it's FileData
if (SUCCEEDED(NextObject->QueryInterface(IID_IDirectXFileData,(LPVOID *)&NextData))) {
LoadFileData(NextData,NewFrame);
SAFERELEASE(NextData);
}
SAFERELEASE(NextObject);
}
} else {
// Unsuported Data Type
hr = S_OK;
}
return hr;
}
Reference in New Issue View Git Blame Copy Permalink