812 lines
21 KiB
C++
812 lines
21 KiB
C++
#pragma once
|
|
#include <kfile/KFiler.h>
|
|
#include "K3DTypes.h"
|
|
#include "KRenderDevice.h"
|
|
#include "KResource.h"
|
|
//#include "kSound.h"
|
|
#include "K3DBound.h"
|
|
#include <kfile/TRFMapper.h>
|
|
|
|
struct NX3LoadPack;
|
|
class KNX3MtlChannel;
|
|
class KNX3Mtl;
|
|
class KNX3MtlElement;
|
|
/**
|
|
KNX3MtelElement description.
|
|
- This class has a texuture and material information.
|
|
- Each object is referenced by KNX3MeshElement using MtlID
|
|
*/
|
|
class KNX3MtlElement
|
|
{
|
|
public:
|
|
KNX3MtlElement();
|
|
~KNX3MtlElement();
|
|
|
|
/// Delete material and texture release.
|
|
void Clear();
|
|
|
|
/// Load from filer object.
|
|
BOOL Load( KTemplateDataObject * pObject, const NX3LoadPack * ploadpack );
|
|
|
|
bool LoadTRF( trf::MTemplatePtr pObject, const NX3LoadPack* pLoadPack );
|
|
|
|
/// Get the Material ID which indicates relation between KNX3MtlElement and KNX3MeshElement.
|
|
DWORD GetMtlID() { return m_dwMtlID; }
|
|
|
|
K3DMaterial * GetMaterial() { return m_pMaterial; }
|
|
int GetBlendMode() { return m_nBlendmode; }
|
|
|
|
K3DTexture * GetTexture();
|
|
K3DTexture * GetBumpTexture();
|
|
K3DTexture * GetIlluminTexture();
|
|
K3DTexture * GetSpecularTexture();
|
|
K3DTexture * GetSpecularColorTexture();
|
|
|
|
private:
|
|
K3DTexture* _GetTexture(LPCSTR name);
|
|
|
|
private:
|
|
int m_nBlendmode; ///< 피직 모드
|
|
K3DMaterial* m_pMaterial; ///< 메트리얼
|
|
|
|
std::string m_sTextureName;
|
|
const NX3LoadPack* m_pLoadPack;
|
|
|
|
K3DTextureSPtr m_spTexture; ///< 텍스쳐 디퓨즈 맵
|
|
K3DTextureSPtr m_spTexture_Bump; ///< 텍스쳐 범프 맵
|
|
K3DTextureSPtr m_spTexture_Illumin; ///< 텍스쳐 셀프 일루민 맵
|
|
K3DTextureSPtr m_spTexture_Specular; ///< 텍스쳐 스페큘러 맵
|
|
K3DTextureSPtr m_spTexture_SpecularColorMap;///< 텍스쳐 스페큘러 칼라 맵
|
|
|
|
DWORD m_dwMtlID; ///< 메트리얼 ID
|
|
};
|
|
|
|
/**
|
|
KNX3MtlChannel description
|
|
- This class has the list of KNX3Mtl pointer object.
|
|
- It is related to KNX3MeshChannel.
|
|
*/
|
|
class KNX3MtlChannel
|
|
{
|
|
public:
|
|
KNX3MtlChannel(K3DRenderDevice * pGraphics);
|
|
~KNX3MtlChannel();
|
|
|
|
/// Get KNX3Mtl from ID.
|
|
KNX3Mtl * GetMtl(int nID);
|
|
/// Delete all mtl list.
|
|
void Clear();
|
|
BOOL Load(KTemplateDataObject * pObject, const NX3LoadPack * pLoadPack);
|
|
|
|
bool LoadTRF( trf::MTemplatePtr pObject, const NX3LoadPack* pLoadPack );
|
|
|
|
private:
|
|
K3DRenderDevice* m_pGraphics;
|
|
std::vector<KNX3Mtl *> m_vtMtlList; ///< 메트리얼 리스트
|
|
};
|
|
|
|
/**
|
|
- This class has the list of KNX3MtlElement pointer object.
|
|
- It is related to KNX3Mesh. (When load the KNX3Mesh, it is necessary)
|
|
*/
|
|
class KNX3Mtl
|
|
{
|
|
public:
|
|
KNX3Mtl(K3DRenderDevice * pGraphics);
|
|
~KNX3Mtl();
|
|
|
|
/// Delete all KNX3MtlElement.
|
|
void Clear();
|
|
BOOL Load(KTemplateDataObject * pObject, const NX3LoadPack * pLoadPack );
|
|
|
|
bool LoadTRF( trf::MTemplatePtr pObject, const NX3LoadPack* pLoadPack );
|
|
|
|
/// Get the MtlID from first item of list. (If list size is 0, return value is -1)
|
|
int GetMtlID()
|
|
{
|
|
if(m_vtMtlElement.size() > 0)
|
|
{
|
|
KNX3MtlElement * pElement = m_vtMtlElement.at(0);
|
|
return pElement->GetMtlID();
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
/// Get KNX3MtlElement from SubID which is index of list.
|
|
KNX3MtlElement * GetMtlElement(unsigned int nSubID)
|
|
{
|
|
if(nSubID >= m_vtMtlElement.size() || nSubID < 0)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
return m_vtMtlElement.at(nSubID);
|
|
}
|
|
|
|
private:
|
|
K3DRenderDevice* m_pGraphics;
|
|
std::vector<KNX3MtlElement*> m_vtMtlElement; ///< 메트리얼 구성 요소 리스트
|
|
};
|
|
|
|
struct KNX3MeshTM
|
|
{
|
|
char szName[64];
|
|
float baseTM[16];
|
|
};
|
|
|
|
//작업중..
|
|
//BERSERK
|
|
#pragma pack(push, 1)
|
|
typedef struct tagKNXgeneric_key_t
|
|
{
|
|
unsigned long msec;
|
|
|
|
union {
|
|
struct { /* linear position */
|
|
float pos[3];
|
|
} lin_pos;
|
|
|
|
struct { /* linear rotation */
|
|
float quat[4];
|
|
} lin_rot;
|
|
};
|
|
} KNXgeneric_key_t;
|
|
#pragma pack(pop)
|
|
|
|
class KNX3Bone
|
|
{
|
|
public:
|
|
KNX3Bone()
|
|
{
|
|
memset( szName, 0, sizeof(szName) );
|
|
m_nParentIndex = -1;
|
|
memset( m_BaseTM, 0, sizeof(m_BaseTM) );
|
|
m_dwFlag = 0; //Key flag
|
|
|
|
m_dwPosCount = 0;
|
|
m_pPosKey = NULL;
|
|
|
|
m_dwRotCount = 0;
|
|
m_pRotKey = NULL;
|
|
|
|
m_dwChildCount = 0;
|
|
m_pChildList = NULL;
|
|
}
|
|
~KNX3Bone()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void Clear()
|
|
{
|
|
SAFE_DELETE_ARRAY( m_pPosKey );
|
|
SAFE_DELETE_ARRAY( m_pRotKey );
|
|
SAFE_DELETE_ARRAY( m_pChildList );
|
|
}
|
|
|
|
BOOL Load( KTemplateDataObject * pObject );
|
|
|
|
bool LoadTRF( trf::MTemplatePtr pObject );
|
|
|
|
int GetParentIndex() { return m_nParentIndex; }
|
|
float * GetBaseTM() { return m_BaseTM; }
|
|
DWORD GetFlag() { return m_dwFlag; }
|
|
DWORD GetPosCount() { return m_dwPosCount; }
|
|
DWORD GetRotCount() { return m_dwRotCount; }
|
|
DWORD GetChildCount() { return m_dwChildCount; }
|
|
|
|
KNXgeneric_key_t* GetPosKey() { return m_pPosKey; }
|
|
KNXgeneric_key_t* GetRotKey() { return m_pRotKey; }
|
|
int * GetChildList() { return m_pChildList; }
|
|
|
|
char * GetName() { return szName; }
|
|
|
|
protected:
|
|
char szName[64]; ///< 본 이름
|
|
int m_nParentIndex;///< 부모 인덱스
|
|
float m_BaseTM[16]; ///< 기본 TM
|
|
DWORD m_dwFlag; ///< Key flag
|
|
|
|
DWORD m_dwPosCount; ///< 위치 수
|
|
KNXgeneric_key_t* m_pPosKey; ///< 위치 키 데이타 배열
|
|
|
|
DWORD m_dwRotCount; ///< 회전 수
|
|
KNXgeneric_key_t* m_pRotKey; ///< 회전 키 데이타 배열
|
|
|
|
DWORD m_dwChildCount; ///< 자식 수
|
|
int * m_pChildList; ///< 자식 리스트
|
|
};
|
|
|
|
class KNX3BoneChannel
|
|
{
|
|
public:
|
|
KNX3BoneChannel(K3DRenderDevice * pGraphics):m_pGraphics(pGraphics),m_spBoneRes(NULL) {};
|
|
~KNX3BoneChannel(){ Clear(); }
|
|
|
|
void Clear();
|
|
|
|
/// Load from filer.
|
|
BOOL Load( KTemplateDataObject * pObject, const char * szName, DWORD dwVersion );
|
|
|
|
bool LoadTRF( trf::MTemplatePtr pObject, const char* szName, DWORD dwVersion );
|
|
|
|
K3DBoneResource * GetBoneRes() { return m_spBoneRes; }
|
|
|
|
protected:
|
|
K3DRenderDevice* m_pGraphics;
|
|
|
|
DWORD m_dwChannelFlag; ///< ???
|
|
DWORD m_dwChannelTimeSpan; ///< 채널 시간 길이
|
|
DWORD m_dwChannelFrameRate;///< 프레임 률
|
|
char m_szChannelName[128];///< 채널 이름
|
|
|
|
K3DBoneResourceSPtr m_spBoneRes;
|
|
};
|
|
|
|
class KNX3Mesh;
|
|
|
|
class KNX3MeshElement;
|
|
class KNX3AniElement;
|
|
class KNX3VisiElement;
|
|
class KNX3FX;
|
|
//class KNX3Sound;
|
|
|
|
class KNX3MeshFrame;
|
|
|
|
typedef std::vector<KNX3MeshElement *> MeshVector;
|
|
typedef std::vector<KNX3FX *> FXVector;
|
|
typedef std::vector<KNX3MeshFrame *> MeshFrameVector;
|
|
|
|
|
|
class KNX3MeshChannel
|
|
{
|
|
public:
|
|
enum LOAD_TYPE
|
|
{
|
|
LT_OLD_MESH = 0,
|
|
LT_NEW_MESH,
|
|
};
|
|
|
|
public:
|
|
KNX3MeshChannel(K3DRenderDevice * pGraphics, KNX3MtlChannel * pMtlChannel);
|
|
~KNX3MeshChannel();
|
|
|
|
/// Delete all KNX3Mesh.
|
|
void Clear();
|
|
|
|
/// Load from filer.
|
|
BOOL Load( const NX3LoadPack * pLoadPack, KTemplateDataObject * pObject, int loadType );
|
|
|
|
bool LoadTRF( const NX3LoadPack * pLoadPack, trf::MTemplatePtr pObject, int loadType );
|
|
|
|
/// Get list of KNX3Mesh. (which is vector)
|
|
std::vector<KNX3Mesh *> & GetMeshList()
|
|
{
|
|
return m_vtMeshList;
|
|
}
|
|
|
|
std::vector<KNX3MeshTM *> & GetMeshTMList()
|
|
{
|
|
return m_vtMeshTM;
|
|
}
|
|
|
|
private:
|
|
K3DRenderDevice* m_pGraphics;
|
|
KNX3MtlChannel* m_pMtlChannel; ///< 메트리얼 채널
|
|
std::vector<KNX3Mesh *> m_vtMeshList; ///< 메쉬 리스트
|
|
|
|
std::vector<KNX3MeshTM *> m_vtMeshTM; ///< 메쉬 TM
|
|
};
|
|
|
|
/**
|
|
KNX3Mesh description.
|
|
- This class has the list of KNX3MeshElement pointer object, matrix animation, visibility information, fx note.
|
|
- When load this mesh, get the appropriate KNX3Mtl from input KNX3MtlChannel by MtlID.
|
|
- The list of Child KNX3Mesh are connected whth this mesh.
|
|
*/
|
|
class KNX3Mesh
|
|
{
|
|
|
|
public:
|
|
KNX3Mesh(K3DRenderDevice * pGraphics);
|
|
~KNX3Mesh();
|
|
|
|
/// Delete all resource.
|
|
void Clear();
|
|
|
|
/// Load from Filer.
|
|
BOOL Load( const NX3LoadPack * pLoadPack, KTemplateDataObject * pObject, KNX3MtlChannel * pMtlChannel, int loadType);
|
|
|
|
bool LoadTRF( const NX3LoadPack * pLoadPack, trf::MTemplatePtr pObject, KNX3MtlChannel * pMtlChannel, int loadType );
|
|
|
|
/// Get MeshElements vector.
|
|
MeshVector& GetMeshElements() { return m_vtMeshElement; }
|
|
|
|
/// Get Fx-Note Vectors.
|
|
FXVector& GetFXVector() { return m_vtFX; }
|
|
|
|
/// Get Matrix Animation information.
|
|
K3DResMeshMatrixAnimation* GetMatrixAniRes() { return m_spAniElement; }
|
|
|
|
/// Get Visibility information.
|
|
K3DResMeshVisibilityAnimation* GetVisibilityRes() { return m_spVisiElement; }
|
|
/// Get UVAni information.
|
|
K3DResMeshUVAnimation* GetUVAniRes() { return m_spUVAniElement; }
|
|
const char *GetMeshName() { return m_sMeshName.c_str(); }
|
|
|
|
/// Exist of FX-Note vector.
|
|
bool IsFX() { return m_bIsFX; }
|
|
/// Event Box
|
|
bool IsEventBox() { return m_bIsEventBox; }
|
|
bool IsEventPoint() { return m_bIsEventPoint; }
|
|
|
|
/// Get child mesh vector.
|
|
std::vector<KNX3Mesh *> & GetChild() { return m_vtChildMesh; }
|
|
private:
|
|
void loadUVAni( KNX3FX *pFX );
|
|
void loadAniAndVisiBlockOldType(KTemplateDataObject* pObject);
|
|
void loadAniAndVisiBlockNewType(KTemplateDataObject* pObject);
|
|
void loadAniAndVisiBlockOldType(trf::MTemplatePtr pObject);
|
|
void loadAniAndVisiBlockNewType(trf::MTemplatePtr pObject);
|
|
private:
|
|
|
|
bool m_bIsEventBox; ///< 이벤트 박스?
|
|
bool m_bIsEventPoint; ///< 이벤트 포인트?
|
|
bool m_bIsFX; ///< FX ?
|
|
std::string m_sMeshName; ///< 메쉬 이름
|
|
|
|
DWORD m_dwMaterialID; ///< 메트리얼 ID
|
|
DWORD m_dwChannelID; ///< 채널 ID
|
|
|
|
MeshVector m_vtMeshElement; ///< MeshElement List
|
|
K3DResMeshMatrixAnimationSPtr m_spAniElement; ///< MeshMatrixAnimation
|
|
K3DResMeshVisibilityAnimationSPtr m_spVisiElement; ///< MeshVisibilityAnimation
|
|
K3DResMeshUVAnimationSPtr m_spUVAniElement; ///< MeshUVAnimation
|
|
FXVector m_vtFX;
|
|
|
|
std::vector<KNX3Mesh *> m_vtChildMesh; ///< 자식 메쉬
|
|
|
|
KNX3Mtl* m_pMtl; ///< 메트리얼
|
|
K3DRenderDevice* m_pGraphics;
|
|
};
|
|
|
|
class KNX3MeshElement
|
|
{
|
|
public:
|
|
KNX3MeshElement(K3DRenderDevice * pGraphics);
|
|
~KNX3MeshElement();
|
|
|
|
/// Delete all resources.
|
|
void Clear();
|
|
|
|
/// Load from filer.
|
|
BOOL Load(const NX3LoadPack * pLoadPack, const char *meshname, KTemplateDataObject * pObject, KNX3Mtl * pMtl);
|
|
|
|
bool LoadTRF( const NX3LoadPack * pLoadPack, const char *meshname, trf::MTemplatePtr pObject, KNX3Mtl * pMtl );
|
|
|
|
/// Get created index buffer.
|
|
K3DIndexBuffer* GetIndexBuffer() { return m_spIndices; }
|
|
|
|
/// 충돌, 높낮이 용
|
|
K3DUnsignedShortRes* GetIndexArray() { return m_spIdxarry; }
|
|
|
|
int GetPrimitiveCount() { return m_dwNumIndexBuffer/3; }
|
|
int GetSimultaneousFrameCount() { return m_nSimultaneousFrameCount; }
|
|
|
|
/// Get number of mesh frame. (ordinarily 1)
|
|
int GetFrameCount() { return static_cast<int>(m_vtMeshFrame.size()); }
|
|
/// Get MeshFrame by index.
|
|
KNX3MeshFrame* GetFrame( int index ) { return m_vtMeshFrame.at(index); }
|
|
|
|
/// Get associated texture. (caution : reference count is added)
|
|
K3DTexture* GetTexture() { return m_spTexture; }
|
|
K3DTexture* GetBumpTexture() { return m_spTexture_Bump; }
|
|
K3DTexture* GetIlluminTexture() { return m_spTexture_Illumin; }
|
|
K3DTexture* GetSpecularTexture() { return m_spTexture_Specular; }
|
|
K3DTexture* GetSpecularColorTexture() { return m_spTexture_SpecularColor; }
|
|
|
|
DWORD GetLightMapIndex() { return m_lightMapIndex; }
|
|
void SetLightMapIndex( DWORD index ) { m_lightMapIndex = index; }
|
|
|
|
/// Get associated material.
|
|
K3DMaterial* GetMaterial()
|
|
{
|
|
return m_pMaterial;
|
|
}
|
|
int GetBlendMode()
|
|
{
|
|
return m_nBlendMode;
|
|
}
|
|
bool IsEventBox()
|
|
{
|
|
return m_bIsEventBox;
|
|
}
|
|
bool IsEventPoint()
|
|
{
|
|
return m_bIsEventPoint;
|
|
}
|
|
const K3DBoundRotCube &GetEventCube()
|
|
{
|
|
return m_bEventCube;
|
|
}
|
|
const K3DBoundSphere &GetBoundSphere()
|
|
{
|
|
return m_bSphere;
|
|
}
|
|
K3DBoundRotCube &GetWritableEventCube()
|
|
{
|
|
return m_bEventCube;
|
|
}
|
|
K3DBoundSphere &GetWritableBoundSphere()
|
|
{
|
|
return m_bSphere;
|
|
}
|
|
|
|
private:
|
|
|
|
// Reference
|
|
bool m_bIsEventBox; ///< 이벤트 박스?
|
|
bool m_bIsEventPoint; ///< 이벤트 포인트?
|
|
K3DBoundRotCube m_bEventCube; ///< 이벤트 큐브
|
|
K3DBoundSphere m_bSphere; ///< 스피어
|
|
K3DRenderDevice* m_pGraphics;
|
|
K3DTextureSPtr m_spTexture; ///< 텍스쳐 디퓨즈
|
|
K3DTextureSPtr m_spTexture_Bump; ///< 텍스쳐 범프
|
|
K3DTextureSPtr m_spTexture_Illumin; ///< 텍스쳐 셀프 일루민
|
|
K3DTextureSPtr m_spTexture_Specular; ///< 텍스쳐 스페큘러
|
|
K3DTextureSPtr m_spTexture_SpecularColor; ///< 텍스쳐 스페큘러 칼라맵
|
|
|
|
K3DMaterial* m_pMaterial; ///< 메트리얼
|
|
int m_nBlendMode; ///< 블랜드 모드
|
|
BOOL m_bDeletK3DMaterial; ///< ??
|
|
DWORD m_dwFormat; ///< 버텍스 포맷
|
|
DWORD m_dwStride; ///< 버텍스 간격
|
|
DWORD m_dwNumVertex; ///< 버텍스 수
|
|
|
|
int m_nSimultaneousFrameCount; ///< 동시에 존재 하는 프레임 수
|
|
DWORD m_dwNumIndexBuffer; ///< 인덱스 버퍼 수
|
|
K3DIndexBufferSPtr m_spIndices; ///< Index Buffer
|
|
|
|
K3DUnsignedShortResSPtr m_spIdxarry; ///< 충돌 정보 관련 버텍스 인덱스
|
|
|
|
DWORD m_lightMapIndex;
|
|
|
|
MeshFrameVector m_vtMeshFrame; ///< MeshFrame 리스트
|
|
};
|
|
|
|
//Weight 작업중..
|
|
class KNX3WeightElement
|
|
{
|
|
public:
|
|
KNX3WeightElement();
|
|
~KNX3WeightElement();
|
|
|
|
BOOL Load(KTemplateDataObject * pObject);
|
|
|
|
bool LoadTRF( trf::MTemplatePtr pObject );
|
|
|
|
DWORD GetWeightSize() { return m_dwWeightSize; }
|
|
float * GetVertexIndex() { return m_pVertexIndex; }
|
|
float * GetVertexWeight() { return m_pVertexWeight; }
|
|
char * GetBoneName() { return m_szBoneName; }
|
|
|
|
K3DVector * GetOffSetVector() { return m_pOffsetVector; }
|
|
|
|
private:
|
|
char m_szBoneName[64];
|
|
DWORD m_dwWeightSize; ///< 가중치 수
|
|
float * m_pVertexIndex; ///< 버텍스 인덱스
|
|
float * m_pVertexWeight; ///< 버텍스 가중치
|
|
DWORD m_dwOffsetVectorSize; ///< Offset Vector 수
|
|
K3DVector * m_pOffsetVector; ///< Offset Vector
|
|
};
|
|
|
|
class KNX3MeshFrame
|
|
{
|
|
public:
|
|
KNX3MeshFrame( K3DRenderDevice *pGraphics );
|
|
~KNX3MeshFrame();
|
|
|
|
void Clear();
|
|
BOOL Load(const NX3LoadPack * pLoadPack, const char *meshname, int idxcount, const WORD *_idxlist, KTemplateDataObject * pObject,
|
|
DWORD & dwFormat, DWORD & dwStride, DWORD & dwNumVertex, KTemplateDataObject* pFirstObject = NULL);
|
|
|
|
bool LoadTRF(const NX3LoadPack * pLoadPack, const char *meshname, int idxcount, const WORD *_idxlist, trf::MTemplatePtr pObject,
|
|
DWORD & dwFormat, DWORD & dwStride, DWORD & dwNumVertex, trf::MTemplatePtr pFirstObject = NULL);
|
|
|
|
K3DVertexBuffer* GetVertexBuffer()
|
|
{
|
|
return m_spVertexBuffer;
|
|
}
|
|
|
|
K3DVertexRes* GetVertexArray()
|
|
{
|
|
return m_spVtxArray;
|
|
}
|
|
|
|
DWORD GetFrameTime()
|
|
{
|
|
return m_dwFrameTime;
|
|
}
|
|
bool IsEventBox()
|
|
{
|
|
return m_bIsEventBox;
|
|
}
|
|
bool IsEventPoint()
|
|
{
|
|
return m_bIsEventPoint;
|
|
}
|
|
const K3DBoundSphere &GetSphere()
|
|
{
|
|
return m_bSphere;
|
|
}
|
|
const K3DBoundRotCube &GetCube()
|
|
{
|
|
return m_bCube;
|
|
}
|
|
|
|
int GetBoneSize() { return m_dwBoneSize; }
|
|
std::vector< KNX3WeightElement * > & GetWeightList() { return m_vWeightList; }
|
|
|
|
int GetSimultaneousFrameCount() { return m_nMeshSimultaneousFrameCount; }
|
|
|
|
K3DMatrix * GetNodeTM() { return &m_NodeTM; }
|
|
|
|
void AddUseBoneIndex( int nIndex );
|
|
int GetUseBoneIndexCount() { return (int)m_vUseBoneList.size(); }
|
|
int * GetUseBoneList() { return &m_vUseBoneList[0]; }
|
|
|
|
private:
|
|
int GetNewBoneIndex( int nBoneIndex );
|
|
|
|
void _MakeVertexBuffer(DWORD numVertex, DWORD format, DWORD stride, KTemplateDataArrayObject* pWeightArray, const NX3LoadPack * pLoadPack,
|
|
KSimpleDataArrayObject* pVertexArray,KSimpleDataArrayObject* pNormalArray, KSimpleDataArrayObject* pColorArray,KSimpleDataArrayObject* pTexelArray,
|
|
int indexCount, const WORD* pIndexArray);
|
|
|
|
void _MakeWeightInfo(KTemplateDataArrayObject* pWeightArray, K3DBLENDEDBUMPVERTEX* pBlendVtxArray, DWORD numVertex);
|
|
|
|
void _MakeVertexBuffer(DWORD numVertex, DWORD format, DWORD stride, trf::MTemplateArrayPtr pWeightArray, const NX3LoadPack * pLoadPack,
|
|
trf::MArrayPtr pVertexArray, trf::MArrayPtr pNormalArray, trf::MArrayPtr pColorArray, trf::MArrayPtr pTexelArray,
|
|
int indexCount, const WORD* pIndexArray);
|
|
|
|
void _MakeWeightInfo( trf::MTemplateArrayPtr pWeightArray, K3DBLENDEDBUMPVERTEX* pBlendVtxArray, DWORD numVertex);
|
|
|
|
private:
|
|
bool m_bIsEventBox; ///< 이벤트 박스?
|
|
bool m_bIsEventPoint; ///< 이벤트 포인트 ?
|
|
K3DRenderDevice* m_pGraphics;
|
|
|
|
DWORD m_dwFrameTime; ///< 프레임 시간
|
|
K3DVertexBufferSPtr m_spVertexBuffer; ///< 버텍스 버퍼
|
|
|
|
|
|
K3DBoundRotCube m_bCube; ///< 큐브
|
|
K3DBoundSphere m_bSphere; ///< 스피어
|
|
|
|
K3DVertexResSPtr m_spVtxArray; ///< 충돌 정보 관련 버텍스
|
|
|
|
bool m_bIsBlended; ///< 쉐이더용 셋팅
|
|
|
|
//Weight
|
|
DWORD m_dwBoneSize; ///<뼈수 만큼.
|
|
std::vector< KNX3WeightElement * > m_vWeightList; ///<뼈수 만큼.
|
|
|
|
int m_nMeshSimultaneousFrameCount; ///< 동시에 찍을 수 있는 갯수
|
|
|
|
//UseBoneIndex
|
|
std::vector< int > m_vUseBoneList; ///< 사용하는 뼈 인덱스
|
|
|
|
K3DMatrix m_NodeTM; ///< TM
|
|
};
|
|
|
|
class KNX3FXElement
|
|
{
|
|
public:
|
|
KNX3FXElement();
|
|
~KNX3FXElement();
|
|
|
|
BOOL Load(KTemplateDataObject * pObject);
|
|
|
|
bool LoadTRF( trf::MTemplatePtr pObject );
|
|
|
|
DWORD GetFrameTime()
|
|
{
|
|
return m_dwFrameTime;
|
|
}
|
|
const char *GetNote()
|
|
{
|
|
return m_sNote.c_str();
|
|
}
|
|
bool IsFX()
|
|
{
|
|
return m_bIsFX;
|
|
}
|
|
const char *GetValue( const char *fname );
|
|
int GetNumValue( const char *key, int nDef );
|
|
float GetFloatValue( const char *key, float fDef );
|
|
K3DVector GetVectorValue( const char *key, const K3DVector &vecDef );
|
|
K3DVector Get2DVectorValue( const char *key, const K3DVector &vecDef );
|
|
void GetVariNumValue( const char *key, int *base_num, int *vari_num );
|
|
|
|
private:
|
|
void parse();
|
|
void getKeyValue( std::string &value, int &pos );
|
|
bool getKey( std::string &key, int &pos );
|
|
struct DATA
|
|
{
|
|
std::string key;
|
|
std::string value;
|
|
};
|
|
std::vector<DATA> m_vecData; ///< FX Data ??
|
|
bool m_bIsFX; ///< FX?
|
|
DWORD m_dwFrameTime; ///< 프레임 시간
|
|
std::string m_sNote; ///< Note 이름 ??
|
|
};
|
|
|
|
class KNX3FX
|
|
{
|
|
public:
|
|
KNX3FX()
|
|
{
|
|
m_bIsFX = false;
|
|
m_vtFXElement.clear();
|
|
}
|
|
|
|
~KNX3FX()
|
|
{
|
|
m_vtFXElement.clear();
|
|
}
|
|
|
|
BOOL Load(KTemplateDataObject * pObject);
|
|
|
|
bool LoadTRF( trf::MTemplatePtr pObject );
|
|
|
|
bool IsFX()
|
|
{
|
|
return m_bIsFX;
|
|
}
|
|
KNX3FXElement * GetFXElement(DWORD dwFrmaeTime);
|
|
KNX3FXElement * GetFxElementByIndeX(int iIndex);
|
|
DWORD GetFXElementSize();
|
|
|
|
private:
|
|
bool m_bIsFX; ///< FX ?
|
|
std::vector<KNX3FXElement> m_vtFXElement; ///< FX Element 구성 요소
|
|
};
|
|
|
|
class KNX3CameraChannel
|
|
{
|
|
public:
|
|
KNX3CameraChannel(K3DRenderDevice * pGraphics)
|
|
{
|
|
m_pGraphics = pGraphics;
|
|
}
|
|
~KNX3CameraChannel()
|
|
{
|
|
}
|
|
|
|
BOOL Load(KTemplateDataObject * pObject);
|
|
|
|
bool LoadTRF( trf::MTemplatePtr pObject );
|
|
|
|
K3DResCamera* GetCameraRes() { return m_spCameraRes; }
|
|
private:
|
|
K3DRenderDevice* m_pGraphics;
|
|
K3DResCameraSPtr m_spCameraRes; ///< 카메라 리소스
|
|
};
|
|
|
|
class KNX3Light
|
|
{
|
|
public:
|
|
KNX3Light(K3DRenderDevice * pGraphics)
|
|
{
|
|
m_pGraphics = pGraphics;
|
|
}
|
|
~KNX3Light()
|
|
{
|
|
}
|
|
K3DResLight* GetLightRes() { return m_spLightRes; }
|
|
BOOL Load(KTemplateDataObject * pObject);
|
|
|
|
bool LoadTRF( trf::MTemplatePtr pObject );
|
|
|
|
private:
|
|
K3DResLightSPtr m_spLightRes; ///< 라이트 리소스
|
|
K3DRenderDevice* m_pGraphics;
|
|
};
|
|
|
|
class KNX3LightChannel
|
|
{
|
|
public:
|
|
KNX3LightChannel(K3DRenderDevice * pGraphics)
|
|
{
|
|
m_pGraphics = pGraphics;
|
|
m_vtLightList.clear();
|
|
}
|
|
~KNX3LightChannel()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void Clear();
|
|
BOOL Load(KTemplateDataObject * pObject);
|
|
|
|
bool LoadTRF( trf::MTemplatePtr pObject );
|
|
|
|
BOOL Render(DWORD dwFrameTime);
|
|
|
|
int GetLightCount() { return static_cast<int>(m_vtLightList.size()); }
|
|
KNX3Light* GetLight( int index ) { return m_vtLightList[index]; }
|
|
private:
|
|
K3DRenderDevice * m_pGraphics;
|
|
std::vector<KNX3Light *> m_vtLightList; ///< 라이트 리스트
|
|
|
|
};
|
|
|
|
|
|
class KNX3ChannelControl
|
|
{
|
|
public:
|
|
KNX3ChannelControl()
|
|
{
|
|
m_pMtlChannel = NULL; m_pMeshChannel = NULL; m_pLightChannel = NULL; m_pCameraChannel = NULL; //m_pSoundChannel = NULL;
|
|
m_pBoneChannel = NULL;
|
|
#ifdef _KPATH_EFFECT
|
|
m_pPfxChannel = NULL;
|
|
#endif
|
|
m_dwVersion = ( 1 << 16 ) | 0;
|
|
}
|
|
~KNX3ChannelControl()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void Clear();
|
|
KNX3MtlChannel* GetMtlChannel()
|
|
{
|
|
return m_pMtlChannel;
|
|
}
|
|
KNX3MeshChannel* GetMeshChannel()
|
|
{
|
|
return m_pMeshChannel;
|
|
}
|
|
KNX3CameraChannel* GetCameraChannel()
|
|
{
|
|
return m_pCameraChannel;
|
|
}
|
|
KNX3LightChannel* GetLightChannel()
|
|
{
|
|
return m_pLightChannel;
|
|
}
|
|
|
|
KNX3BoneChannel * GetBoneChannel()
|
|
{
|
|
return m_pBoneChannel;
|
|
}
|
|
|
|
DWORD GetVersion()
|
|
{
|
|
return m_dwVersion;
|
|
}
|
|
|
|
const char* GetPropertyString()
|
|
{
|
|
return m_strProperty.c_str();
|
|
}
|
|
|
|
BOOL Load( const NX3LoadPack * pLoadPack, K3DRenderDevice * pGraphics, /*KSoundDevice * pSound ,*/ KFiler * pFiler, const char * pFileName );
|
|
|
|
bool LoadTRF( const NX3LoadPack * pLoadPack, K3DRenderDevice * pGraphics, /*KSoundDevice * pSound ,*/ trf::MDictPtr pRoot, const char * pFileName );
|
|
|
|
private:
|
|
KNX3MtlChannel * m_pMtlChannel; ///< 메트리얼 채널
|
|
KNX3MeshChannel * m_pMeshChannel; ///< Mesh 채널
|
|
KNX3LightChannel * m_pLightChannel; ///< 빛 채널
|
|
KNX3CameraChannel * m_pCameraChannel; ///< 카메라 채널
|
|
//작업중..
|
|
KNX3BoneChannel * m_pBoneChannel; ///< 본 채널
|
|
DWORD m_dwVersion;
|
|
std::string m_strProperty;
|
|
};
|