3422 lines
102 KiB
C++
3422 lines
102 KiB
C++
#include "stdafx.h"
|
|
#include "KNX3Loader.h"
|
|
#include "K3DBound.h"
|
|
#include "KResourceManager.h"
|
|
#include "nx10.h"
|
|
#include <mmo/ArTime.h>
|
|
|
|
#include "k3dpccp.h"
|
|
|
|
using namespace trf;
|
|
|
|
namespace
|
|
{
|
|
|
|
void fillAnimatrixFromArray(float* pArray, K3DMatrix* pOutput)
|
|
{
|
|
pOutput->_11 = pArray[0]; pOutput->_12 = pArray[1]; pOutput->_13 = pArray[2]; pOutput->_14 = .0f;
|
|
pOutput->_21 = pArray[3]; pOutput->_22 = pArray[4]; pOutput->_23 = pArray[5]; pOutput->_24 = .0f;
|
|
pOutput->_31 = pArray[6]; pOutput->_32 = pArray[7]; pOutput->_33 = pArray[8]; pOutput->_34 = .0f;
|
|
pOutput->_41 = pArray[9]; pOutput->_42 = pArray[10]; pOutput->_43 = pArray[11]; pOutput->_44 = 1.0f;
|
|
}
|
|
|
|
inline const char* SafeStr( const char* pStr )
|
|
{
|
|
return pStr ? pStr : "";
|
|
}
|
|
}
|
|
|
|
enum LIGHT_TYPE
|
|
{
|
|
NX3LIGHT_OMNI = 0,
|
|
NX3LIGHT_SIMPLE_OMNI,
|
|
NX3LIGHT_TARGET_DIRECTIONAL,
|
|
NX3LIGHT_FREE_DIRECTIONAL,
|
|
};
|
|
|
|
|
|
KNX3MtlChannel::KNX3MtlChannel(K3DRenderDevice * pGraphics)
|
|
{
|
|
m_pGraphics = pGraphics;
|
|
m_vtMtlList.clear();
|
|
}
|
|
|
|
KNX3MtlChannel::~KNX3MtlChannel()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void KNX3MtlChannel::Clear()
|
|
{
|
|
m_pGraphics = NULL;
|
|
SAFE_DELETE_VECTOR(m_vtMtlList);
|
|
}
|
|
|
|
KNX3Mtl * KNX3MtlChannel::GetMtl(int nID)
|
|
{
|
|
for(unsigned int i(0); i < m_vtMtlList.size(); ++i)
|
|
{
|
|
KNX3Mtl * pMtl = m_vtMtlList.at(i);
|
|
|
|
if(pMtl->GetMtlID() == nID)
|
|
{
|
|
return pMtl;
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
BOOL KNX3MtlChannel::Load( KTemplateDataObject* pObject, const NX3LoadPack * pLoadPack )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
DWORD dwNumMtl;
|
|
KSimpleDataObject * pNumMtl = pObject->GetSimpleDataMemberObject("mtl_size");
|
|
pNumMtl->GetDWORD(&dwNumMtl);
|
|
|
|
KTemplateDataArrayObject * pMtlArray = pObject->GetTemplateDataArrayMemberObject("mtl_array");
|
|
|
|
for(unsigned int i(0); i < dwNumMtl; ++i)
|
|
{
|
|
KNX3Mtl * pMtl = new KNX3Mtl(m_pGraphics);
|
|
pMtl->Load( pMtlArray->GetData(i), pLoadPack );
|
|
m_vtMtlList.push_back(pMtl);
|
|
}
|
|
|
|
if( GetSafeTickCount()-dwTime > 80 )
|
|
{
|
|
// _oprint( "Load Time : KNX3MtlChannel::Load - %d : %dms\n", dwNumMtl, GetSafeTickCount()-dwTime );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3MtlChannel::LoadTRF( trf::MTemplatePtr pObject, const NX3LoadPack * pLoadPack )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
trf::MTemplateArrayPtr pMtlArray = pObject->getTemplateArrayBy("mtl_array");
|
|
|
|
for(int i(0); i < pMtlArray->count(); ++i)
|
|
{
|
|
KNX3Mtl * pMtl = new KNX3Mtl(m_pGraphics);
|
|
pMtl->LoadTRF( pMtlArray->getTemplateAt(i), pLoadPack );
|
|
m_vtMtlList.push_back(pMtl);
|
|
}
|
|
|
|
if( GetSafeTickCount()-dwTime > 80 )
|
|
{
|
|
// _oprint( "Load Time : KNX3MtlChannel::Load - %d : %dms\n", pMtlArray->count(), GetSafeTickCount()-dwTime );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Material
|
|
KNX3Mtl::KNX3Mtl(K3DRenderDevice * pGraphics)
|
|
{
|
|
m_pGraphics = pGraphics;
|
|
m_vtMtlElement.clear();
|
|
}
|
|
KNX3Mtl::~KNX3Mtl()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void KNX3Mtl::Clear()
|
|
{
|
|
m_pGraphics = NULL;
|
|
SAFE_DELETE_VECTOR(m_vtMtlElement);
|
|
}
|
|
|
|
BOOL KNX3Mtl::Load( KTemplateDataObject * pObject, const NX3LoadPack * pLoadPack )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
DWORD dwNumSubMtl;
|
|
KSimpleDataObject * pNumSubMtl = pObject->GetSimpleDataMemberObject("sub_mtl_block_size");
|
|
pNumSubMtl->GetDWORD(&dwNumSubMtl);
|
|
|
|
KTemplateDataArrayObject * pSubMtlArray = pObject->GetTemplateDataArrayMemberObject("sub_mtl_block_array");
|
|
|
|
for(unsigned int i(0); i < dwNumSubMtl; ++i)
|
|
{
|
|
KNX3MtlElement* pElement = new KNX3MtlElement();
|
|
pElement->Load( pSubMtlArray->GetData(i), pLoadPack );
|
|
m_vtMtlElement.push_back(pElement);
|
|
}
|
|
|
|
// _oprint( "Load Cnt : KNX3MtlElement::Load : %d\n", dwNumSubMtl );
|
|
|
|
// _oprint( "Load Time : KNX3Mtl::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3Mtl::LoadTRF( trf::MTemplatePtr pObject, const NX3LoadPack * pLoadPack )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
trf::MTemplateArrayPtr pSubMtlArray = pObject->getTemplateArrayBy("sub_mtl_block_array");
|
|
|
|
for(int i(0); i < pSubMtlArray->count(); ++i)
|
|
{
|
|
KNX3MtlElement* pElement = new KNX3MtlElement();
|
|
pElement->LoadTRF( pSubMtlArray->getTemplateAt(i), pLoadPack );
|
|
m_vtMtlElement.push_back(pElement);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// Material Element
|
|
KNX3MtlElement::KNX3MtlElement()
|
|
{
|
|
m_pMaterial = NULL;
|
|
m_dwMtlID = 0;
|
|
m_nBlendmode = K3DMaterial::MBM_DEFAULT;
|
|
}
|
|
KNX3MtlElement::~KNX3MtlElement()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void KNX3MtlElement::Clear()
|
|
{
|
|
SAFE_DELETE(m_pMaterial);
|
|
m_dwMtlID = 0;
|
|
}
|
|
|
|
BOOL KNX3MtlElement::Load( KTemplateDataObject * pObject, const NX3LoadPack * ploadpack )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
char lpszTextureName[512];
|
|
ZeroMemory( lpszTextureName, sizeof( lpszTextureName ) );
|
|
int iStrLen = 512;
|
|
m_pLoadPack = ploadpack;
|
|
|
|
m_pMaterial = new K3DMaterial;
|
|
|
|
KSimpleDataObject * pTextureName = pObject->GetSimpleDataMemberObject("texture_name");
|
|
pTextureName->GetString(lpszTextureName, iStrLen);
|
|
m_sTextureName = lpszTextureName;
|
|
|
|
KSimpleDataObject * pMtlID = pObject->GetSimpleDataMemberObject("mtl_id");
|
|
pMtlID->GetDWORD(&m_dwMtlID);
|
|
|
|
float fPower;
|
|
KSimpleDataObject * pPower = pObject->GetSimpleDataMemberObject("power");
|
|
pPower->GetFloat(&fPower);
|
|
m_pMaterial->SetSpecularPower( fPower );
|
|
|
|
DWORD dwAmbient;
|
|
KSimpleDataObject * pAmbient = pObject->GetSimpleDataMemberObject("ambient");
|
|
pAmbient->GetDWORD(&dwAmbient);
|
|
m_pMaterial->SetAmbient( K3DColor(dwAmbient) );
|
|
|
|
DWORD dwDiffuse;
|
|
KSimpleDataObject * pDiffuse = pObject->GetSimpleDataMemberObject("diffuse");
|
|
pDiffuse->GetDWORD(&dwDiffuse);
|
|
m_pMaterial->SetDiffuse( K3DColor(dwDiffuse) );
|
|
|
|
DWORD dwSpecular;
|
|
KSimpleDataObject * pSpecular = pObject->GetSimpleDataMemberObject("specular");
|
|
pSpecular->GetDWORD(&dwSpecular);
|
|
m_pMaterial->SetSpecular( K3DColor(dwSpecular) );
|
|
|
|
/*
|
|
m_pMaterial->SetAmbient( K3DColor( .2f, .2f, .2f ) );
|
|
m_pMaterial->SetDiffuse( K3DColor( 8.f, 8.f, 8.f ) );
|
|
m_pMaterial->SetSpecular( K3DColor( 1.f, 1.f, 1.f ) );
|
|
*/
|
|
|
|
float fSelfIlum;
|
|
KSimpleDataObject * pSelfIlum = pObject->GetSimpleDataMemberObject("self_illumi");
|
|
pSelfIlum->GetFloat(&fSelfIlum);
|
|
if( fSelfIlum > 0.8f )
|
|
{
|
|
m_nBlendmode = K3DMaterial::MBM_ADDITIVE;
|
|
m_pMaterial->SetAmbient( K3DColor( .5f, .5f, .5f ) );
|
|
m_pMaterial->SetDiffuse( K3DColor( 8.f, 8.f, 8.f ) );
|
|
m_pMaterial->SetSpecular( K3DColor( 1.f, 1.f, 1.f ) );
|
|
}
|
|
else if( fSelfIlum > 0.6f )
|
|
{
|
|
m_nBlendmode = K3DMaterial::MBM_ALPHABLENDTWOPASS;
|
|
}
|
|
else if( fSelfIlum > 0.4f )
|
|
{
|
|
m_nBlendmode = K3DMaterial::MBM_ALPHABLEND;
|
|
}
|
|
else
|
|
{
|
|
m_nBlendmode = K3DMaterial::MBM_DEFAULT;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3MtlElement::LoadTRF( trf::MTemplatePtr pObject, const NX3LoadPack * ploadpack )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
m_pLoadPack = ploadpack;
|
|
|
|
m_pMaterial = new K3DMaterial;
|
|
|
|
m_sTextureName = SafeStr( pObject->getStringBy("texture_name") );
|
|
m_dwMtlID = pObject->getDWordBy("mtl_id");
|
|
|
|
m_pMaterial->SetSpecularPower( pObject->getFloatBy("power") );
|
|
m_pMaterial->SetAmbient( K3DColor( pObject->getDWordBy("ambient") ) );
|
|
m_pMaterial->SetDiffuse( K3DColor( pObject->getDWordBy("diffuse") ) );
|
|
m_pMaterial->SetSpecular( K3DColor( pObject->getDWordBy("specular") ) );
|
|
|
|
float fSelfIlum = pObject->getFloatBy("self_illumi");
|
|
if( fSelfIlum > 0.8f )
|
|
{
|
|
m_nBlendmode = K3DMaterial::MBM_ADDITIVE;
|
|
m_pMaterial->SetAmbient( K3DColor( .5f, .5f, .5f ) );
|
|
m_pMaterial->SetDiffuse( K3DColor( 8.f, 8.f, 8.f ) );
|
|
m_pMaterial->SetSpecular( K3DColor( 1.f, 1.f, 1.f ) );
|
|
}
|
|
else if( fSelfIlum > 0.6f )
|
|
{
|
|
m_nBlendmode = K3DMaterial::MBM_ALPHABLENDTWOPASS;
|
|
}
|
|
else if( fSelfIlum > 0.4f )
|
|
{
|
|
m_nBlendmode = K3DMaterial::MBM_ALPHABLEND;
|
|
}
|
|
else
|
|
{
|
|
m_nBlendmode = K3DMaterial::MBM_DEFAULT;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
K3DTexture* KNX3MtlElement::GetTexture()
|
|
{
|
|
if(NULL == m_spTexture && false == m_sTextureName.empty())
|
|
m_spTexture = _GetTexture(m_sTextureName.c_str() );
|
|
|
|
return m_spTexture;
|
|
}
|
|
K3DTexture* KNX3MtlElement::GetBumpTexture()
|
|
{
|
|
#define DO_NOT_LOAD_BUMPMAP
|
|
#ifndef DO_NOT_LOAD_BUMPMAP
|
|
if(NULL == m_spTexture_Bump && false == m_sTextureName.empty())
|
|
{
|
|
std::string name = m_sTextureName;
|
|
name.replace( name.size() - 4, 1, "_bump." );
|
|
m_spTexture_Bump = _GetTexture(name.c_str() );
|
|
}
|
|
#endif // DO_NOT_LOAD_BUMPMAP
|
|
|
|
return m_spTexture_Bump;
|
|
}
|
|
K3DTexture* KNX3MtlElement::GetIlluminTexture()
|
|
{
|
|
if(NULL == m_spTexture_Illumin && false == m_sTextureName.empty())
|
|
{
|
|
std::string name = m_sTextureName;
|
|
name.replace( name.size() - 4, 1, "_illumin." );
|
|
m_spTexture_Illumin = _GetTexture(name.c_str() );
|
|
}
|
|
|
|
return m_spTexture_Illumin;
|
|
}
|
|
K3DTexture* KNX3MtlElement::GetSpecularTexture()
|
|
{
|
|
if(NULL == m_spTexture_Specular && false == m_sTextureName.empty())
|
|
{
|
|
// 2010.05.19 faceÀÇ ½ºÆåŧ¶ó ¸ÊÀº ÀÏ°ýÀûÀ¸·Î face_spec.dds¸¦ ¾²µµ·Ï ¼öÁ¤- prodongi
|
|
int facePos = m_sTextureName.find("face");
|
|
if (facePos >= 0)
|
|
{
|
|
m_spTexture_Specular = _GetTexture("face_spec.dds");
|
|
}
|
|
else
|
|
{
|
|
#ifdef _SPECULAR_EDITING_
|
|
std::string nameL = m_sTextureName;
|
|
nameL.replace( nameL.size() - 4, 1, "_l_spec." );
|
|
|
|
m_spTexture_Specular = _GetTexture(nameL.c_str());
|
|
if( NULL == m_spTexture_Specular )
|
|
{
|
|
std::string nameM = m_sTextureName;
|
|
nameM.replace( nameM.size() - 4, 1, "_m_spec." );
|
|
m_spTexture_Specular = _GetTexture(nameM.c_str());
|
|
|
|
if( NULL == m_spTexture_Specular )
|
|
{
|
|
std::string name = m_sTextureName;
|
|
name.replace( name.size() - 4, 1, "_spec." );
|
|
m_spTexture_Specular = _GetTexture(name.c_str());
|
|
}
|
|
}
|
|
#else
|
|
std::string name = m_sTextureName;
|
|
name.replace( name.size() - 4, 1, "_spec." );
|
|
m_spTexture_Specular = _GetTexture(name.c_str() );
|
|
#endif
|
|
}
|
|
}
|
|
|
|
return m_spTexture_Specular;
|
|
}
|
|
K3DTexture* KNX3MtlElement::GetSpecularColorTexture()
|
|
{
|
|
#ifdef _SPECULAR_EDITING_
|
|
if( NULL == m_spTexture_SpecularColorMap && false == m_sTextureName.empty() )
|
|
{
|
|
std::string nameL = m_sTextureName;
|
|
nameL.replace( nameL.size() - 4, 1, "_l_spec." );
|
|
|
|
std::string nameM = m_sTextureName;
|
|
nameM.replace( nameM.size() - 4, 1, "_m_spec." );
|
|
|
|
if ( NULL != _GetTexture(nameL.c_str()) )
|
|
m_spTexture_SpecularColorMap = _GetTexture("leather_specular_color.dds");
|
|
else if( NULL != _GetTexture(nameM.c_str()) )
|
|
m_spTexture_SpecularColorMap = _GetTexture("specularColorMap.dds");
|
|
else
|
|
m_spTexture_SpecularColorMap = NULL;
|
|
}
|
|
#else
|
|
if(NULL == m_spTexture_SpecularColorMap && false == m_sTextureName.empty())
|
|
m_spTexture_SpecularColorMap = _GetTexture("specularColorMap.dds");
|
|
#endif
|
|
|
|
return m_spTexture_SpecularColorMap;
|
|
}
|
|
|
|
K3DTexture* KNX3MtlElement::_GetTexture(LPCSTR name)
|
|
{
|
|
|
|
#ifdef _RAC
|
|
if( KTextureManager::GetManager()->IsExistTexture( name , m_pLoadPack ) )
|
|
{
|
|
return KTextureManager::GetManager()->GetTexture( name, m_pLoadPack, true, KTextureManager::GetManager()->GetMipMapBiasLevel() );
|
|
}
|
|
#else
|
|
if( KTextureManager::GetManager()->IsExistTexture( name, m_pLoadPack ) )
|
|
{
|
|
return KTextureManager::GetManager()->GetTexture( name, m_pLoadPack );
|
|
}
|
|
#endif
|
|
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//=======================================================================================================================
|
|
//KNX3BoneChannel========================================================================================================
|
|
//=======================================================================================================================
|
|
|
|
BOOL KNX3Bone::Load( KTemplateDataObject * pObject )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
KSimpleDataObject *pParentIndex = pObject->GetSimpleDataMemberObject("parent_Index");
|
|
DWORD dwParentIndex;
|
|
pParentIndex->GetDWORD(&dwParentIndex);
|
|
m_nParentIndex = dwParentIndex;
|
|
KSimpleDataArrayObject *pBaseTM = pObject->GetSimpleDataArrayMemberObject("base_tm");
|
|
KSimpleDataObject *pFlag = pObject->GetSimpleDataMemberObject("flag");
|
|
pFlag->GetDWORD(&m_dwFlag);
|
|
|
|
//Name
|
|
int iStrLen = 64;
|
|
KSimpleDataObject * pBoneName = pObject->GetSimpleDataMemberObject("szName");
|
|
pBoneName->GetString( szName, iStrLen );
|
|
|
|
//멤버 Load
|
|
pBaseTM->GetDataFloat(0, m_BaseTM, sizeof( m_BaseTM ), 16);
|
|
// OutputDebugString(szName);
|
|
// OutputDebugString("\n");
|
|
|
|
//Pos Key
|
|
KSimpleDataObject *pPosTimeSize = pObject->GetSimpleDataMemberObject("pos_time_size");
|
|
pPosTimeSize->GetDWORD(&m_dwPosCount);
|
|
KSimpleDataArrayObject *pPosTimeArray = pObject->GetSimpleDataArrayMemberObject("pos_time_array");
|
|
KSimpleDataObject *pPosKeySize = pObject->GetSimpleDataMemberObject("pos_key_size");
|
|
m_dwPosCount = pPosTimeArray->GetDataCount(); //시간만큼 있다.
|
|
KSimpleDataArrayObject *pPosKeyArray = pObject->GetSimpleDataArrayMemberObject("pos_key_array");
|
|
|
|
int n(0);
|
|
|
|
std::vector< DWORD > _time_list;
|
|
std::vector< K3DVector > _pos_list;
|
|
K3DVector prev_pos = K3DVector(-10000,-10000, -10000);
|
|
DWORD prev_time = -1;
|
|
DWORD save_time = -1;
|
|
|
|
//_oprint( " Bone Pos Optimize : %4d -> ", m_dwPosCount );
|
|
|
|
for( DWORD i(0); static_cast<int>(m_dwPosCount) > i; i++ )
|
|
{
|
|
DWORD postime;
|
|
pPosTimeArray->GetDataDWORD(i, &postime, sizeof( postime ), 1);
|
|
float fpos[3];
|
|
pPosKeyArray->GetDataFloat(n, fpos, sizeof( fpos ), 3); n+=3;
|
|
|
|
K3DVector pos = K3DVector( fpos[0], fpos[1], fpos[2] );
|
|
float fLen = (pos - prev_pos).Magnitude();
|
|
if( fLen > 0.005f || i == m_dwPosCount - 1 )
|
|
{
|
|
//이전 것과 현재 것이 다르면서, 이전 것을 추가 한다.(더 정확한 보간 위한)
|
|
if( prev_time != save_time )
|
|
{
|
|
_pos_list.push_back( prev_pos );
|
|
_time_list.push_back( prev_time );
|
|
}
|
|
prev_pos = pos;
|
|
|
|
save_time = postime;
|
|
|
|
_pos_list.push_back( pos );
|
|
_time_list.push_back( postime );
|
|
}
|
|
|
|
prev_time = postime;
|
|
}
|
|
|
|
//_oprint( " %4d / ", _pos_list.size() );
|
|
|
|
if( !_pos_list.empty() )
|
|
{
|
|
m_dwPosCount = _pos_list.size();
|
|
|
|
assert( _pos_list.size() == _time_list.size() && "애니메이션 데이타 position 사이즈 이상" );
|
|
|
|
m_pPosKey = new KNXgeneric_key_t[_pos_list.size()];
|
|
memset( m_pPosKey, 0, sizeof(KNXgeneric_key_t)*_pos_list.size() );
|
|
|
|
float fpos[3];
|
|
for( unsigned int i(0); _pos_list.size()>i; i++ )
|
|
{
|
|
fpos[0] = _pos_list[i].x;
|
|
fpos[1] = _pos_list[i].y;
|
|
fpos[2] = _pos_list[i].z;
|
|
|
|
m_pPosKey[i].msec = _time_list[i];
|
|
memcpy( &m_pPosKey[i].lin_pos, fpos, sizeof(float)*3 );
|
|
}
|
|
}
|
|
|
|
//Rot Key
|
|
KSimpleDataObject *pRotTimeSize = pObject->GetSimpleDataMemberObject("rot_time_size");
|
|
pRotTimeSize->GetDWORD(&m_dwRotCount);
|
|
KSimpleDataArrayObject *pRotTimeArray = pObject->GetSimpleDataArrayMemberObject("rot_time_array");
|
|
KSimpleDataObject *pRotKeySize = pObject->GetSimpleDataMemberObject("rot_key_size");
|
|
m_dwRotCount = pRotTimeArray->GetDataCount();
|
|
KSimpleDataArrayObject *pRotKeyArray = pObject->GetSimpleDataArrayMemberObject("rot_key_array");
|
|
|
|
n=0;
|
|
//0 0 0 1
|
|
std::vector< DWORD > _rot_time_list;
|
|
std::vector< K3DQuaternion > _rot_list;
|
|
K3DQuaternion prev_rot_q = K3DQuaternion(-1, 0, 0, 0);
|
|
K3DQuaternion quat;
|
|
K3DQuaternion tempq;
|
|
prev_time = -1;
|
|
save_time = -1;
|
|
|
|
//_oprint( " Bone Rot Optimize : %4d -> ", m_dwRotCount );
|
|
|
|
for( int i(0); static_cast<int>(m_dwRotCount) > i; i++ )
|
|
{
|
|
DWORD rottime;
|
|
pRotTimeArray->GetDataDWORD(i, &rottime, sizeof( rottime ), 1);
|
|
float rot[4];
|
|
pRotKeyArray->GetDataFloat(n, rot, sizeof( rot ), 4); n+=4;
|
|
|
|
quat = K3DQuaternion( rot[0], rot[1], rot[2], rot[3] );
|
|
|
|
K3DQuaternionInverse( tempq, prev_rot_q );
|
|
tempq = quat * tempq;
|
|
|
|
float quat_len = K3DVectorLength(K3DVector(tempq.x, tempq.y, tempq.z));
|
|
if( !(quat_len < 0.002f && tempq.w > 0.99f) || i == m_dwRotCount - 1 )
|
|
{
|
|
//이전 것과 현재 것이 다르면서, 이전 것을 추가 한다.(더 정확한 보간 위한)
|
|
if( prev_time != save_time )
|
|
{
|
|
_rot_time_list.push_back( prev_time );
|
|
_rot_list.push_back( prev_rot_q );
|
|
}
|
|
prev_rot_q = quat;
|
|
|
|
save_time = rottime;
|
|
|
|
_rot_time_list.push_back( rottime );
|
|
_rot_list.push_back( quat );
|
|
}
|
|
prev_time = rottime;
|
|
}
|
|
|
|
//_oprint( " %4d\n", _rot_time_list.size() );
|
|
|
|
if( !_rot_time_list.empty() )
|
|
{
|
|
assert( _rot_time_list.size() == _rot_list.size() && "애니메이션 데이타 position 사이즈 이상" );
|
|
|
|
m_pRotKey = new KNXgeneric_key_t[_rot_time_list.size()];
|
|
memset( m_pRotKey, 0, sizeof(KNXgeneric_key_t)*_rot_time_list.size() );
|
|
|
|
for( unsigned i(0); _rot_time_list.size()>i; i++ )
|
|
{
|
|
float frot[4];
|
|
frot[0] = _rot_list[i].x;
|
|
frot[1] = _rot_list[i].y;
|
|
frot[2] = _rot_list[i].z;
|
|
frot[3] = _rot_list[i].w;
|
|
|
|
m_pRotKey[i].msec = _rot_time_list[i];
|
|
memcpy( &m_pRotKey[i].lin_rot, frot, sizeof(float)*4 );
|
|
}
|
|
}
|
|
|
|
m_dwRotCount = _rot_time_list.size();
|
|
|
|
//Child Index
|
|
KSimpleDataObject *pChildSize = pObject->GetSimpleDataMemberObject("child_size");
|
|
pChildSize->GetDWORD(&m_dwChildCount);
|
|
KSimpleDataArrayObject *pChildIndexArray = pObject->GetSimpleDataArrayMemberObject("child_Index_array");
|
|
|
|
if( m_dwChildCount>0 )
|
|
{
|
|
m_pChildList = new int [m_dwChildCount];
|
|
pChildIndexArray->GetDataDWORD(0, (DWORD*)m_pChildList, sizeof( int )*m_dwChildCount, m_dwChildCount);
|
|
}
|
|
|
|
// _oprint( "Load Time : KNX3Bone::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
/*
|
|
bool KNX3Bone::LoadTRF( trf::MTemplatePtr pObject )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
//Name
|
|
strncpy( szName, SafeStr( pObject->getStringBy("szName") ), 64 );
|
|
|
|
m_nParentIndex = pObject->getDWordBy("parent_Index");
|
|
pObject->getArrayBy("base_tm")->readFixedData( 0, 16, &m_BaseTM, sizeof(m_BaseTM) );
|
|
m_dwFlag = pObject->getDWordBy("flag");
|
|
|
|
//멤버 Load
|
|
|
|
//Pos Key
|
|
|
|
trf::MArrayPtr pPosTimeArray = pObject->getArrayBy( "pos_time_array" );
|
|
trf::MArrayPtr pPosKeyArray = pObject->getArrayBy( "pos_key_array" );
|
|
m_dwPosCount = pPosTimeArray->count();
|
|
|
|
assert( m_dwPosCount * 3 == pPosKeyArray->count() && "애니메이션 데이타 position 사이즈 이상" );
|
|
|
|
const DWORD* pTimeList = pPosTimeArray->getDWordArray();
|
|
const float* pPosList = pPosKeyArray->getFloatArray();
|
|
|
|
int n(0);
|
|
|
|
std::vector< int > indexList;
|
|
indexList.reserve( m_dwPosCount );
|
|
|
|
K3DVector prev_pos = K3DVector(-10000,-10000, -10000);
|
|
DWORD prev_time = -1;
|
|
DWORD save_time = -1;
|
|
int prev_index = -1;
|
|
|
|
//_oprint( " Bone Pos Optimize : %4d -> ", m_dwPosCount );
|
|
|
|
for( DWORD i(0); static_cast<int>(m_dwPosCount) > i; i++ )
|
|
{
|
|
DWORD postime = pTimeList[ i ];
|
|
const K3DVector& pos = *reinterpret_cast< const K3DVector* >( &pPosList[ n ] ); n += 3;
|
|
float fLen = (pos - prev_pos).Magnitude();
|
|
if( fLen > 0.005f || i == m_dwPosCount - 1 )
|
|
{
|
|
//이전 것과 현재 것이 다르면서, 이전 것을 추가 한다.(더 정확한 보간 위한)
|
|
if( prev_time != save_time )
|
|
{
|
|
indexList.push_back( prev_index );
|
|
}
|
|
prev_pos = pos;
|
|
save_time = postime;
|
|
|
|
indexList.push_back( i );
|
|
}
|
|
|
|
prev_time = postime;
|
|
prev_index = i;
|
|
}
|
|
|
|
//_oprint( " %4d / ", _pos_list.size() );
|
|
|
|
if( !indexList.empty() )
|
|
{
|
|
m_dwPosCount = indexList.size();
|
|
|
|
m_pPosKey = new KNXgeneric_key_t[ m_dwPosCount ];
|
|
memset( m_pPosKey, 0, sizeof(KNXgeneric_key_t) * m_dwPosCount );
|
|
|
|
for( unsigned int i(0); m_dwPosCount > i; i++ )
|
|
{
|
|
int index = indexList[ i ];
|
|
m_pPosKey[i].msec = pTimeList[ index ];
|
|
memcpy( &m_pPosKey[i].lin_pos, &pPosList[ index*3 ], sizeof(float)*3 );
|
|
}
|
|
}
|
|
|
|
//Rot Key
|
|
trf::MArrayPtr pRotTimeArray = pObject->getArrayBy( "rot_time_array" );
|
|
trf::MArrayPtr pRotKeyArray = pObject->getArrayBy( "rot_key_array" );
|
|
m_dwRotCount = pRotTimeArray->count();
|
|
|
|
assert( m_dwRotCount * 4 == pRotKeyArray->count() && "애니메이션 데이타 rotation 사이즈 이상" );
|
|
|
|
const DWORD* pRotTimeList = pRotTimeArray->getDWordArray();
|
|
const float* pRotList = pRotKeyArray->getFloatArray();
|
|
|
|
n=0;
|
|
//0 0 0 1
|
|
indexList.clear();
|
|
indexList.reserve( m_dwRotCount );
|
|
|
|
K3DQuaternion prev_rot_q = K3DQuaternion(-1, 0, 0, 0);
|
|
K3DQuaternion quat;
|
|
K3DQuaternion tempq;
|
|
prev_time = -1;
|
|
save_time = -1;
|
|
prev_index = -1;
|
|
|
|
//_oprint( " Bone Rot Optimize : %4d -> ", m_dwRotCount );
|
|
|
|
for( int i(0); static_cast<int>(m_dwRotCount) > i; i++ )
|
|
{
|
|
DWORD rottime = pRotTimeList[ i ];
|
|
const K3DQuaternion& quat = *reinterpret_cast< const K3DQuaternion* >( &pRotList[ n ] ); n += 4;
|
|
|
|
K3DQuaternionInverse( tempq, prev_rot_q );
|
|
tempq = quat * tempq;
|
|
|
|
float quat_len = tempq.AsVec3().Magnitude();
|
|
if( !(quat_len < 0.002f && tempq.w > 0.99f) || i == m_dwRotCount - 1 )
|
|
{
|
|
//이전 것과 현재 것이 다르면서, 이전 것을 추가 한다.(더 정확한 보간 위한)
|
|
if( prev_time != save_time )
|
|
{
|
|
indexList.push_back( prev_index );
|
|
}
|
|
prev_rot_q = quat;
|
|
|
|
save_time = rottime;
|
|
|
|
indexList.push_back( i );
|
|
}
|
|
prev_time = rottime;
|
|
prev_index = i;
|
|
}
|
|
|
|
//_oprint( " %4d\n", _rot_time_list.size() );
|
|
|
|
m_dwRotCount = indexList.size();
|
|
|
|
if( !indexList.empty() )
|
|
{
|
|
m_pRotKey = new KNXgeneric_key_t[ m_dwRotCount ];
|
|
memset( m_pRotKey, 0, sizeof(KNXgeneric_key_t) * m_dwRotCount );
|
|
|
|
for( unsigned i(0); m_dwRotCount > i; i++ )
|
|
{
|
|
int index = indexList[ i ];
|
|
m_pRotKey[i].msec = pRotTimeList[ index ];
|
|
memcpy( &m_pRotKey[i].lin_rot, &pRotList[ index*4 ], sizeof(float)*4 );
|
|
}
|
|
}
|
|
|
|
//Child Index
|
|
trf::MArrayPtr pChildIndexArray = pObject->getArrayBy( "child_Index_array" );
|
|
m_dwChildCount = pChildIndexArray->count();
|
|
|
|
if( m_dwChildCount>0 )
|
|
{
|
|
m_pChildList = new int[ m_dwChildCount ];
|
|
pChildIndexArray->readFixedData( 0, m_dwChildCount, m_pChildList, m_dwChildCount*sizeof(int) );
|
|
}
|
|
|
|
// _oprint( "Load Time : KNX3Bone::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
/*/
|
|
bool KNX3Bone::LoadTRF( trf::MTemplatePtr pObject )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
//Name
|
|
strncpy( szName, SafeStr( pObject->getStringBy("szName") ), 64 );
|
|
|
|
m_nParentIndex = pObject->getDWordBy("parent_Index");
|
|
pObject->getArrayBy("base_tm")->readFixedData( 0, 16, &m_BaseTM, sizeof(m_BaseTM) );
|
|
m_dwFlag = pObject->getDWordBy("flag");
|
|
|
|
//멤버 Load
|
|
|
|
//Pos Key
|
|
|
|
trf::MArrayPtr pPosTimeArray = pObject->getArrayBy( "pos_time_array" );
|
|
trf::MArrayPtr pPosKeyArray = pObject->getArrayBy( "pos_key_array" );
|
|
m_dwPosCount = pPosTimeArray->count();
|
|
|
|
int n(0);
|
|
|
|
std::vector< DWORD > _time_list;
|
|
std::vector< K3DVector > _pos_list;
|
|
_time_list.reserve( m_dwPosCount );
|
|
_pos_list.reserve( m_dwPosCount );
|
|
|
|
K3DVector prev_pos = K3DVector(-10000,-10000, -10000);
|
|
DWORD prev_time = -1;
|
|
DWORD save_time = -1;
|
|
|
|
//_oprint( " Bone Pos Optimize : %4d -> ", m_dwPosCount );
|
|
|
|
for( DWORD i(0); static_cast<int>(m_dwPosCount) > i; i++ )
|
|
{
|
|
DWORD postime = pPosTimeArray->getDWordAt(i);
|
|
const float* fpos = pPosKeyArray->getFloatArray( n ); n+=3;
|
|
|
|
K3DVector pos = K3DVector( fpos[0], fpos[1], fpos[2] );
|
|
float fLen = (pos - prev_pos).Magnitude();
|
|
if( fLen > 0.005f || i == m_dwPosCount - 1 )
|
|
{
|
|
//이전 것과 현재 것이 다르면서, 이전 것을 추가 한다.(더 정확한 보간 위한)
|
|
if( prev_time != save_time )
|
|
{
|
|
_pos_list.push_back( prev_pos );
|
|
_time_list.push_back( prev_time );
|
|
}
|
|
prev_pos = pos;
|
|
|
|
save_time = postime;
|
|
|
|
_pos_list.push_back( pos );
|
|
_time_list.push_back( postime );
|
|
}
|
|
|
|
prev_time = postime;
|
|
}
|
|
|
|
//_oprint( " %4d / ", _pos_list.size() );
|
|
|
|
if( !_pos_list.empty() )
|
|
{
|
|
m_dwPosCount = _pos_list.size();
|
|
|
|
assert( _pos_list.size() == _time_list.size() && "애니메이션 데이타 position 사이즈 이상" );
|
|
|
|
m_pPosKey = new KNXgeneric_key_t[_pos_list.size()];
|
|
memset( m_pPosKey, 0, sizeof(KNXgeneric_key_t)*_pos_list.size() );
|
|
|
|
for( unsigned int i(0); _pos_list.size()>i; i++ )
|
|
{
|
|
m_pPosKey[i].msec = _time_list[i];
|
|
memcpy( &m_pPosKey[i].lin_pos, &_pos_list[i], sizeof(float)*3 );
|
|
}
|
|
}
|
|
|
|
//Rot Key
|
|
trf::MArrayPtr pRotTimeArray = pObject->getArrayBy( "rot_time_array" );
|
|
trf::MArrayPtr pRotKeyArray = pObject->getArrayBy( "rot_key_array" );
|
|
m_dwRotCount = pRotTimeArray->count();
|
|
|
|
n=0;
|
|
//0 0 0 1
|
|
std::vector< DWORD > _rot_time_list;
|
|
std::vector< K3DQuaternion > _rot_list;
|
|
_rot_time_list.reserve( m_dwRotCount );
|
|
_rot_list.reserve( m_dwRotCount );
|
|
|
|
K3DQuaternion prev_rot_q = K3DQuaternion(-1, 0, 0, 0);
|
|
K3DQuaternion quat;
|
|
K3DQuaternion tempq;
|
|
prev_time = -1;
|
|
save_time = -1;
|
|
|
|
//_oprint( " Bone Rot Optimize : %4d -> ", m_dwRotCount );
|
|
|
|
for( int i(0); static_cast<int>(m_dwRotCount) > i; i++ )
|
|
{
|
|
DWORD rottime = pRotTimeArray->getDWordAt( i );
|
|
const float* rot = pRotKeyArray->getFloatArray( n ); n+=4;
|
|
|
|
quat = K3DQuaternion( rot[0], rot[1], rot[2], rot[3] );
|
|
|
|
K3DQuaternionInverse( tempq, prev_rot_q );
|
|
tempq = quat * tempq;
|
|
|
|
float quat_len = K3DVectorLength(K3DVector(tempq.x, tempq.y, tempq.z));
|
|
if( !(quat_len < 0.002f && tempq.w > 0.99f) || i == m_dwRotCount - 1 )
|
|
{
|
|
//이전 것과 현재 것이 다르면서, 이전 것을 추가 한다.(더 정확한 보간 위한)
|
|
if( prev_time != save_time )
|
|
{
|
|
_rot_time_list.push_back( prev_time );
|
|
_rot_list.push_back( prev_rot_q );
|
|
}
|
|
prev_rot_q = quat;
|
|
|
|
save_time = rottime;
|
|
|
|
_rot_time_list.push_back( rottime );
|
|
_rot_list.push_back( quat );
|
|
}
|
|
prev_time = rottime;
|
|
}
|
|
|
|
//_oprint( " %4d\n", _rot_time_list.size() );
|
|
|
|
if( !_rot_time_list.empty() )
|
|
{
|
|
assert( _rot_time_list.size() == _rot_list.size() && "애니메이션 데이타 position 사이즈 이상" );
|
|
|
|
m_pRotKey = new KNXgeneric_key_t[_rot_time_list.size()];
|
|
memset( m_pRotKey, 0, sizeof(KNXgeneric_key_t)*_rot_time_list.size() );
|
|
|
|
for( unsigned i(0); _rot_time_list.size() > i; i++ )
|
|
{
|
|
m_pRotKey[i].msec = _rot_time_list[i];
|
|
memcpy( &m_pRotKey[i].lin_rot, &_rot_list[i], sizeof(float)*4 );
|
|
}
|
|
}
|
|
|
|
m_dwRotCount = _rot_time_list.size();
|
|
|
|
//Child Index
|
|
trf::MArrayPtr pChildIndexArray = pObject->getArrayBy( "child_Index_array" );
|
|
m_dwChildCount = pChildIndexArray->count();
|
|
|
|
if( m_dwChildCount>0 )
|
|
{
|
|
m_pChildList = new int [m_dwChildCount];
|
|
pChildIndexArray->readFixedData( 0, m_dwChildCount, m_pChildList, m_dwChildCount*sizeof(int) );
|
|
}
|
|
|
|
// _oprint( "Load Time : KNX3Bone::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
//*/
|
|
void KNX3BoneChannel::Clear()
|
|
{
|
|
m_spBoneRes = NULL;
|
|
}
|
|
|
|
/// Load from filer.
|
|
BOOL KNX3BoneChannel::Load( KTemplateDataObject * pObject, const char * szName, DWORD dwVersion )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
m_spBoneRes = new K3DBoneResource;
|
|
m_spBoneRes->SetVersion( dwVersion );
|
|
m_spBoneRes->SetName( szName );
|
|
|
|
KFT_nx3_bone_ani_header bone_ani_header(pObject);
|
|
|
|
KSimpleDataObject * pBoneCount = pObject->GetSimpleDataMemberObject( "bone_count" );
|
|
KSimpleDataObject * pChannelCount = pObject->GetSimpleDataMemberObject( "channel_count" );
|
|
KTemplateDataArrayObject * pChannel_Array = pObject->GetTemplateDataArrayMemberObject( "channel_array" );
|
|
|
|
DWORD dwBoneCount = 0;
|
|
DWORD dwChannelCount = 0;
|
|
|
|
dwBoneCount = bone_ani_header.GetValue_bone_count();
|
|
dwChannelCount = bone_ani_header.GetValue_channel_count();
|
|
|
|
pBoneCount->GetDWORD( &dwBoneCount );
|
|
pChannelCount->GetDWORD( &dwChannelCount );
|
|
|
|
if( dwBoneCount <= 0 ) _oprint( "[KNX3BoneChannel::Load] Bones count is less than 0!\n" );
|
|
|
|
//채널은 한개만 지원 된다.
|
|
KTemplateDataObject * pChannelObject = pChannel_Array->GetData(0);
|
|
|
|
//작업중..
|
|
KSimpleDataObject * pChannel_flag = pChannelObject->GetSimpleDataMemberObject( "channel_flag" );
|
|
KSimpleDataObject * pChannel_timespan = pChannelObject->GetSimpleDataMemberObject( "channel_time_span" );
|
|
KSimpleDataObject * pChannel_framerate = pChannelObject->GetSimpleDataMemberObject( "channel_frame_rate" );
|
|
KSimpleDataObject * pChannel_channelname = pChannelObject->GetSimpleDataMemberObject( "channel_name" );
|
|
|
|
m_dwChannelFlag = 0;
|
|
m_dwChannelTimeSpan = 0;
|
|
m_dwChannelFrameRate = 0;
|
|
m_szChannelName[_countof(m_szChannelName)-1] = '\0';
|
|
|
|
pChannel_flag->GetDWORD(&m_dwChannelFlag);
|
|
pChannel_timespan->GetDWORD(&m_dwChannelTimeSpan);
|
|
pChannel_framerate->GetDWORD(&m_dwChannelFrameRate);
|
|
int nLen = pChannel_channelname->GetSize();
|
|
if( nLen < _countof(m_szChannelName) )
|
|
pChannel_channelname->GetString(m_szChannelName, nLen );
|
|
|
|
DWORD dwBoneSize = 0;
|
|
KSimpleDataObject * pBoneSize = pChannelObject->GetSimpleDataMemberObject( "bone_ani_size" );
|
|
pBoneSize->GetDWORD(&dwBoneSize);
|
|
KTemplateDataArrayObject * pBoneArray = pChannelObject->GetTemplateDataArrayMemberObject( "bone_ani_array" );
|
|
|
|
m_spBoneRes->SetTimeSpan(m_dwChannelTimeSpan);
|
|
|
|
m_spBoneRes->SetBone(dwBoneSize);
|
|
|
|
for(unsigned int i(0); i < dwBoneSize; ++i)
|
|
{
|
|
KTemplateDataObject * pTemplateBone = pBoneArray->GetData(i);
|
|
|
|
KNX3Bone Bone;
|
|
Bone.Load( pTemplateBone );
|
|
|
|
K3DBone * pBoneRes = new K3DBone;
|
|
|
|
pBoneRes->SetParentIndex( Bone.GetParentIndex() );
|
|
pBoneRes->SetBaseTM( Bone.GetBaseTM() );
|
|
pBoneRes->SetFlag( Bone.GetFlag() );
|
|
pBoneRes->SetPosKey( Bone.GetPosCount(), (Kgeneric_key_t *)Bone.GetPosKey() );
|
|
pBoneRes->SetRotKey( Bone.GetRotCount(), (Kgeneric_key_t *)Bone.GetRotKey() );
|
|
pBoneRes->SetChildList( Bone.GetChildCount(), Bone.GetChildList() );
|
|
pBoneRes->SetName( Bone.GetName() );
|
|
|
|
m_spBoneRes->AddBone( i, pBoneRes );
|
|
}
|
|
|
|
//자식 본 포인터 설정
|
|
int nChildren = 0;
|
|
for( unsigned int i(0); i < dwBoneSize; ++i)
|
|
{
|
|
K3DBone * pBone = m_spBoneRes->GetBone(i);
|
|
|
|
int nParentIndex = pBone->GetParentIndex();
|
|
if( nParentIndex >= 0 && static_cast<DWORD>(nParentIndex) < dwBoneSize )
|
|
{
|
|
pBone->SetParentBone( m_spBoneRes->GetBone(nParentIndex) );
|
|
}
|
|
else
|
|
{
|
|
nChildren++;
|
|
pBone->SetParentBone( NULL );
|
|
}
|
|
|
|
for( int j(0); pBone->GetChildCount()>j; j++ )
|
|
{
|
|
K3DBone * pChildBone = m_spBoneRes->GetBone(pBone->GetChildIndex(j));
|
|
if( pChildBone )
|
|
pBone->SetChildBone( j, pChildBone );
|
|
}
|
|
}
|
|
|
|
//최상위 본의 자식 설정
|
|
m_spBoneRes->SetChildCount( nChildren );
|
|
|
|
// _oprint( "Load Time : KNX3BoneChannel::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3BoneChannel::LoadTRF( trf::MTemplatePtr pObject, const char * szName, DWORD dwVersion )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
m_spBoneRes = new K3DBoneResource;
|
|
m_spBoneRes->SetName( szName );
|
|
m_spBoneRes->SetVersion( dwVersion );
|
|
|
|
DWORD dwBoneCount = pObject->getDWordBy( "bone_count" );
|
|
trf::MTemplateArrayPtr pChannel_Array = pObject->getTemplateArrayBy( "channel_array" );
|
|
|
|
if( dwBoneCount <= 0 ) _oprint( "[KNX3BoneChannel::LoadTRF] Bones count is less than 0!\n" );
|
|
|
|
//채널은 한개만 지원 된다.
|
|
trf::MTemplatePtr pChannelObject = pChannel_Array->getTemplateAt(0);
|
|
|
|
//작업중..
|
|
strncpy( m_szChannelName, SafeStr( pChannelObject->getStringBy( "channel_name" ) ), 127 );
|
|
m_dwChannelFlag = pChannelObject->getDWordBy( "channel_flag" );
|
|
m_dwChannelTimeSpan = pChannelObject->getDWordBy( "channel_time_span" );
|
|
m_dwChannelFrameRate = pChannelObject->getDWordBy( "channel_frame_rate" );
|
|
|
|
trf::MTemplateArrayPtr pBoneArray = pChannelObject->getTemplateArrayBy( "bone_ani_array" );
|
|
DWORD dwBoneSize = pBoneArray->count();
|
|
|
|
m_spBoneRes->SetTimeSpan(m_dwChannelTimeSpan);
|
|
|
|
m_spBoneRes->SetBone(dwBoneSize);
|
|
|
|
for(unsigned int i(0); i < dwBoneSize; ++i)
|
|
{
|
|
trf::MTemplatePtr pTemplateBone = pBoneArray->getTemplateAt(i);
|
|
|
|
KNX3Bone Bone;
|
|
Bone.LoadTRF( pTemplateBone );
|
|
|
|
K3DBone * pBoneRes = new K3DBone;
|
|
|
|
pBoneRes->SetParentIndex( Bone.GetParentIndex() );
|
|
pBoneRes->SetBaseTM( Bone.GetBaseTM() );
|
|
pBoneRes->SetFlag( Bone.GetFlag() );
|
|
pBoneRes->SetPosKey( Bone.GetPosCount(), (Kgeneric_key_t *)Bone.GetPosKey() );
|
|
pBoneRes->SetRotKey( Bone.GetRotCount(), (Kgeneric_key_t *)Bone.GetRotKey() );
|
|
pBoneRes->SetChildList( Bone.GetChildCount(), Bone.GetChildList() );
|
|
pBoneRes->SetName( Bone.GetName() );
|
|
|
|
m_spBoneRes->AddBone( i, pBoneRes );
|
|
}
|
|
|
|
//자식 본 포인터 설정
|
|
int nChildren = 0;
|
|
for( unsigned int i(0); i < dwBoneSize; ++i)
|
|
{
|
|
K3DBone * pBone = m_spBoneRes->GetBone(i);
|
|
|
|
int nParentIndex = pBone->GetParentIndex();
|
|
if( nParentIndex >= 0 && static_cast<DWORD>(nParentIndex) < dwBoneSize )
|
|
{
|
|
pBone->SetParentBone( m_spBoneRes->GetBone(nParentIndex) );
|
|
}
|
|
else
|
|
{
|
|
nChildren++;
|
|
pBone->SetParentBone( NULL );
|
|
}
|
|
|
|
for( int j(0); pBone->GetChildCount()>j; j++ )
|
|
{
|
|
K3DBone * pChildBone = m_spBoneRes->GetBone(pBone->GetChildIndex(j));
|
|
if( pChildBone )
|
|
pBone->SetChildBone( j, pChildBone );
|
|
}
|
|
}
|
|
|
|
//최상위 본의 자식 설정
|
|
m_spBoneRes->SetChildCount( nChildren );
|
|
|
|
// _oprint( "Load Time : KNX3BoneChannel::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return true;
|
|
}
|
|
|
|
//=======================================================================================================================
|
|
//KNX3MeshChannel========================================================================================================
|
|
//=======================================================================================================================
|
|
|
|
KNX3MeshChannel::KNX3MeshChannel(K3DRenderDevice * pGraphics, KNX3MtlChannel * pMtlChannel)
|
|
{
|
|
m_pGraphics = pGraphics;
|
|
m_pMtlChannel = pMtlChannel;
|
|
m_vtMeshList.clear();
|
|
}
|
|
|
|
KNX3MeshChannel::~KNX3MeshChannel()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void KNX3MeshChannel::Clear()
|
|
{
|
|
m_pGraphics = NULL;
|
|
m_pMtlChannel = NULL;
|
|
SAFE_DELETE_VECTOR(m_vtMeshList);
|
|
SAFE_DELETE_VECTOR(m_vtMeshTM);
|
|
}
|
|
|
|
BOOL KNX3MeshChannel::Load( const NX3LoadPack * pLoadPack, KTemplateDataObject * pObject , int loadType)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
DWORD dwMeshSize;
|
|
KSimpleDataObject * pMeshSize = pObject->GetSimpleDataMemberObject("mesh_size");
|
|
pMeshSize->GetDWORD(&dwMeshSize);
|
|
|
|
KTemplateDataArrayObject * pMeshArray = pObject->GetTemplateDataArrayMemberObject("mesh_array");
|
|
|
|
m_vtMeshList.reserve( dwMeshSize );
|
|
for(unsigned int i(0); i < dwMeshSize; ++i)
|
|
{
|
|
KNX3Mesh * pMesh = new KNX3Mesh(m_pGraphics);
|
|
pMesh->Load( pLoadPack, pMeshArray->GetData(i), m_pMtlChannel, loadType );
|
|
m_vtMeshList.push_back(pMesh);
|
|
}
|
|
|
|
m_vtMeshTM.erase( m_vtMeshTM.begin(), m_vtMeshTM.end() );
|
|
|
|
DWORD dwMeshTMSize = 0;
|
|
KSimpleDataObject * pMeshTMSize = pObject->GetSimpleDataMemberObject("mesh_tm_size");
|
|
pMeshTMSize->GetDWORD(&dwMeshTMSize);
|
|
KTemplateDataArrayObject * pMeshTMArray = pObject->GetTemplateDataArrayMemberObject("mesh_tm_array");
|
|
|
|
for(unsigned int i(0); i < dwMeshTMSize; ++i)
|
|
{
|
|
KNX3MeshTM * pMeshTM = new KNX3MeshTM;
|
|
memset( pMeshTM, 0, sizeof(*pMeshTM) );
|
|
|
|
KTemplateDataObject * pObject = pMeshTMArray->GetData(i);
|
|
|
|
//Load
|
|
KSimpleDataObject * pName = pObject->GetSimpleDataMemberObject( "name" );
|
|
int nLen = 64;
|
|
pName->GetString( pMeshTM->szName, nLen );
|
|
|
|
KSimpleDataArrayObject * pBaseTM = pObject->GetSimpleDataArrayMemberObject("tm");
|
|
pBaseTM->GetDataFloat(0, pMeshTM->baseTM, sizeof( pMeshTM->baseTM ), 16);
|
|
|
|
m_vtMeshTM.push_back( pMeshTM );
|
|
}
|
|
|
|
if( GetSafeTickCount()-dwTime > 80 )
|
|
{
|
|
// _oprint( "Load Time : KNX3MeshChannel::Load - %dms\n", GetSafeTickCount()-dwTime );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3MeshChannel::LoadTRF( const NX3LoadPack * pLoadPack, trf::MTemplatePtr pObject , int loadType)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
trf::MTemplateArrayPtr pMeshArray = pObject->getTemplateArrayBy("mesh_array");
|
|
DWORD dwMeshSize = pMeshArray->count();
|
|
|
|
m_vtMeshList.reserve( dwMeshSize );
|
|
for(unsigned int i(0); i < dwMeshSize; ++i)
|
|
{
|
|
KNX3Mesh * pMesh = new KNX3Mesh(m_pGraphics);
|
|
pMesh->LoadTRF( pLoadPack, pMeshArray->getTemplateAt(i), m_pMtlChannel, loadType );
|
|
m_vtMeshList.push_back(pMesh);
|
|
}
|
|
|
|
m_vtMeshTM.erase( m_vtMeshTM.begin(), m_vtMeshTM.end() );
|
|
|
|
trf::MTemplateArrayPtr pMeshTMArray = pObject->getTemplateArrayBy("mesh_tm_array");
|
|
DWORD dwMeshTMSize = pMeshTMArray->count();
|
|
|
|
for(unsigned int i(0); i < dwMeshTMSize; ++i)
|
|
{
|
|
KNX3MeshTM * pMeshTM = new KNX3MeshTM;
|
|
memset( pMeshTM, 0, sizeof(*pMeshTM) );
|
|
|
|
trf::MTemplatePtr pObject = pMeshTMArray->getTemplateAt(i);
|
|
|
|
//Load
|
|
|
|
strncpy( pMeshTM->szName, SafeStr( pObject->getStringBy("name") ), 64 );
|
|
pObject->getArrayBy( "tm" )->readFixedData( 0, 16, pMeshTM->baseTM, sizeof( pMeshTM->baseTM ) );
|
|
m_vtMeshTM.push_back( pMeshTM );
|
|
}
|
|
|
|
if( GetSafeTickCount()-dwTime > 80 )
|
|
{
|
|
// _oprint( "Load Time : KNX3MeshChannel::Load - %dms\n", GetSafeTickCount()-dwTime );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
KNX3Mesh::KNX3Mesh(K3DRenderDevice * pGraphics)
|
|
{
|
|
m_pGraphics = pGraphics;
|
|
m_dwMaterialID = 0;
|
|
m_dwChannelID = 0;
|
|
|
|
m_vtMeshElement.clear();
|
|
m_spAniElement = NULL;
|
|
m_spVisiElement = NULL;
|
|
m_spUVAniElement = NULL;
|
|
m_vtFX.clear();
|
|
|
|
m_vtChildMesh.clear();
|
|
|
|
m_bIsFX = false;
|
|
m_bIsEventBox = false;
|
|
m_bIsEventPoint = false;
|
|
}
|
|
|
|
KNX3Mesh::~KNX3Mesh()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void KNX3Mesh::Clear()
|
|
{
|
|
m_pGraphics = NULL;
|
|
|
|
SAFE_DELETE_VECTOR(m_vtMeshElement);
|
|
m_spAniElement = NULL;
|
|
m_spVisiElement = NULL;
|
|
m_spUVAniElement = NULL;
|
|
SAFE_DELETE_VECTOR(m_vtFX);
|
|
|
|
SAFE_DELETE_VECTOR(m_vtChildMesh);
|
|
}
|
|
|
|
void KNX3Mesh::loadUVAni( KNX3FX *pFX )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
std::vector<KNX3FXElement*> vFXEle;
|
|
for ( unsigned int i=0; i<pFX->GetFXElementSize() ; ++i )
|
|
{
|
|
if( pFX->GetFxElementByIndeX(i)->GetValue( "UVTRANSFORM" ) != NULL || pFX->GetFxElementByIndeX(i)->GetValue( "UVANI" ) != NULL )
|
|
vFXEle.push_back( pFX->GetFxElementByIndeX( i ) );
|
|
}
|
|
|
|
if ( vFXEle.size() > 0 )
|
|
{
|
|
int nMode = 0;
|
|
int nTexSize = 1024;
|
|
K3DVector vecUvAni;
|
|
K3DResMeshUVAnimation::Key *key = new K3DResMeshUVAnimation::Key[vFXEle.size()];
|
|
m_spUVAniElement = new K3DResMeshUVAnimation;
|
|
for( unsigned int i = 0; i < vFXEle.size(); ++i )
|
|
{
|
|
KNX3FXElement *fxele = vFXEle[i];
|
|
key[i].time = fxele->GetFrameTime();
|
|
|
|
if( i == 0 )
|
|
{
|
|
nMode = fxele->GetNumValue( "UVMODE", nMode );
|
|
vecUvAni = fxele->GetVectorValue( "UVANI", K3DVector( 0.0f, 0.0f, 0.0f ) );
|
|
}
|
|
|
|
nTexSize = fxele->GetNumValue( "UVTEXTURESIZE", nTexSize );
|
|
K3DVector pos(0,0,0);
|
|
pos = fxele->Get2DVectorValue( "UVTRANSFORM", pos );
|
|
pos.x /= (float)nTexSize;
|
|
pos.y /= (float)nTexSize;
|
|
K3DMatrixIdentity( key[i].mat );
|
|
key[i].mat._31 = pos.x;
|
|
key[i].mat._32 = pos.y;
|
|
}
|
|
m_spUVAniElement->SetMode( nMode );
|
|
m_spUVAniElement->SetUvAnimation( vecUvAni.x > 0.0f, static_cast< int >( vecUvAni.y ), static_cast< int >( vecUvAni.z ) );
|
|
m_spUVAniElement->SetWholeKey( key, (int)vFXEle.size() );
|
|
delete[] key;
|
|
}
|
|
|
|
// _oprint( "Load Time : KNX3Mesh::loadUVAni - %d\n", GetSafeTickCount()-dwTime );
|
|
}
|
|
|
|
BOOL KNX3Mesh::Load( const NX3LoadPack * pLoadPack, KTemplateDataObject * pObject, KNX3MtlChannel * pMtlChannel,int loadType )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
KSimpleDataObject *pMeshName = pObject->GetSimpleDataMemberObject( "mesh_name" );
|
|
char name[1024];
|
|
int namelen = 1024;
|
|
pMeshName->GetString( name, namelen );
|
|
m_sMeshName = name;
|
|
|
|
int nMtlID;
|
|
KSimpleDataObject * pMtlID = pObject->GetSimpleDataMemberObject("material_id");
|
|
pMtlID->GetDWORD(reinterpret_cast<DWORD *>(&nMtlID) );
|
|
|
|
if(pMtlChannel)
|
|
m_pMtl = pMtlChannel->GetMtl(nMtlID);
|
|
else
|
|
m_pMtl = NULL;
|
|
|
|
DWORD dwMeshSize;
|
|
KSimpleDataObject * pMeshBlockSize = pObject->GetSimpleDataMemberObject("mesh_block_size");
|
|
pMeshBlockSize->GetDWORD(&dwMeshSize);
|
|
|
|
KTemplateDataArrayObject * pMeshBlockArray = pObject->GetTemplateDataArrayMemberObject("mesh_block_array");
|
|
|
|
// Mesh Data Load
|
|
int i;
|
|
for(i = 0; i < (int)dwMeshSize; ++i)
|
|
{
|
|
KNX3MeshElement* pElement = new KNX3MeshElement(m_pGraphics);
|
|
pElement->Load( pLoadPack, name, pMeshBlockArray->GetData(i), m_pMtl );
|
|
m_vtMeshElement.push_back(pElement);
|
|
}
|
|
|
|
if ( dwMeshSize > 0 )
|
|
{
|
|
m_bIsEventPoint = m_vtMeshElement[0]->IsEventPoint();
|
|
m_bIsEventBox = m_vtMeshElement[0]->IsEventBox();
|
|
}
|
|
|
|
// Animation & Visi Block Load
|
|
if(loadType == KNX3MeshChannel::LT_OLD_MESH)
|
|
loadAniAndVisiBlockOldType(pObject);
|
|
else
|
|
loadAniAndVisiBlockNewType(pObject);
|
|
|
|
|
|
// FX Load
|
|
|
|
KTemplateDataArrayObject * pFXArray = pObject->GetTemplateDataArrayMemberObject("fx_array");
|
|
|
|
for( i=0; i < pFXArray->GetDataCount(); ++i )
|
|
{
|
|
KNX3FX * pFX = new KNX3FX();
|
|
pFX->Load(pFXArray->GetData(i));
|
|
if ( pFX->IsFX() )
|
|
m_bIsFX = true;
|
|
|
|
if ( pFX->GetFXElementSize() > 0 )
|
|
{
|
|
if ( pFX->GetFXElement( 0 )->GetValue( "UVTRANSFORM" ) != NULL )
|
|
{
|
|
loadUVAni( pFX );
|
|
}
|
|
}
|
|
|
|
m_vtFX.push_back(pFX);
|
|
}
|
|
|
|
// Children Load
|
|
DWORD dwChildrenSize;
|
|
KSimpleDataObject * pMeshChildrenSize = pObject->GetSimpleDataMemberObject("mesh_children_size");
|
|
pMeshChildrenSize->GetDWORD(&dwChildrenSize);
|
|
|
|
KTemplateDataArrayObject * pMeshChildrenArray = pObject->GetTemplateDataArrayMemberObject("mesh_children_array");
|
|
|
|
for( i=0; i < (int)dwChildrenSize; ++i )
|
|
{
|
|
KNX3Mesh * pMesh = new KNX3Mesh(m_pGraphics);
|
|
pMesh->Load( pLoadPack, pMeshChildrenArray->GetData(i), pMtlChannel, loadType );
|
|
m_vtChildMesh.push_back(pMesh);
|
|
}
|
|
|
|
// _oprint( "Load Time : KNX3Mesh::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3Mesh::LoadTRF( const NX3LoadPack * pLoadPack, trf::MTemplatePtr pObject, KNX3MtlChannel * pMtlChannel, int loadType )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
m_sMeshName = SafeStr( pObject->getStringBy( "mesh_name" ) );
|
|
|
|
int nMtlID = pObject->getDWordBy( "material_id" );
|
|
|
|
if(pMtlChannel)
|
|
m_pMtl = pMtlChannel->GetMtl(nMtlID);
|
|
else
|
|
m_pMtl = NULL;
|
|
|
|
trf::MTemplateArrayPtr pMeshBlockArray = pObject->getTemplateArrayBy( "mesh_block_array" );
|
|
DWORD dwMeshSize = pMeshBlockArray->count();
|
|
|
|
// Mesh Data Load
|
|
int i;
|
|
for(i = 0; i < (int)dwMeshSize; ++i)
|
|
{
|
|
KNX3MeshElement* pElement = new KNX3MeshElement(m_pGraphics);
|
|
pElement->LoadTRF( pLoadPack, m_sMeshName.c_str(), pMeshBlockArray->getTemplateAt(i), m_pMtl );
|
|
m_vtMeshElement.push_back(pElement);
|
|
}
|
|
|
|
if ( dwMeshSize > 0 )
|
|
{
|
|
m_bIsEventPoint = m_vtMeshElement[0]->IsEventPoint();
|
|
m_bIsEventBox = m_vtMeshElement[0]->IsEventBox();
|
|
}
|
|
|
|
// Animation & Visi Block Load
|
|
if(loadType == KNX3MeshChannel::LT_OLD_MESH)
|
|
loadAniAndVisiBlockOldType(pObject);
|
|
else
|
|
loadAniAndVisiBlockNewType(pObject);
|
|
|
|
|
|
// FX Load
|
|
|
|
trf::MTemplateArrayPtr pFXArray = pObject->getTemplateArrayBy("fx_array");
|
|
|
|
for( i=0; i < pFXArray->count(); ++i )
|
|
{
|
|
KNX3FX * pFX = new KNX3FX();
|
|
pFX->LoadTRF( pFXArray->getTemplateAt(i) );
|
|
if ( pFX->IsFX() )
|
|
m_bIsFX = true;
|
|
|
|
if ( pFX->GetFXElementSize() > 0 )
|
|
{
|
|
if( pFX->GetFXElement( 0 )->GetValue( "UVTRANSFORM" ) != NULL || pFX->GetFXElement( 0 )->GetValue( "UVANI" ) != NULL )
|
|
{
|
|
loadUVAni( pFX );
|
|
|
|
//UVTRANSFORM,UVANI가 적용된 매쉬는 라이트 맵 적용 안시킨다
|
|
MeshVector::iterator iter = m_vtMeshElement.begin();
|
|
for( ; iter != m_vtMeshElement.end(); ++iter )
|
|
{
|
|
(*iter)->SetLightMapIndex( 0 );
|
|
}
|
|
}
|
|
}
|
|
|
|
m_vtFX.push_back(pFX);
|
|
}
|
|
|
|
// Children Load
|
|
trf::MTemplateArrayPtr pMeshChildrenArray = pObject->getTemplateArrayBy("mesh_children_array");
|
|
DWORD dwChildrenSize = pMeshChildrenArray->count();
|
|
|
|
for( i=0; i < (int)dwChildrenSize; ++i )
|
|
{
|
|
KNX3Mesh * pMesh = new KNX3Mesh(m_pGraphics);
|
|
pMesh->LoadTRF( pLoadPack, pMeshChildrenArray->getTemplateAt(i), pMtlChannel, loadType );
|
|
m_vtChildMesh.push_back(pMesh);
|
|
}
|
|
|
|
// _oprint( "Load Time : KNX3Mesh::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return true;
|
|
}
|
|
|
|
void KNX3Mesh::loadAniAndVisiBlockOldType(KTemplateDataObject* pObject)
|
|
{
|
|
KTemplateDataArrayObject * pAniBlockArray = pObject->GetTemplateDataArrayMemberObject("ani_block_array");
|
|
if ( pAniBlockArray->GetDataCount() > 0 )
|
|
{
|
|
K3DResMeshMatrixAnimation::Key *key = new K3DResMeshMatrixAnimation::Key[pAniBlockArray->GetDataCount()];
|
|
m_spAniElement = new K3DResMeshMatrixAnimation;
|
|
for(int i = 0; i < pAniBlockArray->GetDataCount(); ++i )
|
|
{
|
|
KTemplateDataObject * pObject = pAniBlockArray->GetData(i);
|
|
|
|
KSimpleDataObject * pTime = pObject->GetSimpleDataMemberObject("time");
|
|
pTime->GetDWORD(reinterpret_cast<DWORD*>(&key[i].time));
|
|
|
|
float fArray[12];
|
|
KSimpleDataArrayObject * pMatrix = pObject->GetSimpleDataArrayMemberObject("matrix");
|
|
pMatrix->GetDataFloat(0, fArray, sizeof( fArray ), 12);
|
|
|
|
fillAnimatrixFromArray(fArray, &key[i].mat);
|
|
}
|
|
m_spAniElement->SetWholeKey( key, pAniBlockArray->GetDataCount() );
|
|
|
|
for ( unsigned int i=0 ; i<m_vtMeshElement.size() ; ++i )
|
|
{
|
|
KNX3MeshElement* pElement = m_vtMeshElement[i];
|
|
pElement->GetWritableEventCube().SetTransform( key[0].mat );
|
|
pElement->GetWritableBoundSphere().SetTransform( key[0].mat );
|
|
}
|
|
|
|
delete[] key;
|
|
}
|
|
|
|
// Visibility Block Load
|
|
|
|
KTemplateDataArrayObject * pVisiBlockArray = pObject->GetTemplateDataArrayMemberObject("visi_block_array");
|
|
if ( pVisiBlockArray->GetDataCount() > 0 )
|
|
{
|
|
K3DResMeshVisibilityAnimation::Key *viskey = new K3DResMeshVisibilityAnimation::Key[pVisiBlockArray->GetDataCount()];
|
|
m_spVisiElement = new K3DResMeshVisibilityAnimation;
|
|
for(int i =0 ; i < pVisiBlockArray->GetDataCount(); ++i )
|
|
{
|
|
KTemplateDataObject *pObject = pVisiBlockArray->GetData(i);
|
|
KSimpleDataObject * pTime = pObject->GetSimpleDataMemberObject("time");
|
|
pTime->GetDWORD(reinterpret_cast<DWORD*>(&viskey[i].time));
|
|
KSimpleDataObject * pVisibility = pObject->GetSimpleDataMemberObject("visibility");
|
|
pVisibility->GetFloat(&viskey[i].val);
|
|
}
|
|
m_spVisiElement->SetWholeKey( viskey, pVisiBlockArray->GetDataCount() );
|
|
delete[] viskey;
|
|
}
|
|
|
|
}
|
|
void KNX3Mesh::loadAniAndVisiBlockNewType(KTemplateDataObject* pObject)
|
|
{
|
|
KSimpleDataArrayObject * pAniTimeArray = pObject->GetSimpleDataArrayMemberObject("ani_time_array");
|
|
KSimpleDataArrayObject * pAniMatrixArray = pObject->GetSimpleDataArrayMemberObject("ani_matrix_array");
|
|
|
|
int count = pAniTimeArray->GetDataCount();
|
|
|
|
if(count > 0)
|
|
{
|
|
K3DResMeshMatrixAnimation::Key *key = new K3DResMeshMatrixAnimation::Key[count];
|
|
m_spAniElement = new K3DResMeshMatrixAnimation;
|
|
|
|
const size_t MATRIX_SIZE = 12;
|
|
static float fArray[MATRIX_SIZE];
|
|
for( int i = 0; i < count; ++i)
|
|
{
|
|
pAniTimeArray->GetDataDWORD(i, reinterpret_cast<DWORD*>(&key[i].time), sizeof( key[i].time ), 1);
|
|
pAniMatrixArray->GetDataFloat(i * MATRIX_SIZE, fArray, sizeof( fArray ), MATRIX_SIZE);
|
|
fillAnimatrixFromArray(fArray,&key[i].mat);
|
|
}
|
|
|
|
m_spAniElement->SetWholeKey(key, count);
|
|
for ( unsigned int i=0 ; i<m_vtMeshElement.size() ; ++i )
|
|
{
|
|
KNX3MeshElement* pElement = m_vtMeshElement[i];
|
|
pElement->GetWritableEventCube().SetTransform( key[0].mat );
|
|
pElement->GetWritableBoundSphere().SetTransform( key[0].mat );
|
|
}
|
|
delete[] key;
|
|
}
|
|
|
|
// Visibility Block Load
|
|
KSimpleDataArrayObject * pVisiTimeArray = pObject->GetSimpleDataArrayMemberObject("visi_time_array");
|
|
KSimpleDataArrayObject * pVisiValueArray = pObject->GetSimpleDataArrayMemberObject("visi_value_array");
|
|
|
|
count = pVisiTimeArray->GetDataCount();
|
|
|
|
if ( count > 0)
|
|
{
|
|
K3DResMeshVisibilityAnimation::Key *viskey = new K3DResMeshVisibilityAnimation::Key[count];
|
|
m_spVisiElement = new K3DResMeshVisibilityAnimation;
|
|
|
|
for(int i = 0; i < count; ++i)
|
|
{
|
|
pVisiTimeArray->GetDataDWORD(i, reinterpret_cast<DWORD*>(&viskey[i].time), sizeof( viskey[i].time ), 1);
|
|
pVisiValueArray->GetDataFloat(i, &viskey[i].val, sizeof( viskey[i].val ), 1);
|
|
}
|
|
m_spVisiElement->SetWholeKey( viskey, count);
|
|
delete[] viskey;
|
|
}
|
|
}
|
|
|
|
void KNX3Mesh::loadAniAndVisiBlockOldType( trf::MTemplatePtr pObject )
|
|
{
|
|
trf::MTemplateArrayPtr pAniBlockArray = pObject->getTemplateArrayBy("ani_block_array");
|
|
if ( pAniBlockArray->count() > 0 )
|
|
{
|
|
K3DResMeshMatrixAnimation::Key* key = new K3DResMeshMatrixAnimation::Key[ pAniBlockArray->count() ];
|
|
m_spAniElement = new K3DResMeshMatrixAnimation;
|
|
for(int i = 0; i < pAniBlockArray->count(); ++i )
|
|
{
|
|
trf::MTemplatePtr pObject = pAniBlockArray->getTemplateAt(i);
|
|
|
|
key[i].time = pObject->getDWordBy("time");
|
|
|
|
float fArray[12];
|
|
pObject->getArrayBy("matrix")->readFixedData( 0, 12, fArray, sizeof(fArray) );
|
|
|
|
fillAnimatrixFromArray(fArray, &key[i].mat);
|
|
}
|
|
m_spAniElement->SetWholeKey( key, pAniBlockArray->count() );
|
|
|
|
for ( unsigned int i=0 ; i<m_vtMeshElement.size() ; ++i )
|
|
{
|
|
KNX3MeshElement* pElement = m_vtMeshElement[i];
|
|
pElement->GetWritableEventCube().SetTransform( key[0].mat );
|
|
pElement->GetWritableBoundSphere().SetTransform( key[0].mat );
|
|
}
|
|
|
|
delete[] key;
|
|
}
|
|
|
|
// Visibility Block Load
|
|
|
|
trf::MTemplateArrayPtr pVisiBlockArray = pObject->getTemplateArrayBy("visi_block_array");
|
|
if ( pVisiBlockArray->count() > 0 )
|
|
{
|
|
K3DResMeshVisibilityAnimation::Key *viskey = new K3DResMeshVisibilityAnimation::Key[ pVisiBlockArray->count() ];
|
|
m_spVisiElement = new K3DResMeshVisibilityAnimation;
|
|
for(int i =0 ; i < pVisiBlockArray->count(); ++i )
|
|
{
|
|
trf::MTemplatePtr pObject = pVisiBlockArray->getTemplateAt(i);
|
|
viskey[i].time = pObject->getDWordBy("time");
|
|
viskey[i].val = pObject->getFloatBy("visibility");
|
|
}
|
|
m_spVisiElement->SetWholeKey( viskey, pVisiBlockArray->count() );
|
|
delete[] viskey;
|
|
}
|
|
|
|
}
|
|
void KNX3Mesh::loadAniAndVisiBlockNewType( trf::MTemplatePtr pObject )
|
|
{
|
|
trf::MArrayPtr pAniTimeArray = pObject->getArrayBy("ani_time_array");
|
|
trf::MArrayPtr pAniMatrixArray = pObject->getArrayBy("ani_matrix_array");
|
|
|
|
int count = pAniTimeArray->count();
|
|
|
|
if(count > 0)
|
|
{
|
|
K3DResMeshMatrixAnimation::Key *key = new K3DResMeshMatrixAnimation::Key[count];
|
|
m_spAniElement = new K3DResMeshMatrixAnimation;
|
|
|
|
const size_t MATRIX_SIZE = 12;
|
|
float fArray[MATRIX_SIZE];
|
|
for( int i = 0; i < count; ++i)
|
|
{
|
|
key[i].time = pAniTimeArray->getDWordAt( i );
|
|
pAniMatrixArray->readFixedData( i*MATRIX_SIZE, MATRIX_SIZE, fArray, sizeof(fArray) );
|
|
fillAnimatrixFromArray(fArray,&key[i].mat);
|
|
}
|
|
|
|
m_spAniElement->SetWholeKey(key, count);
|
|
for ( unsigned int i=0 ; i<m_vtMeshElement.size() ; ++i )
|
|
{
|
|
KNX3MeshElement* pElement = m_vtMeshElement[i];
|
|
pElement->GetWritableEventCube().SetTransform( key[0].mat );
|
|
pElement->GetWritableBoundSphere().SetTransform( key[0].mat );
|
|
}
|
|
delete[] key;
|
|
}
|
|
|
|
// Visibility Block Load
|
|
trf::MArrayPtr pVisiTimeArray = pObject->getArrayBy("visi_time_array");
|
|
trf::MArrayPtr pVisiValueArray = pObject->getArrayBy("visi_value_array");
|
|
|
|
count = pVisiTimeArray->count();
|
|
|
|
if ( count > 0)
|
|
{
|
|
K3DResMeshVisibilityAnimation::Key *viskey = new K3DResMeshVisibilityAnimation::Key[count];
|
|
m_spVisiElement = new K3DResMeshVisibilityAnimation;
|
|
|
|
for(int i = 0; i < count; ++i)
|
|
{
|
|
viskey[i].time = pVisiTimeArray->getDWordAt(i);
|
|
viskey[i].val = pVisiValueArray->getFloatAt(i);
|
|
}
|
|
m_spVisiElement->SetWholeKey( viskey, count);
|
|
delete[] viskey;
|
|
}
|
|
}
|
|
|
|
KNX3MeshElement::KNX3MeshElement( K3DRenderDevice * pGraphics )
|
|
{
|
|
m_bIsEventBox = false;
|
|
m_bIsEventPoint = false;
|
|
m_pGraphics = pGraphics;
|
|
|
|
m_pMaterial = NULL;
|
|
|
|
m_bDeletK3DMaterial = FALSE;
|
|
|
|
m_dwFormat = 0;
|
|
m_dwStride = 0;
|
|
|
|
m_dwNumIndexBuffer = 0;
|
|
m_vtMeshFrame.clear();
|
|
}
|
|
|
|
KNX3MeshElement::~KNX3MeshElement()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void KNX3MeshElement::Clear()
|
|
{
|
|
m_spIndices = NULL;
|
|
m_spIdxarry = NULL;
|
|
|
|
SAFE_DELETE_VECTOR(m_vtMeshFrame);
|
|
|
|
if(m_bDeletK3DMaterial)
|
|
{
|
|
SAFE_DELETE(m_pMaterial);
|
|
}
|
|
else
|
|
{
|
|
m_pMaterial = NULL;
|
|
}
|
|
}
|
|
|
|
BOOL KNX3MeshElement::Load(const NX3LoadPack * pLoadPack, const char *meshname, KTemplateDataObject * pObject, KNX3Mtl * pMtl)
|
|
{
|
|
|
|
if ( _strnicmp( meshname, "ep_", 3 ) == 0 )
|
|
{
|
|
m_bIsEventPoint = true;
|
|
return TRUE;
|
|
}
|
|
else if ( (_strnicmp( meshname, "ev_", 3 ) == 0 ) )
|
|
{
|
|
m_bIsEventBox = true;
|
|
|
|
const int EVBOX_VTX_COUNT = 3 * 8;
|
|
KTemplateDataArrayObject * pMeshFrameArray = pObject->GetTemplateDataArrayMemberObject("mesh_frame_array");
|
|
assert(pMeshFrameArray);
|
|
|
|
KTemplateDataObject* pMeshFrame = pMeshFrameArray->GetData(0);
|
|
assert(pMeshFrame);
|
|
|
|
KSimpleDataArrayObject * pVertexArray = pMeshFrame->GetSimpleDataArrayMemberObject("vertex_array");
|
|
assert(pVertexArray->GetDataCount() == EVBOX_VTX_COUNT);
|
|
|
|
K3DVector p[8];
|
|
pVertexArray->GetDataFloat( 0, reinterpret_cast<float *>(&p[0]), sizeof( p ), EVBOX_VTX_COUNT);
|
|
K3DBoundSetCube( &m_bEventCube, p, 8 );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
// DWORD dwTime = GetSafeTickCount();
|
|
|
|
DWORD dwTextureIndex;
|
|
KNX3MtlElement * pMtlElement = NULL;
|
|
KSimpleDataObject * pTextureIndex = pObject->GetSimpleDataMemberObject("texture_index");
|
|
pTextureIndex->GetDWORD(&dwTextureIndex);
|
|
|
|
|
|
KSimpleDataObject* pLightMapIndex = pObject->GetSimpleDataMemberObject("lightmap_index");
|
|
|
|
if(pLightMapIndex)
|
|
pLightMapIndex->GetDWORD(&m_lightMapIndex);
|
|
else
|
|
m_lightMapIndex = 0;
|
|
|
|
|
|
if(NULL != pMtl && NULL != (pMtlElement = pMtl->GetMtlElement(dwTextureIndex) ) )
|
|
{
|
|
m_spTexture = pMtlElement->GetTexture();
|
|
m_spTexture_Bump = pMtlElement->GetBumpTexture();
|
|
m_spTexture_Illumin = pMtlElement->GetIlluminTexture();
|
|
m_spTexture_Specular = pMtlElement->GetSpecularTexture();
|
|
m_spTexture_SpecularColor = pMtlElement->GetSpecularColorTexture();
|
|
|
|
m_pMaterial = pMtlElement->GetMaterial();
|
|
m_nBlendMode = pMtlElement->GetBlendMode();
|
|
}
|
|
else
|
|
{
|
|
// Default Material로 세팅
|
|
m_bDeletK3DMaterial = TRUE;
|
|
m_pMaterial = new K3DMaterial;
|
|
m_pMaterial->SetAmbient( K3DColor(.1f, .1f, .1f) );
|
|
m_pMaterial->SetDiffuse( K3DColor( .8f, .8f, .8f ) );
|
|
m_pMaterial->SetSpecular( K3DColor( .8f, .8f, .8f) );
|
|
m_pMaterial->SetSpecularPower( 1.0f );
|
|
m_nBlendMode = K3DMaterial::MBM_DEFAULT;
|
|
}
|
|
|
|
DWORD dwMeshFrameSize;
|
|
KSimpleDataObject * pMeshFrameSize = pObject->GetSimpleDataMemberObject("mesh_frame_size");
|
|
pMeshFrameSize->GetDWORD(&dwMeshFrameSize);
|
|
|
|
KTemplateDataArrayObject * pMeshFrameArray = pObject->GetTemplateDataArrayMemberObject("mesh_frame_array");
|
|
|
|
|
|
// 인덱스 먼저 읽음
|
|
KSimpleDataObject * pIndexBufferSize = pObject->GetSimpleDataMemberObject("index_buffer_size");
|
|
pIndexBufferSize->GetDWORD(&m_dwNumIndexBuffer);
|
|
|
|
KSimpleDataArrayObject * pIndexBufferArray = pObject->GetSimpleDataArrayMemberObject("index_buffer_array");
|
|
unsigned short *_idxlist = new unsigned short[m_dwNumIndexBuffer];
|
|
pIndexBufferArray->GetDataWORD( 0, _idxlist, sizeof( unsigned short )*m_dwNumIndexBuffer, m_dwNumIndexBuffer );
|
|
|
|
KTemplateDataObject *pFirstTemplateFrame = pMeshFrameArray->GetData(0);
|
|
KNX3MeshFrame * pMeshFrameFirst = new KNX3MeshFrame( m_pGraphics );
|
|
pMeshFrameFirst->Load(pLoadPack, meshname, m_dwNumIndexBuffer, _idxlist, pFirstTemplateFrame, m_dwFormat, m_dwStride,m_dwNumVertex);
|
|
m_vtMeshFrame.push_back(pMeshFrameFirst);
|
|
|
|
m_bEventCube = pMeshFrameFirst->GetCube();
|
|
m_bSphere = pMeshFrameFirst->GetSphere();
|
|
|
|
for(size_t i = 0; i < dwMeshFrameSize; ++i)
|
|
{
|
|
KNX3MeshFrame * pMeshFrame = new KNX3MeshFrame( m_pGraphics );
|
|
pMeshFrame->Load(pLoadPack, meshname, m_dwNumIndexBuffer, _idxlist, pMeshFrameArray->GetData(i), m_dwFormat, m_dwStride,m_dwNumVertex,pFirstTemplateFrame);
|
|
m_vtMeshFrame.push_back(pMeshFrame);
|
|
}
|
|
|
|
m_nSimultaneousFrameCount = m_vtMeshFrame[0]->GetSimultaneousFrameCount();
|
|
|
|
int size = m_dwNumIndexBuffer * sizeof(WORD);
|
|
|
|
m_spIndices = m_pGraphics->CreateIndexBuffer( m_dwNumIndexBuffer);
|
|
if( m_spIndices && m_spIndices->IsValidVtx() )
|
|
{
|
|
char *tmpbuffer = NULL;
|
|
m_spIndices->Lock( (void**)&tmpbuffer, size );
|
|
if( tmpbuffer != NULL )
|
|
{
|
|
memcpy(tmpbuffer, _idxlist, size );
|
|
m_spIndices->Unlock();
|
|
}
|
|
}
|
|
|
|
if( pLoadPack && pLoadPack->bLoad_PolyGon )
|
|
{
|
|
m_spIdxarry = new K3DUnsignedShortRes;
|
|
m_spIdxarry->SetArray( _idxlist, m_dwNumIndexBuffer );
|
|
}
|
|
delete[] _idxlist;
|
|
|
|
// _oprint( "Load Time : KNX3MeshElement::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3MeshElement::LoadTRF(const NX3LoadPack * pLoadPack, const char *meshname, trf::MTemplatePtr pObject, KNX3Mtl * pMtl)
|
|
{
|
|
if ( _strnicmp( meshname, "ep_", 3 ) == 0 )
|
|
{
|
|
m_bIsEventPoint = true;
|
|
return true;
|
|
}
|
|
else if ( (_strnicmp( meshname, "ev_", 3 ) == 0 ) )
|
|
{
|
|
m_bIsEventBox = true;
|
|
|
|
const int EVBOX_VTX_COUNT = 3 * 8;
|
|
trf::MTemplateArrayPtr pMeshFrameArray = pObject->getTemplateArrayBy("mesh_frame_array");
|
|
assert(pMeshFrameArray);
|
|
|
|
trf::MTemplatePtr pMeshFrame = pMeshFrameArray->getTemplateAt(0);
|
|
assert(pMeshFrame);
|
|
|
|
K3DVector p[8];
|
|
pMeshFrame->getArrayBy( "vertex_array" )->readFixedData( 0, EVBOX_VTX_COUNT, p, sizeof( p ) );
|
|
K3DBoundSetCube( &m_bEventCube, p, 8 );
|
|
|
|
return true;
|
|
}
|
|
|
|
// DWORD dwTime = GetSafeTickCount();
|
|
|
|
// Fraun MTE reminder (KNX3MtlElement)
|
|
DWORD dwTextureIndex = pObject->getDWordBy( "texture_index" );
|
|
KNX3MtlElement * pMtlElement = NULL;
|
|
|
|
int index = pObject->indexBy( "lightmap_index" );
|
|
if ( index >= 0 && index < pObject->count() )
|
|
m_lightMapIndex = pObject->getDWordAt( index );
|
|
else
|
|
m_lightMapIndex = 0;
|
|
|
|
if(NULL != pMtl && NULL != (pMtlElement = pMtl->GetMtlElement(dwTextureIndex) ) )
|
|
{
|
|
m_spTexture = pMtlElement->GetTexture();
|
|
m_spTexture_Bump = pMtlElement->GetBumpTexture();
|
|
m_spTexture_Illumin = pMtlElement->GetIlluminTexture();
|
|
m_spTexture_Specular = pMtlElement->GetSpecularTexture();
|
|
m_spTexture_SpecularColor = pMtlElement->GetSpecularColorTexture();
|
|
|
|
m_pMaterial = pMtlElement->GetMaterial();
|
|
m_nBlendMode = pMtlElement->GetBlendMode();
|
|
}
|
|
else
|
|
{
|
|
// Default Material로 세팅
|
|
m_bDeletK3DMaterial = TRUE;
|
|
m_pMaterial = new K3DMaterial;
|
|
m_pMaterial->SetAmbient( K3DColor(.1f, .1f, .1f) );
|
|
m_pMaterial->SetDiffuse( K3DColor( .8f, .8f, .8f ) );
|
|
m_pMaterial->SetSpecular( K3DColor( .8f, .8f, .8f) );
|
|
m_pMaterial->SetSpecularPower( 1.0f );
|
|
m_nBlendMode = K3DMaterial::MBM_DEFAULT;
|
|
}
|
|
|
|
trf::MTemplateArrayPtr pMeshFrameArray = pObject->getTemplateArrayBy("mesh_frame_array");
|
|
DWORD dwMeshFrameSize = pMeshFrameArray->count();
|
|
|
|
|
|
// 인덱스 먼저 읽음
|
|
trf::MArrayPtr pIndexBufferArray = pObject->getArrayBy("index_buffer_array");
|
|
m_dwNumIndexBuffer = pIndexBufferArray->count();
|
|
|
|
unsigned short *_idxlist = new unsigned short[m_dwNumIndexBuffer];
|
|
pIndexBufferArray->readFixedData( 0, m_dwNumIndexBuffer, _idxlist, m_dwNumIndexBuffer * sizeof(unsigned short) );
|
|
|
|
trf::MTemplatePtr pFirstTemplateFrame = pMeshFrameArray->getTemplateAt(0);
|
|
KNX3MeshFrame * pMeshFrameFirst = new KNX3MeshFrame( m_pGraphics );
|
|
pMeshFrameFirst->LoadTRF( pLoadPack, meshname, m_dwNumIndexBuffer, _idxlist, pFirstTemplateFrame, m_dwFormat, m_dwStride, m_dwNumVertex );
|
|
m_vtMeshFrame.push_back(pMeshFrameFirst);
|
|
|
|
m_bEventCube = pMeshFrameFirst->GetCube();
|
|
m_bSphere = pMeshFrameFirst->GetSphere();
|
|
|
|
for(size_t i = 0; i < dwMeshFrameSize; ++i)
|
|
{
|
|
KNX3MeshFrame * pMeshFrame = new KNX3MeshFrame( m_pGraphics );
|
|
pMeshFrame->LoadTRF( pLoadPack, meshname, m_dwNumIndexBuffer, _idxlist, pMeshFrameArray->getTemplateAt(i), m_dwFormat, m_dwStride,m_dwNumVertex,pFirstTemplateFrame );
|
|
m_vtMeshFrame.push_back(pMeshFrame);
|
|
}
|
|
|
|
m_nSimultaneousFrameCount = m_vtMeshFrame[0]->GetSimultaneousFrameCount();
|
|
|
|
int size = m_dwNumIndexBuffer * sizeof(WORD);
|
|
|
|
m_spIndices = m_pGraphics->CreateIndexBuffer( m_dwNumIndexBuffer);
|
|
if( m_spIndices && m_spIndices->IsValidVtx() )
|
|
{
|
|
char *tmpbuffer = NULL;
|
|
m_spIndices->Lock( (void**)&tmpbuffer, size );
|
|
if( tmpbuffer != NULL )
|
|
{
|
|
memcpy(tmpbuffer, _idxlist, size );
|
|
m_spIndices->Unlock();
|
|
}
|
|
}
|
|
|
|
if( pLoadPack && pLoadPack->bLoad_PolyGon )
|
|
{
|
|
m_spIdxarry = new K3DUnsignedShortRes;
|
|
m_spIdxarry->SetArray( _idxlist, m_dwNumIndexBuffer );
|
|
}
|
|
delete[] _idxlist;
|
|
|
|
// _oprint( "Load Time : KNX3MeshElement::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return true;
|
|
}
|
|
|
|
KNX3MeshFrame::KNX3MeshFrame( K3DRenderDevice *pGraphics )
|
|
{
|
|
m_pGraphics = pGraphics;
|
|
m_dwFrameTime = 0;
|
|
m_bIsEventBox = false;
|
|
m_bIsEventPoint = false;
|
|
m_dwBoneSize = 0;
|
|
m_bIsBlended = false;
|
|
}
|
|
KNX3MeshFrame::~KNX3MeshFrame()
|
|
{
|
|
Clear();
|
|
}
|
|
|
|
void KNX3MeshFrame::Clear()
|
|
{
|
|
m_spVtxArray = NULL;
|
|
m_spVertexBuffer = NULL;
|
|
|
|
for( size_t i(0); m_vWeightList.size()>i; i++ )
|
|
{
|
|
delete m_vWeightList[i];
|
|
}
|
|
m_vWeightList.clear();
|
|
|
|
m_vUseBoneList.clear();
|
|
}
|
|
|
|
//사용하는 본들을 모은다...
|
|
void KNX3MeshFrame::AddUseBoneIndex( int nIndex )
|
|
{
|
|
for( unsigned int i(0); m_vUseBoneList.size()>i; i++ )
|
|
{
|
|
if( m_vUseBoneList[i] == nIndex )
|
|
return;
|
|
}
|
|
|
|
m_vUseBoneList.push_back( nIndex );
|
|
}
|
|
|
|
//새로 정렬된 인덱스를 알려준다.
|
|
int KNX3MeshFrame::GetNewBoneIndex( int nBoneIndex )
|
|
{
|
|
for( unsigned int i(0); m_vUseBoneList.size()>i; i++ )
|
|
{
|
|
if( m_vUseBoneList[i] == nBoneIndex )
|
|
return i;
|
|
}
|
|
|
|
assert( 0 && "이 메세지는, 피지크가 3개이상일 경우도 발생됨...여기는 말두 안돼!!! - Call BERSERK~" );
|
|
return 0;
|
|
}
|
|
|
|
//#define _USE_NORMAL_
|
|
|
|
namespace {
|
|
void CalculateTangentArray(long vertexCount, K3DBLENDEDBUMPVERTEX *vertex, long triangleCount, const unsigned short *triangle)
|
|
{
|
|
K3DVector* tan1 = new K3DVector[vertexCount * 2];
|
|
K3DVector* tan2 = tan1 + vertexCount;
|
|
ZeroMemory(tan1, vertexCount * sizeof(K3DVector) * 2);
|
|
|
|
for (long a = 0; a < triangleCount; a+=3)
|
|
{
|
|
long i1 = triangle[0];
|
|
long i2 = triangle[1];
|
|
long i3 = triangle[2];
|
|
|
|
const K3DVertex& v1 = vertex[i1].position;
|
|
const K3DVertex& v2 = vertex[i2].position;
|
|
const K3DVertex& v3 = vertex[i3].position;
|
|
|
|
const K3DPoint& w1 = vertex[i1].texcoord;
|
|
const K3DPoint& w2 = vertex[i2].texcoord;
|
|
const K3DPoint& w3 = vertex[i3].texcoord;
|
|
|
|
float x1 = v2.x - v1.x;
|
|
float x2 = v3.x - v1.x;
|
|
float y1 = v2.y - v1.y;
|
|
float y2 = v3.y - v1.y;
|
|
float z1 = v2.z - v1.z;
|
|
float z2 = v3.z - v1.z;
|
|
|
|
float s1 = w2.x - w1.x;
|
|
float s2 = w3.x - w1.x;
|
|
float t1 = w2.y - w1.y;
|
|
float t2 = w3.y - w1.y;
|
|
|
|
float r = 1.0F / (s1 * t2 - s2 * t1);
|
|
K3DVector sdir((t2 * x1 - t1 * x2) * r, (t2 * y1 - t1 * y2) * r,
|
|
(t2 * z1 - t1 * z2) * r);
|
|
K3DVector tdir((s1 * x2 - s2 * x1) * r, (s1 * y2 - s2 * y1) * r,
|
|
(s1 * z2 - s2 * z1) * r);
|
|
|
|
tan1[i1] += sdir;
|
|
tan1[i2] += sdir;
|
|
tan1[i3] += sdir;
|
|
|
|
tan2[i1] += tdir;
|
|
tan2[i2] += tdir;
|
|
tan2[i3] += tdir;
|
|
|
|
triangle+=3;
|
|
}
|
|
|
|
long count = vertexCount;
|
|
for (long a = 0; a < count; a++)
|
|
{
|
|
const K3DVector& n = vertex[a].normal;
|
|
const K3DVector& t = tan1[a];
|
|
|
|
// Gram-Schmidt orthogonalize
|
|
K3DVector cross = DotProduct(n,t) * n;
|
|
cross = (t - cross);
|
|
Normalize(cross);
|
|
vertex[a].tangent = K3DVector4(cross.x, cross.y, cross.z, 0);
|
|
|
|
// Calculate handedness
|
|
cross = CrossProduct(n,t);
|
|
vertex[a].tangent.w = DotProduct(cross,tan2[a]) < 0.f ? -1.0f : 1.0f;
|
|
}
|
|
|
|
delete[] tan1;
|
|
}
|
|
};
|
|
|
|
BOOL KNX3MeshFrame::Load(const NX3LoadPack * pLoadPack, const char *meshname, int idxcount, const WORD *_idxlist, KTemplateDataObject * pObject,
|
|
DWORD & dwFormat, DWORD & dwStride, DWORD & dwNumVertex, KTemplateDataObject * pFirstObject)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
KSimpleDataObject * pTimeValue = pObject->GetSimpleDataMemberObject("time_value");
|
|
pTimeValue->GetDWORD(&m_dwFrameTime);
|
|
|
|
KSimpleDataArrayObject * pVertexArray = pObject->GetSimpleDataArrayMemberObject("vertex_array");
|
|
KSimpleDataArrayObject * pNormalArray = pObject->GetSimpleDataArrayMemberObject("normal_array");
|
|
KSimpleDataArrayObject * pColorArray = NULL;
|
|
KSimpleDataArrayObject * pTexelArray = NULL;
|
|
|
|
if(pFirstObject)
|
|
{
|
|
pColorArray = pFirstObject->GetSimpleDataArrayMemberObject("color_array");
|
|
pTexelArray = pFirstObject->GetSimpleDataArrayMemberObject("texel_array");
|
|
}
|
|
else
|
|
{
|
|
pColorArray = pObject->GetSimpleDataArrayMemberObject("color_array");
|
|
pTexelArray = pObject->GetSimpleDataArrayMemberObject("texel_array");
|
|
}
|
|
|
|
if(NULL != pColorArray && pColorArray->GetDataCount() == 0)
|
|
pColorArray = NULL;
|
|
if(NULL != pTexelArray && pTexelArray->GetDataCount() == 0)
|
|
pTexelArray = NULL;
|
|
|
|
KSimpleDataArrayObject * pMeshTMArray = pObject->GetSimpleDataArrayMemberObject("mesh_tm");
|
|
|
|
float fArray[16];
|
|
if( pMeshTMArray )
|
|
{
|
|
pMeshTMArray->GetDataFloat(0, fArray, sizeof(fArray), 16);
|
|
m_NodeTM = K3DMatrix( fArray );
|
|
}
|
|
|
|
//Weight 작업중..
|
|
KSimpleDataObject * pBoneSize = pObject->GetSimpleDataMemberObject("bone_size");
|
|
pBoneSize->GetDWORD(&m_dwBoneSize);
|
|
|
|
if( m_dwBoneSize > 0 )
|
|
{
|
|
m_bIsBlended = true;
|
|
}
|
|
|
|
KTemplateDataArrayObject * pWeightArray = pObject->GetTemplateDataArrayMemberObject("bone_block");
|
|
if( pWeightArray )
|
|
{
|
|
// Format은 현재 사용하고 있지않음.
|
|
dwFormat = 0;
|
|
dwStride = sizeof(K3DBLENDEDBUMPVERTEX);
|
|
dwNumVertex = pVertexArray->GetDataCount() / 3;
|
|
_MakeVertexBuffer(dwNumVertex, dwFormat, dwStride,pWeightArray, pLoadPack, pVertexArray,pNormalArray,pColorArray,pTexelArray, idxcount, _idxlist);
|
|
// _oprint( "Load Time : KNX3MeshFrame::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3MeshFrame::LoadTRF(const NX3LoadPack * pLoadPack, const char *meshname, int idxcount, const WORD *_idxlist, trf::MTemplatePtr pObject,
|
|
DWORD & dwFormat, DWORD & dwStride, DWORD & dwNumVertex, trf::MTemplatePtr pFirstObject)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
m_dwFrameTime = pObject->getDWordBy("time_value");
|
|
|
|
trf::MArrayPtr pVertexArray = pObject->getArrayBy("vertex_array");
|
|
trf::MArrayPtr pNormalArray = pObject->getArrayBy("normal_array");
|
|
trf::MArrayPtr pColorArray = NULL;
|
|
trf::MArrayPtr pTexelArray = NULL;
|
|
|
|
if(pFirstObject)
|
|
{
|
|
pColorArray = pFirstObject->getArrayBy("color_array");
|
|
pTexelArray = pFirstObject->getArrayBy("texel_array");
|
|
}
|
|
else
|
|
{
|
|
pColorArray = pObject->getArrayBy("color_array");
|
|
pTexelArray = pObject->getArrayBy("texel_array");
|
|
}
|
|
|
|
if(NULL != pColorArray && pColorArray->count() == 0)
|
|
pColorArray = NULL;
|
|
if(NULL != pTexelArray && pTexelArray->count() == 0)
|
|
pTexelArray = NULL;
|
|
|
|
float fArray[16];
|
|
pObject->getArrayBy("mesh_tm")->readFixedData( 0, 16, fArray, sizeof(fArray) );
|
|
m_NodeTM = K3DMatrix( fArray );
|
|
|
|
//Weight 작업중..
|
|
trf::MTemplateArrayPtr pWeightArray = pObject->getTemplateArrayBy("bone_block");
|
|
m_dwBoneSize = pWeightArray->count();
|
|
|
|
if( m_dwBoneSize > 0 )
|
|
{
|
|
m_bIsBlended = true;
|
|
}
|
|
|
|
// Format은 현재 사용하고 있지않음.
|
|
dwFormat = 0;
|
|
dwStride = sizeof(K3DBLENDEDBUMPVERTEX);
|
|
dwNumVertex = pVertexArray->count() / 3;
|
|
_MakeVertexBuffer(dwNumVertex, dwFormat, dwStride,pWeightArray, pLoadPack, pVertexArray,pNormalArray,pColorArray,pTexelArray, idxcount, _idxlist);
|
|
// _oprint( "Load Time : KNX3MeshFrame::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return true;
|
|
}
|
|
|
|
template< typename T > static inline T _min( const T& a, const T& b ) { return a < b ? a : b; }
|
|
template< typename T > static inline T _max( const T& a, const T& b ) { return a > b ? a : b; }
|
|
|
|
void KNX3MeshFrame::_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)
|
|
{
|
|
K3DVector sp_pos;
|
|
float sp_radius = 0;
|
|
|
|
if ( numVertex > 0) // 초기값은 첫번째 버텍스로 넣어준다
|
|
pVertexArray->GetDataFloat( 0, reinterpret_cast<float *> (&sp_pos), sizeof( sp_pos ), 3 );
|
|
|
|
K3DVector cube_min(sp_pos), cube_max(sp_pos);
|
|
|
|
K3DVertex* pVtxArray = NULL;
|
|
if( NULL != pLoadPack && pLoadPack->bLoad_PolyGon )
|
|
{
|
|
pVtxArray = new K3DVertex[numVertex];
|
|
m_spVtxArray = new K3DVertexRes;
|
|
}
|
|
|
|
// Data가 기존의 2배라면 Light map용 채널이 같이 들어 있다.
|
|
bool bLoadLightMapUV = pTexelArray && pTexelArray->GetDataCount() / 2 == (pVertexArray->GetDataCount() / 3) * 2;
|
|
|
|
K3DBLENDEDBUMPVERTEX* pBlendVtxArray = new K3DBLENDEDBUMPVERTEX[numVertex];
|
|
|
|
for(DWORD i = 0; i < numVertex; ++i)
|
|
{
|
|
K3DBLENDEDBUMPVERTEX* pCurBlendVtx = &(pBlendVtxArray[i]);
|
|
|
|
pCurBlendVtx->matrixIndices = 0;
|
|
pCurBlendVtx->matrixWeights.x = m_bIsBlended ? 0.f : 1.f;
|
|
pCurBlendVtx->matrixWeights.y = 0.f;
|
|
|
|
pVertexArray->GetDataFloat(i * 3, reinterpret_cast<float *> (&(pCurBlendVtx->position)), sizeof( pCurBlendVtx->position ), 3 );
|
|
|
|
if(pVtxArray != NULL)
|
|
pVtxArray[i] = pCurBlendVtx->position;
|
|
|
|
pNormalArray->GetDataFloat(i * 3, reinterpret_cast<float *> (&(pCurBlendVtx->normal)), sizeof( pCurBlendVtx->normal ), 3 );
|
|
|
|
if(NULL != pTexelArray)
|
|
{
|
|
pTexelArray->GetDataFloat(i * 2, reinterpret_cast<float *> (&(pCurBlendVtx->texcoord)), sizeof( pCurBlendVtx->texcoord ), 2 );
|
|
|
|
// 우선 Lightmap쓰는 놈은 Skinning을 절대 하지 않으므로 Weight에 넣어볼까? -_- (뜯어 고치기 귀찮3)
|
|
if(bLoadLightMapUV)
|
|
pTexelArray->GetDataFloat(numVertex * 2 + i * 2, reinterpret_cast<float *> (&(pCurBlendVtx->matrixWeights)), sizeof( pCurBlendVtx->matrixWeights ), 2 );
|
|
|
|
}
|
|
|
|
if(NULL != pColorArray)
|
|
pColorArray->GetDataDWORD( i, reinterpret_cast<DWORD *> (&(pCurBlendVtx->color)), sizeof( pCurBlendVtx->color ), 1 );
|
|
else
|
|
pCurBlendVtx->color = 0xFFFFFFFF;
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// make bound object
|
|
// sphere calc
|
|
const K3DVector& vCur = pCurBlendVtx->position;
|
|
K3DVector vDiff = vCur - sp_pos; // 원점으로부터 새로 들어온 점까지의 벡터
|
|
float fLen = K3DVectorLength(vDiff);
|
|
if( fLen > sp_radius )
|
|
{
|
|
// 반지름의 크기를 가지는 vDiff의 반대 방향
|
|
K3DVector vDV = vDiff - ( sp_radius / fLen ) * vDiff;
|
|
sp_pos += vDV * .5f;
|
|
sp_radius = (fLen + sp_radius) / 2.f;
|
|
}
|
|
|
|
// make axis aligned cube
|
|
cube_min.x = _min(cube_min.x , vCur.x);
|
|
cube_min.y = _min(cube_min.y , vCur.y);
|
|
cube_min.z = _min(cube_min.z , vCur.z);
|
|
cube_max.x = _max(cube_max.x , vCur.x);
|
|
cube_max.y = _max(cube_max.y , vCur.y);
|
|
cube_max.z = _max(cube_max.z , vCur.z);
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
}
|
|
if(true == m_bIsBlended )
|
|
{
|
|
_MakeWeightInfo(pWeightArray, pBlendVtxArray, numVertex);
|
|
#ifdef _USE_NORMAL_
|
|
CalculateTangentArray(numVertex,pBlendVtxArray, indexCount, pIndexArray );
|
|
#endif
|
|
}
|
|
|
|
// Blended Vertex Array
|
|
m_spVertexBuffer = m_pGraphics->CreateVertexBufferBlend( stride, format, numVertex);
|
|
K3DBLENDEDBUMPVERTEX* pVtxBuffer = NULL;
|
|
int vtxCount = numVertex;
|
|
m_spVertexBuffer->Lock( reinterpret_cast<void**>(&pVtxBuffer), vtxCount);
|
|
if( pVtxBuffer )
|
|
{
|
|
memcpy(pVtxBuffer,pBlendVtxArray, stride * numVertex );
|
|
m_spVertexBuffer->Unlock();
|
|
}
|
|
|
|
if(NULL != pVtxArray)
|
|
{
|
|
m_spVtxArray->SetArray( pVtxArray, numVertex );
|
|
delete [] pVtxArray;
|
|
}
|
|
m_nMeshSimultaneousFrameCount = 1;
|
|
|
|
// set bounding sphere
|
|
m_bSphere.SetPosition( sp_pos );
|
|
m_bSphere.SetRadius( sp_radius );
|
|
|
|
// set bounding cube
|
|
K3DVertex rotc[8];
|
|
cube_min += K3DVector(-1, -1, -1);
|
|
cube_max += K3DVector( 1, 1, 1);
|
|
|
|
for(size_t i = 0; i < 8; ++i)
|
|
rotc[i] = KPCCP::get_cube_vertex(i, cube_min.x, cube_max.x, cube_min.y, cube_max.y, cube_min.z, cube_max.z);
|
|
|
|
m_bCube.SetCube(rotc);
|
|
|
|
delete [] pBlendVtxArray;
|
|
}
|
|
|
|
void KNX3MeshFrame::_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)
|
|
{
|
|
K3DVector sp_pos;
|
|
float sp_radius = 0;
|
|
|
|
if ( numVertex > 0) // 초기값은 첫번째 버텍스로 넣어준다
|
|
pVertexArray->readFixedData( 0, 3, &sp_pos, sizeof( sp_pos ) );
|
|
|
|
K3DVector cube_min(sp_pos), cube_max(sp_pos);
|
|
|
|
K3DVertex* pVtxArray = NULL;
|
|
if( NULL != pLoadPack && pLoadPack->bLoad_PolyGon )
|
|
{
|
|
pVtxArray = new K3DVertex[numVertex];
|
|
m_spVtxArray = new K3DVertexRes;
|
|
}
|
|
// Data가 기존의 2배라면 Light map용 채널이 같이 들어 있다.
|
|
bool bLoadLightMapUV = pTexelArray && pTexelArray->count() / 2 == (pVertexArray->count() / 3) * 2;
|
|
|
|
K3DBLENDEDBUMPVERTEX* pBlendVtxArray = new K3DBLENDEDBUMPVERTEX[numVertex];
|
|
|
|
for(DWORD i = 0; i < numVertex; ++i)
|
|
{
|
|
K3DBLENDEDBUMPVERTEX* pCurBlendVtx = &(pBlendVtxArray[i]);
|
|
|
|
pCurBlendVtx->matrixIndices = 0;
|
|
pCurBlendVtx->matrixWeights.x = m_bIsBlended ? 0.f : 1.f;
|
|
pCurBlendVtx->matrixWeights.y = 0.f;
|
|
|
|
pVertexArray->readFixedData(i * 3, 3, &(pCurBlendVtx->position), sizeof( pCurBlendVtx->position ) );
|
|
|
|
if(pVtxArray != NULL)
|
|
pVtxArray[i] = pCurBlendVtx->position;
|
|
|
|
pNormalArray->readFixedData(i * 3, 3, &(pCurBlendVtx->normal), sizeof( pCurBlendVtx->normal ) );
|
|
|
|
if(NULL != pTexelArray)
|
|
pTexelArray->readFixedData(i * 2, 2, &(pCurBlendVtx->texcoord), sizeof( pCurBlendVtx->texcoord ) );
|
|
|
|
|
|
// 우선 Lightmap쓰는 놈은 Skinning을 절대 하지 않으므로 Weight에 넣어볼까? -_- (뜯어 고치기 귀찮3)
|
|
if(bLoadLightMapUV)
|
|
pTexelArray->readFixedData(numVertex * 2 + i * 2, 2, reinterpret_cast<float *> (&(pCurBlendVtx->matrixWeights) ), sizeof( pCurBlendVtx->matrixWeights ) );
|
|
|
|
if(NULL != pColorArray)
|
|
pCurBlendVtx->color = pColorArray->getDWordAt( i );
|
|
else
|
|
pCurBlendVtx->color = 0xFFFFFFFF;
|
|
|
|
|
|
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
// make bound object
|
|
// sphere calc
|
|
const K3DVector& vCur = pCurBlendVtx->position;
|
|
K3DVector vDiff = vCur - sp_pos; // 원점으로부터 새로 들어온 점까지의 벡터
|
|
float fLen = K3DVectorLength(vDiff);
|
|
if( fLen > sp_radius )
|
|
{
|
|
// 반지름의 크기를 가지는 vDiff의 반대 방향
|
|
K3DVector vDV = vDiff - ( sp_radius / fLen ) * vDiff;
|
|
sp_pos += vDV * .5f;
|
|
sp_radius = (fLen + sp_radius) / 2.f;
|
|
}
|
|
|
|
// make axis aligned cube
|
|
cube_min.x = _min(cube_min.x , vCur.x);
|
|
cube_min.y = _min(cube_min.y , vCur.y);
|
|
cube_min.z = _min(cube_min.z , vCur.z);
|
|
cube_max.x = _max(cube_max.x , vCur.x);
|
|
cube_max.y = _max(cube_max.y , vCur.y);
|
|
cube_max.z = _max(cube_max.z , vCur.z);
|
|
//////////////////////////////////////////////////////////////////////////////
|
|
}
|
|
if(true == m_bIsBlended )
|
|
{
|
|
_MakeWeightInfo(pWeightArray, pBlendVtxArray, numVertex);
|
|
#ifdef _USE_NORMAL_
|
|
CalculateTangentArray(numVertex,pBlendVtxArray, indexCount, pIndexArray );
|
|
#endif
|
|
}
|
|
|
|
// Blended Vertex Array
|
|
m_spVertexBuffer = m_pGraphics->CreateVertexBufferBlend( stride, format, numVertex);
|
|
K3DBLENDEDBUMPVERTEX* pVtxBuffer = NULL;
|
|
int vtxCount = numVertex;
|
|
m_spVertexBuffer->Lock( reinterpret_cast<void**>(&pVtxBuffer), vtxCount);
|
|
if( pVtxBuffer )
|
|
{
|
|
memcpy(pVtxBuffer,pBlendVtxArray, stride * numVertex );
|
|
m_spVertexBuffer->Unlock();
|
|
}
|
|
|
|
if(NULL != pVtxArray)
|
|
{
|
|
m_spVtxArray->SetArray( pVtxArray, numVertex );
|
|
delete [] pVtxArray;
|
|
}
|
|
m_nMeshSimultaneousFrameCount = 1;
|
|
|
|
// set bounding sphere
|
|
m_bSphere.SetPosition( sp_pos );
|
|
m_bSphere.SetRadius( sp_radius );
|
|
|
|
// set bounding cube
|
|
K3DVertex rotc[8];
|
|
cube_min += K3DVector(-1, -1, -1);
|
|
cube_max += K3DVector( 1, 1, 1);
|
|
|
|
for(size_t i = 0; i < 8; ++i)
|
|
rotc[i] = KPCCP::get_cube_vertex(i, cube_min.x, cube_max.x, cube_min.y, cube_max.y, cube_min.z, cube_max.z);
|
|
|
|
m_bCube.SetCube(rotc);
|
|
|
|
delete [] pBlendVtxArray;
|
|
}
|
|
|
|
void KNX3MeshFrame::_MakeWeightInfo(KTemplateDataArrayObject* pWeightArray, K3DBLENDEDBUMPVERTEX* pBlendVtxArray, DWORD numVertex)
|
|
{
|
|
//Weight 작업중. Blended 버텍스 넣어 주기 위해, 미리 로드 한다.
|
|
for( DWORD i = 0; m_dwBoneSize > i; ++i)
|
|
{
|
|
KNX3WeightElement * pWeightElement = new KNX3WeightElement;
|
|
pWeightElement->Load( pWeightArray->GetData(i) );
|
|
m_vWeightList.push_back(pWeightElement);
|
|
}
|
|
|
|
//Weight 와 Bone Index를 설정.
|
|
std::vector<int> useBone;
|
|
|
|
for( unsigned int i(0); m_dwBoneSize>i; i++ )
|
|
{
|
|
DWORD nVtxCount = m_vWeightList[i]->GetWeightSize();
|
|
for( DWORD j(0); nVtxCount>j; j++ )
|
|
{
|
|
float * pVtxIndexArray = m_vWeightList[i]->GetVertexIndex();
|
|
float * pWeightArray = m_vWeightList[i]->GetVertexWeight();
|
|
|
|
int nVtxIdx = (int)pVtxIndexArray[j]; //버텍스 인덱스
|
|
float fWeight = pWeightArray[j]; //가중치
|
|
|
|
K3DBLENDEDBUMPVERTEX * pCurBleneVtx = &(pBlendVtxArray[nVtxIdx]);
|
|
if( pCurBleneVtx->matrixWeights.x == 0.f ) //가중치가 설정이 안되어 있으면..
|
|
{
|
|
pCurBleneVtx->matrixWeights.x = fWeight;
|
|
pCurBleneVtx->matrixIndices = i;
|
|
AddUseBoneIndex( i ); //사용하는 본으로 추가
|
|
}
|
|
else if( pCurBleneVtx->matrixWeights.y == 0.f ) //첫번째 가중치가 설정 되어 있으면..
|
|
{
|
|
pCurBleneVtx->matrixWeights.y = fWeight; //두번째는 여기.
|
|
pCurBleneVtx->matrixIndices |= (i)*256;
|
|
AddUseBoneIndex( i );
|
|
}
|
|
else
|
|
{
|
|
_oprint( "Error: more than 3 weights are not supported yet (x: %f; y: %f) \n", pCurBleneVtx->matrixWeights.x, pCurBleneVtx->matrixWeights.y);
|
|
}
|
|
|
|
// sprintf( szBuf, "UseBone Index : %d %d\n", i, pBleneVtx->matrixIndices );
|
|
// OutputDebugString(szBuf);
|
|
}
|
|
}
|
|
|
|
//사용하는 뼈 인덱스로 변경..
|
|
//우선 Sort
|
|
std::sort( m_vUseBoneList.begin( ), m_vUseBoneList.end( ) );
|
|
|
|
//_oprint( "!!!최적화 : Bone Count : %d\n", m_vUseBoneList.size() );
|
|
|
|
//기존에 들어 있는 인덱스 변경.
|
|
for(DWORD i = 0; i < numVertex; ++i )
|
|
{
|
|
K3DBLENDEDBUMPVERTEX * pCurBleneVtx = &(pBlendVtxArray[i]);
|
|
|
|
for( unsigned int j(0); m_vUseBoneList.size(); ++j )
|
|
{
|
|
//같은 인덱스, 인덱스를 변경 한다.
|
|
//256보다 큰 것들은 변경 한다.
|
|
if( pCurBleneVtx->matrixIndices >= 256 )
|
|
{ //Weight 값이 2개 인것들..
|
|
int nTemp1 = pCurBleneVtx->matrixIndices/256;
|
|
int nTemp2 = nTemp1*256; //나중에 추가 된것.
|
|
int nTemp3 = pCurBleneVtx->matrixIndices - nTemp2; //원래 값
|
|
|
|
pCurBleneVtx->matrixIndices = GetNewBoneIndex(nTemp3);
|
|
pCurBleneVtx->matrixIndices |= GetNewBoneIndex(nTemp1)*256;
|
|
}
|
|
else
|
|
{ //Weight 값이 1개 인것들
|
|
pCurBleneVtx->matrixIndices = GetNewBoneIndex(pCurBleneVtx->matrixIndices);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
void KNX3MeshFrame::_MakeWeightInfo( trf::MTemplateArrayPtr pWeightArray, K3DBLENDEDBUMPVERTEX* pBlendVtxArray, DWORD numVertex)
|
|
{
|
|
//Weight 작업중. Blended 버텍스 넣어 주기 위해, 미리 로드 한다.
|
|
for( DWORD i = 0; m_dwBoneSize > i; ++i)
|
|
{
|
|
KNX3WeightElement * pWeightElement = new KNX3WeightElement;
|
|
pWeightElement->LoadTRF( pWeightArray->getTemplateAt(i) );
|
|
m_vWeightList.push_back(pWeightElement);
|
|
}
|
|
|
|
//Weight 와 Bone Index를 설정.
|
|
std::vector<int> useBone;
|
|
|
|
for( unsigned int i(0); m_dwBoneSize>i; i++ )
|
|
{
|
|
DWORD nVtxCount = m_vWeightList[i]->GetWeightSize();
|
|
for( DWORD j(0); nVtxCount>j; j++ )
|
|
{
|
|
float * pVtxIndexArray = m_vWeightList[i]->GetVertexIndex();
|
|
float * pWeightArray = m_vWeightList[i]->GetVertexWeight();
|
|
|
|
int nVtxIdx = (int)pVtxIndexArray[j]; //버텍스 인덱스
|
|
float fWeight = pWeightArray[j]; //가중치
|
|
|
|
K3DBLENDEDBUMPVERTEX * pCurBleneVtx = &(pBlendVtxArray[nVtxIdx]);
|
|
if( pCurBleneVtx->matrixWeights.x == 0.f ) //가중치가 설정이 안되어 있으면..
|
|
{
|
|
pCurBleneVtx->matrixWeights.x = fWeight;
|
|
pCurBleneVtx->matrixIndices = i;
|
|
AddUseBoneIndex( i ); //사용하는 본으로 추가
|
|
}
|
|
else if( pCurBleneVtx->matrixWeights.y == 0.f ) //첫번째 가중치가 설정 되어 있으면..
|
|
{
|
|
pCurBleneVtx->matrixWeights.y = fWeight; //두번째는 여기.
|
|
pCurBleneVtx->matrixIndices |= (i)*256;
|
|
AddUseBoneIndex( i );
|
|
}
|
|
else
|
|
{
|
|
_oprint("Error: more than 3 weights are not supported yet (x: %f; y: %f) \n", pCurBleneVtx->matrixWeights.x, pCurBleneVtx->matrixWeights.y);
|
|
}
|
|
|
|
// sprintf( szBuf, "UseBone Index : %d %d\n", i, pBleneVtx->matrixIndices );
|
|
// OutputDebugString(szBuf);
|
|
}
|
|
}
|
|
|
|
//사용하는 뼈 인덱스로 변경..
|
|
//우선 Sort
|
|
std::sort( m_vUseBoneList.begin( ), m_vUseBoneList.end( ) );
|
|
|
|
//_oprint( "!!!최적화 : Bone Count : %d\n", m_vUseBoneList.size() );
|
|
|
|
//기존에 들어 있는 인덱스 변경.
|
|
for(DWORD i = 0; i < numVertex; ++i )
|
|
{
|
|
K3DBLENDEDBUMPVERTEX * pCurBleneVtx = &(pBlendVtxArray[i]);
|
|
|
|
for( unsigned int j(0); m_vUseBoneList.size(); ++j )
|
|
{
|
|
//같은 인덱스, 인덱스를 변경 한다.
|
|
//256보다 큰 것들은 변경 한다.
|
|
if( pCurBleneVtx->matrixIndices >= 256 )
|
|
{ //Weight 값이 2개 인것들..
|
|
int nTemp1 = pCurBleneVtx->matrixIndices/256;
|
|
int nTemp2 = nTemp1*256; //나중에 추가 된것.
|
|
int nTemp3 = pCurBleneVtx->matrixIndices - nTemp2; //원래 값
|
|
|
|
pCurBleneVtx->matrixIndices = GetNewBoneIndex(nTemp3);
|
|
pCurBleneVtx->matrixIndices |= GetNewBoneIndex(nTemp1)*256;
|
|
}
|
|
else
|
|
{ //Weight 값이 1개 인것들
|
|
pCurBleneVtx->matrixIndices = GetNewBoneIndex(pCurBleneVtx->matrixIndices);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
KNX3WeightElement::KNX3WeightElement()
|
|
{
|
|
m_dwWeightSize = 0;
|
|
m_pVertexIndex = NULL; //버텍스 인덱스
|
|
m_pVertexWeight= NULL; //버텍스 가중치
|
|
m_pOffsetVector= NULL; //버텍스 OffSet
|
|
}
|
|
|
|
KNX3WeightElement::~KNX3WeightElement()
|
|
{
|
|
if( m_pVertexIndex ) { delete [] m_pVertexIndex; m_pVertexIndex = NULL; }
|
|
if( m_pVertexWeight) { delete [] m_pVertexWeight; m_pVertexWeight= NULL; }
|
|
if( m_pOffsetVector) { delete [] m_pOffsetVector; m_pOffsetVector= NULL; }
|
|
}
|
|
|
|
BOOL KNX3WeightElement::Load(KTemplateDataObject * pObject)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
KSimpleDataObject * pWeightSize = pObject->GetSimpleDataMemberObject("weight_size");
|
|
pWeightSize->GetDWORD(&m_dwWeightSize);
|
|
KSimpleDataArrayObject * pWeightArray = pObject->GetSimpleDataArrayMemberObject("weight_array");
|
|
|
|
KSimpleDataObject * pOffsetVectorSize = pObject->GetSimpleDataMemberObject("offset_vector_size");
|
|
pOffsetVectorSize->GetDWORD(&m_dwOffsetVectorSize);
|
|
KSimpleDataArrayObject * pOffsetVectorArray = pObject->GetSimpleDataArrayMemberObject("offset_vector_array");
|
|
|
|
int iStrLen = 64;
|
|
KSimpleDataObject * pBoneName = pObject->GetSimpleDataMemberObject("bone_name");
|
|
pBoneName->GetString(m_szBoneName, iStrLen);
|
|
|
|
if( m_dwWeightSize <= 0 ) return TRUE;
|
|
|
|
m_pVertexIndex = new float[m_dwWeightSize/2];
|
|
m_pVertexWeight = new float[m_dwWeightSize/2];
|
|
memset( m_pVertexIndex , 0, sizeof(float)*m_dwWeightSize/2 );
|
|
memset( m_pVertexWeight, 0, sizeof(float)*m_dwWeightSize/2 );
|
|
|
|
int n(0);
|
|
for( DWORD dw(0); (m_dwWeightSize/2) > dw; dw++ )
|
|
{
|
|
pWeightArray->GetDataFloat( n++, &m_pVertexIndex[dw], sizeof( m_pVertexIndex[dw] ), 1 );
|
|
pWeightArray->GetDataFloat( n++, &m_pVertexWeight[dw], sizeof( m_pVertexWeight[dw] ), 1 );
|
|
}
|
|
|
|
#ifdef _USE_OFFSETVECTOR_
|
|
if( m_dwOffsetVectorSize && pOffsetVectorArray )
|
|
{
|
|
n = 0;
|
|
m_pOffsetVector = new K3DVector[m_dwOffsetVectorSize/3];
|
|
for( DWORD dw(0); (m_dwOffsetVectorSize/3) > dw; dw++ )
|
|
{
|
|
K3DVector offsetvector;
|
|
pOffsetVectorArray->GetDataFloat( n++, &offsetvector.x, sizeof( offsetvector.x ), 1 );
|
|
pOffsetVectorArray->GetDataFloat( n++, &offsetvector.y, sizeof( offsetvector.y ), 1 );
|
|
pOffsetVectorArray->GetDataFloat( n++, &offsetvector.z, sizeof( offsetvector.z ), 1 );
|
|
m_pOffsetVector[dw] = offsetvector;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
m_dwWeightSize = m_dwWeightSize/2;
|
|
|
|
// _oprint( "Load Time : KNX3WeightElement::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3WeightElement::LoadTRF( trf::MTemplatePtr pObject)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
trf::MArrayPtr pWeightArray = pObject->getArrayBy("weight_array");
|
|
m_dwWeightSize = pWeightArray->count();
|
|
|
|
trf::MArrayPtr pOffsetVectorArray = pObject->getArrayBy("offset_vector_array");
|
|
m_dwOffsetVectorSize = pOffsetVectorArray->count();
|
|
|
|
strncpy( m_szBoneName, SafeStr( pObject->getStringBy( "bone_name" ) ), 64 );
|
|
|
|
if( m_dwWeightSize <= 0 )
|
|
return true;
|
|
|
|
m_pVertexIndex = new float[m_dwWeightSize/2];
|
|
m_pVertexWeight = new float[m_dwWeightSize/2];
|
|
memset( m_pVertexIndex , 0, sizeof(float)*m_dwWeightSize/2 );
|
|
memset( m_pVertexWeight, 0, sizeof(float)*m_dwWeightSize/2 );
|
|
|
|
int n(0);
|
|
for( DWORD dw(0); (m_dwWeightSize/2) > dw; dw++ )
|
|
{
|
|
m_pVertexIndex[dw] = pWeightArray->getFloatAt( n++ );
|
|
m_pVertexWeight[dw] = pWeightArray->getFloatAt( n++ );
|
|
}
|
|
|
|
#ifdef _USE_OFFSETVECTOR_
|
|
n = 0;
|
|
m_pOffsetVector = new K3DVector[m_dwOffsetVectorSize/3];
|
|
for( DWORD dw(0); (m_dwOffsetVectorSize/3) > dw; dw++ )
|
|
{
|
|
K3DVector offsetvector;
|
|
offsetvector.x = pOffsetVectorArray->getFloatAt( n++ );
|
|
offsetvector.y = pOffsetVectorArray->getFloatAt( n++ );
|
|
offsetvector.z = pOffsetVectorArray->getFloatAt( n++ );
|
|
m_pOffsetVector[dw] = offsetvector;
|
|
}
|
|
#endif
|
|
|
|
m_dwWeightSize = m_dwWeightSize/2;
|
|
|
|
// _oprint( "Load Time : KNX3WeightElement::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return true;
|
|
}
|
|
|
|
KNX3FXElement::KNX3FXElement()
|
|
{
|
|
m_dwFrameTime = 0;
|
|
m_bIsFX = false;
|
|
}
|
|
|
|
KNX3FXElement::~KNX3FXElement()
|
|
{
|
|
m_dwFrameTime = 0;
|
|
m_vecData.clear();
|
|
}
|
|
|
|
bool KNX3FXElement::getKey( std::string &key, int &pos )
|
|
{
|
|
const char *str = m_sNote.c_str();
|
|
int len = static_cast<int>(m_sNote.size());
|
|
std::string strkey;
|
|
for ( int i = pos ; i < len ; ++i )
|
|
{
|
|
if ( str[i] == '\n' || str[i] == '\r' || str[i] == '\t' || str[i] == ' ' )
|
|
{
|
|
continue;
|
|
}
|
|
if ( str[i] == '=' )
|
|
{
|
|
if ( strkey.size() == 0 ) return false;
|
|
key = strkey;
|
|
pos = i + 1;
|
|
return true;
|
|
}
|
|
strkey += str[i];
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void KNX3FXElement::getKeyValue( std::string &value, int &pos )
|
|
{
|
|
const char *str = m_sNote.c_str();
|
|
int len = static_cast<int>(m_sNote.size());
|
|
std::string strvalue;
|
|
int i;
|
|
for ( i = pos ; i < len ; ++i )
|
|
{
|
|
if ( isalnum( str[i] ) )
|
|
{
|
|
if( i > 0 )
|
|
{
|
|
if( str[ i - 1 ] == '+' || str[ i - 1 ] == '-' )
|
|
{
|
|
i--;
|
|
}
|
|
}
|
|
|
|
pos = i;
|
|
break;
|
|
}
|
|
}
|
|
for ( i = pos ; i < len ; ++i )
|
|
{
|
|
if ( str[i] == '\t' || str[i] == ' ' )
|
|
{
|
|
continue;
|
|
}
|
|
if ( (str[i] == '\r' || str[i] == '\n') && strvalue.size() > 0 )
|
|
{
|
|
value = strvalue;
|
|
pos = i + 1;
|
|
return;
|
|
}
|
|
strvalue += str[i];
|
|
}
|
|
if ( strvalue.size() > 0 )
|
|
{
|
|
value = strvalue;
|
|
pos = i + 1;
|
|
return;
|
|
}
|
|
}
|
|
|
|
void KNX3FXElement::parse()
|
|
{
|
|
DATA data;
|
|
int pos = 0;
|
|
while( true )
|
|
{
|
|
if ( getKey( data.key, pos ) )
|
|
{
|
|
getKeyValue( data.value, pos );
|
|
m_vecData.push_back( data );
|
|
data.key = "";
|
|
data.value = "";
|
|
}
|
|
else break;
|
|
}
|
|
}
|
|
|
|
const char *KNX3FXElement::GetValue( const char *fname )
|
|
{
|
|
std::vector<DATA>::iterator it = m_vecData.begin();
|
|
for ( ; it != m_vecData.end() ; ++it )
|
|
{
|
|
if ( _stricmp( (*it).key.c_str(), fname ) == 0 )
|
|
{
|
|
return (*it).value.c_str();
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
int KNX3FXElement::GetNumValue( const char *key, int nDef )
|
|
{
|
|
const char *value = GetValue( key );
|
|
if ( value == NULL ) return nDef;
|
|
return atoi( value );
|
|
}
|
|
|
|
float KNX3FXElement::GetFloatValue( const char *key, float fDef )
|
|
{
|
|
const char *value = GetValue( key );
|
|
if ( value == NULL ) return fDef;
|
|
return (float)atof( value );
|
|
}
|
|
|
|
K3DVector KNX3FXElement::GetVectorValue( const char *key, const K3DVector &vecDef )
|
|
{
|
|
const char *vstr = GetValue( key );
|
|
if ( vstr == NULL ) return vecDef;
|
|
|
|
K3DVector v;
|
|
sscanf( vstr, "%f,%f,%f", &v.x, &v.y, &v.z );
|
|
return v;
|
|
}
|
|
|
|
K3DVector KNX3FXElement::Get2DVectorValue( const char *key, const K3DVector &vecDef )
|
|
{
|
|
const char *vstr = GetValue( key );
|
|
if ( vstr == NULL ) return vecDef;
|
|
|
|
K3DVector v;
|
|
sscanf( vstr, "%f,%f", &v.x, &v.y );
|
|
v.z = vecDef.z;
|
|
return v;
|
|
}
|
|
|
|
void KNX3FXElement::GetVariNumValue( const char *key, int *base_num, int *vari_num )
|
|
{
|
|
const char *vstr = GetValue( key );
|
|
if ( vstr == NULL ) return;
|
|
|
|
sscanf( vstr, "%d,%d", base_num, vari_num );
|
|
}
|
|
|
|
BOOL KNX3FXElement::Load(KTemplateDataObject * pObject)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
KSimpleDataObject * pTime = pObject->GetSimpleDataMemberObject("time");
|
|
pTime->GetDWORD(&m_dwFrameTime);
|
|
|
|
char lpszNote[512];
|
|
int maxLen = 512;
|
|
KSimpleDataObject * pNote = pObject->GetSimpleDataMemberObject("note");
|
|
pNote->GetString(lpszNote,maxLen);
|
|
m_sNote.assign(lpszNote);
|
|
|
|
parse();
|
|
const char *value = GetValue( "NXFX" );
|
|
if ( value != NULL )
|
|
{
|
|
m_bIsFX = true;
|
|
}
|
|
else m_bIsFX = false;
|
|
|
|
// _oprint( "Load Time : KNX3FXElement::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3FXElement::LoadTRF( trf::MTemplatePtr pObject)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
m_dwFrameTime = pObject->getDWordBy("time");
|
|
m_sNote = SafeStr( pObject->getStringBy("note") );
|
|
|
|
parse();
|
|
const char *value = GetValue( "NXFX" );
|
|
if ( value != NULL )
|
|
{
|
|
m_bIsFX = true;
|
|
}
|
|
else m_bIsFX = false;
|
|
|
|
// _oprint( "Load Time : KNX3FXElement::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return true;
|
|
}
|
|
|
|
BOOL KNX3FX::Load(KTemplateDataObject * pObject)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
KTemplateDataArrayObject * pFxBlockArray = pObject->GetTemplateDataArrayMemberObject("fx_block_array");
|
|
|
|
for(int i(0); i < pFxBlockArray->GetDataCount(); ++i)
|
|
{
|
|
KNX3FXElement element;
|
|
element.Load(pFxBlockArray->GetData(i));
|
|
if ( i == 0 && element.IsFX() == true )
|
|
m_bIsFX = true;
|
|
m_vtFXElement.push_back(element);
|
|
}
|
|
|
|
// _oprint( "Load Time : KNX3FX::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3FX::LoadTRF( trf::MTemplatePtr pObject )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
trf::MTemplateArrayPtr pFxBlockArray = pObject->getTemplateArrayBy("fx_block_array");
|
|
|
|
for(int i(0); i < pFxBlockArray->count(); ++i)
|
|
{
|
|
KNX3FXElement element;
|
|
element.LoadTRF(pFxBlockArray->getTemplateAt(i));
|
|
if ( i == 0 && element.IsFX() == true )
|
|
m_bIsFX = true;
|
|
m_vtFXElement.push_back(element);
|
|
}
|
|
|
|
// _oprint( "Load Time : KNX3FX::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return true;
|
|
}
|
|
|
|
KNX3FXElement * KNX3FX::GetFXElement(DWORD dwFrameTime)
|
|
{
|
|
|
|
if(m_vtFXElement.size() == 0)
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
for(unsigned int i(0); i < m_vtFXElement.size() - 1; ++i)
|
|
{
|
|
if( m_vtFXElement.at(i).GetFrameTime() <= dwFrameTime &&
|
|
m_vtFXElement.at(i + 1).GetFrameTime() > dwFrameTime)
|
|
{
|
|
return &m_vtFXElement.at(i);
|
|
}
|
|
}
|
|
|
|
return &m_vtFXElement.back();
|
|
}
|
|
|
|
KNX3FXElement * KNX3FX::GetFxElementByIndeX(int iIndex)
|
|
{
|
|
if(iIndex < 0 || iIndex >= (int)m_vtFXElement.size() )
|
|
return NULL;
|
|
|
|
return &m_vtFXElement.at(iIndex);
|
|
}
|
|
DWORD KNX3FX::GetFXElementSize()
|
|
{
|
|
return static_cast<DWORD>(m_vtFXElement.size());
|
|
}
|
|
|
|
BOOL KNX3CameraChannel::Load(KTemplateDataObject * pObject)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
KTemplateDataArrayObject * pCameraArray = pObject->GetTemplateDataArrayMemberObject("camera_block_array");
|
|
|
|
m_spCameraRes = new K3DResCamera;
|
|
K3DResCamera::Key *key = new K3DResCamera::Key[pCameraArray->GetDataCount()];
|
|
float fArray[12];
|
|
for(int i(0); i < pCameraArray->GetDataCount(); ++i)
|
|
{
|
|
KTemplateDataObject *pObject = pCameraArray->GetData(i);
|
|
char bHasTarget;
|
|
KSimpleDataObject * pHasTarget = pObject->GetSimpleDataMemberObject("has_target");
|
|
pHasTarget->GetChar(reinterpret_cast<char *>(&bHasTarget) );
|
|
if ( bHasTarget )
|
|
{
|
|
KSimpleDataArrayObject * pMatObject = pObject->GetSimpleDataArrayMemberObject("mat_object");
|
|
pMatObject->GetDataFloat(0,fArray,sizeof(fArray),12);
|
|
key[i].up.x = fArray[3]; key[i].up.y = fArray[4]; key[i].up.z = fArray[5];
|
|
key[i].pos.x = fArray[9]; key[i].pos.y = fArray[10]; key[i].pos.z = fArray[11];
|
|
|
|
KSimpleDataArrayObject * pMatTarget = pObject->GetSimpleDataArrayMemberObject("mat_target");
|
|
pMatTarget->GetDataFloat(0,fArray,sizeof(fArray),12);
|
|
key[i].view.x = fArray[9] - key[i].pos.x; key[i].view.y = fArray[10] - key[i].pos.y; key[i].view.z = fArray[11] - key[i].pos.z;
|
|
}
|
|
else
|
|
{
|
|
KSimpleDataArrayObject * pMatObject = pObject->GetSimpleDataArrayMemberObject("mat_object");
|
|
pMatObject->GetDataFloat(0,fArray,sizeof(fArray),12);
|
|
key[i].view.x = fArray[0]; key[i].view.y = fArray[1]; key[i].view.z = fArray[2];
|
|
key[i].up.x = fArray[3]; key[i].up.y = fArray[4]; key[i].up.z = fArray[5];
|
|
key[i].pos.x = fArray[9]; key[i].pos.y = fArray[10]; key[i].pos.z = fArray[11];
|
|
}
|
|
KSimpleDataObject * pTime = pObject->GetSimpleDataMemberObject("time_value");
|
|
pTime->GetDWORD(reinterpret_cast<DWORD*>(&key[i].time));
|
|
|
|
KSimpleDataObject * pFov = pObject->GetSimpleDataMemberObject("fov");
|
|
pFov->GetFloat(&key[i].fov);
|
|
}
|
|
m_spCameraRes->SetWholeKey( key, pCameraArray->GetDataCount() );
|
|
delete[] key;
|
|
|
|
// _oprint( "Load Time : KNX3CameraChannel::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3CameraChannel::LoadTRF( trf::MTemplatePtr pObject )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
trf::MTemplateArrayPtr pCameraArray = pObject->getTemplateArrayBy( "camera_block_array" );
|
|
|
|
m_spCameraRes = new K3DResCamera;
|
|
K3DResCamera::Key *key = new K3DResCamera::Key[ pCameraArray->count() ];
|
|
// float fArray[12];
|
|
for(int i(0); i < pCameraArray->count(); ++i)
|
|
{
|
|
trf::MTemplatePtr pObject = pCameraArray->getTemplateAt(i);
|
|
char bHasTarget = pObject->getCharBy( "has_target" );
|
|
if ( bHasTarget )
|
|
{
|
|
const float* fArray = pObject->getArrayBy("mat_object")->getFloatArray();
|
|
key[i].up.x = fArray[3]; key[i].up.y = fArray[4]; key[i].up.z = fArray[5];
|
|
key[i].pos.x = fArray[9]; key[i].pos.y = fArray[10]; key[i].pos.z = fArray[11];
|
|
|
|
fArray = pObject->getArrayBy("mat_target")->getFloatArray();
|
|
key[i].view.x = fArray[9] - key[i].pos.x; key[i].view.y = fArray[10] - key[i].pos.y; key[i].view.z = fArray[11] - key[i].pos.z;
|
|
}
|
|
else
|
|
{
|
|
const float* fArray = pObject->getArrayBy("mat_object")->getFloatArray();
|
|
key[i].view.x = fArray[0]; key[i].view.y = fArray[1]; key[i].view.z = fArray[2];
|
|
key[i].up.x = fArray[3]; key[i].up.y = fArray[4]; key[i].up.z = fArray[5];
|
|
key[i].pos.x = fArray[9]; key[i].pos.y = fArray[10]; key[i].pos.z = fArray[11];
|
|
}
|
|
key[i].time = pObject->getDWordBy("time_value");
|
|
key[i].fov = pObject->getFloatBy("fov");
|
|
}
|
|
m_spCameraRes->SetWholeKey( key, pCameraArray->count() );
|
|
delete[] key;
|
|
|
|
// _oprint( "Load Time : KNX3CameraChannel::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return true;
|
|
}
|
|
|
|
void KNX3LightChannel::Clear()
|
|
{
|
|
SAFE_DELETE_VECTOR(m_vtLightList);
|
|
}
|
|
|
|
BOOL KNX3LightChannel::Load(KTemplateDataObject * pObject)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
KTemplateDataArrayObject * pLightArray = pObject->GetTemplateDataArrayMemberObject("light_array");
|
|
|
|
for(int i(0); i < pLightArray->GetDataCount(); ++i)
|
|
{
|
|
KNX3Light * pLight = new KNX3Light(m_pGraphics);
|
|
pLight->Load(pLightArray->GetData(i));
|
|
m_vtLightList.push_back(pLight);
|
|
}
|
|
|
|
// _oprint( "Load Time : KNX3LightChannel::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3LightChannel::LoadTRF( trf::MTemplatePtr pObject)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
trf::MTemplateArrayPtr pLightArray = pObject->getTemplateArrayBy( "light_array" );
|
|
|
|
for(int i(0); i < pLightArray->count(); ++i)
|
|
{
|
|
KNX3Light * pLight = new KNX3Light(m_pGraphics);
|
|
pLight->LoadTRF(pLightArray->getTemplateAt(i));
|
|
m_vtLightList.push_back(pLight);
|
|
}
|
|
|
|
// _oprint( "Load Time : KNX3LightChannel::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return true;
|
|
}
|
|
|
|
BOOL KNX3Light::Load(KTemplateDataObject * pObject)
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
DWORD dwLightType;
|
|
DWORD dwAmbient;
|
|
KSimpleDataObject *pLightType = pObject->GetSimpleDataMemberObject("light_type");
|
|
pLightType->GetDWORD(&dwLightType);
|
|
|
|
KSimpleDataObject * pAmbientColor = pObject->GetSimpleDataMemberObject("ambient_light");
|
|
pAmbientColor->GetDWORD(&dwAmbient);
|
|
|
|
m_spLightRes = new K3DResLight;
|
|
KTemplateDataArrayObject * pLightBlockArray = pObject->GetTemplateDataArrayMemberObject("light_block_array");
|
|
|
|
K3DResLight::Key *key = new K3DResLight::Key[pLightBlockArray->GetDataCount()];
|
|
for(int i(0); i < pLightBlockArray->GetDataCount(); ++i)
|
|
{
|
|
KTemplateDataObject *pElementObject = pLightBlockArray->GetData(i);
|
|
|
|
K3DMatrix pos, target;
|
|
DWORD dwColor;
|
|
float fIntens, fAttStart, fAttEnd;
|
|
char bOn;
|
|
float fArray[12];
|
|
KSimpleDataArrayObject * pMatObject = pElementObject->GetSimpleDataArrayMemberObject("mat_object");
|
|
pMatObject->GetDataFloat(0,fArray,sizeof(fArray),12);
|
|
|
|
pos._11 = fArray[0]; pos._12 = fArray[1]; pos._13 = fArray[2];
|
|
pos._21 = fArray[3]; pos._22 = fArray[4]; pos._23 = fArray[5];
|
|
pos._31 = fArray[6]; pos._32 = fArray[7]; pos._33 = fArray[8];
|
|
pos._41 = fArray[9]; pos._42 = fArray[10]; pos._43 = fArray[11];
|
|
|
|
KSimpleDataArrayObject * pMatTarget = pElementObject->GetSimpleDataArrayMemberObject("mat_target");
|
|
pMatTarget->GetDataFloat(0,fArray,sizeof(fArray),12);
|
|
|
|
target._11 = fArray[0]; target._12 = fArray[1]; target._13 = fArray[2];
|
|
target._21 = fArray[3]; target._22 = fArray[4]; target._23 = fArray[5];
|
|
target._31 = fArray[6]; target._32 = fArray[7]; target._33 = fArray[8];
|
|
target._41 = fArray[9]; target._42 = fArray[10]; target._43 = fArray[11];
|
|
|
|
KSimpleDataObject * pTime = pElementObject->GetSimpleDataMemberObject("time_value");
|
|
pTime->GetDWORD(reinterpret_cast<DWORD*>(&key[i].time));
|
|
|
|
KSimpleDataObject * pColorLight = pElementObject->GetSimpleDataMemberObject("clr_light");
|
|
pColorLight->GetDWORD(&dwColor);
|
|
|
|
KSimpleDataObject * pIntens = pElementObject->GetSimpleDataMemberObject("intens");
|
|
pIntens->GetFloat(&fIntens);
|
|
|
|
KSimpleDataObject * pAttenStart = pElementObject->GetSimpleDataMemberObject("atten_start");
|
|
pAttenStart->GetFloat(&fAttStart);
|
|
|
|
KSimpleDataObject * pAttenEnd = pElementObject->GetSimpleDataMemberObject("atten_end");
|
|
pAttenEnd->GetFloat(&fAttEnd);
|
|
|
|
KSimpleDataObject * pOnOff = pElementObject->GetSimpleDataMemberObject("onoff");
|
|
pOnOff->GetChar( reinterpret_cast<char *>(&bOn) );
|
|
|
|
if ( bOn == false )
|
|
dwColor = 0;
|
|
|
|
//라이트 설정하는 방법 바꿔야 함.
|
|
K3DColor diffuse(dwColor);
|
|
K3DColor ambient(dwAmbient);
|
|
K3DColor specular(.3f, .3f, .3f);
|
|
|
|
diffuse *= fIntens;
|
|
switch(dwLightType)
|
|
{
|
|
case NX3LIGHT_OMNI:
|
|
case NX3LIGHT_SIMPLE_OMNI:
|
|
key[i].light = K3DLight( diffuse, specular, ambient,
|
|
K3DVector(pos._41, pos._42, pos._43), fAttEnd * 1.0f, .0f, 1.0f, 1.0f );
|
|
break;
|
|
case NX3LIGHT_TARGET_DIRECTIONAL:
|
|
key[i].light = K3DLight( diffuse, specular, ambient,
|
|
K3DVector(target._41 - pos._41, target._42 - pos._42, target._43 - pos._43) );
|
|
key[i].light.position = K3DVector(pos._41, pos._42, pos._43);
|
|
break;
|
|
case NX3LIGHT_FREE_DIRECTIONAL:
|
|
key[i].light = K3DLight( diffuse, specular, ambient,
|
|
K3DVector(pos._41 - pos._31, pos._42 - pos._32, pos._43 - pos._33) );
|
|
key[i].light.position = K3DVector(pos._41, pos._42, pos._43);
|
|
break;
|
|
}
|
|
}
|
|
m_spLightRes->SetWholeKey( key, pLightBlockArray->GetDataCount() );
|
|
delete[] key;
|
|
|
|
// _oprint( "Load Time : KNX3Light::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3Light::LoadTRF( trf::MTemplatePtr pObject )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
DWORD dwLightType = pObject->getDWordBy( "light_type" );
|
|
DWORD dwAmbient = pObject->getDWordBy( "ambient_light" );
|
|
|
|
m_spLightRes = new K3DResLight;
|
|
trf::MTemplateArrayPtr pLightBlockArray = pObject->getTemplateArrayBy( "light_block_array" );
|
|
|
|
K3DResLight::Key *key = new K3DResLight::Key[ pLightBlockArray->count() ];
|
|
for(int i(0); i < pLightBlockArray->count(); ++i)
|
|
{
|
|
trf::MTemplatePtr pElementObject = pLightBlockArray->getTemplateAt( i );
|
|
|
|
K3DMatrix pos, target;
|
|
DWORD dwColor;
|
|
float fIntens, fAttStart, fAttEnd;
|
|
char bOn;
|
|
|
|
const float* fArray = pElementObject->getArrayBy( "mat_object" )->getFloatArray();
|
|
pos._11 = fArray[0]; pos._12 = fArray[1]; pos._13 = fArray[2];
|
|
pos._21 = fArray[3]; pos._22 = fArray[4]; pos._23 = fArray[5];
|
|
pos._31 = fArray[6]; pos._32 = fArray[7]; pos._33 = fArray[8];
|
|
pos._41 = fArray[9]; pos._42 = fArray[10]; pos._43 = fArray[11];
|
|
|
|
fArray = pElementObject->getArrayBy( "mat_target" )->getFloatArray();
|
|
target._11 = fArray[0]; target._12 = fArray[1]; target._13 = fArray[2];
|
|
target._21 = fArray[3]; target._22 = fArray[4]; target._23 = fArray[5];
|
|
target._31 = fArray[6]; target._32 = fArray[7]; target._33 = fArray[8];
|
|
target._41 = fArray[9]; target._42 = fArray[10]; target._43 = fArray[11];
|
|
|
|
key[i].time = pElementObject->getDWordBy( "time_value" );
|
|
dwColor = pElementObject->getDWordBy( "clr_light" );
|
|
fIntens = (float)(pElementObject->getDWordBy( "intens" ));
|
|
fAttStart = (float)(pElementObject->getDWordBy( "atten_start" ));
|
|
fAttEnd = (float)(pElementObject->getDWordBy( "atten_end" ));
|
|
bOn = pElementObject->getCharBy( "onoff" );
|
|
|
|
if ( bOn == false )
|
|
dwColor = 0;
|
|
|
|
//라이트 설정하는 방법 바꿔야 함.
|
|
K3DColor diffuse(dwColor);
|
|
K3DColor ambient(dwAmbient);
|
|
K3DColor specular(.3f, .3f, .3f);
|
|
|
|
diffuse *= fIntens;
|
|
switch(dwLightType)
|
|
{
|
|
case NX3LIGHT_OMNI:
|
|
case NX3LIGHT_SIMPLE_OMNI:
|
|
key[i].light = K3DLight( diffuse, specular, ambient,
|
|
K3DVector(pos._41, pos._42, pos._43), fAttEnd * 1.0f, .0f, 1.0f, 1.0f );
|
|
break;
|
|
case NX3LIGHT_TARGET_DIRECTIONAL:
|
|
key[i].light = K3DLight( diffuse, specular, ambient,
|
|
K3DVector(target._41 - pos._41, target._42 - pos._42, target._43 - pos._43) );
|
|
key[i].light.position = K3DVector(pos._41, pos._42, pos._43);
|
|
break;
|
|
case NX3LIGHT_FREE_DIRECTIONAL:
|
|
key[i].light = K3DLight( diffuse, specular, ambient,
|
|
K3DVector(pos._41 - pos._31, pos._42 - pos._32, pos._43 - pos._33) );
|
|
key[i].light.position = K3DVector(pos._41, pos._42, pos._43);
|
|
break;
|
|
}
|
|
}
|
|
m_spLightRes->SetWholeKey( key, pLightBlockArray->count() );
|
|
delete[] key;
|
|
|
|
// _oprint( "Load Time : KNX3Light::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
void KNX3ChannelControl::Clear()
|
|
{
|
|
SAFE_DELETE(m_pMtlChannel);
|
|
SAFE_DELETE(m_pMeshChannel);
|
|
SAFE_DELETE(m_pLightChannel);
|
|
SAFE_DELETE(m_pCameraChannel);
|
|
SAFE_DELETE(m_pBoneChannel);
|
|
}
|
|
|
|
BOOL KNX3ChannelControl::Load( const NX3LoadPack * pLoadPack, K3DRenderDevice *pGraphics, /*KSoundDevice * pSound,*/ KFiler *pFiler, const char * szName )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
Clear();
|
|
|
|
for(int i(0); i <pFiler->GetDataObjectCount(); ++i)
|
|
{
|
|
KTemplateDataObject * pObject = pFiler->GetDataObjectAt(i);
|
|
|
|
const char *lpszName = pObject->GetTemplateName();
|
|
|
|
if(strcmp(lpszName, "nx3_version_header") == 0)
|
|
{
|
|
KSimpleDataObject* pVersionObj = pObject->GetSimpleDataMemberObject("version");
|
|
pVersionObj->GetDWORD(&m_dwVersion);
|
|
}
|
|
if(strcmp(lpszName, "nx3_mtl_header") == 0)
|
|
{
|
|
m_pMtlChannel = new KNX3MtlChannel(pGraphics);
|
|
m_pMtlChannel->Load( pObject, pLoadPack );
|
|
}
|
|
else if(strcmp(lpszName, "nx3_mesh_header") == 0)
|
|
{
|
|
m_pMeshChannel = new KNX3MeshChannel(pGraphics, m_pMtlChannel);
|
|
m_pMeshChannel->Load( pLoadPack, pObject, KNX3MeshChannel::LT_OLD_MESH );
|
|
}
|
|
else if(strcmp(lpszName,"nx3_new_mesh_header") == 0) // 새로 추가
|
|
{
|
|
m_pMeshChannel = new KNX3MeshChannel(pGraphics, m_pMtlChannel);
|
|
m_pMeshChannel->Load( pLoadPack, pObject, KNX3MeshChannel::LT_NEW_MESH );
|
|
}
|
|
else if(strcmp(lpszName, "nx3_light_header") == 0)
|
|
{
|
|
m_pLightChannel = new KNX3LightChannel(pGraphics);
|
|
m_pLightChannel->Load(pObject);
|
|
}
|
|
else if(strcmp(lpszName, "nx3_camera") == 0)
|
|
{
|
|
m_pCameraChannel = new KNX3CameraChannel(pGraphics);
|
|
m_pCameraChannel->Load(pObject);
|
|
}
|
|
else if(strcmp(lpszName, "nx3_bone_ani_header") == 0)
|
|
{
|
|
m_pBoneChannel = new KNX3BoneChannel(pGraphics);
|
|
m_pBoneChannel->Load(pObject, szName, m_dwVersion);
|
|
}
|
|
}
|
|
DWORD dwEndTime = (GetSafeTickCount() - dwTime);
|
|
if( dwEndTime > 50 )
|
|
// _performance_print( "%04dms NX3 Load : %s ThreadId:%d\n", dwEndTime, szName, GetCurrentThreadId() );
|
|
_oprint( "Load Time : KNX3ChannelControl::Load - %d\n", GetSafeTickCount()-dwTime );
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
bool KNX3ChannelControl::LoadTRF( const NX3LoadPack * pLoadPack, K3DRenderDevice *pGraphics, /*KSoundDevice * pSound,*/ trf::MDictPtr pDict, const char * szName )
|
|
{
|
|
DWORD dwTime = GetSafeTickCount();
|
|
|
|
Clear();
|
|
|
|
for(int i(0); i < pDict->count(); ++i)
|
|
{
|
|
trf::MTemplatePtr pObject = pDict->getTemplateAt( i );
|
|
const char *lpszName = pObject->className();
|
|
|
|
if(strcmp(lpszName, "nx3_version_header") == 0)
|
|
{
|
|
m_dwVersion = pObject->getDWordBy( "version" );
|
|
}
|
|
if( strcmp( lpszName, "nx3_property" ) == 0 )
|
|
{
|
|
m_strProperty = pObject->getStringBy( "property_string" );
|
|
}
|
|
if(strcmp(lpszName, "nx3_mtl_header") == 0)
|
|
{
|
|
m_pMtlChannel = new KNX3MtlChannel(pGraphics);
|
|
m_pMtlChannel->LoadTRF( pObject, pLoadPack );
|
|
}
|
|
else if(strcmp(lpszName, "nx3_mesh_header") == 0)
|
|
{
|
|
m_pMeshChannel = new KNX3MeshChannel(pGraphics, m_pMtlChannel);
|
|
m_pMeshChannel->LoadTRF( pLoadPack, pObject, KNX3MeshChannel::LT_OLD_MESH );
|
|
}
|
|
else if(strcmp(lpszName,"nx3_new_mesh_header") == 0) // 새로 추가
|
|
{
|
|
m_pMeshChannel = new KNX3MeshChannel(pGraphics, m_pMtlChannel);
|
|
m_pMeshChannel->LoadTRF( pLoadPack, pObject, KNX3MeshChannel::LT_NEW_MESH );
|
|
}
|
|
else if(strcmp(lpszName, "nx3_light_header") == 0)
|
|
{
|
|
m_pLightChannel = new KNX3LightChannel(pGraphics);
|
|
m_pLightChannel->LoadTRF(pObject);
|
|
}
|
|
else if(strcmp(lpszName, "nx3_camera") == 0)
|
|
{
|
|
m_pCameraChannel = new KNX3CameraChannel(pGraphics);
|
|
m_pCameraChannel->LoadTRF(pObject);
|
|
}
|
|
//Bone 작업중..
|
|
else if(strcmp(lpszName, "nx3_bone_ani_header") == 0)
|
|
{
|
|
m_pBoneChannel = new KNX3BoneChannel(pGraphics);
|
|
m_pBoneChannel->LoadTRF(pObject, szName, m_dwVersion);
|
|
}
|
|
}
|
|
DWORD dwEndTime = (GetSafeTickCount() - dwTime);
|
|
if( dwEndTime > 50 )
|
|
{
|
|
// _performance_print( "%04dms TRF Load : %s ThreadId:%d\n", dwEndTime, szName, GetCurrentThreadId() );
|
|
_oprint( "Load Time : KNX3ChannelControl::LoadTRF - %d\n", GetSafeTickCount()-dwTime );
|
|
}
|
|
|
|
return TRUE;
|
|
}
|