LGram16
e067522598
Game client codebase including: - CharacterActionControl: Character and creature management - GlobalScript: Network, items, skills, quests, utilities - RYLClient: Main client application with GUI and event handlers - Engine: 3D rendering engine (RYLGL) - MemoryManager: Custom memory allocation - Library: Third-party dependencies (DirectX, boost, etc.) - Tools: Development utilities 🤖 Generated with [Claude Code](https://claude.com/claude-code) Co-Authored-By: Claude <noreply@anthropic.com>
1666 lines
46 KiB
C++
1666 lines
46 KiB
C++
// MeshObject.cpp: implementation of the CMeshObject class.
|
||
//
|
||
//////////////////////////////////////////////////////////////////////
|
||
|
||
#include "MeshObject.h"
|
||
#include "SceneManager.h"
|
||
#include "FileLoad.h"
|
||
#include "RenderOption.h"
|
||
#include <Src/Scene/D3DBufferPools.h>
|
||
#include "GMMemory.h"
|
||
|
||
//////////////////////////////////////////////////////////////////////
|
||
// Construction/Destruction
|
||
//////////////////////////////////////////////////////////////////////
|
||
|
||
LPDIRECT3DDEVICE8 CMeshObject::m_pd3dDevice;
|
||
|
||
CMeshObject::CMeshObject()
|
||
{
|
||
m_MaxBox.x=-1.0f;
|
||
m_MinBox.x=-1.0f;
|
||
m_isAlreadyLock=false;
|
||
m_dwCustomizeShader=0xffffffff;
|
||
}
|
||
|
||
CMeshObject::~CMeshObject()
|
||
{
|
||
int i;
|
||
|
||
for(i=0;i<(int)m_pLoadedIndices.size();i++)
|
||
delete[] m_pLoadedIndices[i];
|
||
|
||
for(i=0;i<(int)m_pLoadedVertex.size();i++)
|
||
delete[] m_pLoadedVertex[i];
|
||
|
||
m_pLoadedVertex.clear();
|
||
m_pLoadedIndices.clear();
|
||
|
||
|
||
for(i=0;i<(int)m_pVertex.size();i++)
|
||
delete m_pVertex[i];
|
||
|
||
for(i=0;i<(int)m_pIndices.size();i++)
|
||
delete m_pIndices[i];
|
||
|
||
m_pVertex.clear();
|
||
m_pIndices.clear();
|
||
|
||
if(m_bLoaded == false)
|
||
{
|
||
for(i=0;i<(int)m_pVertexBuffer.size();i++)
|
||
m_pVertexBuffer[i]->Release();
|
||
|
||
for(i=0;i<(int)m_pIndicesBuffer.size();i++)
|
||
m_pIndicesBuffer[i]->Release();
|
||
|
||
m_pVertexBuffer.clear();
|
||
m_pIndicesBuffer.clear();
|
||
}
|
||
else // Buffer Pool ÀÌ¿ë
|
||
{
|
||
if(CSceneManager::ms_pBufferPools)
|
||
{
|
||
for(i=0;i<(int)m_pVertexBuffer.size();i++)
|
||
{
|
||
CSceneManager::ms_pBufferPools->UnRef(Caldron::Scene::D3DBUFFEROBJ_VERTEX,m_pVertexBuffer[i]);
|
||
}
|
||
|
||
for(i=0;i<(int)m_pIndicesBuffer.size();i++)
|
||
{
|
||
CSceneManager::ms_pBufferPools->UnRef(Caldron::Scene::D3DBUFFEROBJ_INDEX,m_pIndicesBuffer[i]);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
|
||
for(i=0;i<(int)m_pVertexBuffer.size();i++)
|
||
m_pVertexBuffer[i]->Release();
|
||
|
||
for(i=0;i<(int)m_pIndicesBuffer.size();i++)
|
||
m_pIndicesBuffer[i]->Release();
|
||
|
||
}
|
||
m_pVertexBuffer.clear();
|
||
m_pIndicesBuffer.clear();
|
||
}
|
||
|
||
for(i=0;i<(int)m_pMat.size();i++)
|
||
{
|
||
//m_pMat[i]->DeleteTexture();
|
||
delete m_pMat[i];
|
||
}
|
||
m_pMat.clear();
|
||
|
||
for(i=0;i<(int)m_pDetailMap.size();i++)
|
||
{
|
||
if(m_pDetailMap[i])
|
||
delete m_pDetailMap[i];
|
||
}
|
||
m_pDetailMap.clear();
|
||
|
||
for(i=0;i<(int)m_pBumpTexture.size();i++)
|
||
{
|
||
if(m_pBumpTexture[i])
|
||
delete m_pBumpTexture[i];
|
||
}
|
||
m_pBumpTexture.clear();
|
||
|
||
/*
|
||
CVertexBuffer *pDelVertexBuffer;
|
||
WORD *pDelIndices;
|
||
CTexture *pDelTexture;
|
||
for(int i=0;i<m_pVertexBuffer.num;i++)
|
||
{
|
||
pDelVertexBuffer=m_pVertexBuffer[i];
|
||
pDelIndices=m_pIndices[i];
|
||
delete [] pDelIndices;
|
||
delete pDelVertexBuffer;
|
||
}
|
||
for(i=0;i<m_pMat.num;i++)
|
||
{
|
||
pDelTexture=m_pMat[i];
|
||
delete pDelTexture;
|
||
}
|
||
*/
|
||
}
|
||
bool CMeshObject::Load(Caldron::Base::CCaldronByteDataObj *pDataObj)
|
||
{
|
||
|
||
strcpy(m_strMeshName,m_strName);
|
||
|
||
int nObject,nMat,ObjectMethod;
|
||
pDataObj->Read(&nObject,sizeof(int),1);
|
||
pDataObj->Read(&nMat,sizeof(int),1);
|
||
pDataObj->Read(&ObjectMethod,sizeof(int),1);
|
||
|
||
m_bRender=false;
|
||
|
||
if(ObjectMethod==0)
|
||
{
|
||
m_bCompleteMesh=false;
|
||
|
||
char strTextureName[256];
|
||
for(int i=0;i<nMat;i++)
|
||
{
|
||
pDataObj->Read(strTextureName,sizeof(char)*MAX_NAMEBUFFER,1);
|
||
if(strcmp(strTextureName,"")==0)
|
||
continue;
|
||
|
||
m_pMat.push_back(new CTexture());
|
||
strcpy(m_pMat[i]->m_strName,strTextureName);
|
||
}
|
||
|
||
char strObjectName[256];
|
||
int MatRef,cVertex,cIndices;
|
||
|
||
|
||
vector3 vecNormal;
|
||
vector3 *v[3];
|
||
|
||
SetShader(LightFVF);
|
||
|
||
for(int i=0;i<nObject;i++)
|
||
{
|
||
pDataObj->Read(strObjectName,sizeof(char)*256,1);
|
||
pDataObj->Read(&MatRef,sizeof(long),1);
|
||
pDataObj->Read(&cVertex,sizeof(long),1);
|
||
pDataObj->Read(&cIndices,sizeof(int),1);
|
||
|
||
LightVertex *pTempLightVertex = new LightVertex[cVertex];
|
||
MultiVertex *pTempVertex=new MultiVertex[cVertex];
|
||
WORD *pTempIndices=new WORD[cIndices*3];
|
||
|
||
pDataObj->Read(pTempVertex,sizeof(MultiVertex) * cVertex,1);
|
||
pDataObj->Read(pTempIndices,sizeof(WORD) * cIndices*3,1);
|
||
// CalcBox
|
||
if(m_MaxBox.x==-1.0f && m_MinBox.x==-1.0f)
|
||
{
|
||
m_MinBox.x=m_MaxBox.x=pTempVertex[0].v.x;
|
||
m_MinBox.y=m_MaxBox.y=pTempVertex[0].v.y;
|
||
m_MinBox.z=m_MaxBox.z=pTempVertex[0].v.z;
|
||
}
|
||
|
||
|
||
for(int cv = 0; cv < cVertex; cv++)
|
||
{
|
||
if(m_MaxBox.x < pTempVertex[cv].v.x)
|
||
m_MaxBox.x=pTempVertex[cv].v.x;
|
||
if(m_MaxBox.y < pTempVertex[cv].v.y)
|
||
m_MaxBox.y=pTempVertex[cv].v.y;
|
||
if(m_MaxBox.z < pTempVertex[cv].v.z)
|
||
m_MaxBox.z=pTempVertex[cv].v.z;
|
||
|
||
if(m_MinBox.x > pTempVertex[cv].v.x)
|
||
m_MinBox.x=pTempVertex[cv].v.x;
|
||
if(m_MinBox.y > pTempVertex[cv].v.y)
|
||
m_MinBox.y=pTempVertex[cv].v.y;
|
||
if(m_MinBox.z > pTempVertex[cv].v.z)
|
||
m_MinBox.z=pTempVertex[cv].v.z;
|
||
|
||
}
|
||
// Convert Normal
|
||
for(int cIn=0;cIn<cIndices;cIn++)
|
||
{
|
||
v[0]=(vector3*)&pTempVertex[ pTempIndices[cIn*3+0] ].v;
|
||
v[1]=(vector3*)&pTempVertex[ pTempIndices[cIn*3+1] ].v;
|
||
v[2]=(vector3*)&pTempVertex[ pTempIndices[cIn*3+2] ].v;
|
||
|
||
vecNormal= (*v[1]-*v[0])^(*v[2]-*v[1]);
|
||
vecNormal.Normalize();
|
||
|
||
pTempLightVertex[pTempIndices[cIn*3+0]].v=pTempVertex[ pTempIndices[cIn*3+0] ].v;
|
||
pTempLightVertex[pTempIndices[cIn*3+0]].tu=pTempVertex[ pTempIndices[cIn*3+0] ].tu;
|
||
pTempLightVertex[pTempIndices[cIn*3+0]].tv=pTempVertex[ pTempIndices[cIn*3+0] ].tv;
|
||
pTempLightVertex[pTempIndices[cIn*3+0]].spec.c=0x0;
|
||
pTempLightVertex[pTempIndices[cIn*3+0]].n=vecNormal;
|
||
|
||
pTempLightVertex[pTempIndices[cIn*3+1]].v=pTempVertex[ pTempIndices[cIn*3+1] ].v;
|
||
pTempLightVertex[pTempIndices[cIn*3+1]].tu=pTempVertex[ pTempIndices[cIn*3+1] ].tu;
|
||
pTempLightVertex[pTempIndices[cIn*3+1]].tv=pTempVertex[ pTempIndices[cIn*3+1] ].tv;
|
||
pTempLightVertex[pTempIndices[cIn*3+1]].spec.c=0x0;
|
||
pTempLightVertex[pTempIndices[cIn*3+1]].n=vecNormal;
|
||
|
||
pTempLightVertex[pTempIndices[cIn*3+2]].v=pTempVertex[ pTempIndices[cIn*3+2] ].v;
|
||
pTempLightVertex[pTempIndices[cIn*3+2]].tu=pTempVertex[ pTempIndices[cIn*3+2] ].tu;
|
||
pTempLightVertex[pTempIndices[cIn*3+2]].tv=pTempVertex[ pTempIndices[cIn*3+2] ].tv;
|
||
pTempLightVertex[pTempIndices[cIn*3+2]].spec.c=0x0;
|
||
pTempLightVertex[pTempIndices[cIn*3+2]].n=vecNormal;
|
||
|
||
}
|
||
|
||
|
||
|
||
m_pLoadedVertex.push_back(pTempLightVertex);
|
||
m_pLoadedIndices.push_back(pTempIndices);
|
||
|
||
m_nVertex.push_back(cVertex);
|
||
m_nIndices.push_back(cIndices);
|
||
m_pMatRef.push_back(MatRef);
|
||
|
||
delete[] pTempVertex;
|
||
}
|
||
|
||
|
||
|
||
}
|
||
return true;
|
||
}
|
||
bool CMeshObject::PostLoad()
|
||
{
|
||
int i;
|
||
|
||
m_bLoaded = true;
|
||
|
||
m_bRender=true;
|
||
|
||
if(COLLISIONOBJECTVIEW==0 && strstr(m_strMeshName,"collision")!=NULL)
|
||
{
|
||
m_bRender=false;
|
||
}
|
||
|
||
LightVertex *pVertexData;
|
||
WORD *pIndicesData;
|
||
|
||
int cVertex = 0;
|
||
int cIndices = 0;
|
||
|
||
for(i = 0; i < (int)m_pLoadedVertex.size(); i++ )
|
||
{
|
||
cVertex = m_nVertex[i];
|
||
cIndices = m_nIndices[i];
|
||
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
LPDIRECT3DINDEXBUFFER8 pAllocIB;
|
||
|
||
|
||
pAllocVB = CSceneManager::ms_pBufferPools->GetVertexBuffer(cVertex*sizeof(LightVertex),LightFVF,false);
|
||
pAllocIB = CSceneManager::ms_pBufferPools->GetIndexBuffer(cIndices*3*sizeof(WORD),D3DFMT_INDEX16,false);
|
||
/*
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(cVertex*sizeof(MultiVertex),NULL,
|
||
MultiFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
CSceneManager::GetDevice()->CreateIndexBuffer(cIndices*3*sizeof(WORD),NULL,
|
||
D3DFMT_INDEX16,D3DPOOL_MANAGED,&pAllocIB);
|
||
*/
|
||
// pAllocVB->Lock(0,sizeof(LightVertex) * cVertex,(BYTE**)&pVertexData,0);
|
||
// pAllocIB->Lock(0,cIndices*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
pAllocIB->Lock(0,0,(BYTE**)&pIndicesData,0);
|
||
|
||
memcpy(pVertexData,m_pLoadedVertex[i],sizeof(LightVertex) * cVertex);
|
||
memcpy(pIndicesData,m_pLoadedIndices[i],sizeof(WORD) * cIndices * 3);
|
||
|
||
pAllocVB->Unlock();
|
||
pAllocIB->Unlock();
|
||
|
||
m_pVertexBuffer.push_back(pAllocVB);
|
||
m_pIndicesBuffer.push_back(pAllocIB);
|
||
|
||
delete[] m_pLoadedVertex[i];
|
||
delete[] m_pLoadedIndices[i];
|
||
|
||
}
|
||
|
||
|
||
for(i=0;i<(int)m_pLoadedIndices.size();i++)
|
||
delete[] m_pLoadedIndices[i];
|
||
|
||
for(i=0;i<(int)m_pLoadedVertex.size();i++)
|
||
delete[] m_pLoadedVertex[i];
|
||
|
||
|
||
m_pLoadedVertex.clear();
|
||
m_pLoadedIndices.clear();
|
||
|
||
CTexture::SetPath(OBJECTTEXTUREPATH);
|
||
|
||
TextureLoad();
|
||
|
||
return true;
|
||
|
||
}
|
||
/*
|
||
bool CMeshObject::Unload()
|
||
{
|
||
return true;
|
||
}
|
||
*/
|
||
|
||
void CMeshObject::Load(char *strFilename)
|
||
{
|
||
strcpy(m_strMeshName,strFilename);
|
||
|
||
CFileLoad FileLoader;
|
||
FileLoader.Load(strFilename);
|
||
// By Belldandy : Load¿¡¼ »¶³µÀ»¶§ ÀÚ¿¬½º·¹ ³ª°¡´Â ·çƾÀÌ ÇÊ¿ä or Á¤»óÀûÀ¸·Î ½ÇÇàµÇ´Â ·çƾ ÇÊ¿ä
|
||
|
||
int nObject,nMat,ObjectMethod;
|
||
FileLoader.GetData(&nObject,sizeof(int));
|
||
FileLoader.GetData(&nMat,sizeof(int));
|
||
FileLoader.GetData(&ObjectMethod,sizeof(int));
|
||
|
||
m_bRender=true;
|
||
|
||
if(COLLISIONOBJECTVIEW==0 && strstr(strFilename,"collision")!=NULL)
|
||
{
|
||
m_bRender=false;
|
||
}
|
||
|
||
if(ObjectMethod==0)
|
||
{
|
||
m_bCompleteMesh=false;
|
||
|
||
|
||
|
||
char strTextureName[256];
|
||
for(int i=0;i<nMat;i++)
|
||
{
|
||
FileLoader.GetData(strTextureName,sizeof(char)*MAX_NAMEBUFFER);
|
||
if(strcmp(strTextureName,"")==0)
|
||
continue;
|
||
m_pMat.push_back(new CTexture());
|
||
strcpy(m_pMat[i]->m_strName,strTextureName);
|
||
}
|
||
char strObjectName[256];
|
||
int MatRef,cVertex,cIndices;
|
||
MultiVertex *pVertexData;
|
||
WORD *pIndicesData;
|
||
|
||
for(int i=0;i<nObject;i++)
|
||
{
|
||
FileLoader.GetData(strObjectName,sizeof(char)*256);
|
||
FileLoader.GetData(&MatRef,sizeof(long));
|
||
FileLoader.GetData(&cVertex,sizeof(long));
|
||
FileLoader.GetData(&cIndices,sizeof(int));
|
||
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
LPDIRECT3DINDEXBUFFER8 pAllocIB;
|
||
|
||
MultiVertex *pTempVertex=new MultiVertex[cVertex];
|
||
WORD *pTempIndices=new WORD[cIndices*3];
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(cVertex*sizeof(MultiVertex),NULL,
|
||
MultiFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
CSceneManager::GetDevice()->CreateIndexBuffer(cIndices*3*sizeof(WORD),NULL,
|
||
D3DFMT_INDEX16,D3DPOOL_MANAGED,&pAllocIB);
|
||
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
pAllocIB->Lock(0,cIndices*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
|
||
FileLoader.GetData(pVertexData,sizeof(MultiVertex)*cVertex);
|
||
FileLoader.GetData(pIndicesData,sizeof(WORD)*cIndices*3);
|
||
|
||
pAllocVB->Unlock();
|
||
pAllocIB->Unlock();
|
||
|
||
m_pVertexBuffer.push_back(pAllocVB);
|
||
m_pIndicesBuffer.push_back(pAllocIB);
|
||
|
||
m_nVertex.push_back(cVertex);
|
||
m_nIndices.push_back(cIndices);
|
||
m_pMatRef.push_back(MatRef);
|
||
|
||
delete [] pTempIndices;
|
||
delete [] pTempVertex;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if(ObjectMethod==1)
|
||
{
|
||
m_bCompleteMesh=true;
|
||
char strTextureName[256];
|
||
for(int i=0;i<nMat;i++)
|
||
{
|
||
m_nVertex.push_back(0);
|
||
m_nIndices.push_back(0);
|
||
m_pMatRef.push_back(0);
|
||
FileLoader.GetData(strTextureName,sizeof(char)*MAX_NAMEBUFFER);
|
||
|
||
if(strcmp(strTextureName,"")==0)
|
||
continue;
|
||
|
||
m_pMat.push_back(new CTexture());
|
||
strcpy(m_pMat[i]->m_strName,strTextureName);
|
||
|
||
if(CRenderOption::m_AllObjectBump)
|
||
{
|
||
int nPos=strlen(strTextureName);
|
||
|
||
strTextureName[nPos-4]='_';
|
||
strTextureName[nPos-3]='b';
|
||
strTextureName[nPos-2]='u';
|
||
strTextureName[nPos-1]='m';
|
||
strTextureName[nPos-0]='p';
|
||
strTextureName[nPos+1]='.';
|
||
strTextureName[nPos+2]='d';
|
||
strTextureName[nPos+3]='d';
|
||
strTextureName[nPos+4]='s';
|
||
strTextureName[nPos+5]=0;
|
||
|
||
m_pBumpTexture.push_back(new CTexture());
|
||
|
||
strcpy(m_pBumpTexture[i]->m_strName,strTextureName);
|
||
}
|
||
}
|
||
|
||
FileLoader.GetData(&m_MaxBox,sizeof(vector3));
|
||
FileLoader.GetData(&m_MinBox,sizeof(vector3));
|
||
int nTotalVertex,nTotalIndices;
|
||
|
||
FileLoader.GetData(&nTotalVertex,sizeof(int));
|
||
FileLoader.GetData(&nTotalIndices,sizeof(int));
|
||
|
||
FileLoader.GetData(&m_nIndices[0],sizeof(int)*nObject);
|
||
FileLoader.GetData(&m_nVertex[0],sizeof(int)*nObject);
|
||
FileLoader.GetData(&m_pMatRef[0],sizeof(int)*nObject);
|
||
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
LPDIRECT3DINDEXBUFFER8 pAllocIB;
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(nTotalVertex*sizeof(BumpVertex2),
|
||
D3DUSAGE_WRITEONLY,BUMPVERTEX2FVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
|
||
CSceneManager::GetDevice()->CreateIndexBuffer(nTotalIndices*3*sizeof(WORD),
|
||
D3DUSAGE_WRITEONLY,D3DFMT_INDEX16,D3DPOOL_MANAGED,&pAllocIB);
|
||
|
||
BumpVertex2 *pVertexData;
|
||
WORD *pIndicesData;
|
||
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
pAllocIB->Lock(0,nTotalIndices*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
|
||
FileLoader.GetData(pVertexData,sizeof(BumpVertex2)*nTotalVertex);
|
||
FileLoader.GetData(pIndicesData,sizeof(WORD)*nTotalIndices*3);
|
||
|
||
pAllocVB->Unlock();
|
||
pAllocIB->Unlock();
|
||
|
||
m_pVertexBuffer.push_back(pAllocVB);
|
||
m_pIndicesBuffer.push_back(pAllocIB);
|
||
|
||
m_dwShader=BUMPVERTEX2FVF;
|
||
}
|
||
else
|
||
{
|
||
return;
|
||
m_bCompleteMesh=true;
|
||
|
||
char strTextureName[256];
|
||
for(int i=0;i<nMat;i++)
|
||
{
|
||
m_nVertex.push_back(0);
|
||
m_nIndices.push_back(0);
|
||
m_pMatRef.push_back(0);
|
||
FileLoader.GetData(strTextureName,sizeof(char)*MAX_NAMEBUFFER);
|
||
if(strcmp(strTextureName,"")==0)
|
||
continue;
|
||
|
||
m_pMat.push_back(new CTexture());
|
||
strcpy(m_pMat[i]->m_strName,strTextureName);
|
||
|
||
if(CRenderOption::m_AllObjectBump)
|
||
{
|
||
int nPos=strlen(strTextureName);
|
||
|
||
strTextureName[nPos-4]='_';
|
||
strTextureName[nPos-3]='b';
|
||
strTextureName[nPos-2]='u';
|
||
strTextureName[nPos-1]='m';
|
||
strTextureName[nPos-0]='p';
|
||
strTextureName[nPos+1]='.';
|
||
strTextureName[nPos+2]='d';
|
||
strTextureName[nPos+3]='d';
|
||
strTextureName[nPos+4]='s';
|
||
strTextureName[nPos+5]=0;
|
||
|
||
m_pBumpTexture.push_back(new CTexture());
|
||
|
||
strcpy(m_pBumpTexture[i]->m_strName,strTextureName);
|
||
}
|
||
}
|
||
|
||
|
||
|
||
FileLoader.GetData(&m_MaxBox,sizeof(vector3));
|
||
FileLoader.GetData(&m_MinBox,sizeof(vector3));
|
||
int nTotalVertex,nTotalIndices;
|
||
|
||
FileLoader.GetData(&nTotalVertex,sizeof(int));
|
||
FileLoader.GetData(&nTotalIndices,sizeof(int));
|
||
|
||
FileLoader.GetData(&m_nIndices[0],sizeof(int)*nObject);
|
||
FileLoader.GetData(&m_nVertex[0],sizeof(int)*nObject);
|
||
FileLoader.GetData(&m_pMatRef[0],sizeof(int)*nObject);
|
||
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
LPDIRECT3DINDEXBUFFER8 pAllocIB;
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(nTotalVertex*sizeof(BumpVertex),
|
||
D3DUSAGE_WRITEONLY,BUMPVERTEXFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
|
||
CSceneManager::GetDevice()->CreateIndexBuffer(nTotalIndices*3*sizeof(WORD),
|
||
D3DUSAGE_WRITEONLY,D3DFMT_INDEX16,D3DPOOL_MANAGED,&pAllocIB);
|
||
|
||
BumpVertex2 *pVertexData;
|
||
WORD *pIndicesData;
|
||
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
pAllocIB->Lock(0,nTotalIndices*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
|
||
FileLoader.GetData(pVertexData,sizeof(BumpVertex)*nTotalVertex);
|
||
FileLoader.GetData(pIndicesData,sizeof(WORD)*nTotalIndices*3);
|
||
|
||
pAllocVB->Unlock();
|
||
pAllocIB->Unlock();
|
||
|
||
m_pVertexBuffer.push_back(pAllocVB);
|
||
m_pIndicesBuffer.push_back(pAllocIB);
|
||
|
||
m_dwShader=BUMPVERTEXFVF;
|
||
}
|
||
|
||
}
|
||
|
||
/*
|
||
FILE *fp;
|
||
fp=fopen(strFilename,"rb");
|
||
|
||
int Lens;
|
||
if(fp==NULL)
|
||
{
|
||
char errormsg[256];
|
||
strcpy(errormsg,"CMeshObject:Load , File not found :");
|
||
strcat(errormsg,strFilename);
|
||
throw CSceneLayerError(errormsg);
|
||
}
|
||
fseek(fp,0L,SEEK_END);
|
||
Lens=ftell(fp);
|
||
fseek(fp,0L,SEEK_SET);
|
||
|
||
|
||
int nObject,nMat,TextureSize;
|
||
fread((void*)(&nObject),sizeof(int),1,fp);
|
||
fread((void*)(&nMat),sizeof(int),1,fp);
|
||
fread((void*)(&TextureSize),sizeof(int),1,fp);
|
||
|
||
char strTextureName[256];
|
||
for(int i=0;i<nMat;i++)
|
||
{
|
||
fread(strTextureName,sizeof(char)*256,1,fp);
|
||
m_pMat.Add(new CTexture());
|
||
//strcpy(m_pMat[i]->m_strName,strTextureName);
|
||
m_pMat[i]->Load(strTextureName);
|
||
}
|
||
char strObjectName[256];
|
||
int MatRef,cVertex,cIndices;
|
||
MultiVertex *pVertexData;
|
||
WORD *pIndicesData;
|
||
for(i=0;i<nObject;i++)
|
||
{
|
||
fread(strObjectName,sizeof(char)*256,1,fp);
|
||
fread((void*)(&MatRef),sizeof(long),1,fp);
|
||
fread((void*)(&cVertex),sizeof(long),1,fp);
|
||
fread((void*)(&cIndices),sizeof(int),1,fp);
|
||
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
LPDIRECT3DINDEXBUFFER8 pAllocIB;
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(cVertex*sizeof(MultiVertex),D3DUSAGE_WRITEONLY,
|
||
MultiFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
CSceneManager::GetDevice()->CreateIndexBuffer(cIndices*3*sizeof(WORD),D3DUSAGE_WRITEONLY,
|
||
D3DFMT_INDEX16,D3DPOOL_MANAGED,&pAllocIB);
|
||
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
pAllocIB->Lock(0,cIndices*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
fread((void*)pVertexData,sizeof(MultiVertex)*cVertex,1,fp);
|
||
fread((void*)pIndicesData,sizeof(WORD)*cIndices*3,1,fp);
|
||
pAllocVB->Unlock();
|
||
pAllocIB->Unlock();
|
||
|
||
m_pVertexBuffer.Add(pAllocVB);
|
||
m_pIndicesBuffer.Add(pAllocIB);
|
||
|
||
m_nVertex.Add(cVertex);
|
||
m_nIndices.Add(cIndices);
|
||
|
||
m_pMatRef.Add(MatRef);
|
||
}
|
||
fclose(fp);
|
||
//Optimize();
|
||
*/
|
||
}
|
||
|
||
void CMeshObject::CalcBox()
|
||
{
|
||
if(m_bCompleteMesh)
|
||
return;
|
||
|
||
MultiVertex *pVertexData;
|
||
|
||
if(m_pVertexBuffer.empty())
|
||
{
|
||
throw CSceneLayerError("CMeshObject:CalcBox, This meshobject have not vertex");
|
||
}
|
||
|
||
for(int i=0;i<(int)m_pVertexBuffer.size();i++)
|
||
{
|
||
m_pVertexBuffer[i]->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
if(m_MaxBox.x==-1.0f && m_MinBox.x==-1.0f)
|
||
{
|
||
m_MinBox.x=m_MaxBox.x=pVertexData[0].v.x;
|
||
m_MinBox.y=m_MaxBox.y=pVertexData[0].v.y;
|
||
m_MinBox.z=m_MaxBox.z=pVertexData[0].v.z;
|
||
|
||
}
|
||
for(int cv=0;cv<m_nVertex[i];cv++)
|
||
{
|
||
if(m_MaxBox.x < pVertexData[cv].v.x)
|
||
m_MaxBox.x=pVertexData[cv].v.x;
|
||
if(m_MaxBox.y < pVertexData[cv].v.y)
|
||
m_MaxBox.y=pVertexData[cv].v.y;
|
||
if(m_MaxBox.z < pVertexData[cv].v.z)
|
||
m_MaxBox.z=pVertexData[cv].v.z;
|
||
|
||
if(m_MinBox.x > pVertexData[cv].v.x)
|
||
m_MinBox.x=pVertexData[cv].v.x;
|
||
if(m_MinBox.y > pVertexData[cv].v.y)
|
||
m_MinBox.y=pVertexData[cv].v.y;
|
||
if(m_MinBox.z > pVertexData[cv].v.z)
|
||
m_MinBox.z=pVertexData[cv].v.z;
|
||
pVertexData[cv].diff.a=0xaa;
|
||
}
|
||
m_pVertexBuffer[i]->Unlock();
|
||
}
|
||
}
|
||
|
||
void CMeshObject::Render(LPDIRECT3DDEVICE8 pd3dDevice)
|
||
{
|
||
if(!m_bRender)
|
||
return;
|
||
if(m_dwCustomizeShader!=0xffffffff)
|
||
{
|
||
pd3dDevice->SetVertexShader(m_dwCustomizeShader);
|
||
|
||
if(m_dwShader==BUMPVERTEX2FVF)
|
||
pd3dDevice->SetStreamSource(0,m_pVertexBuffer[0],sizeof(BumpVertex2));
|
||
if(m_dwShader==BUMPVERTEXFVF)
|
||
pd3dDevice->SetStreamSource(0,m_pVertexBuffer[0],sizeof(BumpVertex));
|
||
pd3dDevice->SetIndices(m_pIndicesBuffer[0],0);
|
||
int nVertexOffset,nIndicesOffset;
|
||
nVertexOffset=nIndicesOffset=0;
|
||
|
||
for(int i=0;i<(int)m_nVertex.size();i++)
|
||
{
|
||
pd3dDevice->SetTexture(0,m_pMat[m_pMatRef[i]]->GetTexture());
|
||
if(CRenderOption::m_AllObjectBump && m_pBumpTexture.size()!=0)
|
||
{
|
||
pd3dDevice->SetTexture(1,m_pBumpTexture[m_pMatRef[i]]->GetTexture());
|
||
}
|
||
|
||
if(m_nVertex[i]==0 || m_nIndices[i]==0)
|
||
continue;
|
||
|
||
pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,nVertexOffset,
|
||
m_nVertex[i],
|
||
nIndicesOffset,
|
||
m_nIndices[i]);
|
||
nVertexOffset+=m_nVertex[i];
|
||
nIndicesOffset+=m_nIndices[i]*3;
|
||
}
|
||
|
||
return;
|
||
}
|
||
else
|
||
pd3dDevice->SetVertexShader(m_dwShader);
|
||
|
||
if(m_dwShader==MultiFVF)
|
||
{
|
||
for(int i=0;i<(int)m_pVertexBuffer.size();i++)
|
||
{
|
||
pd3dDevice->SetTexture(0,m_pMat[m_pMatRef[i]]->GetTexture());
|
||
pd3dDevice->SetStreamSource(0,m_pVertexBuffer[i],sizeof(MultiVertex));
|
||
pd3dDevice->SetIndices(m_pIndicesBuffer[i],0);
|
||
|
||
pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,
|
||
0,m_nVertex[i],
|
||
0,m_nIndices[i]);
|
||
|
||
CSceneManager::m_cRenderPolygon+=m_nIndices[i];
|
||
CSceneManager::m_cRenderVertex+=m_nVertex[i];
|
||
|
||
}
|
||
return;
|
||
}
|
||
if(m_dwShader==LightFVF)
|
||
{
|
||
for(int i=0;i<(int)m_pVertexBuffer.size();i++)
|
||
{
|
||
pd3dDevice->SetTexture(0,m_pMat[m_pMatRef[i]]->GetTexture());
|
||
pd3dDevice->SetStreamSource(0,m_pVertexBuffer[i],sizeof(LightVertex));
|
||
|
||
pd3dDevice->SetIndices(m_pIndicesBuffer[i],0);
|
||
pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,
|
||
0,m_nVertex[i],
|
||
0,m_nIndices[i]);
|
||
|
||
CSceneManager::m_cRenderPolygon+=m_nIndices[i];
|
||
CSceneManager::m_cRenderVertex+=m_nVertex[i];
|
||
|
||
}
|
||
return;
|
||
}
|
||
if(m_dwShader==DetailFVF)
|
||
{
|
||
for(int i=0;i<(int)m_pVertexBuffer.size();i++)
|
||
{
|
||
pd3dDevice->SetTexture(0,m_pMat[m_pMatRef[i]]->GetTexture());
|
||
|
||
pd3dDevice->SetStreamSource(0,m_pVertexBuffer[i],sizeof(DetailVertex));
|
||
|
||
pd3dDevice->SetIndices(m_pIndicesBuffer[i],0);
|
||
pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,
|
||
0,m_nVertex[i],
|
||
0,m_nIndices[i]);
|
||
CSceneManager::m_cRenderPolygon+=m_nIndices[i];
|
||
CSceneManager::m_cRenderVertex+=m_nVertex[i];
|
||
|
||
}
|
||
return;
|
||
}
|
||
if(m_dwShader==TREEVERTEXFVF)
|
||
{
|
||
for(int i=0;i<(int)m_pVertexBuffer.size();i++)
|
||
{
|
||
pd3dDevice->SetTexture(0,m_pMat[m_pMatRef[i]]->GetTexture());
|
||
pd3dDevice->SetStreamSource(0,m_pVertexBuffer[i],sizeof(LightVertex));
|
||
|
||
pd3dDevice->SetIndices(m_pIndicesBuffer[i],0);
|
||
pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,
|
||
0,m_nVertex[i],
|
||
0,m_nIndices[i]);
|
||
CSceneManager::m_cRenderPolygon+=m_nIndices[i];
|
||
CSceneManager::m_cRenderVertex+=m_nVertex[i];
|
||
|
||
}
|
||
return;
|
||
}
|
||
if(m_dwShader==BUMPVERTEX2FVF)
|
||
{
|
||
pd3dDevice->SetStreamSource(0,m_pVertexBuffer[0],sizeof(BumpVertex2));
|
||
pd3dDevice->SetIndices(m_pIndicesBuffer[0],0);
|
||
int nVertexOffset,nIndicesOffset;
|
||
nVertexOffset=nIndicesOffset=0;
|
||
|
||
for(int i=0;i<(int)m_nVertex.size();i++)
|
||
{
|
||
pd3dDevice->SetTexture(0,m_pMat[m_pMatRef[i]]->GetTexture());
|
||
if(m_nVertex[i]==0 || m_nIndices[i]==0)
|
||
continue;
|
||
pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,nVertexOffset,
|
||
m_nVertex[i],
|
||
nIndicesOffset,
|
||
m_nIndices[i]);
|
||
nVertexOffset+=m_nVertex[i];
|
||
nIndicesOffset+=m_nIndices[i]*3;
|
||
}
|
||
return;
|
||
}
|
||
|
||
if(m_dwShader==BUMPVERTEXFVF)
|
||
{
|
||
pd3dDevice->SetStreamSource(0,m_pVertexBuffer[0],sizeof(BumpVertex));
|
||
pd3dDevice->SetIndices(m_pIndicesBuffer[0],0);
|
||
int nVertexOffset,nIndicesOffset;
|
||
nVertexOffset=nIndicesOffset=0;
|
||
|
||
for(int i=0;i<(int)m_nVertex.size();i++)
|
||
{
|
||
pd3dDevice->SetTexture(0,m_pMat[m_pMatRef[i]]->GetTexture());
|
||
if(m_nVertex[i]==0 || m_nIndices[i]==0)
|
||
continue;
|
||
pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST,nVertexOffset,
|
||
m_nVertex[i],
|
||
nIndicesOffset,
|
||
m_nIndices[i]);
|
||
nVertexOffset+=m_nVertex[i];
|
||
nIndicesOffset+=m_nIndices[i]*3;
|
||
}
|
||
return;
|
||
}
|
||
}
|
||
|
||
void CMeshObject::RenderBox(LPDIRECT3DDEVICE8 pd3dDevice)
|
||
{
|
||
LPDIRECT3DVERTEXBUFFER8 pBoxVB;
|
||
MultiVertex *BoxVertex;
|
||
|
||
LPDIRECT3DINDEXBUFFER8 pBoxIB;
|
||
WORD *pIndices;
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(8*sizeof(MultiVertex),D3DUSAGE_WRITEONLY,
|
||
MultiFVF,D3DPOOL_MANAGED,&pBoxVB);
|
||
CSceneManager::GetDevice()->CreateIndexBuffer(24*sizeof(WORD),D3DUSAGE_WRITEONLY,
|
||
D3DFMT_INDEX16,D3DPOOL_MANAGED,&pBoxIB);
|
||
|
||
pBoxVB->Lock(0,0,(BYTE**)&BoxVertex,0);
|
||
pBoxIB->Lock(0, 24*sizeof(WORD),(BYTE**)&pIndices,0);
|
||
BoxVertex[0].v.x=m_MaxBox.x;
|
||
BoxVertex[0].v.y=m_MaxBox.y;
|
||
BoxVertex[0].v.z=m_MaxBox.z;
|
||
|
||
BoxVertex[1].v.x=m_MinBox.x;
|
||
BoxVertex[1].v.y=m_MaxBox.y;
|
||
BoxVertex[1].v.z=m_MaxBox.z;
|
||
|
||
BoxVertex[2].v.x=m_MaxBox.x;
|
||
BoxVertex[2].v.y=m_MaxBox.y;
|
||
BoxVertex[2].v.z=m_MinBox.z;
|
||
|
||
BoxVertex[3].v.x=m_MinBox.x;
|
||
BoxVertex[3].v.y=m_MaxBox.y;
|
||
BoxVertex[3].v.z=m_MinBox.z;
|
||
|
||
BoxVertex[4].v.x=m_MaxBox.x;
|
||
BoxVertex[4].v.y=m_MinBox.y;
|
||
BoxVertex[4].v.z=m_MaxBox.z;
|
||
|
||
BoxVertex[5].v.x=m_MinBox.x;
|
||
BoxVertex[5].v.y=m_MinBox.y;
|
||
BoxVertex[5].v.z=m_MaxBox.z;
|
||
|
||
BoxVertex[6].v.x=m_MaxBox.x;
|
||
BoxVertex[6].v.y=m_MinBox.y;
|
||
BoxVertex[6].v.z=m_MinBox.z;
|
||
|
||
BoxVertex[7].v.x=m_MinBox.x;
|
||
BoxVertex[7].v.y=m_MinBox.y;
|
||
BoxVertex[7].v.z=m_MinBox.z;
|
||
for(int i=0;i<8;i++)
|
||
{
|
||
BoxVertex[i].diff.c=0xffffffff;
|
||
BoxVertex[i].spec.c=0xffffffff;
|
||
}
|
||
|
||
*(pIndices++)=0;
|
||
*(pIndices++)=1;
|
||
*(pIndices++)=1;
|
||
*(pIndices++)=3;
|
||
*(pIndices++)=3;
|
||
*(pIndices++)=2;
|
||
*(pIndices++)=2;
|
||
*(pIndices++)=0;
|
||
|
||
*(pIndices++)=4;
|
||
*(pIndices++)=5;
|
||
*(pIndices++)=5;
|
||
*(pIndices++)=7;
|
||
*(pIndices++)=7;
|
||
*(pIndices++)=6;
|
||
*(pIndices++)=6;
|
||
*(pIndices++)=4;
|
||
|
||
*(pIndices++)=0;
|
||
*(pIndices++)=4;
|
||
*(pIndices++)=1;
|
||
*(pIndices++)=5;
|
||
*(pIndices++)=3;
|
||
*(pIndices++)=7;
|
||
*(pIndices++)=2;
|
||
*(pIndices++)=6;
|
||
|
||
pBoxVB->Unlock();
|
||
pBoxIB->Unlock();
|
||
|
||
pd3dDevice->SetTexture(0,NULL);
|
||
pd3dDevice->SetTexture(1,NULL);
|
||
pd3dDevice->SetVertexShader(MultiFVF);
|
||
|
||
pd3dDevice->SetStreamSource(0,pBoxVB,sizeof(MultiVertex));
|
||
pd3dDevice->SetIndices(pBoxIB,0);
|
||
pd3dDevice->DrawIndexedPrimitive(D3DPT_LINELIST,
|
||
0,8,
|
||
0,12);
|
||
pBoxVB->Release();
|
||
pBoxIB->Release();
|
||
}
|
||
|
||
void CMeshObject::AllLockBuffer()
|
||
{
|
||
if(m_bCompleteMesh)
|
||
return;
|
||
if(m_isAlreadyLock==true)
|
||
return;
|
||
m_isAlreadyLock=true;
|
||
if(m_dwShader==LightFVF)
|
||
{
|
||
LightVertex *pVertexData;
|
||
m_pVertex.clear();
|
||
|
||
for(int cVB=0;cVB<(int)m_pVertexBuffer.size();cVB++)
|
||
{
|
||
m_pVertexBuffer[cVB]->Lock(0,0,(BYTE**)&pVertexData,NULL);
|
||
m_pVertex.push_back(pVertexData);
|
||
}
|
||
}
|
||
else
|
||
{
|
||
MultiVertex *pVertexData;
|
||
m_pVertex.clear();
|
||
for(int cVB=0;cVB<(int)m_pVertexBuffer.size();cVB++)
|
||
{
|
||
m_pVertexBuffer[cVB]->Lock(0,0,(BYTE**)&pVertexData,NULL);
|
||
m_pVertex.push_back(pVertexData);
|
||
}
|
||
}
|
||
WORD *pIndicesData;
|
||
m_pIndices.clear();
|
||
for(int cIB=0;cIB<(int)m_pIndicesBuffer.size();cIB++)
|
||
{
|
||
m_pIndicesBuffer[cIB]->Lock(0,m_nIndices[cIB]*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
m_pIndices.push_back(pIndicesData);
|
||
}
|
||
}
|
||
|
||
void CMeshObject::AllUnlockBuffer()
|
||
{
|
||
if(m_bCompleteMesh)
|
||
return;
|
||
|
||
for(int cVB=0;cVB<(int)m_pVertexBuffer.size();cVB++)
|
||
m_pVertexBuffer[cVB]->Unlock();
|
||
|
||
for(int cIB=0;cIB<(int)m_pIndicesBuffer.size();cIB++)
|
||
m_pIndicesBuffer[cIB]->Unlock();
|
||
|
||
m_pVertex.clear();
|
||
m_pIndices.clear();
|
||
m_isAlreadyLock=false;
|
||
}
|
||
|
||
void CMeshObject::CopyBuffer()
|
||
{
|
||
if(m_bCompleteMesh)
|
||
return;
|
||
MultiVertex *pVertexData=NULL;
|
||
MultiVertex *pCopyVertex=NULL;
|
||
|
||
WORD *pIndicesData=NULL;
|
||
WORD *pCopyIndices=NULL;
|
||
|
||
m_pVertex.clear();
|
||
m_pIndices.clear();
|
||
|
||
for(int cVB=0;cVB<(int)m_pVertexBuffer.size();cVB++)
|
||
{
|
||
pCopyVertex=new MultiVertex[m_nVertex[cVB]];
|
||
m_pVertexBuffer[cVB]->Lock(0,0,(BYTE**)&pVertexData,NULL);
|
||
memcpy(pCopyVertex,pVertexData,sizeof(MultiVertex)*m_nVertex[cVB]);
|
||
m_pVertexBuffer[cVB]->Unlock();
|
||
m_pVertex.push_back(pCopyVertex);
|
||
}
|
||
|
||
for(int cIB=0;cIB<(int)m_pIndicesBuffer.size();cIB++)
|
||
{
|
||
pCopyIndices=new WORD[m_nIndices[cIB]*3*sizeof(WORD)];
|
||
m_pIndicesBuffer[cIB]->Lock(0,m_nIndices[cIB]*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
memcpy(pCopyIndices,pIndicesData,m_nIndices[cIB]*3*sizeof(WORD));
|
||
m_pIndicesBuffer[cIB]->Unlock();
|
||
m_pIndices.push_back(pCopyIndices);
|
||
}
|
||
}
|
||
|
||
void CMeshObject::Save(char *strFilename)
|
||
{
|
||
bool bConvert=false;
|
||
if(m_dwShader!=MultiFVF)
|
||
{
|
||
bConvert=true;
|
||
ConvertMulti();
|
||
}
|
||
FILE *fp;
|
||
int TextureSize=0;
|
||
fp=fopen(strFilename,"wb");
|
||
int iCnt = m_pVertexBuffer.size();
|
||
fwrite(&iCnt,sizeof(int),1,fp);
|
||
|
||
iCnt = m_pMat.size();
|
||
fwrite(&iCnt,sizeof(int),1,fp);
|
||
|
||
fwrite(&TextureSize,sizeof(int),1,fp);
|
||
char strTextureName[256];
|
||
|
||
for(int i=0;i<(int)m_pMat.size();i++)
|
||
{
|
||
sscanf(m_pMat[i]->m_strName,"%s",strTextureName);
|
||
fwrite(strTextureName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
|
||
}
|
||
AllLockBuffer();
|
||
|
||
char strObjectName[MAX_NAMEBUFFER]="";
|
||
for(int i=0;i<(int)m_pVertexBuffer.size();i++)
|
||
{
|
||
fwrite(strObjectName,sizeof(char)*MAX_NAMEBUFFER,1,fp);
|
||
fwrite(&m_pMatRef[i],sizeof(long),1,fp);
|
||
fwrite(&m_nVertex[i],sizeof(long),1,fp);
|
||
fwrite(&m_nIndices[i],sizeof(int),1,fp);
|
||
fwrite(m_pVertex[i],sizeof(MultiVertex)*m_nVertex[i],1,fp);
|
||
fwrite(m_pIndices[i],sizeof(WORD)*m_nIndices[i]*3,1,fp);
|
||
}
|
||
fclose(fp);
|
||
AllUnlockBuffer();
|
||
if(bConvert)
|
||
{
|
||
ConvertNormal();
|
||
}
|
||
}
|
||
|
||
void CMeshObject::ConvertNormal()
|
||
{
|
||
if(m_bCompleteMesh)
|
||
return;
|
||
if(m_dwShader==LightFVF)
|
||
return;
|
||
SetShader(LightFVF);
|
||
LightVertex *pVertexNormalData;
|
||
MultiVertex *pVertexData;
|
||
WORD *pIndicesData;
|
||
|
||
vector3 vecNormal;
|
||
vector3 *v[3];
|
||
for(int i=0;i<(int)m_nVertex.size();i++)
|
||
{
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(m_nVertex[i]*sizeof(LightVertex),D3DUSAGE_WRITEONLY,
|
||
LightFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexNormalData,0);
|
||
m_pIndicesBuffer[i]->Lock(0,m_nIndices[i]*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
m_pVertexBuffer[i]->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
|
||
for(int cIndices=0;cIndices<m_nIndices[i];cIndices++)
|
||
{
|
||
v[0]=(vector3*)&pVertexData[ pIndicesData[cIndices*3+0] ].v;
|
||
v[1]=(vector3*)&pVertexData[ pIndicesData[cIndices*3+1] ].v;
|
||
v[2]=(vector3*)&pVertexData[ pIndicesData[cIndices*3+2] ].v;
|
||
|
||
vecNormal= (*v[1]-*v[0])^(*v[2]-*v[1]);
|
||
vecNormal.Normalize();
|
||
|
||
pVertexData[ pIndicesData[cIndices*3+0] ].v;
|
||
pVertexData[ pIndicesData[cIndices*3+1] ].v;
|
||
pVertexData[ pIndicesData[cIndices*3+2] ].v;
|
||
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].v=pVertexData[ pIndicesData[cIndices*3+0] ].v;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].tu=pVertexData[ pIndicesData[cIndices*3+0] ].tu;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].tv=pVertexData[ pIndicesData[cIndices*3+0] ].tv;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].spec.c=0x0;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].n=vecNormal;
|
||
|
||
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].v=pVertexData[ pIndicesData[cIndices*3+1] ].v;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].tu=pVertexData[ pIndicesData[cIndices*3+1] ].tu;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].tv=pVertexData[ pIndicesData[cIndices*3+1] ].tv;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].spec.c=0x0;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].n=vecNormal;
|
||
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].v=pVertexData[ pIndicesData[cIndices*3+2] ].v;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].tu=pVertexData[ pIndicesData[cIndices*3+2] ].tu;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].tv=pVertexData[ pIndicesData[cIndices*3+2] ].tv;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].spec.c=0x0;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].n=vecNormal;
|
||
|
||
}
|
||
|
||
#ifndef _DEBUG
|
||
// smoothing
|
||
int *iTmp = new int[m_nVertex[i]];
|
||
int iCount;
|
||
|
||
for(int iVert = 0; iVert < m_nVertex[i]; iVert++)
|
||
{
|
||
memset(iTmp,0,sizeof(int) * m_nVertex[i]);
|
||
iCount = 0;
|
||
|
||
vector3 vecPos = pVertexNormalData[iVert].v;
|
||
vector3 vecNormal = vector3(0.0f,0.0f,0.0f);
|
||
for(int j = 0; j < m_nVertex[i]; j++ )
|
||
{
|
||
if(pVertexNormalData[j].v.x == pVertexNormalData[iVert].v.x &&
|
||
pVertexNormalData[j].v.y == pVertexNormalData[iVert].v.y &&
|
||
pVertexNormalData[j].v.z == pVertexNormalData[iVert].v.z)
|
||
{
|
||
if(D3DXVec3Dot((D3DXVECTOR3 *)(&pVertexNormalData[j].n),(D3DXVECTOR3 *)(&pVertexNormalData[iVert].n)) >= 0.5f)
|
||
{
|
||
|
||
iTmp[iCount++] = j;
|
||
vecNormal += pVertexNormalData[j].n;
|
||
}
|
||
}
|
||
}
|
||
vecNormal.Normalize();
|
||
for(int iT = 0; iT < iCount; iT++)
|
||
{
|
||
pVertexNormalData[iTmp[iT]].n = vecNormal;
|
||
}
|
||
|
||
|
||
}
|
||
delete[] iTmp;
|
||
iTmp = NULL;
|
||
#endif
|
||
|
||
pAllocVB->Unlock();
|
||
m_pIndicesBuffer[i]->Unlock();
|
||
m_pVertexBuffer[i]->Unlock();
|
||
m_pVertexBuffer[i]->Release();
|
||
m_pVertexBuffer[i]=pAllocVB;
|
||
}
|
||
}
|
||
|
||
void CMeshObject::ConvertMulti()
|
||
{
|
||
if(m_bCompleteMesh)
|
||
return;
|
||
if(MultiFVF==m_dwShader)
|
||
return;
|
||
if(LightFVF==m_dwShader)
|
||
{
|
||
SetShader(MultiFVF);
|
||
LightVertex *pVertexNormalData;
|
||
MultiVertex *pVertexData;
|
||
|
||
for(int i=0;i<(int)m_nVertex.size();i++)
|
||
{
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(m_nVertex[i]*sizeof(MultiVertex),D3DUSAGE_WRITEONLY,
|
||
MultiFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
m_pVertexBuffer[i]->Lock(0,0,(BYTE**)&pVertexNormalData,0);
|
||
for(int cVertex=0;cVertex<m_nVertex[i];cVertex++)
|
||
{
|
||
pVertexData[cVertex].v=pVertexNormalData[cVertex].v;
|
||
pVertexData[cVertex].tu=pVertexNormalData[cVertex].tu;
|
||
pVertexData[cVertex].tv=pVertexNormalData[cVertex].tv;
|
||
pVertexData[cVertex].spec.c=0x0;
|
||
pVertexData[cVertex].diff.c=0xffffffff;
|
||
}
|
||
pAllocVB->Unlock();
|
||
m_pVertexBuffer[i]->Unlock();
|
||
m_pVertexBuffer[i]->Release();
|
||
m_pVertexBuffer[i]=pAllocVB;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
SetShader(MultiFVF);
|
||
DetailVertex *pVertexNormalData;
|
||
MultiVertex *pVertexData;
|
||
|
||
for(int i=0;i<(int)m_nVertex.size();i++)
|
||
{
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(m_nVertex[i]*sizeof(MultiVertex),D3DUSAGE_WRITEONLY,
|
||
MultiFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
m_pVertexBuffer[i]->Lock(0,0,(BYTE**)&pVertexNormalData,0);
|
||
for(int cVertex=0;cVertex<m_nVertex[i];cVertex++)
|
||
{
|
||
|
||
pVertexData[cVertex].v=pVertexNormalData[cVertex].v;
|
||
pVertexData[cVertex].tu=pVertexNormalData[cVertex].tu;
|
||
pVertexData[cVertex].tv=pVertexNormalData[cVertex].tv;
|
||
pVertexData[cVertex].spec.c=0x0;
|
||
pVertexData[cVertex].diff.c=0xffffffff;
|
||
}
|
||
pAllocVB->Unlock();
|
||
m_pVertexBuffer[i]->Unlock();
|
||
m_pVertexBuffer[i]->Release();
|
||
m_pVertexBuffer[i]=pAllocVB;
|
||
}
|
||
}
|
||
}
|
||
|
||
void CMeshObject::Optimize()
|
||
{
|
||
if(m_bCompleteMesh)
|
||
return;
|
||
DWORD dwShaderTemp=m_dwShader;
|
||
if(m_dwShader!=MultiFVF)
|
||
ConvertMulti();
|
||
|
||
const float fEll=0.0001f;
|
||
CopyBuffer();
|
||
for(int i=0;i<(int)m_nIndices.size();i++)
|
||
{
|
||
MultiVertex *pOPVertexData=new MultiVertex[m_nVertex[i]];
|
||
MultiVertex *pOldVertexData=(MultiVertex *)m_pVertex[i];
|
||
WORD *pOPIndicesData=new WORD[m_nIndices[i]*3];
|
||
int cNowAdd=0;
|
||
for(int cIndices=0;cIndices<m_nIndices[i]*3;cIndices++)
|
||
{
|
||
MultiVertex CompareVertex=pOldVertexData[m_pIndices[i][cIndices]];
|
||
bool isAlready=false;
|
||
int cVertex=0;
|
||
|
||
for(;cVertex<cNowAdd;cVertex++)
|
||
{
|
||
if(dwShaderTemp==MultiFVF)
|
||
{
|
||
if( fabs( CompareVertex.v.x - pOPVertexData[cVertex].v.x ) <= fEll &&
|
||
fabs( CompareVertex.v.y - pOPVertexData[cVertex].v.y ) <= fEll &&
|
||
fabs( CompareVertex.v.z - pOPVertexData[cVertex].v.z ) <= fEll &&
|
||
fabs( CompareVertex.tu - pOPVertexData[cVertex].tu ) <= fEll &&
|
||
fabs( CompareVertex.tv - pOPVertexData[cVertex].tv ) <= fEll &&
|
||
fabs( CompareVertex.tu1 - pOPVertexData[cVertex].tu1) <= fEll &&
|
||
fabs( CompareVertex.tv1 - pOPVertexData[cVertex].tv1) <= fEll)
|
||
{
|
||
isAlready=true;
|
||
break;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
if( fabs( CompareVertex.v.x - pOPVertexData[cVertex].v.x ) <= fEll &&
|
||
fabs( CompareVertex.v.y - pOPVertexData[cVertex].v.y ) <= fEll &&
|
||
fabs( CompareVertex.v.z - pOPVertexData[cVertex].v.z ) <= fEll &&
|
||
fabs( CompareVertex.tu - pOPVertexData[cVertex].tu ) <= fEll &&
|
||
fabs( CompareVertex.tv - pOPVertexData[cVertex].tv ) <= fEll )
|
||
{
|
||
isAlready=true;
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if(isAlready)
|
||
{
|
||
pOPIndicesData[cIndices]=cVertex;
|
||
}
|
||
else
|
||
{
|
||
pOPVertexData[cVertex]=CompareVertex;
|
||
pOPIndicesData[cIndices]=cVertex;
|
||
cNowAdd++;
|
||
}
|
||
}
|
||
m_nVertex[i]=cNowAdd;
|
||
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
|
||
MultiVertex *pVertexData;
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(m_nVertex[i]*sizeof(MultiVertex),D3DUSAGE_WRITEONLY,
|
||
MultiFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
memcpy(pVertexData,pOPVertexData,sizeof(MultiVertex)*m_nVertex[i]);
|
||
pAllocVB->Unlock();
|
||
m_pVertexBuffer[i]->Release();
|
||
m_pVertexBuffer[i]=pAllocVB;
|
||
|
||
WORD *pIndicesData;
|
||
m_pIndicesBuffer[i]->Lock(0,m_nIndices[i]*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
memcpy(pIndicesData,pOPIndicesData,sizeof(WORD)*m_nIndices[i]*3);
|
||
m_pIndicesBuffer[i]->Unlock();
|
||
}
|
||
if(dwShaderTemp!=MultiFVF)
|
||
ConvertNormal();
|
||
}
|
||
|
||
void CMeshObject::TextureLoad()
|
||
{
|
||
for(int i=0;i<(int)m_pMat.size();i++)
|
||
{
|
||
//if(m_nVertex[i]==0 || m_nIndices[i]==0)
|
||
// continue;
|
||
m_pMat[i]->Load(m_pMat[i]->m_strName);
|
||
|
||
if(CRenderOption::m_AllObjectBump && m_pBumpTexture.size()!=0)
|
||
{
|
||
m_pBumpTexture[i]->Load(m_pBumpTexture[i]->m_strName);
|
||
}
|
||
|
||
}
|
||
}
|
||
|
||
void CMeshObject::ConvertDetail()
|
||
{
|
||
if(m_bCompleteMesh)
|
||
return;
|
||
if(m_dwShader==DetailFVF)
|
||
return;
|
||
if(m_dwShader==MultiFVF)
|
||
{
|
||
MultiVertex *pVertexData;
|
||
WORD *pIndicesData;
|
||
DetailVertex *pVertexNormalData;
|
||
for(int i=0;i<(int)m_nVertex.size();i++)
|
||
{
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(m_nVertex[i]*sizeof(DetailVertex),D3DUSAGE_WRITEONLY,
|
||
DetailFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexNormalData,0);
|
||
m_pIndicesBuffer[i]->Lock(0,m_nIndices[i]*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
m_pVertexBuffer[i]->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
|
||
vector3 *v[3];
|
||
|
||
vector3 vecNormal;
|
||
|
||
for(int cIndices=0;cIndices<m_nIndices[i];cIndices++)
|
||
{
|
||
v[0]=(vector3*)&pVertexData[ pIndicesData[cIndices*3+0] ].v;
|
||
v[1]=(vector3*)&pVertexData[ pIndicesData[cIndices*3+1] ].v;
|
||
v[2]=(vector3*)&pVertexData[ pIndicesData[cIndices*3+2] ].v;
|
||
|
||
vecNormal= (*v[1]-*v[0])^(*v[2]-*v[1]);
|
||
vecNormal.Normalize();
|
||
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].v=pVertexData[ pIndicesData[cIndices*3+0] ].v;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].tu=pVertexData[ pIndicesData[cIndices*3+0] ].tu;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].tv=pVertexData[ pIndicesData[cIndices*3+0] ].tv;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].tu1=pVertexData[ pIndicesData[cIndices*3+0] ].tu*30.0f;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].tv1=pVertexData[ pIndicesData[cIndices*3+0] ].tv*30.0f;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].n=vecNormal;
|
||
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].v=pVertexData[ pIndicesData[cIndices*3+1] ].v;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].tu=pVertexData[ pIndicesData[cIndices*3+1] ].tu;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].tv=pVertexData[ pIndicesData[cIndices*3+1] ].tv;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].tu1=pVertexData[ pIndicesData[cIndices*3+1] ].tu*30.0f;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].tv1=pVertexData[ pIndicesData[cIndices*3+1] ].tv*30.0f;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].n=vecNormal;
|
||
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].v=pVertexData[ pIndicesData[cIndices*3+2] ].v;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].tu=pVertexData[ pIndicesData[cIndices*3+2] ].tu;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].tv=pVertexData[ pIndicesData[cIndices*3+2] ].tv;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].tu1=pVertexData[ pIndicesData[cIndices*3+2] ].tu*30.0f;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].tv1=pVertexData[ pIndicesData[cIndices*3+2] ].tv*30.0f;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].n=vecNormal;
|
||
|
||
}
|
||
pAllocVB->Unlock();
|
||
m_pIndicesBuffer[i]->Unlock();
|
||
m_pVertexBuffer[i]->Unlock();
|
||
m_pVertexBuffer[i]->Release();
|
||
m_pVertexBuffer[i]=pAllocVB;
|
||
}
|
||
}
|
||
else
|
||
{
|
||
LightVertex *pVertexNormalData;
|
||
DetailVertex *pVertexData;
|
||
|
||
for(int i=0;i<(int)m_nVertex.size();i++)
|
||
{
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(m_nVertex[i]*sizeof(MultiVertex),D3DUSAGE_WRITEONLY,
|
||
MultiFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
m_pVertexBuffer[i]->Lock(0,0,(BYTE**)&pVertexNormalData,0);
|
||
for(int cVertex=0;cVertex<m_nVertex[i];cVertex++)
|
||
{
|
||
pVertexData[cVertex].v=pVertexNormalData[cVertex].v;
|
||
pVertexData[cVertex].tu=pVertexNormalData[cVertex].tu;
|
||
pVertexData[cVertex].tv=pVertexNormalData[cVertex].tv;
|
||
pVertexData[cVertex].n=pVertexNormalData[cVertex].n;
|
||
pVertexData[cVertex].tu1=pVertexNormalData[cVertex].tu*10.0f;
|
||
pVertexData[cVertex].tv1=pVertexNormalData[cVertex].tv*10.0f;
|
||
}
|
||
pAllocVB->Unlock();
|
||
m_pVertexBuffer[i]->Unlock();
|
||
m_pVertexBuffer[i]->Release();
|
||
m_pVertexBuffer[i]=pAllocVB;
|
||
}
|
||
}
|
||
SetShader(DetailFVF);
|
||
//DetailTextureLoad();
|
||
}
|
||
|
||
//DEL void CMeshObject::DetailTextureLoad()
|
||
//DEL {
|
||
//DEL char strDetailName[256];
|
||
//DEL char strFullName[256];
|
||
//DEL int nlens;
|
||
//DEL FILE *fp=NULL;
|
||
//DEL CTexture::SetPath(OBJECTTEXTUREPATH);
|
||
//DEL
|
||
//DEL for(int i=0;i<m_pMat.num;i++)
|
||
//DEL {
|
||
//DEL strcpy(strDetailName,m_pMat[i]->m_strName);
|
||
//DEL nlens=strlen(strDetailName);
|
||
//DEL strDetailName[nlens-4]='\0';
|
||
//DEL strcat(strDetailName,"_detail.dds");
|
||
//DEL sprintf(strFullName,"%s\\%s",OBJECTTEXTUREPATH,strDetailName);
|
||
//DEL fp=fopen(strFullName,"rb");
|
||
//DEL if(fp)
|
||
//DEL {
|
||
//DEL fclose(fp);
|
||
//DEL CTexture *AddNode=new CTexture();
|
||
//DEL strcpy(AddNode->m_strName,strDetailName);
|
||
//DEL AddNode->Load(AddNode->m_strName);
|
||
//DEL m_pDetailMap.Add(AddNode);
|
||
//DEL }
|
||
//DEL else
|
||
//DEL {
|
||
//DEL m_pDetailMap.Add(NULL);
|
||
//DEL }
|
||
//DEL }
|
||
//DEL m_bDetailTexture=true;
|
||
//DEL }
|
||
|
||
void CMeshObject::ConvertTree()
|
||
{
|
||
SetShader(TREEVERTEXFVF);
|
||
TreeVertex *pVertexNormalData;
|
||
MultiVertex *pVertexData;
|
||
WORD *pIndicesData;
|
||
|
||
vector3 vecNormal;
|
||
vector3 *v[3];
|
||
float fMaxY,fMinY;
|
||
fMaxY=-100000000000.0f;
|
||
fMinY=100000000000.0f;
|
||
for(int i=0;i<(int)m_nVertex.size();i++)
|
||
{
|
||
m_pVertexBuffer[i]->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
for(int cVertex=0;cVertex<m_nVertex[i];cVertex++)
|
||
{
|
||
if(fMaxY<pVertexData[cVertex].v.y)
|
||
fMaxY=pVertexData[cVertex].v.y;
|
||
if(fMinY>pVertexData[cVertex].v.y)
|
||
fMinY=pVertexData[cVertex].v.y;
|
||
|
||
}
|
||
m_pVertexBuffer[i]->Unlock();
|
||
}
|
||
|
||
float fSize=fMaxY-fMinY;
|
||
float fRate;//,fEnd;
|
||
for(int i=0;i<(int)m_nVertex.size();i++)
|
||
{
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(m_nVertex[i]*sizeof(TreeVertex),D3DUSAGE_WRITEONLY,
|
||
TREEVERTEXFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexNormalData,0);
|
||
m_pIndicesBuffer[i]->Lock(0,m_nIndices[i]*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
m_pVertexBuffer[i]->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
|
||
for(int cIndices=0;cIndices<m_nIndices[i];cIndices++)
|
||
{
|
||
v[0]=(vector3*)&pVertexData[ pIndicesData[cIndices*3+0] ].v;
|
||
v[1]=(vector3*)&pVertexData[ pIndicesData[cIndices*3+1] ].v;
|
||
v[2]=(vector3*)&pVertexData[ pIndicesData[cIndices*3+2] ].v;
|
||
|
||
vecNormal= (*v[1]-*v[0])^(*v[2]-*v[1]);
|
||
vecNormal.Normalize();
|
||
|
||
pVertexData[ pIndicesData[cIndices*3+0] ].v;
|
||
pVertexData[ pIndicesData[cIndices*3+1] ].v;
|
||
pVertexData[ pIndicesData[cIndices*3+2] ].v;
|
||
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].v=pVertexData[ pIndicesData[cIndices*3+0] ].v;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].tu=pVertexData[ pIndicesData[cIndices*3+0] ].tu;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].tv=pVertexData[ pIndicesData[cIndices*3+0] ].tv;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].n=vecNormal;
|
||
fRate=(pVertexNormalData[pIndicesData[cIndices*3+0]].v.y-fMinY)/fSize;
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].fWeight=fRate*fRate;
|
||
/*
|
||
if(fRate<0.5)
|
||
pVertexNormalData[pIndicesData[cIndices*3+0]].fWeight=0.0f;
|
||
else
|
||
{
|
||
fEnd=(fRate-0.5f)*2.0f;
|
||
*/
|
||
//pVertexNormalData[pIndicesData[cIndices*3+0]].fWeight=fEnd*fEnd;
|
||
//}
|
||
|
||
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].v=pVertexData[ pIndicesData[cIndices*3+1] ].v;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].tu=pVertexData[ pIndicesData[cIndices*3+1] ].tu;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].tv=pVertexData[ pIndicesData[cIndices*3+1] ].tv;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].n=vecNormal;
|
||
fRate=(pVertexNormalData[pIndicesData[cIndices*3+1]].v.y-fMinY)/fSize;
|
||
pVertexNormalData[pIndicesData[cIndices*3+1]].fWeight=fRate*fRate;
|
||
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].v=pVertexData[ pIndicesData[cIndices*3+2] ].v;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].tu=pVertexData[ pIndicesData[cIndices*3+2] ].tu;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].tv=pVertexData[ pIndicesData[cIndices*3+2] ].tv;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].n=vecNormal;
|
||
fRate=(pVertexNormalData[pIndicesData[cIndices*3+2]].v.y-fMinY)/fSize;
|
||
pVertexNormalData[pIndicesData[cIndices*3+2]].fWeight=fRate*fRate;
|
||
|
||
}
|
||
// smoothing
|
||
int *iTmp = new int[m_nVertex[i]];
|
||
int iCount;
|
||
|
||
for(int iVert = 0; iVert < m_nVertex[i]; iVert++)
|
||
{
|
||
memset(iTmp,0,sizeof(int) * m_nVertex[i]);
|
||
iCount = 0;
|
||
|
||
vector3 vecPos = pVertexNormalData[iVert].v;
|
||
vector3 vecNormal = vector3(0.0f,0.0f,0.0f);
|
||
for(int j = 0; j < m_nVertex[i]; j++ )
|
||
{
|
||
if(pVertexNormalData[j].v.x == pVertexNormalData[iVert].v.x &&
|
||
pVertexNormalData[j].v.y == pVertexNormalData[iVert].v.y &&
|
||
pVertexNormalData[j].v.z == pVertexNormalData[iVert].v.z)
|
||
{
|
||
iTmp[iCount++] = j;
|
||
vecNormal += pVertexNormalData[j].n;
|
||
|
||
}
|
||
}
|
||
vecNormal.Normalize();
|
||
for(int iT = 0; iT < iCount; iT++)
|
||
{
|
||
pVertexNormalData[iTmp[iT]].n = vecNormal;
|
||
}
|
||
|
||
|
||
}
|
||
delete[] iTmp;
|
||
iTmp = NULL;
|
||
|
||
//
|
||
|
||
pAllocVB->Unlock();
|
||
m_pIndicesBuffer[i]->Unlock();
|
||
m_pVertexBuffer[i]->Unlock();
|
||
m_pVertexBuffer[i]->Release();
|
||
m_pVertexBuffer[i]=pAllocVB;
|
||
}
|
||
}
|
||
|
||
void CMeshObject::MeshReload()
|
||
{
|
||
m_pVertex.clear();
|
||
m_pIndices.clear();
|
||
for(int i=0;i<(int)m_pVertexBuffer.size();i++)
|
||
m_pVertexBuffer[i]->Release();
|
||
|
||
m_pVertexBuffer.clear();
|
||
m_nVertex.clear();
|
||
|
||
for(int i=0;i<(int)m_pIndicesBuffer.size();i++)
|
||
m_pIndicesBuffer[i]->Release();
|
||
|
||
m_pIndicesBuffer.clear();
|
||
m_nIndices.clear();
|
||
|
||
CFileLoad FileLoader;
|
||
FileLoader.Load(m_strMeshName);
|
||
|
||
int nObject,nMat,TextureSize;
|
||
FileLoader.GetData(&nObject,sizeof(int));
|
||
FileLoader.GetData(&nMat,sizeof(int));
|
||
FileLoader.GetData(&TextureSize,sizeof(int));
|
||
|
||
m_bRender=true;
|
||
|
||
|
||
char strTextureName[256];
|
||
for(int i=0;i<nMat;i++)
|
||
{
|
||
FileLoader.GetData(strTextureName,sizeof(char)*MAX_NAMEBUFFER);
|
||
|
||
}
|
||
char strObjectName[256];
|
||
int MatRef,cVertex,cIndices;
|
||
MultiVertex *pVertexData;
|
||
WORD *pIndicesData;
|
||
|
||
for(int i=0;i<nObject;i++)
|
||
{
|
||
FileLoader.GetData(strObjectName,sizeof(char)*256);
|
||
FileLoader.GetData(&MatRef,sizeof(long));
|
||
FileLoader.GetData(&cVertex,sizeof(long));
|
||
FileLoader.GetData(&cIndices,sizeof(int));
|
||
|
||
LPDIRECT3DVERTEXBUFFER8 pAllocVB;
|
||
LPDIRECT3DINDEXBUFFER8 pAllocIB;
|
||
|
||
MultiVertex *pTempVertex=new MultiVertex[cVertex];
|
||
WORD *pTempIndices=new WORD[cIndices*3];
|
||
|
||
CSceneManager::GetDevice()->CreateVertexBuffer(cVertex*sizeof(MultiVertex),D3DUSAGE_WRITEONLY,
|
||
MultiFVF,D3DPOOL_MANAGED,&pAllocVB);
|
||
CSceneManager::GetDevice()->CreateIndexBuffer(cIndices*3*sizeof(WORD),D3DUSAGE_WRITEONLY,
|
||
D3DFMT_INDEX16,D3DPOOL_MANAGED,&pAllocIB);
|
||
|
||
pAllocVB->Lock(0,0,(BYTE**)&pVertexData,0);
|
||
pAllocIB->Lock(0,cIndices*3*sizeof(WORD),(BYTE**)&pIndicesData,0);
|
||
|
||
FileLoader.GetData(pVertexData,sizeof(MultiVertex)*cVertex);
|
||
FileLoader.GetData(pIndicesData,sizeof(WORD)*cIndices*3);
|
||
|
||
pAllocVB->Unlock();
|
||
pAllocIB->Unlock();
|
||
|
||
m_pVertexBuffer.push_back(pAllocVB);
|
||
m_pIndicesBuffer.push_back(pAllocIB);
|
||
|
||
m_nVertex.push_back(cVertex);
|
||
m_nIndices.push_back(cIndices);
|
||
m_pMatRef.push_back(MatRef);
|
||
|
||
delete [] pTempIndices;
|
||
delete [] pTempVertex;
|
||
}
|
||
if(m_dwShader!=MultiFVF)
|
||
{
|
||
m_dwShader=MultiFVF;
|
||
ConvertNormal();
|
||
}
|
||
}
|