Ejemplo n.º 1
0
																																					//
// Loads mesh after device loss
void DirectX::Mesh::onDeviceReset( )
{
	if( m_meshInfo ) {
		char* infoIter = (char*)m_meshInfo;
		unsigned long fvf = *(unsigned long*)infoIter; infoIter += sizeof(long);
		unsigned long stride = *(unsigned long*)infoIter; infoIter += sizeof(long);
		unsigned long options = *(unsigned long*)infoIter; infoIter += sizeof(long);
		unsigned int nVertices = *(unsigned int*)infoIter; infoIter += sizeof(int);
		unsigned int nIndices = *(unsigned int*)infoIter; infoIter += sizeof(int);
		unsigned int vbSize = *(unsigned int*)infoIter; infoIter += sizeof(int);
		unsigned int ibSize = *(unsigned int*)infoIter; infoIter += sizeof(int);
				
		// Create the mesh
		HRESULT hr = D3DXCreateMeshFVF( nIndices*3, nVertices, options, fvf, DirectX::Manager::instance( )->getD3DDev( ), &m_mesh );
		if( hr ) MessageBox( NULL, L"Call to D3DXCreateMeshFVF has failed.", L"DirectX Engine", NULL );

		void *vb, *ib;
		m_mesh->LockVertexBuffer( D3DLOCK_READONLY, &vb );
		m_mesh->LockIndexBuffer( D3DLOCK_READONLY, &ib );

		memcpy( vb, infoIter, vbSize ); infoIter += vbSize;
		memcpy( ib, infoIter, ibSize ); infoIter += ibSize;

		free(m_meshInfo);
	}
}
Ejemplo n.º 2
0
																																					//
// Creates a DirectX mesh
void DirectX::Mesh::create( unsigned int nFaces, unsigned int nVertices, unsigned long fvf, unsigned long options ) 
{
	// Create the mesh
	HRESULT hr = D3DXCreateMeshFVF( nFaces, nVertices, options, fvf, DirectX::Manager::instance( )->getD3DDev( ), &m_mesh );
	if( hr ) MessageBox( NULL, L"Call to D3DXCreateMeshFVF has failed.", L"DirectX Engine", NULL );

	// Register with the manager
	if( !(options&D3DXMESH_SYSTEMMEM) ) 
		DirectX::Manager::instance( )->addResource( this );
}
Ejemplo n.º 3
0
void D3D9Mesh::Allocate(UINT VertexCount, UINT FaceCount)
{
    FreeMemory();
    if(VertexCount == 0 || FaceCount == 0)
    {
        return;
    }

    D3DXCreateMeshFVF(FaceCount, VertexCount, D3DMeshOptions, D3DMeshFVF, GetD3DDevice(), &_Mesh);    //tell DirectX to allocate space for the _Mesh
    Lock();        //toggle the buffer locking just to clear things up
    Unlock();    //we want the buffers unlocked whenever possible
}
Ejemplo n.º 4
0
//------------------------------------------------------
//		DirectXメッシュの作成
//------------------------------------------------------
LPD3DXMESH	iex3DObj::CreateMesh( LPIEMFILE lpIem )
{
	LPD3DXMESH	lpMesh;
	u8			*pVertex, *pFace;
	u32			*pData;
	
	if( lpIem->version < 4 )
	{
		u32	Declaration = D3DFVF_MESHVERTEX;
		//	メッシュ作成
		D3DXCreateMeshFVF( lpIem->NumFace, lpIem->NumVertex, D3DXMESH_MANAGED, Declaration, tdnSystem::GetDevice(), &lpMesh );
		//	頂点設定
		lpMesh->LockVertexBuffer( 0, (void**)&pVertex );
		CopyMemory( pVertex, lpIem->lpVertex, sizeof(MESHVERTEX)*lpIem->NumVertex );
	} else {
		u32	Declaration = D3DFVF_MESHVERTEX2;
		//	メッシュ作成
		D3DXCreateMeshFVF( lpIem->NumFace, lpIem->NumVertex, D3DXMESH_MANAGED, Declaration, tdnSystem::GetDevice(), &lpMesh );
		//	頂点設定
		lpMesh->LockVertexBuffer( 0, (void**)&pVertex );
		CopyMemory( pVertex, lpIem->lpVertex, sizeof(MESHVERTEX2)*lpIem->NumVertex );
	}

	lpMesh->UnlockVertexBuffer();


	//	面設定
	lpMesh->LockIndexBuffer( 0, (void**)&pFace );
	CopyMemory( pFace, lpIem->lpFace, sizeof(u16)*lpIem->NumFace*3 );
	lpMesh->UnlockIndexBuffer();

	//	属性設定
	lpMesh->LockAttributeBuffer( 0, &pData );
	CopyMemory( pData, lpIem->lpAtr, sizeof(u32)*lpIem->NumFace );
	lpMesh->UnlockAttributeBuffer();

	return lpMesh;
}
Ejemplo n.º 5
0
// 板ポリメッシュ作成関数
HRESULT D3DXPlus::CreateBoard(IDirect3DDevice* pDevice, float width, float height, LPD3DXMESH* ppMesh)
{
	struct D3DVERTEX {
		D3DXVECTOR3 v;	// 頂点
		D3DXVECTOR3 n;	// 法線
		float tu, tv;	// テクスチャUV
		enum { FVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1 };
	};
	HRESULT hr = D3DXCreateMeshFVF(2, 4, D3DXMESH_MANAGED, D3DVERTEX::FVF, pDevice, ppMesh);
	if (FAILED(hr)) {
		return hr;
	}
	
	D3DVERTEX* pVertex;
	WORD* pIndex;
	(*ppMesh)->LockVertexBuffer(D3DLOCK_DISCARD, (void**)&pVertex);
	(*ppMesh)->LockIndexBuffer(D3DLOCK_DISCARD, (void**)&pIndex);

	float hlen = width / 2.0f;
	float vlen = height/ 2.0f;

	pVertex[0].v = D3DXVECTOR3(-hlen, 0.0f, -vlen);
	pVertex[1].v = D3DXVECTOR3(-hlen, 0.0f,  vlen);
	pVertex[2].v = D3DXVECTOR3( hlen, 0.0f,  vlen);
	pVertex[3].v = D3DXVECTOR3( hlen, 0.0f, -vlen);

	pVertex[0].n = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
	pVertex[1].n = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
	pVertex[2].n = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
	pVertex[3].n = D3DXVECTOR3(0.0f, 1.0f, 0.0f);

	pVertex[0].tu = 0.0f;	pVertex[0].tv = 0.0f;
	pVertex[1].tu = 0.0f;	pVertex[1].tv = 1.0f;
	pVertex[2].tu = 1.0f;	pVertex[2].tv = 1.0f;
	pVertex[3].tu = 1.0f;	pVertex[3].tv = 0.0f;

	pIndex[0] = 0;
	pIndex[1] = 1;
	pIndex[2] = 2;

	pIndex[3] = 2;
	pIndex[4] = 3;
	pIndex[5] = 0;

	(*ppMesh)->UnlockIndexBuffer();
	(*ppMesh)->UnlockVertexBuffer();

	return hr;
}
Ejemplo n.º 6
0
PrimMesh::PrimMesh(IDirect3DDevice9 *device, LLVolumeFace *volumeFace)
{
	int numVertices = volumeFace->mVertices.size();
	int numIndices = volumeFace->mIndices.size();
	HRESULT hr = D3DXCreateMeshFVF(
							numIndices/3, //NumFaces,三角形个数
							numVertices, //NumVertices
							D3DXMESH_MANAGED, //Options
							FVF_VERTEX, //FVF
							device, 
							&primMesh); //产出的mesh结果

	//向空mesh填充点坐标
	Vertex* v = 0;
	primMesh->LockVertexBuffer(0, (void**)&v);

	for(int j = 0; j<numVertices; j++)
	{
		float p0 = volumeFace->mVertices[j].mPosition.mV[0];
		float p1 = volumeFace->mVertices[j].mPosition.mV[1];
		float p2 = volumeFace->mVertices[j].mPosition.mV[2];
		float n0 = volumeFace->mVertices[j].mNormal.mV[0];
		float n1 = volumeFace->mVertices[j].mNormal.mV[1];
		float n2 = volumeFace->mVertices[j].mNormal.mV[2];
		float u1 = volumeFace->mVertices[j].mTexCoord.mV[0];
		float u2 = volumeFace->mVertices[j].mTexCoord.mV[1];

		v[j] = Vertex(p0, p1, p2, n0, n1, n2, u1, u2);
	}
	primMesh->UnlockVertexBuffer();

	//填充index
	WORD* i = 0;
	primMesh->LockIndexBuffer(0, (void**)&i);
	for(U32 j=0; j<numIndices; j++)
	{
		i[j] = volumeFace->mIndices[j];
	}
	primMesh->UnlockIndexBuffer();

	//指明哪些三角形属于哪个Subset,为贴纹理作准备,这里将所有三角形都归一个类了
	DWORD* attributeBuffer = 0;
	primMesh->LockAttributeBuffer(0, &attributeBuffer);
	for(int j=0; j<numIndices/3; j++) 
	{
		attributeBuffer[j] = 0;
	}
	primMesh->UnlockAttributeBuffer();
}
Ejemplo n.º 7
0
void LoadEffectResources(IDirect3DDevice9 *m_pDevice)
{
	//Calculate sight mesh (a simple quad)
	D3DXCreateMeshFVF(2, 4, D3DXMESH_MANAGED, SimpleVertex::FVF, m_pDevice, &billboardMesh);

	//Create 4 vertices
	SimpleVertex* v = 0;
	billboardMesh->LockVertexBuffer(0,(void**)&v);
	v[0] = SimpleVertex(D3DXVECTOR3(-0.5f, 0.0f, 0.5f), D3DXVECTOR3(0.0f, 1.0f, 0.0f), D3DXVECTOR2(0, 0));
	v[1] = SimpleVertex(D3DXVECTOR3( 0.5f, 0.0f, 0.5f), D3DXVECTOR3(0.0f, 1.0f, 0.0f), D3DXVECTOR2(1, 0));
	v[2] = SimpleVertex(D3DXVECTOR3(-0.5f, 0.0f, -0.5f),D3DXVECTOR3(0.0f, 1.0f, 0.0f), D3DXVECTOR2(0, 1));
	v[3] = SimpleVertex(D3DXVECTOR3( 0.5f, 0.0f, -0.5f),D3DXVECTOR3(0.0f, 1.0f, 0.0f), D3DXVECTOR2(1, 1));
	billboardMesh->UnlockVertexBuffer();

	//Create 2 faces
	WORD* indices = 0;
	billboardMesh->LockIndexBuffer(0,(void**)&indices);	
	indices[0] = 0; indices[1] = 1; indices[2] = 2;
	indices[3] = 1; indices[4] = 3; indices[5] = 2;
	billboardMesh->UnlockIndexBuffer();

	//Set Attributes for the 2 faces
	DWORD *att = 0;
	billboardMesh->LockAttributeBuffer(0,&att);
	att[0] = 0; att[1] = 0;
	billboardMesh->UnlockAttributeBuffer();

	//Sight MTRL
	memset(&whiteMtrl, 0, sizeof(D3DMATERIAL9));
	whiteMtrl.Diffuse = whiteMtrl.Ambient = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);

	//Load Shaders
	effectVertexShader.Init(m_pDevice, "shaders/effect.vs", VERTEX_SHADER);
	effectPixelShader.Init(m_pDevice, "shaders/effect.ps", PIXEL_SHADER);

	//Get constants
	effectMatW = effectVertexShader.GetConstant("matW");
	effectMatVP = effectVertexShader.GetConstant("matVP");
	effectVCol = effectVertexShader.GetConstant("vertexColor");

	//Create Sprite
	D3DXCreateSprite(m_pDevice, &sprite);

	//Load textures
	D3DXCreateTextureFromFile(m_pDevice, "textures/runes.dds", &runesTexture);
	D3DXCreateTextureFromFile(m_pDevice, "textures/cloud.dds", &cloudTexture);
	D3DXCreateTextureFromFile(m_pDevice, "textures/fireball.dds", &fireballTexture);
	D3DXCreateTextureFromFile(m_pDevice, "textures/lensflare.dds", &lensflareTexture);
}
Ejemplo n.º 8
0
/*-----------------------------------------------------------------------------------------*
| <<< メッシュ作成 >>>
*-----------------------------------------------------------------------------------------*/
static	void	CreateMeshFromMetaseq(void)
{

	if(meta->iPolyCount	== 0){ return;}

	// Xファイルから読み込む場合は
	// 立方体の場合 インデックスは	40 個
	//				 頂点情報   	24 個	となっていた。
	D3DXCreateMeshFVF(meta->iPolyCount,		// 表面数	数は適当
					  meta->uiVtxCount,		// 頂点数	数は適当
					  D3DXMESH_MANAGED,		// メッシュのオプション
					  D3_FVF_DEFAULT,		// 頂点フォーマット
					  d3.dev,				// デバイス
					  &meta->lpMesh);		// 作成されたメッシュ

	//--- 頂点情報を書き込む ----------------------------------------
	D3_VTX_DEFAULT	*pvtxBuf;				// 頂点バッファ
	WORD			*pwIndex;				// インデックスバッファ
	DWORD			*pdwMaterial;			// マテリアルバッファ
	meta->lpMesh->LockVertexBuffer(   D3DLOCK_DISCARD, (void **)&pvtxBuf);
	meta->lpMesh->LockIndexBuffer(    D3DLOCK_DISCARD, (void **)&pwIndex);
	meta->lpMesh->LockAttributeBuffer(D3DLOCK_DISCARD, &pdwMaterial);

	// 頂点バッファ転送
	for(uint i = 0; i < meta->uiVtxCount; i++)
	{
		pvtxBuf[i].p  = meta->avtx[i].p;
		pvtxBuf[i].n  = meta->avtx[i].n;
		pvtxBuf[i].uv = meta->avtx[i].uv;
	}

	// インデックスバッファ転送
	for(int i = 0; i < meta->iPolyCount * 3; i++)
	{
		pwIndex[i] = meta->auiIndex[i];
	}

	// マテリアルバッファ転送
	for(int i = 0; i < meta->iPolyCount; i++)
	{
		pdwMaterial[i] = meta->aucMat[i];
	}

	//--- 頂点バッファ閉じる ----------------------------------------
	meta->lpMesh->UnlockAttributeBuffer();
	meta->lpMesh->UnlockIndexBuffer();
	meta->lpMesh->UnlockVertexBuffer();
}
Ejemplo n.º 9
0
void cAllignedQuad::Init()
{
#pragma region CreateRenderToSurface
	D3DXCreateTexture( g_pEngine->core->lpd3dd9, 1920, 1080, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pDynamicTexture_1 );
	m_pDynamicTexture_1->GetSurfaceLevel( 0, &m_pTextureSurface_1 );

	D3DXCreateTexture( g_pEngine->core->lpd3dd9, 1920, 1080, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &m_pDynamicTexture_2 );
	m_pDynamicTexture_2->GetSurfaceLevel( 0, &m_pTextureSurface_2 );

	D3DXCreateRenderToSurface( g_pEngine->core->lpd3dd9, 1920, 1080, D3DFMT_A8R8G8B8, TRUE, D3DFMT_D16, &m_pRenderToSurface );
#pragma endregion 

#pragma region CreateAllignedQuad
	VERTEX3 VertexAllignedQuad[] =
	{
		VERTEX3( -1,  1, 0, 1, 0, 0, 0, 0 ),
		VERTEX3( 1,  1, 0, 1, 0, 0, 1, 0 ),
		VERTEX3( 1, -1, 0, 1, 0, 0, 1, 1 ),
		VERTEX3( -1, -1, 0, 1, 0, 0, 0, 1 )
	};

	short IndexAllignedQuad[] = { 0, 1, 2, 2, 3, 0 };

	D3DXCreateMeshFVF( 2, 6, D3DXMESH_MANAGED, VERTEX3::FVF, g_pEngine->core->lpd3dd9, &m_meshAllignedQuad );

	VERTEX3 *pVD;
	m_meshAllignedQuad->LockVertexBuffer( NULL, reinterpret_cast< void** >( &pVD ) );
	memcpy( pVD, VertexAllignedQuad, sizeof( VertexAllignedQuad ) );
	m_meshAllignedQuad->UnlockVertexBuffer();

	short *pID;
	m_meshAllignedQuad->LockIndexBuffer( NULL, reinterpret_cast< void** >( &pID ) );
	memcpy( pID, IndexAllignedQuad, sizeof( IndexAllignedQuad ) );
	m_meshAllignedQuad->UnlockIndexBuffer();

	DWORD *pAB;
	m_meshAllignedQuad->LockAttributeBuffer( NULL, static_cast< DWORD** >( &pAB ) );
	memset( pAB, 0, 2 );
	m_meshAllignedQuad->UnlockAttributeBuffer();
#pragma endregion

	m_allignedQuadEffect = new AllignedQuadEffect();
	m_allignedQuadEffect->Init();
}
Ejemplo n.º 10
0
bool XFileUtils::LoadMesh(
	ID3DXFileData*		pFileData, 
	IDirect3DDevice9*	pDevice, 
	ID3DXMesh**			pNewMesh, 
	ID3DXBuffer**		pMaterial,
	DWORD*				pNumAttribute,
	GSkinInfo**			pNewSkininfo)
{
	//检查类型
	_XCheckType(pFileData, "Mesh", false);
	DWORD nVertices = 0;
	DWORD nFaces = 0;
	_XCheckExcute(ParseBasemesh(pFileData, &nVertices, &nFaces, 
		nullptr, nullptr, sizeof(XVertex_p3_n3_t1)));
	ID3DXMesh* pMesh = nullptr;
	if (FAILED(D3DXCreateMeshFVF(nFaces, nVertices, 
		D3DXMESH_32BIT | D3DXMESH_MANAGED, XVertex_p3_n3_t1::fvf, pDevice, &pMesh)))
		return false;
	void* pVertices = nullptr;
	DWORD* pIndices = nullptr;
	DWORD* pAttribtues = nullptr;
	pMesh->LockVertexBuffer(0, &pVertices);
	pMesh->LockIndexBuffer(0, (void**)&pIndices);
	pMesh->LockAttributeBuffer(0, &pAttribtues);
	_XCheckExcute(ParseBasemesh(pFileData, &nVertices, &nFaces, 
		pVertices, pIndices, sizeof(XVertex_p3_n3_t1)));

	_XCheckExcute(ParseNormals(pFileData, nVertices, pVertices, pIndices,
		sizeof(XVertex_p3_n3_t1), sizeof(D3DXVECTOR3)));

	_XCheckExcute(ParseTexcoord(pFileData, pVertices,
		sizeof(XVertex_p3_n3_t1), sizeof(D3DXVECTOR3) * 2));

	_XCheckExcute(ParseMaterial(pFileData, pAttribtues, nFaces, pNumAttribute, pMaterial));

	pMesh->UnlockAttributeBuffer();
	pMesh->UnlockIndexBuffer();
	pMesh->UnlockVertexBuffer();

	*pNewMesh = pMesh;
	
	ParseSkinInfo(pFileData, pNewSkininfo);
	return true;
}
Ejemplo n.º 11
0
																																					//
// Creates a DirectX mesh
void DirectX::Mesh::create( void* vertexBuffer, void* indexBuffer, unsigned long FVF, unsigned int nVertices, unsigned int nFaces, unsigned long options )
{
	// Calculate vertex stride
	int vertexStride =
		((FVF|D3DFVF_XYZ)      == FVF) * 12 +
		((FVF|D3DFVF_XYZRHW)   == FVF) * 12 +
		((FVF|D3DFVF_XYZB1)    == FVF) * 12 +
		((FVF|D3DFVF_XYZB2)    == FVF) * 12 +
		((FVF|D3DFVF_XYZB3)    == FVF) * 12 +
		((FVF|D3DFVF_XYZB4)    == FVF) * 12 +
		((FVF|D3DFVF_XYZB5)    == FVF) * 12 +
		((FVF|D3DFVF_XYZW)     == FVF) * 12 +
		((FVF|D3DFVF_NORMAL)   == FVF) * 12 +
		((FVF|D3DFVF_DIFFUSE)  == FVF) * 4  +
		((FVF|D3DFVF_SPECULAR) == FVF) * 4  +
		((FVF|D3DFVF_TEX1)     == FVF) * 8  +
		((FVF|D3DFVF_TEX2)     == FVF) * 8  +
		((FVF|D3DFVF_TEX3)     == FVF) * 8  +
		((FVF|D3DFVF_TEX4)     == FVF) * 8  +
		((FVF|D3DFVF_TEX5)     == FVF) * 8  +
		((FVF|D3DFVF_TEX6)     == FVF) * 8  +
		((FVF|D3DFVF_TEX7)     == FVF) * 8  +
		((FVF|D3DFVF_TEX8)     == FVF) * 8;

	// Create mesh  of sufficient size to store vertex/index buffer data
	HRESULT hr = D3DXCreateMeshFVF( nFaces, nVertices, options, FVF, DirectX::Manager::instance( )->getD3DDev( ), &m_mesh );
	if( hr ) MessageBox( NULL, L"Call to D3DXCreateMeshFVF has failed.", L"DirectX Engine", NULL );
	LPDIRECT3DVERTEXBUFFER9 vb; LPDIRECT3DINDEXBUFFER9 ib; m_mesh->GetVertexBuffer( &vb ); m_mesh->GetIndexBuffer( &ib );
	
	// Lock the ibuffer and load the indices
	char* pVertices; vb->Lock( NULL, NULL, (void**)&pVertices, D3DLOCK_DISCARD );
	memcpy( pVertices, vertexBuffer, nVertices*vertexStride ); vb->Unlock( );

	// Lock the vbuffer and load the vertices
	char* pIndices; ib->Lock( NULL, NULL, (void**)&pIndices, D3DLOCK_DISCARD );
	memcpy( pIndices, indexBuffer, nFaces*3*sizeof(short) ); ib->Unlock( );

	// Register with the manager
	if( !(options&D3DXMESH_SYSTEMMEM) ) 
		DirectX::Manager::instance( )->addResource( this );
}
Ejemplo n.º 12
0
HRESULT AiPathReader::CreateMesh(LPDIRECT3DDEVICE9 pD3DDevice, LPD3DXMESH &pMesh) {
    //Todo: ID3DXMesh::SetAttributeTable  (set materials how they are defined in the face struct)
    DWORD dwFVF = (D3DFVF_XYZ | D3DFVF_NORMAL);
    struct D3DVERTEX {
        D3DXVECTOR3 p;
        D3DXVECTOR3 n;
    };
    HRESULT r = D3DXCreateMeshFVF(3 * nodes.size(), 3 * nodes.size(), D3DXMESH_MANAGED, dwFVF, pD3DDevice, &pMesh);
    if(FAILED(r)) {
        return r;
    }
    D3DVERTEX *vertexBuffer;
    WORD *indexBuffer = nullptr;
    unsigned long *pAdjacency = new unsigned long[nodes.size() * 3];
    pMesh->LockIndexBuffer(0, reinterpret_cast<void **>(&indexBuffer));
    pMesh->LockVertexBuffer(0, reinterpret_cast<void **>(&vertexBuffer));
    for(int i = 0; i < nodes.size(); i++) {
        auto face = nodes[i];
        for(int j = 0; j < 3; j++) {
            D3DVERTEX &vert = vertexBuffer[3 * i + j];
            vert.p.x = face.triangle[j].x;
            vert.p.y = face.triangle[j].y;
            vert.p.z = face.triangle[j].z;
            indexBuffer[3 * i + j] = 3 * i + j;
            pAdjacency[3 * i + j] = (face.adjacency[j] == 0xffff) ? 0xffffffffUL : face.adjacency[j];
        }
    }
    //D3DXWeldVertices(pMesh, D3DXWELDEPSILONS_WELDALL, nullptr, pAdjacency, nullptr, nullptr, nullptr);
    //pMesh->OptimizeInplace(D3DXMESHOPT_COMPACT | D3DXMESHOPT_IGNOREVERTS | D3DXMESHOPT_STRIPREORDER, newAdjacency, pAdjacency, nullptr, nullptr);
    delete[] pAdjacency;
    HRESULT hr = D3DXComputeNormals(pMesh, nullptr);
    D3DXMATERIAL *m_pMaterials = nullptr;
    DWORD         m_dwNumMaterials = 0;
    hr = D3DXSaveMeshToX("NavMesh.x", pMesh, nullptr, m_pMaterials, nullptr, m_dwNumMaterials, D3DXF_FILEFORMAT_BINARY);
    pMesh->UnlockVertexBuffer();
    pMesh->UnlockIndexBuffer();
    return S_OK;
}
Ejemplo n.º 13
0
//-------------------------------------------------
// Name: Create
// Desc:
//-------------------------------------------------
HRESULT cprimitive::Create(int iID, 
						   LPDIRECT3DDEVICE9 pd3dDevice, 
						   float length, 
						   D3DXVECTOR2 angle, 
						   float width, 
						   D3DXVECTOR2 restrAngX, 
						   D3DXVECTOR2 restrAngY,
						   D3DXVECTOR3 ivOffset, 
						   float displace, 
						   float direction, 
						   float coefficient,
						   float mass,
						   BOOL ibTilt,
						   BOOL ibPressure,
						   BOOL ibLaser
						   )
{
	HRESULT hr;
	int i;

	//store
	id = iID;
	vAngle = angle;
	rAngle = angle;
	fLength = length;
	fWidth = width;
	restrictAngleX = restrAngX;
	restrictAngleY = restrAngY;
	fDisplace = displace;
	fDirection = direction;
	fCoefficient = coefficient;
	vOffset = ivOffset;
	fMass = mass;
	bTilt = ibTilt;
	bPressure = ibPressure;
	bLaser = ibLaser;


	// VERTEX BUFFER

	// Initialize three vertices for rendering a triangle
    CUSTOMVERTEX vertices[] =
    {
		{ -width, 0.0f, -width, 0.f, 0.f,},
        { width, 0.0f, -width, 1.f, 0.f,},
        { width, length, -width, 1.f, 1.f,},
		{ -width, length, -width, 0.f, 1.f, },
		{ -width, 0.0f, width, 0.f, 0.f,},
        { width, 0.0f, width, 1.f, 0.f,},
        { width, length, width, 1.f, 1.f,},
		{ -width, length, width, 0.f, 1.f,},
		
    };
	WORD indices[] =
	{
		0,3,2,
		0,2,1,

		4,7,6,
		4,6,5,

		3,7,4,
		3,4,0,

		2,6,5,
		2,5,1,

		0,4,5,
		0,5,1,

		3,6,7,
		3,2,6
	};


	m_numVertices = sizeof(vertices)/sizeof(CUSTOMVERTEX);
	m_numIndices = sizeof(indices)/sizeof(WORD);


	// CREATE MESH
	hr = D3DXCreateMeshFVF( m_numIndices / 3, m_numVertices,
					D3DXMESH_MANAGED, D3DFVF_CUSTOMVERTEX,
					pd3dDevice, &pMesh );
	if(FAILED(hr)) return NULL;

    // Create the vertex buffer	
	CUSTOMVERTEX* pVertices;
	pMesh->LockVertexBuffer(D3DLOCK_DISCARD, (void**)&pVertices);

    memcpy( pVertices, vertices, sizeof(vertices) );

	pMesh->UnlockVertexBuffer();


	// INDEX BUFFER
	WORD* pBI;
	pMesh->LockIndexBuffer(D3DLOCK_DISCARD,(void**)&pBI);

    memcpy( pBI, indices, m_numIndices*sizeof(WORD) );
    
	for(i=0;i<m_numIndices;i++)
	{
		HTMLLog("index %d ", (int)pBI[i]);
	}

	pMesh->UnlockIndexBuffer();
	

	// TEXTURE
	if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, L"./data/tex000.jpg", &tex ) ) )
        return E_FAIL;

	return S_OK;
}
Ejemplo n.º 14
0
	void CreateBox( const float &w, const float &h, const float &d, const bool &centerWidth, const bool &centerHeight, const bool &centerDepth, LPD3DXMESH &mesh )
	{
		float offsetX = 0, offsetY = 0, offsetZ = 0;
		if( centerWidth )
			offsetX = -w / 2.f;
		if( centerHeight )
			offsetY = -h / 2.f;
		if( centerDepth )
			offsetZ = -d / 2.f;

		std::vector<DWORD> vIB;
		std::vector<VERTEX3> vVB;
		std::vector<DWORD> vAB;
		DWORD offset = 0;

		// fill in the front face index data
		vIB.push_back( 0 + offset );
		vIB.push_back( 1 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 0 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 3 + offset );

		// fill in the front face vertex data
		vVB.push_back( VERTEX3( 0.f + offsetX, 0.f + offsetY, 0.f + offsetZ, 0.f, 0.f, -1.f, 0.f, 1.f ) );
		vVB.push_back( VERTEX3( 0.f + offsetX, h + offsetY, 0.f + offsetZ, 0.f, 0.f, -1.f, 0.f, 0.f ) );
		vVB.push_back( VERTEX3( w + offsetX, h + offsetY, 0.f + offsetZ, 0.f, 0.f, -1.f, 1.f, 0.f ) );
		vVB.push_back( VERTEX3( w + offsetX, 0.f + offsetY, 0.f + offsetZ, 0.f, 0.f, -1.f, 1.f, 1.f ) );

		vAB.push_back( 0 );
		vAB.push_back( 0 );

		offset += 4;

		// fill in the back face index data
		vIB.push_back( 0 + offset );
		vIB.push_back( 1 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 0 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 3 + offset );

		// fill in the back face vertex data
		vVB.push_back( VERTEX3( 0.f + offsetX, 0.f + offsetY, d + offsetZ, 0.f, 0.f, 1.f, 1.f, 1.f ) );
		vVB.push_back( VERTEX3( w + offsetX, 0.f + offsetY, d + offsetZ, 0.f, 0.f, 1.f, 0.f, 1.f ) );
		vVB.push_back( VERTEX3( w + offsetX, h + offsetY, d + offsetZ, 0.f, 0.f, 1.f, 0.f, 0.f ) );
		vVB.push_back( VERTEX3( 0.f + offsetX, h + offsetY, d + offsetZ, 0.f, 0.f, 1.f, 1.f, 0.f ) );

		vAB.push_back( 1 );
		vAB.push_back( 1 );

		offset += 4;

		// fill in the top face index data
		vIB.push_back( 0 + offset );
		vIB.push_back( 1 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 0 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 3 + offset );

		//fill in the top face vertex data
		vVB.push_back( VERTEX3( 0.f + offsetX, h + offsetY, 0.f + offsetZ, 0.f, 1.f, 0.f, 0.f, 1.f ) );
		vVB.push_back( VERTEX3( 0.f + offsetX, h + offsetY, d + offsetZ, 0.f, 1.f, 0.f, 0.f, 0.f ) );
		vVB.push_back( VERTEX3( w + offsetX, h + offsetY, d + offsetZ, 0.f, 1.f, 0.f, 1.f, 0.f ) );
		vVB.push_back( VERTEX3( w + offsetX, h + offsetY, 0.f + offsetZ, 0.f, 1.f, 0.f, 1.f, 1.f ) );

		vAB.push_back( 2 );
		vAB.push_back( 2 );

		offset += 4;

		// fill in the bottom face index data
		vIB.push_back( 0 + offset );
		vIB.push_back( 1 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 0 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 3 + offset );

		// fill in the bottom face vertex data
		vVB.push_back( VERTEX3( 0.f + offsetX, 0.f + offsetY, 0.f + offsetZ, 0.f, -1.f, 0.f, 0.f, 1.f ) );
		vVB.push_back( VERTEX3( w + offsetX, 0.f + offsetY, 0.f + offsetZ, 0.f, -1.f, 0.f, 0.f, 0.f ) );
		vVB.push_back( VERTEX3( w + offsetX, 0.f + offsetY, d + offsetZ, 0.f, -1.f, 0.f, 1.f, 0.f ) );
		vVB.push_back( VERTEX3( 0.f + offsetX, 0.f + offsetY, d + offsetZ, 0.f, -1.f, 0.f, 1.f, 1.f ) );

		vAB.push_back( 3 );
		vAB.push_back( 3 );

		offset += 4;

		// fill in the left face index data
		vIB.push_back( 0 + offset );
		vIB.push_back( 1 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 0 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 3 + offset );

		// fill in the left face vertex data
		vVB.push_back( VERTEX3( 0.f + offsetX, 0.f + offsetY, d + offsetZ, -1.f, 0.f, 0.f, 0.f, 1.f ) );
		vVB.push_back( VERTEX3( 0.f + offsetX, h + offsetY, d + offsetZ, -1.f, 0.f, 0.f, 0.f, 0.f ) );
		vVB.push_back( VERTEX3( 0.f + offsetX, h + offsetY, 0.f + offsetZ, -1.f, 0.f, 0.f, 1.f, 0.f ) );
		vVB.push_back( VERTEX3( 0.f + offsetX, 0.f + offsetY, 0.f + offsetZ, -1.f, 0.f, 0.f, 1.f, 1.f ) );

		vAB.push_back( 4 );
		vAB.push_back( 4 );

		offset += 4;

		// fill in the right face index data
		vIB.push_back( 0 + offset );
		vIB.push_back( 1 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 0 + offset );
		vIB.push_back( 2 + offset );
		vIB.push_back( 3 + offset );

		// fill in the right face vertex data
		vVB.push_back( VERTEX3( w + offsetX, 0.f + offsetY, 0.f + offsetZ, 1.f, 0.f, 0.f, 0.f, 1.f ) );
		vVB.push_back( VERTEX3( w + offsetX, h + offsetY, 0.f + offsetZ, 1.f, 0.f, 0.f, 0.f, 0.f ) );
		vVB.push_back( VERTEX3( w + offsetX, h + offsetY, d + offsetZ, 1.f, 0.f, 0.f, 1.f, 0.f ) );
		vVB.push_back( VERTEX3( w + offsetX, 0.f + offsetY, d + offsetZ, 1.f, 0.f, 0.f, 1.f, 1.f ) );

		vAB.push_back( 5 );
		vAB.push_back( 5 );

		offset += 4;

		D3DXCreateMeshFVF( offset / 2, offset, D3DXMESH_MANAGED | D3DXMESH_32BIT, VERTEX3::FVF, g_pEngine->core->lpd3dd9, &mesh );

		VERTEX3 *pVB = nullptr;
		mesh->LockVertexBuffer( D3DLOCK_DISCARD, reinterpret_cast< void** >( &pVB ) );
		copy( vVB.begin(), vVB.end(), pVB );
		mesh->UnlockVertexBuffer();

		DWORD *pIB = nullptr;
		mesh->LockIndexBuffer( D3DLOCK_DISCARD, reinterpret_cast< void** >( &pIB ) );
		copy( vIB.begin(), vIB.end(), pIB );
		mesh->UnlockIndexBuffer();

		DWORD *pAB = nullptr;
		mesh->LockAttributeBuffer( D3DLOCK_DISCARD, &pAB );
		copy( vAB.begin(), vAB.end(), pAB );
		mesh->UnlockAttributeBuffer();

		std::vector<DWORD> adjacencyBuffer( mesh->GetNumFaces() * 3 );
		mesh->GenerateAdjacency( 0.f, &adjacencyBuffer[ 0 ] );
		mesh->OptimizeInplace( D3DXMESHOPT_COMPACT | D3DXMESHOPT_ATTRSORT | D3DXMESHOPT_VERTEXCACHE, &adjacencyBuffer[ 0 ], nullptr, nullptr, nullptr );
	}
Ejemplo n.º 15
0
HRESULT D3DXMeshCreateDiamond( LPDIRECT3DDEVICE9 pDevice, DWORD dwFVF, DWORD dwOption, UINT uSlice
							, FLOAT fRadius, FLOAT fUpperConeHeight, FLOAT fLowerConeHeight, LPD3DXMESH* pRet )
{
	//创建上下各一棱锥的钻石型
	_ASSERTE(fRadius > 0 && fUpperConeHeight >= 0 && fLowerConeHeight >= 0 && uSlice >= 3);

	HRESULT hr = E_FAIL;
	LPD3DXMESH pMesh = NULL;
	KG_PROCESS_ERROR(NULL != pRet);
	KG_PROCESS_ERROR(fRadius > 0 && fUpperConeHeight >= 0 && fLowerConeHeight >= 0 && uSlice >= 3);

	{
		UINT uNumVertices = uSlice + 2; //2是上下两个点
		UINT uNumFaces = uSlice * 2;

		_ASSERTE(IsMeshValidToBeCreated(dwOption, uNumVertices, uNumFaces * 3));
		
		hr = D3DXCreateMeshFVF(uNumFaces, uNumVertices, dwOption, dwFVF, pDevice, &pMesh);
		KG_COM_CHECK_ERROR(hr);

		//点的分布是先填圆周的一圈,然后填上下两个点
		{
			D3DXMeshVertexEnumer vertexEnumer;
			hr = D3DXMeshCreateVertexEnumer(pMesh, vertexEnumer);
			KG_COM_PROCESS_ERROR(hr);
			_ASSERTE(vertexEnumer.IsValid() && vertexEnumer.GetVertexCount() == uNumVertices);

			float fAnglePerVertex = 2 * D3DX_PI /static_cast<FLOAT>(uSlice);
			float fAngleRotate = D3DX_PI / 4.f;	//把所有顶点旋转45度,这样子好些

			//注意Angle是不可能超过cos和sin的值域的,不用检查了
			for (UINT i = 0; i < vertexEnumer.GetVertexCount() - 2; ++i)
			{
				FLOAT fAngle = fAnglePerVertex * i;
				D3DXVECTOR3 vTemp;
				vTemp.x = fRadius * cosf(fAngle + fAngleRotate);	//单位圆锥,最后再放缩,所以这里用1
				vTemp.y = 0;
				vTemp.z = fRadius * sinf(fAngle + fAngleRotate);
				vertexEnumer.SetPos(i, vTemp);
			}
			_ASSERTE(vertexEnumer.GetVertexCount() > 2);
			//填上上下两个点
			UINT uTopPoint = vertexEnumer.GetVertexCount() - 2;
			vertexEnumer.SetPos(uTopPoint, D3DXVECTOR3(0, fUpperConeHeight, 0));
			UINT uBottomPoint = vertexEnumer.GetVertexCount() - 1;
			vertexEnumer.SetPos(uBottomPoint, D3DXVECTOR3(0, -fLowerConeHeight, 0));
		}

		{
			D3DXMeshIndexEnumer indexEnumer;
			hr = D3DXMeshCreateIndexEnumer(pMesh, indexEnumer);
			KG_COM_PROCESS_ERROR(hr);

			_ASSERTE(indexEnumer.IsValid()&& indexEnumer.GetIndexCount() == 2 * uSlice * 3);

			UINT uVertexCountInCircle = pMesh->GetNumVertices() - 2;
			{
				UINT uUpperFaceCount = uVertexCountInCircle;
				DWORD uTopPointIndex = pMesh->GetNumVertices() - 2;

				for (UINT uIt = 0, uIndexIndex = 0; uIt < uUpperFaceCount; ++uIt, uIndexIndex += 3)
				{
					indexEnumer.SetIndex(uIndexIndex, uIt);
					indexEnumer.SetIndex(uIndexIndex + 1, uTopPointIndex);
					indexEnumer.SetIndex(uIndexIndex + 2, (uIt + 1) % uVertexCountInCircle);
				}
			}

			{
				UINT uBottomFaceCount = uVertexCountInCircle;
				UINT uUpperFaceCount = uVertexCountInCircle;
				DWORD uBottomPointIndex = pMesh->GetNumVertices() - 1;

				for (UINT uIt = 0, uIndexIndex = uUpperFaceCount * 3
					; uIt < uBottomFaceCount; ++uIt, uIndexIndex += 3)
				{
					indexEnumer.SetIndex(uIndexIndex,  uIt);
					indexEnumer.SetIndex(uIndexIndex + 1, (uIt + 1) % uVertexCountInCircle);
					indexEnumer.SetIndex(uIndexIndex + 2, uBottomPointIndex);
				}
			}
		}
		hr = D3DXMeshZeroMeshAttributes(pMesh);
	}

	_ASSERTE(NULL != pRet);
	*pRet = pMesh;
	return S_OK;
Exit0:
	SAFE_RELEASE(pMesh);
	return E_FAIL;
}
Ejemplo n.º 16
0
HRESULT D3DXMeshCreatePlane( LPDIRECT3DDEVICE9 pDevice, DWORD dwFVF, DWORD dwOption, UINT uXSlice, UINT uZSlice
						, FLOAT fXLength, FLOAT fZLength, LPD3DXMESH* pRet )
{
	HRESULT hr = E_FAIL;
	LPD3DXMESH pMesh = NULL;

	KG_PROCESS_ERROR(D3DFVF_XYZ & dwFVF);//不是XYZ型的Mesh无法自动处理
	KG_PROCESS_ERROR(NULL != pRet);
	KG_PROCESS_ERROR(uXSlice < 2048 && uZSlice < 2048 && _T("不能创建太大的Plane"));

	{
		DWORD dwVertexCountInXAxis = (uXSlice + 1);
		DWORD dwVertexCountInZAxis = (uZSlice + 1);
		DWORD dwVertexCount = dwVertexCountInXAxis * dwVertexCountInZAxis; 
		DWORD dwNumFaces = uXSlice * uZSlice;

		_ASSERTE(IsMeshValidToBeCreated(dwOption, dwVertexCount, dwNumFaces * 3));

		hr = D3DXCreateMeshFVF(dwNumFaces, dwVertexCount, dwOption, dwFVF, pDevice, &pMesh);
		KG_COM_PROCESS_ERROR(hr);

		_ASSERTE(sizeof(BYTE) == 1);

		////填点,D3DXMeshVertexEnumer生命域
		{
			D3DXMeshVertexEnumer vertexEnumer;
			hr = D3DXMeshCreateVertexEnumer(pMesh, vertexEnumer);
			KG_COM_PROCESS_ERROR(hr);

			FLOAT XSliceGap = fXLength / static_cast<FLOAT>(uXSlice);
			FLOAT ZSliceGap = fZLength / static_cast<FLOAT>(uZSlice);

			_ASSERTE(vertexEnumer.GetVertexCount() == dwVertexCount);

			for (UINT i = 0; i < dwVertexCountInXAxis; ++i)
			{
				for (UINT j = 0; j < dwVertexCountInZAxis; ++j)
				{
					FLOAT xPos = i * XSliceGap;
					FLOAT zPos = i * ZSliceGap;

					UINT uIndex = i * dwVertexCountInXAxis + j;
					vertexEnumer.SetPos(uIndex, D3DXVECTOR3(xPos, 0, zPos));
				}
			}

			//把坐标填上
			if (D3DFVF_TEX1 & dwFVF)	//这个默认就是UV两个浮点的。如果用了D3DFVF_TEXCOORDn的话,位会变
			{
				D3DXMeshVertexTexCoordEnumer texEnumer;
				hr = D3DXMeshCreateVertexTexCoordEnumer(vertexEnumer, texEnumer);

				FLOAT xUGap = 1.f / static_cast<FLOAT>(uXSlice);
				FLOAT zVGap = 1.f / static_cast<FLOAT>(uZSlice);

				if (SUCCEEDED(hr))
				{
					_ASSERTE(2 == texEnumer.GetTexCoordSize());
					for (UINT i = 0; i < dwVertexCountInXAxis; ++i)
					{
						for (UINT j = 0; j < dwVertexCountInZAxis; ++j)
						{
							UINT uIndex = i * dwVertexCountInXAxis + j;
							texEnumer.GetTexCoord2(uIndex) = D3DXVECTOR2(xUGap * i, zVGap * j);
						}
					}
				}
			}
		}////填点,D3DXMeshVertexEnumer生命域

		//填Index
		{
			D3DXMeshIndexEnumer indexEnumer;
			hr = D3DXMeshCreateIndexEnumer(pMesh, indexEnumer);
			KG_COM_PROCESS_ERROR(hr);
			if (! indexEnumer.Is32Bit())
			{
				KG_PROCESS_ERROR((pMesh->GetNumVertices() < SHRT_MAX) && _T("顶点数超过IndexBuffer的最大数"));
			}
			
			for (UINT i = 0; i < uXSlice; ++i)
			{
				for (UINT j = 0; j < uZSlice; ++j)
				{
					DWORD uLowerLeftVertexIndex = i * (uXSlice + 1) + j;
					DWORD uLowerRightVertexIndex = uLowerLeftVertexIndex + 1;
					DWORD uUpperLeftVertexIndex = uLowerLeftVertexIndex + (uXSlice + 1);
					DWORD uUpperRightVertexIndex = uUpperLeftVertexIndex + 1;

					UINT uRegionIndexBegin = (i * uXSlice + j) * 6;

					indexEnumer.SetIndex(uRegionIndexBegin, uLowerLeftVertexIndex);
					indexEnumer.SetIndex(uRegionIndexBegin + 1, uUpperLeftVertexIndex);
					indexEnumer.SetIndex(uRegionIndexBegin + 2, uLowerRightVertexIndex);
					indexEnumer.SetIndex(uRegionIndexBegin + 3, uLowerLeftVertexIndex);
					indexEnumer.SetIndex(uRegionIndexBegin + 4, uUpperLeftVertexIndex);
					indexEnumer.SetIndex(uRegionIndexBegin + 5, uUpperRightVertexIndex);
					indexEnumer.SetIndex(uRegionIndexBegin + 6, uLowerRightVertexIndex);
				}
			}
		}
		
		//填Attribute
		hr = D3DXMeshZeroMeshAttributes(pMesh);
		
		_ASSERTE(NULL != pRet);
		*pRet = pMesh;
		return S_OK;
	}
Exit0:
	SAFE_RELEASE(pMesh);
	return NULL;
	return E_FAIL;
}
Ejemplo n.º 17
0
HRESULT D3DXMeshCreateByVerticesPos( DWORD dwFVF, D3DVECTOR* pPosArray, DWORD dwVertexCount
									, DWORD* pIndexArray, DWORD dwNumIndexCount
									, LPDIRECT3DDEVICE9 pDevice, DWORD dwOption, LPD3DXMESH* pRet )
{
	HRESULT hr = E_FAIL;
	LPD3DXMESH pMesh = NULL;
	KG_PROCESS_ERROR((dwFVF & D3DFVF_XYZ));
	KG_PROCESS_ERROR(NULL != pPosArray && NULL != pIndexArray && NULL != pDevice && NULL != pRet);

	_ASSERTE(IsMeshValidToBeCreated(dwOption, dwVertexCount, dwNumIndexCount));

	{
		DWORD dwNumFaces = dwNumIndexCount / 3;
		
		hr = D3DXCreateMeshFVF(dwNumFaces, dwVertexCount, dwOption, dwFVF, pDevice, &pMesh);
		KG_COM_PROCESS_ERROR(hr);
		
#if defined(DEBUG) | defined(_DEBUG)
		ULONG uRefSave = KGGetRef(pMesh);
#endif

		{
			BOOL bValidity = pMesh->GetNumVertices() == dwVertexCount && pMesh->GetNumFaces() == dwNumFaces;
			KG_PROCESS_ERROR(bValidity);
		}
		
		_ASSERTE(sizeof(BYTE) == 1);
		{
			D3DXMeshVertexEnumer vertexEnumer;
			hr = D3DXMeshCreateVertexEnumer(pMesh, vertexEnumer);
			KG_COM_PROCESS_ERROR(hr);
			_ASSERTE(vertexEnumer.IsValid() && vertexEnumer.GetVertexCount() == dwVertexCount);
			for (UINT i = 0; i < vertexEnumer.GetVertexCount(); ++i)
			{
				vertexEnumer.SetPos(i, pPosArray[i]);
			}
		}

		{
			D3DXMeshIndexEnumer indexEnumer;
			hr = D3DXMeshCreateIndexEnumer(pMesh, indexEnumer);
			KG_COM_PROCESS_ERROR(hr);
			_ASSERTE(indexEnumer.IsValid() && indexEnumer.GetIndexCount() <= dwNumIndexCount);
			
			for (UINT i = 0; i < indexEnumer.GetIndexCount(); ++i)
			{
				indexEnumer.SetIndex(i, pIndexArray[i]);
			}
		}

		D3DXMeshZeroMeshAttributes(pMesh);

		_ASSERTE(uRefSave == KGGetRef(pMesh));
	}
	
	*pRet = pMesh;
	return S_OK;
Exit0:
	SAFE_RELEASE(pMesh);
	return E_FAIL;
}
Ejemplo n.º 18
0
Mesh* GenerateCylinder(IDirect3DDevice9* device, float radius, float height, UINT sectors)
{
    if (!device)
	{
		return 0;
	}
	const DWORD numVertexes = 2 * (sectors + 1);
	const DWORD numFaces = 2 * sectors;
    
    ID3DXMesh* mesh = 0;

    HRESULT hr = D3DXCreateMeshFVF(numFaces,
                      numVertexes,
                      D3DXMESH_32BIT | D3DXMESH_VB_WRITEONLY | D3DXMESH_IB_WRITEONLY,
                      D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX1,
                      device,
                      &mesh);
    if (FAILED(hr))
    {
        MessageBox(0, L"Unable to generate sphere", L"Application error", MB_ICONSTOP);
        return 0;
    }
    SphereVertex* vertexes = 0;
    DWORD* indexes = 0;

    mesh->LockVertexBuffer(0, (void**)&vertexes);
    mesh->LockIndexBuffer(0, (void**)&indexes);

    const UINT rings = 1;
    //
    for (UINT ring = 0; ring < rings + 1; ring++)
    {
        for (UINT sector = 0; sector < sectors + 1; sector++)
        {
            const float z = sinf(sector * D3DX_PI * 2.f / sectors) * radius;
            const float x = cosf(sector * D3DX_PI * 2.f / sectors) * radius ;
            const float y = height * (1.0f - (ring / rings));

            SphereVertex* vertex = vertexes++;
            vertex->pos = Vec3(x, y, z);
            vertex->normal = Vec3(x, 0, z);
            vertex->tex = Vec2((FLOAT)sector / (sectors - 1), (FLOAT)ring / rings );
        }
    }

    //
    for (UINT ring = 0; ring < rings; ++ring)
    {
        for (UINT sector = 0; sector < sectors; ++sector)
        {
            DWORD v0 = (ring * (sectors + 1) + sector);
            DWORD v1 = (ring * (sectors + 1) + sector + 1);
            DWORD v2 = ((ring + 1) * (sectors + 1) + sector);
            DWORD v3 = ((ring + 1) * (sectors + 1) + sector + 1);

            *indexes++ = v0;
            *indexes++ = v1;
            *indexes++ = v2;

            *indexes++ = v2;
            *indexes++ = v1;
            *indexes++ = v3;
        }
    }

    mesh->UnlockIndexBuffer();
    mesh->UnlockVertexBuffer();
    return mesh;
}
Ejemplo n.º 19
0
HRESULT PATCH::CreateMesh(HEIGHTMAP &hm, RECT source, IDirect3DDevice9* Dev, int index)
{
	if(m_pMesh != NULL)
	{
		m_pMesh->Release();
		m_pMesh = NULL;
	}

	try
	{
		m_pDevice = Dev;

		int width = source.right - source.left;
		int height = source.bottom - source.top;
		int nrVert = (width + 1) * (height + 1);
		int nrTri = width * height * 2;

		if(FAILED(D3DXCreateMeshFVF(nrTri, nrVert, D3DXMESH_MANAGED, TERRAINVertex::FVF, m_pDevice, &m_pMesh)))
		{
			debug.Print("Couldn't create mesh for PATCH");
			return E_FAIL;
		}

		//Create vertices
		TERRAINVertex* ver = 0;
		m_pMesh->LockVertexBuffer(0,(void**)&ver);
		for(int z=source.top, z0 = 0;z<=source.bottom;z++, z0++)
			for(int x=source.left, x0 = 0;x<=source.right;x++, x0++)
			{
				//Calculate vertex color
				float prc = hm.m_pHeightMap[x + z * hm.m_size.x] / hm.m_maxHeight;
				int red =   (int)(255 * prc);
				int green = (int)(255 * (1.0f - prc));

				D3DCOLOR col;

				if(index % 2 == 0)		//Invert color depending on what patch it is...
					col = D3DCOLOR_ARGB(255, red, green, 0);
				else col = D3DCOLOR_ARGB(255, green, red, 0);

				//Extract height (and position) from heightmap
				D3DXVECTOR3 pos = D3DXVECTOR3((float)x, hm.m_pHeightMap[x + z * hm.m_size.x], (float)-z);

				//Set new vertex
				ver[z0 * (width + 1) + x0] = TERRAINVertex(pos, col);
			}
		m_pMesh->UnlockVertexBuffer();

		//Calculate Indices
		WORD* ind = 0;
		m_pMesh->LockIndexBuffer(0,(void**)&ind);	
		int index = 0;

		for(int z=source.top, z0 = 0;z<source.bottom;z++, z0++)
			for(int x=source.left, x0 = 0;x<source.right;x++, x0++)
			{
				//Triangle 1
				ind[index++] =   z0   * (width + 1) + x0;
				ind[index++] =   z0   * (width + 1) + x0 + 1;
				ind[index++] = (z0+1) * (width + 1) + x0;		

				//Triangle 2
				ind[index++] = (z0+1) * (width + 1) + x0;
				ind[index++] =   z0   * (width + 1) + x0 + 1;
				ind[index++] = (z0+1) * (width + 1) + x0 + 1;
			}

		m_pMesh->UnlockIndexBuffer();

		//Set Attributes
		DWORD *att = 0;
		m_pMesh->LockAttributeBuffer(0,&att);
		memset(att, 0, sizeof(DWORD)*nrTri);
		m_pMesh->UnlockAttributeBuffer();

		//Compute normals
		D3DXComputeNormals(m_pMesh, NULL);
	}
	catch(...)
	{
		debug.Print("Error in PATCH::CreateMesh()");
		return E_FAIL;
	}

	return S_OK;
}
Ejemplo n.º 20
0
//
// Framework functions
//
bool Setup()
{
	HRESULT hr = 0;

	//
	// We are going to fill the empty mesh with the geometry of a box,
	// so we need 12 triangles and 24 vetices.
	//

	hr = D3DXCreateMeshFVF(
		12,
		24,
		D3DXMESH_MANAGED,
		Vertex::FVF,
		Device,
		&Mesh);

	if(FAILED(hr))
	{
		::MessageBox(0, "D3DXCreateMeshFVF() - FAILED", 0, 0);
		return false;
	}

	//
	// Fill in vertices of a box
	//
	Vertex* v = 0;
	Mesh->LockVertexBuffer(0, (void**)&v);

	// fill in the front face vertex data
	v[0] = Vertex(-1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
	v[1] = Vertex(-1.0f,  1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
	v[2] = Vertex( 1.0f,  1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 1.0f);
	v[3] = Vertex( 1.0f, -1.0f, -1.0f, 0.0f, 0.0f, -1.0f, 1.0f, 0.0f);

	// fill in the back face vertex data
	v[4] = Vertex(-1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f);
	v[5] = Vertex( 1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 1.0f);
	v[6] = Vertex( 1.0f,  1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f);
	v[7] = Vertex(-1.0f,  1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 0.0f);

	// fill in the top face vertex data
	v[8]  = Vertex(-1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f);
	v[9]  = Vertex(-1.0f, 1.0f,  1.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f);
	v[10] = Vertex( 1.0f, 1.0f,  1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f);
	v[11] = Vertex( 1.0f, 1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);

	// fill in the bottom face vertex data
	v[12] = Vertex(-1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 0.0f);
	v[13] = Vertex( 1.0f, -1.0f, -1.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f);
	v[14] = Vertex( 1.0f, -1.0f,  1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 1.0f);
	v[15] = Vertex(-1.0f, -1.0f,  1.0f, 0.0f, -1.0f, 0.0f, 1.0f, 0.0f);

	// fill in the left face vertex data
	v[16] = Vertex(-1.0f, -1.0f,  1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
	v[17] = Vertex(-1.0f,  1.0f,  1.0f, -1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
	v[18] = Vertex(-1.0f,  1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
	v[19] = Vertex(-1.0f, -1.0f, -1.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f);

	// fill in the right face vertex data
	v[20] = Vertex( 1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f);
	v[21] = Vertex( 1.0f,  1.0f, -1.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f);
	v[22] = Vertex( 1.0f,  1.0f,  1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f);
	v[23] = Vertex( 1.0f, -1.0f,  1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f);

	Mesh->UnlockVertexBuffer();

	//
	// Define the triangles of the box
	//
	WORD* i = 0;
	Mesh->LockIndexBuffer(0, (void**)&i);

	// fill in the front face index data
	i[0] = 0; i[1] = 1; i[2] = 2;
	i[3] = 0; i[4] = 2; i[5] = 3;

	// fill in the back face index data
	i[6] = 4; i[7]  = 5; i[8]  = 6;
	i[9] = 4; i[10] = 6; i[11] = 7;

	// fill in the top face index data
	i[12] = 8; i[13] =  9; i[14] = 10;
	i[15] = 8; i[16] = 10; i[17] = 11;

	// fill in the bottom face index data
	i[18] = 12; i[19] = 13; i[20] = 14;
	i[21] = 12; i[22] = 14; i[23] = 15;

	// fill in the left face index data
	i[24] = 16; i[25] = 17; i[26] = 18;
	i[27] = 16; i[28] = 18; i[29] = 19;

	// fill in the right face index data
	i[30] = 20; i[31] = 21; i[32] = 22;
	i[33] = 20; i[34] = 22; i[35] = 23;

	Mesh->UnlockIndexBuffer();

	//
	// Specify the subset each triangle belongs to, in this example
	// we will use three subsets, the first two faces of the cube specified
	// will be in subset 0, the next two faces will be in subset 1 and
	// the the last two faces will be in subset 2.
	//
	DWORD* attributeBuffer = 0;
	Mesh->LockAttributeBuffer(0, &attributeBuffer);

	for(int a = 0; a < 4; a++)
		attributeBuffer[a] = 0;

	for(int b = 4; b < 8; b++)
		attributeBuffer[b] = 1;

	for(int c = 8; c < 12; c++)
		attributeBuffer[c] = 2;

	Mesh->UnlockAttributeBuffer();

	//
	// Optimize the mesh to generate an attribute table.
	//

	std::vector<DWORD> adjacencyBuffer(Mesh->GetNumFaces() * 3);
	Mesh->GenerateAdjacency(0.0f, &adjacencyBuffer[0]);

	hr = Mesh->OptimizeInplace(		
		D3DXMESHOPT_ATTRSORT |
		D3DXMESHOPT_COMPACT  |
		D3DXMESHOPT_VERTEXCACHE,
		&adjacencyBuffer[0],
		0, 0, 0);

	//
	// Dump the Mesh Data to file.
	//

	OutFile.open("Mesh Dump.txt");

	dumpVertices(OutFile, Mesh);
	dumpIndices(OutFile, Mesh);
	dumpAttributeTable(OutFile, Mesh); 	
	dumpAttributeBuffer(OutFile, Mesh);		
	dumpAdjacencyBuffer(OutFile, Mesh);
	
	OutFile.close();

	//
	// Load the textures and set filters.
	//

	D3DXCreateTextureFromFile(
		Device,
		"brick0.jpg",
		&Textures[0]);

	D3DXCreateTextureFromFile(
		Device,
		"brick1.jpg",
		&Textures[1]);

	D3DXCreateTextureFromFile(
		Device,
		"checker.jpg",
		&Textures[2]);

	Device->SetSamplerState(0, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
	Device->SetSamplerState(0, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
	Device->SetSamplerState(0, D3DSAMP_MIPFILTER, D3DTEXF_POINT);

	// 
	// Disable lighting.
	//

	Device->SetRenderState(D3DRS_LIGHTING, false);

	//
	// Set camera.
	//

	D3DXVECTOR3 pos(0.0f, 0.f, -4.0f);
	D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
	D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);

	D3DXMATRIX V;
	D3DXMatrixLookAtLH(
		&V,
		&pos,
		&target,
		&up);

	Device->SetTransform(D3DTS_VIEW, &V);

	//
	// Set projection matrix.
	//

	D3DXMATRIX proj;
	D3DXMatrixPerspectiveFovLH(
			&proj,
			D3DX_PI * 0.5f, // 90 - degree
			(float)Width / (float)Height,
			1.0f,
			1000.0f);
	Device->SetTransform(D3DTS_PROJECTION, &proj);

	return true;
}
Ejemplo n.º 21
0
void GWater::recreateGraphInfo()
{
	HRESULT hr = S_FALSE;

	SeaVertex *pVertextBuffer = NULL;	  //Mesh的顶点缓冲区

	DWORD *pIndexBuffer = NULL;	  //Mesh的索引缓冲区
	ID3DXMesh* mesh = 0;
	hr = D3DXCreateMeshFVF (
		mCellCount * mCellCount * 2,
		( mCellCount + 1 ) * ( mCellCount + 1 ),
		D3DXMESH_32BIT | D3DXMESH_MANAGED, FVFSea,  Content::Device.getD9Device(),
		&mesh
		);

	dDebugMsgBox ( hr, "创建海面Mesh失败!" );

	DWORD dwIndex = 0;

	mesh->LockVertexBuffer ( D3DLOCK_DISCARD, ( void** ) &pVertextBuffer );

	for ( int i = 0; i < mCellCount + 1; i++ )
	{
		for ( int j = 0; j < mCellCount + 1; j++ )
		{
			dwIndex = i * ( mCellCount + 1 ) + j;

			pVertextBuffer[dwIndex].vertex.x = ( j - mCellCount / 2.0f ) * mCellWidth;
			pVertextBuffer[dwIndex].vertex.y = 0;
			pVertextBuffer[dwIndex].vertex.z = ( i - mCellCount / 2.0f ) * mCellWidth;
			pVertextBuffer[dwIndex].u = j / 10.0f;
			pVertextBuffer[dwIndex].v = ( mCellCount - i ) / 10.0f;
		}
	}

	mesh->UnlockVertexBuffer();

	mesh->LockIndexBuffer ( D3DLOCK_DISCARD, ( void** ) &pIndexBuffer );

	DWORD dwBaseIndex = 0;

	for ( int i = 0; i < mCellCount; i++ )
	{
		for ( int j = 0; j < mCellCount; j++ )
		{
			pIndexBuffer[dwBaseIndex + 0] = i * ( mCellCount + 1 ) + j;
			pIndexBuffer[dwBaseIndex + 1] = ( i + 1 ) * ( mCellCount + 1 ) + j;
			pIndexBuffer[dwBaseIndex + 2] = ( i + 1 ) * ( mCellCount + 1 ) + j + 1;

			pIndexBuffer[dwBaseIndex + 3] = i * ( mCellCount + 1 ) + j;
			pIndexBuffer[dwBaseIndex + 4] = ( i + 1 ) * ( mCellCount + 1 ) + j + 1;;
			pIndexBuffer[dwBaseIndex + 5] = i * ( mCellCount + 1 ) + j + 1;

			dwBaseIndex += 6;
		}
	}

	mesh->UnlockIndexBuffer();

	mMeshBufferNode->setMesh ( mesh );
	mMeshBufferNode->setSubCount ( 1 );

	DWORD *pAdj = new DWORD[mesh->GetNumFaces() * 3];

	mesh->GenerateAdjacency ( 1.0f, pAdj );

	delete []pAdj ;
}
Ejemplo n.º 22
0
	bool GraphicalPlane::GenerateBoard(const std::string& path, const int &width, const int &height, const TextureSP &texture)
	{
		// キーネーム設定
		std::stringstream nameBuffer("");
		// ファイルパス→生成番号→幅高さの順で追加
		nameBuffer << path << ++_createCount << width << height;
		std::string name = nameBuffer.str();
		// メッシュインスタンスの生成
		_mesh = Mesh::CreateEmpty(name);
		// サイズを記録
		_size.x = (float)width ;
		_size.y = (float)height ;
		//_size.z = 0 ;
		// テクスチャ指定がある場合そのサイズを取得
		if(texture != NULL)
		{
			while(UINT(_textureSize.x) < _texture->GetImageInfo().Width)
			{
				_textureSize.x *= 2;
			}
			while(UINT(_textureSize.y) < _texture->GetImageInfo().Height)
			{
				_textureSize.y *= 2;
			}
		}
		// シェーダー設定
		_shader = ShaderNormal::Create();
		// メッシュを生成する
		LPD3DXMESH mesh;
		if (FAILED(D3DXCreateMeshFVF(2, 4, D3DXMESH_MANAGED, Vertex::FVF, GraphicsManager::_device, &mesh)))
			return false;

		//頂点データの作成
		Vertex* vertex;
		mesh->LockVertexBuffer(0, (void**)&vertex);
		for (int y = 0 ; y < 2 ; y++) {
			for (int x = 0 ; x < 2 ; x++) {
				float x1 = (float)(x * width - ((float)width / 2));
				float y1 = (float)(y * height - ((float)height / 2));
				int index = y * 2 + x;
				vertex[index]._position.x = x1;
				vertex[index]._position.y = y1;
				vertex[index]._position.z = 0;
				vertex[index]._normal.x = 0;
				vertex[index]._normal.y = 0;
				vertex[index]._normal.z = 1;
				if( texture == NULL )
				{
					vertex[index]._uv.x = (float)x * 1.0f;
					vertex[index]._uv.y = 1.0f - ((float)y * 1.0f);
				}
			}
		}
		if(texture)
		{
			vertex[0]._uv.x = (float)_rects[_number].left / _texture->GetImageInfo().Width;
			vertex[0]._uv.y = (float)_rects[_number].bottom / _texture->GetImageInfo().Height;
			vertex[1]._uv.x = (float)_rects[_number].right / _texture->GetImageInfo().Width;
			vertex[1]._uv.y = (float)_rects[_number].bottom / _texture->GetImageInfo().Height;
			vertex[2]._uv.x = (float)_rects[_number].left / _texture->GetImageInfo().Width;
			vertex[2]._uv.y = (float)_rects[_number].top / _texture->GetImageInfo().Height;
			vertex[3]._uv.x = (float)_rects[_number].right / _texture->GetImageInfo().Width;
			vertex[3]._uv.y = (float)_rects[_number].top / _texture->GetImageInfo().Height;
		}
		mesh->UnlockVertexBuffer();
		//インデックスデータの作成
		WORD *index;
		mesh->LockIndexBuffer(0, (void **)&index);
		index[0] = 0;
		index[1] = 2;
		index[2] = 1;
		index[3] = 1;
		index[4] = 2;
		index[5] = 3;
		mesh->UnlockIndexBuffer();
	    _mesh->SetMesh(mesh);

		return true;
	}
Ejemplo n.º 23
0
void ObjParser::Load(LPCSTR Filename, LPDIRECT3DDEVICE9 pDevice)
{
		FILE* fileHandle = fopen(Filename, "r+");
		if( fileHandle == NULL )
			return;

		char line[256];
		D3DXVECTOR3 vec;

		while( !feof(fileHandle) )//Foreach Line
		{
			fgets(line, 256, fileHandle);

			#pragma region Line Read
			switch(line[0])
			{
			case 'm':
				{
				LPCSTR name = new CHAR[256];
				sscanf_s(line, "mtllib %s", name, 255);

				ParseMaterial(name);
				}
				break;
			case 'v'://Vertex Item
				{
				switch(line[1])
					{
					case ' '://Vertex
						{
						sscanf_s(line, "v %f %f %f", &vec.x, &vec.y, &vec.z );

						Vertexs.push_back(vec);
						mVertexsHT.push_back(NULL);//expand HashTable
						}
						break;
					case 't'://Texture Coordinates
						{
						D3DXVECTOR3 tex;
						sscanf_s(line, "vt %f %f %f", &vec.x, &vec.y, &vec.z);

						Textures.push_back(vec);
						}
						break;
					case 'n'://Normal
						{
						D3DXVECTOR3 nor;
						sscanf_s(line, "vn %f %f %f", &vec.x, &vec.y, &vec.z );

						Normals.push_back(vec);
						}
						break;
					default:// Not supposed to happen
						assert( false );
					}

				}
				break;
			case 'f'://Face Item
				{
				DWORD quadP[4];//Position Index quad
				DWORD quadT[4];//Texture  Index quad
				DWORD quadN[4];//Normal   Index quad
				memset(quadP, -1, sizeof(DWORD)*4);
				memset(quadT, -1, sizeof(DWORD)*4);
				memset(quadN, -1, sizeof(DWORD)*4);

				int size = strlen(line);
				int barCount = std::count(line, line+size, '/');

				int readed = 0;

				//By default .obj file puts faces with CW winding
				switch( barCount )
					{
					case 0:// tri/quad	pos
						{
							if( m_Winding == VertexWinding::CCW )
								readed = sscanf_s(line, "f %d %d %d %d", &quadP[3], &quadP[2], &quadP[1], &quadP[0] );
							else
								readed = sscanf_s(line, "f %d %d %d %d", &quadP[0], &quadP[1], &quadP[2], &quadP[3] );
							assert( readed == 3 || readed == 4 );
						}
						break;
					case 3:// tri	pos/tex
						{
							if( m_Winding == VertexWinding::CCW )
								readed = sscanf_s(line, "f %d/%d %d/%d %d/%d", 
								&quadP[2], &quadT[2],
								&quadP[1], &quadT[1],
								&quadP[0], &quadT[0]
								);
							else
								readed = sscanf_s(line, "f %d/%d %d/%d %d/%d", 
								&quadP[0], quadT[0],
								&quadP[1], quadT[1],
								&quadP[2], quadT[2]
								);
							assert( readed == 6 );
							readed /= 2;
						}
						break;
					case 4:// quad	pos/tex
						{
							if( m_Winding == VertexWinding::CCW )
								readed = sscanf_s(line, "f %d/%d %d/%d %d/%d %d/%d", 
								&quadP[3], &quadT[3],
								&quadP[2], &quadT[2], 
								&quadP[1], &quadT[1],
								&quadP[0], &quadT[0] 
								);
							else
								readed = sscanf_s(line, "f %d/%d %d/%d %d/%d %d/%d", 
								&quadP[0], &quadT[0],
								&quadP[1], &quadT[1],
								&quadP[2], &quadT[2],
								&quadP[3], &quadT[3]
								);
							assert( readed == 8 );
							readed /= 2;
						}
						break;
					case 6:// tri	pos/tex/nor
						{
							if( m_Winding == VertexWinding::CCW )
								readed = sscanf_s(line, "f %d/%d/%d %d/%d/%d %d/%d/%d", 
								&quadP[2], &quadT[2], &quadN[2],
								&quadP[1], &quadT[1], &quadN[1],
								&quadP[0], &quadT[0], &quadN[0]
								);
							else
								readed = sscanf_s(line, "f %d/%d/%d %d/%d/%d %d/%d/%d", 
								&quadP[0], &quadT[0], &quadN[0],
								&quadP[1], &quadT[1], &quadN[1],
								&quadP[2], &quadT[2], &quadN[2]
								);
							assert( readed == 9 );
							readed /= 3;
						}
						break;
					case 8:// quad	pos/tex/nor
						{
							if( m_Winding == VertexWinding::CCW )
								readed = sscanf_s(line, "f %d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d", 
								&quadP[3], &quadT[3], &quadN[3],
								&quadP[2], &quadT[2], &quadN[2],
								&quadP[1], &quadT[1], &quadN[1],
								&quadP[0], &quadT[0], &quadN[0]
								);
							else
								readed = sscanf_s(line, "f %d/%d/%d %d/%d/%d %d/%d/%d %d/%d/%d", 
								&quadP[0], &quadT[0], &quadN[0],
								&quadP[1], &quadT[1], &quadN[1],
								&quadP[2], &quadT[2], &quadN[2],
								&quadP[3], &quadT[3], &quadN[3]
								);
							assert( readed == 12 );
							readed /= 3;
						}
						break;
					default:// Not supposed to happen
						assert( false );
					}

				//The indexs are in 1 Base, we transform to 0 Base
				for( int i=0; i < 4 ; ++i )
				{
					quadP[i]--; quadT[i]--; quadN[i]--;
				}

				for(int j=0; j < 3 ; ++j)
					{
						VertexTextureNormal NewVertex;
						NewVertex.SetPosition( Vertexs[quadP[j]] );
						if( quadT[j] != (DWORD(-1)-1) )
							NewVertex.SetTexture ( Textures[quadT[j]].x, Textures[quadT[j]].y );
						if( quadN[j] != (DWORD(-1)-1) )
							NewVertex.SetNormal  ( Normals[quadN[j]] );
						
						DWORD index = AddVertex(quadP[j], NewVertex);
						mIndexs.push_back(index);
					}
 
				if( readed == 4 )// quad readed
					{
						quadP[1] = quadP[2]; quadT[1] = quadT[2]; quadN[1] = quadN[2]; 
						quadP[2] = quadP[3]; quadT[2] = quadT[3]; quadN[1] = quadN[2]; 
												
						for(int j=0; j < 3 ; ++j)
							{
							VertexTextureNormal NewVertex;
							NewVertex.SetPosition( Vertexs[quadP[j]] );
							if( quadT[j] != (DWORD(-1)-1) )
								NewVertex.SetTexture ( Textures[quadT[j]].x, Textures[quadT[j]].y );
							if( quadN[j] != (DWORD(-1)-1) )
								NewVertex.SetNormal  ( Normals[quadN[j]] );
						
							DWORD index = AddVertex(quadP[j], NewVertex);
							mIndexs.push_back(index);
							}
					}

				}
				break;

			}
			#pragma endregion

		}
			
		fclose(fileHandle);
		
		DWORD FVF = NULL;
		D3DVERTEXELEMENT9* pMeshVDeclaration = NULL;
		int code = 0;
		IdentifieLoadedFormat(FVF, pMeshVDeclaration, code);
		if( code == 0 )
			return;
		
		//Setup Mesh with VertexDeclaration corresponding to the loaded data
		LPD3DXMESH pMesh = NULL;
		HRESULT hr = NULL;
		
		int FacesCount = mIndexs.size()/3;
		switch( m_VertexMetaFormat )
		{
		case VertexMetaFormat::VertexDeclaration:
			{
				if( FacesCount > 65535 )// if huge mesh, 32 bits face index
					hr = D3DXCreateMesh(FacesCount, mVertexs.size(), D3DXMESH_32BIT | D3DXMESH_VB_SYSTEMMEM | D3DXMESH_IB_SYSTEMMEM | D3DXMESH_SYSTEMMEM , 
						pMeshVDeclaration, pDevice, &pMesh);
				else
					hr = D3DXCreateMesh(FacesCount, mVertexs.size(), D3DXMESH_VB_SYSTEMMEM | D3DXMESH_IB_SYSTEMMEM | D3DXMESH_SYSTEMMEM , 
						pMeshVDeclaration, pDevice, &pMesh);
			}
			break;
		case VertexMetaFormat::FVF:
			{
				if( FacesCount > 65535 )// if huge mesh, 32 bits face index
					hr = D3DXCreateMeshFVF(FacesCount, Vertexs.size(), D3DXMESH_32BIT | D3DXMESH_VB_SYSTEMMEM | D3DXMESH_IB_SYSTEMMEM | D3DXMESH_SYSTEMMEM ,
						FVF, pDevice, &pMesh);
				else
					hr = D3DXCreateMeshFVF(FacesCount, Vertexs.size(), D3DXMESH_VB_SYSTEMMEM | D3DXMESH_IB_SYSTEMMEM | D3DXMESH_SYSTEMMEM ,
						FVF, pDevice, &pMesh);
			}
			break;
		default:
			assert( false );
		}

		assert( !FAILED(hr) );
		
		//Puts vertex data inside loadedData in the smallest format needed
		//(not nesesarily VertexTextureNormal)
		void* loadedData = NULL;
		void* loadedIndex = NULL;
		size_t size = 0;
		//Pass to our vertex format
		PutLoadedDataInVertexDeclarationFormat(loadedData,loadedIndex,size,code, FacesCount);

		//Free Auxiliary Arrays
		Vertexs.clear();
		Textures.clear();
		Normals.clear();
		mVertexsHT.clear();
		
		void* data = NULL;
		//Loads the Vertex Buffer
		if( FAILED(pMesh->LockVertexBuffer(NULL, &data)) )
			return;

			memcpy(data, loadedData, size*mVertexs.size());

		pMesh->UnlockVertexBuffer();

		//Loads the Index Buffer
		if( FAILED(pMesh->LockIndexBuffer(NULL, &data)) )
			return;

			if( FacesCount > 65535 )
				memcpy(data, loadedIndex, sizeof(DWORD)*mIndexs.size());
			else
				memcpy(data, loadedIndex, sizeof(WORD)*mIndexs.size());

		pMesh->UnlockIndexBuffer();

		//Free main Arrays
		mVertexs.clear();
		mIndexs.clear();

		//Mesh data ready
		m_RootMeshContainer = new D3DXMESHCONTAINER;
		m_RootMeshContainer->MeshData.pMesh = pMesh;

		return;
	}
Ejemplo n.º 24
0
//------------------------------------------------------
//	IMO読み込み
//------------------------------------------------------
BOOL iexMesh::LoadIMO( LPSTR filename )
{
	IMOOBJ		imo;
	DWORD		i;
	//	ファイル読み込み
	HANDLE	hfile;
	DWORD	dum;

	int		version = 1;

	hfile = CreateFile( filename, GENERIC_READ, FILE_SHARE_READ, (LPSECURITY_ATTRIBUTES)NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, (HANDLE) NULL );
	if( hfile == INVALID_HANDLE_VALUE ) return FALSE;

	ReadFile( hfile, &imo, sizeof(IMOOBJ), &dum, NULL );
	if( imo.id == '2OMI' ) version = 2;

	//	メッシュ作成
	BYTE	*pVertex, *pFace;
	DWORD	*pData;

	LVERTEX*	workV = new LVERTEX[imo.NumVertex];
	MESHVERTEX2*	workV2 = new MESHVERTEX2[imo.NumVertex];
	WORD*		workF = new WORD[imo.NumFace*3];

	if( version == 1 )
	{
		//	頂点読み込み
		ReadFile( hfile, workV, sizeof(LVERTEX)*imo.NumVertex, &dum, NULL );
		//	インデックス読み込み
		ReadFile( hfile, workF, sizeof(WORD)*imo.NumFace*3, &dum, NULL );
		
		for (DWORD i = 0; i < imo.NumVertex; i++)
		{
			workV2[i].x = workV[i].x;
			workV2[i].y = workV[i].y;
			workV2[i].z = workV[i].z;
			workV2[i].tu = workV[i].tu;
			workV2[i].tv = workV[i].tv;
			workV2[i].color = workV[i].color;
			workV2[i].nx = .0f;
			workV2[i].ny = .0f;
			workV2[i].nz = .0f;
		}

		for (DWORD i = 0; i < imo.NumFace; i++)
		{
			//	法線計算
			Vector3 v1, v2, n;
			v1.x = workV[workF[i * 3 + 0]].x - workV[workF[i * 3 + 1]].x;
			v1.y = workV[workF[i * 3 + 0]].y - workV[workF[i * 3 + 1]].y;
			v1.z = workV[workF[i * 3 + 0]].z - workV[workF[i * 3 + 1]].z;
			
			v2.x = workV[workF[i * 3 + 1]].x - workV[workF[i * 3 + 2]].x;
			v2.y = workV[workF[i * 3 + 1]].y - workV[workF[i * 3 + 2]].y;
			v2.z = workV[workF[i * 3 + 1]].z - workV[workF[i * 3 + 2]].z;

			n.x = (v1.y*v2.z - v1.z*v2.y);
			n.y = (v1.z*v2.x - v1.x*v2.z);
			n.z = (v1.x*v2.y - v1.y*v2.x);
			float d = sqrtf( n.x*n.x + n.y*n.y + n.z*n.z );
			n.x /= d;
			n.y /= d;
			n.z /= d;

			workV2[workF[i * 3 + 0]].nx += n.x;
			workV2[workF[i * 3 + 0]].ny += n.y;
			workV2[workF[i * 3 + 0]].nz += n.z;
			workV2[workF[i * 3 + 1]].nx += n.x;
			workV2[workF[i * 3 + 1]].ny += n.y;
			workV2[workF[i * 3 + 1]].nz += n.z;
			workV2[workF[i * 3 + 2]].nx += n.x;
			workV2[workF[i * 3 + 2]].ny += n.y;
			workV2[workF[i * 3 + 2]].nz += n.z;
		}
		for (DWORD i = 0; i < imo.NumVertex; i++)
		{
			float d = sqrtf( workV2[i].nx*workV2[i].nx + workV2[i].ny*workV2[i].ny + workV2[i].nz*workV2[i].nz );
			workV2[i].nx /= d;
			workV2[i].ny /= d;
			workV2[i].nz /= d;
		}
	} else {
		//	頂点読み込み
		ReadFile( hfile, workV2, sizeof(MESHVERTEX2)*imo.NumVertex, &dum, NULL );
		//	インデックス読み込み
		ReadFile( hfile, workF, sizeof(WORD)*imo.NumFace*3, &dum, NULL );
	}

	DWORD	Declaration = D3DFVF_MESHVERTEX2;
	D3DXCreateMeshFVF( imo.NumFace, imo.NumVertex, D3DXMESH_MANAGED, Declaration, tdnSystem::GetDevice(), &lpMesh );
	//	頂点設定
	lpMesh->LockVertexBuffer( 0, (void**)&pVertex );
	memcpy( pVertex, workV2, sizeof(MESHVERTEX2)*imo.NumVertex );
	lpMesh->UnlockVertexBuffer();

	//	面設定
	lpMesh->LockIndexBuffer( 0, (void**)&pFace );
	memcpy( pFace, workF, sizeof(WORD)*imo.NumFace*3 );
	lpMesh->UnlockIndexBuffer();

	//	属性設定
	lpMesh->LockAttributeBuffer( 0, &pData );
	ReadFile( hfile, pData, sizeof(DWORD)*imo.NumFace, &dum, NULL );
	lpMesh->UnlockAttributeBuffer();

	//	パス分割
	char	workpath[MAX_PATH];
	CopyMemory( workpath, filename, lstrlen(filename)+1 );
	for( i=lstrlen(filename) ; i>0 ; i-- ){
		if( IsDBCSLeadByte(workpath[i-2]) ){
			i--;
			continue;
		}
		if( workpath[i-1] == '\\' || workpath[i-1] == '/' ){
			workpath[i] = '\0';
			break;
		}
	}

	//	マテリアル設定
	MaterialCount = imo.NumMaterial;
	lpMaterial = new D3DMATERIAL9[ MaterialCount ];
	CopyMemory( lpMaterial, imo.Material, sizeof(D3DMATERIAL9)*imo.NumMaterial );
	//	テクスチャ設定
	lpTexture  = new Texture2D* [ imo.NumMaterial ];
	lpNormal   = new Texture2D* [ imo.NumMaterial ];
	lpSpecular = new Texture2D* [ imo.NumMaterial ];
	lpHeight   = new Texture2D* [ imo.NumMaterial ];

	char temp[256];
	for( i=0 ; i<MaterialCount ; i++ ){
		lpTexture[i]  = NULL;
		lpNormal[i]   = NULL;
		lpSpecular[i] = NULL;
		lpHeight[i]   = NULL;

		if( imo.Texture[i][0] == '\0' ) continue;
		//	テクスチャ読み込み
		sprintf( temp, "%s%s", workpath, imo.Texture[i] );
		lpTexture[i] = tdnTexture::Load( temp );

		sprintf( temp, "%sN%s", workpath, imo.Texture[i] );
		lpNormal[i] = tdnTexture::Load( temp );

		sprintf( temp, "%sS%s", workpath, imo.Texture[i] );
		lpSpecular[i] = tdnTexture::Load( temp );

		sprintf( temp, "%sH%s", workpath, imo.Texture[i] );
		lpHeight[i] = tdnTexture::Load( temp, 1 );
	}
	CloseHandle(hfile);

	delete[] workV;
	delete[] workV2;
	delete[] workF;

	//	初期設定
	SetPos(0,0,0);
	SetAngle(0.0f);
	SetScale(1.0f);
	dwFlags = 0;

	bLoad = TRUE;

	return TRUE;
}
Ejemplo n.º 25
0
HRESULT KModelWater::LoadMesh(LPSTR pFileName)
{
	HRESULT hr = S_OK;

	m_dwNumPoly_X = 63;     //长方形网格的长,网格数
	m_dwNumPoly_Z = 63;     //长方形网格的宽,网格数

	LPD3DXMESH pMesh = m_pWaterUp;
	LPD3DXMESH pDMesh = m_pWaterDn;

	DWORD m_dNumPloy     = m_dwNumPoly_X * m_dwNumPoly_Z;
	DWORD m_dNumFaces    = m_dNumPloy * 2;
	DWORD m_dNumVertices = (m_dwNumPoly_X+1)*(m_dwNumPoly_Z+1);

	SAFE_RELEASE(pMesh);	
	SAFE_RELEASE(pDMesh);
	WORD *pwIndices;

	//建立水面网格 
	if(FAILED(hr = g_pd3dDevice->CreateIndexBuffer(m_dNumFaces * 3 * sizeof(WORD), D3DUSAGE_DYNAMIC | D3DUSAGE_WRITEONLY, 
		D3DFMT_INDEX16, D3DPOOL_DEFAULT, &m_pibIndices, NULL)))
	{
		return hr;
	}

	if (FAILED(hr = D3DXCreateMeshFVF(m_dNumFaces,m_dNumVertices,D3DXMESH_MANAGED|D3DXMESH_32BIT,
		D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_NORMAL|D3DFVF_TEX1,g_pd3dDevice,&pMesh)))
	{
		return hr;
	}	
	if (FAILED(hr = D3DXCreateMeshFVF(m_dNumFaces,m_dNumVertices,D3DXMESH_MANAGED|D3DXMESH_32BIT,
		D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_NORMAL|D3DFVF_TEX1,g_pd3dDevice,&pDMesh)))
	{
		return hr;
	}




	VFormat::FACES_NORMAL_TEXTURE1 * pVers = NULL;
	DWORD* pIndex = NULL;
	DWORD * pAttrib = NULL;	

	VFormat::FACES_NORMAL_TEXTURE1 * pDVers = NULL;
	DWORD* pDIndex = NULL;
	DWORD * pDAttrib = NULL;	
	if(FAILED(hr = m_pibIndices->Lock(0, m_dNumFaces *3 * sizeof(WORD), (void**) &pwIndices, D3DLOCK_DISCARD)))
		return E_FAIL;
	if (FAILED(pMesh->LockVertexBuffer(0,(void**)&pVers)))
		return E_FAIL;
	if (FAILED(pMesh->LockIndexBuffer (0,(void**)&pIndex)))
		return E_FAIL;
	if (FAILED(pMesh->LockAttributeBuffer(0,(DWORD**)&pAttrib)))
		return E_FAIL;

	if (FAILED(pDMesh->LockVertexBuffer(0,(void**)&pDVers)))
		return E_FAIL;
	if (FAILED(pDMesh->LockIndexBuffer (0,(void**)&pDIndex)))
		return E_FAIL;
	if (FAILED(pDMesh->LockAttributeBuffer(0,(DWORD**)&pDAttrib)))
		return E_FAIL;

	DWORD i = 0;
	float _X = 1.0f/m_dwNumPoly_X;
	float _Z = 1.0f/m_dwNumPoly_Z;

	float m_fPolyWidth  = 200;
	float m_fPolyHeight = 200;

	for(DWORD X =0;X<=m_dwNumPoly_X;X++)
	{
		for(DWORD Y =0;Y<=m_dwNumPoly_Z;Y++)
		{
			float PX = X * m_fPolyWidth;
			float PZ = Y * m_fPolyHeight;

			D3DXVECTOR2 Pos(PX,PZ);

			pVers[i].p = D3DXVECTOR3(PX,200,PZ);

			pVers[i].Normal = D3DXVECTOR3(0,1,0);

			pVers[i].tu1 = (X * _X);
			pVers[i].tv1 = (1 - Y *_Z);
			pDVers[i].p = D3DXVECTOR3(PX,0,PZ);
			pDVers[i].Normal = D3DXVECTOR3(0,1,0);
			pDVers[i].tu1 = (X * _X);
			pDVers[i].tv1 = (1 - Y *_Z);
			i++;
		}
	}

	DWORD  Weight = m_dwNumPoly_X + 1;

	for(X =0;X<m_dwNumPoly_X;X++)
	{
		for(DWORD Y =0;Y<m_dwNumPoly_Z;Y++)
		{
			DWORD PloyIndex = Y*m_dwNumPoly_X +X;

			DWORD PolyMaterialID = 0;

			DWORD Vertex_A = X    *Weight+ Y;
			DWORD Vertex_B = (X+1)*Weight+ Y;
			DWORD Vertex_C = (X+1)*Weight+(Y+1);
			DWORD Vertex_D = X    *Weight+(Y+1);

			DWORD Faces_A1 = (PloyIndex*2)*3;
			DWORD Faces_B1 = Faces_A1 + 1;
			DWORD Faces_C1 = Faces_B1 + 1;

			pIndex[Faces_A1] = Vertex_A;
			pIndex[Faces_B1] = Vertex_B;
			pIndex[Faces_C1] = Vertex_D;
			pAttrib[PloyIndex*2] = PolyMaterialID;
			pDIndex[Faces_A1] = Vertex_A;
			pDIndex[Faces_B1] = Vertex_B;
			pDIndex[Faces_C1] = Vertex_D;
			pDAttrib[PloyIndex*2] = PolyMaterialID;

			pwIndices[Faces_A1] = WORD(Vertex_A);
			pwIndices[Faces_B1] = WORD(Vertex_B);
			pwIndices[Faces_C1] = WORD(Vertex_D);

			DWORD Faces_A2 = (PloyIndex*2+1)*3;
			DWORD Faces_B2 = Faces_A2 + 1;
			DWORD Faces_C2 = Faces_B2 + 1;

			pIndex[Faces_A2] = Vertex_D;
			pIndex[Faces_B2] = Vertex_B;
			pIndex[Faces_C2] = Vertex_C;
			pAttrib[PloyIndex*2+1] = PolyMaterialID;
			pDIndex[Faces_A2] = Vertex_D;
			pDIndex[Faces_B2] = Vertex_B;
			pDIndex[Faces_C2] = Vertex_C;
			pDAttrib[PloyIndex*2+1] = PolyMaterialID;

			pwIndices[Faces_A2] = WORD(Vertex_D);
			pwIndices[Faces_B2] = WORD(Vertex_B);
			pwIndices[Faces_C2] = WORD(Vertex_C);

		}
	}	

	D3DXComputeBoundingBox((D3DXVECTOR3*)pVers,m_dNumVertices,sizeof(VFormat::FACES_NORMAL_TEXTURE1),
		&m_BBox_A,&m_BBox_B);
	D3DXComputeBoundingBox((D3DXVECTOR3*)pDVers,m_dNumVertices,sizeof(VFormat::FACES_NORMAL_TEXTURE1),
		&m_BBox_A,&m_BBox_B);

	if (FAILED(pMesh->UnlockVertexBuffer()))
		return E_FAIL;
	if (FAILED(pMesh->UnlockIndexBuffer()))
		return E_FAIL;
	if (FAILED(pMesh->UnlockAttributeBuffer()))
		return E_FAIL;

	if (FAILED(pDMesh->UnlockVertexBuffer()))
		return E_FAIL;
	if (FAILED(pDMesh->UnlockIndexBuffer()))
		return E_FAIL;
	if (FAILED(pDMesh->UnlockAttributeBuffer()))
		return E_FAIL;
	if (FAILED(m_pibIndices->Unlock()))
		return E_FAIL;
	m_pWaterUp = pMesh;		
	m_pWaterDn = pDMesh;	


	//水面网格的材质
	m_dNumMaterial = 1;
	m_lpMaterial = new MATERIAL[m_dNumMaterial];
	ZeroMemory(m_lpMaterial,sizeof(MATERIAL)*m_dNumMaterial);

	DWORD Def_Option = MATERIAL_OPTION_ZBUFFER_TRUE|
		MATERIAL_OPTION_FILL_SOLID|
		MATERIAL_OPTION_SHADE_GOURAUD|
		MATERIAL_OPTION_CULL_NONE|
		MATERIAL_OPTION_SPECULARENABLE;

	for(DWORD i=0;i<m_dNumMaterial;i++)
	{
		m_lpMaterial[i].m_sMaterial9.Diffuse.r = 0.7f ;
		m_lpMaterial[i].m_sMaterial9.Diffuse.g = 0.7f ;
		m_lpMaterial[i].m_sMaterial9.Diffuse.b = 0.7f ;
		m_lpMaterial[i].m_sMaterial9.Diffuse.a = 1.0f ;
		m_lpMaterial[i].m_sMaterial9.Ambient = m_lpMaterial[i].m_sMaterial9.Diffuse;
		m_lpMaterial[i].m_sMaterial9.Specular = m_lpMaterial[i].m_sMaterial9.Diffuse;
		m_lpMaterial[i].m_sMaterial9.Power = 15;
		m_lpMaterial[i].m_dOption = Def_Option;
	} 

	TCHAR Name[256];
	wsprintf(Name,"%s\\Water.Mtl",g_Def_ModelDirectory);
	LoadMaterial(Name);  


	//天空盒的纹理
	wsprintf(Name,"%s\\%s",g_Def_AppDirectory,"Textures\\LobbyCube.dds");
	if( FAILED( hr = D3DXCreateCubeTextureFromFile( g_pd3dDevice,Name, &m_pSkyCubeTex ) ) )
		return hr; 
	//水面的纹理
	wsprintf(Name,"%s\\%s",g_Def_AppDirectory,"Textures\\Water.bmp");
	if( FAILED( hr = D3DXCreateTextureFromFileEx(g_pd3dDevice, Name, D3DX_DEFAULT, D3DX_DEFAULT, 
		D3DX_DEFAULT, 0, D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT, 
		D3DX_DEFAULT, 0, NULL, NULL, &m_pWaterTex) ))
		return hr;
	/*
	// Effect
	wsprintf(Name,"%s\\%s",g_Def_AppDirectory,"water.fx");
	if(FAILED(hr = D3DXCreateEffectFromFile(g_pd3dDevice, Name, NULL, NULL, 0, NULL, &m_pEffect, NULL)))
	return hr;
	m_pEffect->OnResetDevice();
	m_pEffect->SetTexture("tFLR", m_pWaterTex);
	m_pEffect->SetTexture("tENV", m_pSkyCubeTex);
	*/

	//创建水面bump纹理
	if( FAILED( InitBumpMap() ) )
		return E_FAIL;
	//	m_pEffect->SetTexture("tBump", m_pBumpMapTexture);
	WSea.Initialize(m_dwNumPoly_X,m_dwNumPoly_Z);
	Water.Initialize(m_pWaterUp,m_dwNumPoly_X,m_dwNumPoly_Z);   //初始化水纹
	Water.Drop();                                               //产生水纹  
	Ripple.Initialize(m_pWaterUp,m_dwNumPoly_X,m_dwNumPoly_Z);  //初始化涟漪纹


	return S_OK;

}
Ejemplo n.º 26
0
HRESULT KG3DMeshBone::_CreateMesh()
{
    HRESULT hResult  = E_FAIL;
    HRESULT hRetCode = E_FAIL;

    DWORD dwNumFaces    = (DWORD)m_vecSubMeshInfo.size() * 8;
    DWORD dwNumVertices = (DWORD)m_vecSubMeshInfo.size() * 6;

    VFormat::FACES_NORMAL_DIFFUSE_TEXTURE0* pVBuffer = NULL;
    WORD*  pIBuffer = NULL;
    DWORD* pABuffer = NULL;

    hRetCode = D3DXCreateMeshFVF(
        dwNumFaces,
        dwNumVertices,
        D3DXMESH_MANAGED,
        D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_DIFFUSE,
        g_pd3dDevice,
        &m_pSysMesh
    );
    KG_COM_PROCESS_ERROR(hRetCode);

    // vertex
    hRetCode = m_pSysMesh->LockVertexBuffer(0, (void**)&pVBuffer);
    KG_COM_PROCESS_ERROR(hRetCode);

    for (DWORD i = 0; i < m_vecSubMeshInfo.size(); i++)
    {
        pVBuffer[i * 6].p     = m_vecSubMeshInfo[i].vPosition[0];
        pVBuffer[i * 6].diffuse = 0xFFFFFFFF;
        pVBuffer[i * 6 + 1].p = m_vecSubMeshInfo[i].vPosition[1];
        pVBuffer[i * 6 + 1].diffuse = 0xFFFF0000;
        pVBuffer[i * 6 + 2].p = m_vecSubMeshInfo[i].vPosition[2];
        pVBuffer[i * 6 + 2].diffuse = 0xFF0000FF;
        pVBuffer[i * 6 + 3].p = m_vecSubMeshInfo[i].vPosition[3];
        pVBuffer[i * 6 + 3].diffuse = 0xFF00FF00;
        pVBuffer[i * 6 + 4].p = m_vecSubMeshInfo[i].vPosition[4];
        pVBuffer[i * 6 + 4].diffuse = 0xFFFFFF00;
        pVBuffer[i * 6 + 5].p = m_vecSubMeshInfo[i].vPosition[5];
        pVBuffer[i * 6 + 5].diffuse = 0xFFFFFFFF;
    }

    hRetCode = m_pSysMesh->UnlockVertexBuffer();
    KG_COM_PROCESS_ERROR(hRetCode);


    // index
    hRetCode = m_pSysMesh->LockIndexBuffer(0, (void**)&pIBuffer);
    KG_COM_PROCESS_ERROR(hRetCode);

    for (DWORD i = 0; i < m_vecSubMeshInfo.size(); i++)
    {
        for (DWORD j = 0; j < 24; j++)
        {
            pIBuffer[i * 24 + j] = (WORD)(m_vecSubMeshInfo[i].dwIndex[j] + 6 * i);
        }
    }

    hRetCode = m_pSysMesh->UnlockIndexBuffer();
    KG_COM_PROCESS_ERROR(hRetCode);


    // index
    hRetCode = m_pSysMesh->LockAttributeBuffer(0, (DWORD**)&pABuffer);
    KG_COM_PROCESS_ERROR(hRetCode);

    for (DWORD i = 0; i < m_vecSubMeshInfo.size(); i++)
    {
        for (DWORD j = 0; j < 8; j++)
        {
            pABuffer[i * 8 + j] = i;
        }
    }

    hRetCode = m_pSysMesh->UnlockAttributeBuffer();
    KG_COM_PROCESS_ERROR(hRetCode);

    D3DXComputeNormals(m_pSysMesh, NULL);

    hResult = S_OK;
Exit0:
    return hResult;
}
Ejemplo n.º 27
0
/**
 * Exports all geometry into a D3D .x file into the current working folder.
 * @param Filename	Desired filename (may include path)
 * @param bShow		Whether the D3D .x file viewer should be invoked. If shown, we'll block until it has been closed.
 */
void F3DVisualizer::Export( const TCHAR* Filename, bool bShow/*=false*/ )
{
	ID3DXMesh* Mesh;
	Mesh = NULL;
	int32 NumPrimitives = NumTriangles() + NumLines()*2;
	int32 NumVertices = NumTriangles()*3 + NumLines()*4;
	HRESULT Result = D3DXCreateMeshFVF( NumPrimitives, NumVertices, D3DXMESH_32BIT, D3DFVF_XYZ|D3DFVF_NORMAL|D3DFVF_DIFFUSE|D3DFVF_SPECULAR, D3D->D3DDevice, &Mesh );
	void* VertexBuffer = NULL;
	void* IndexBuffer = NULL;
	Result = Mesh->LockVertexBuffer(D3DLOCK_DISCARD, &VertexBuffer);
	Result = Mesh->LockIndexBuffer(D3DLOCK_DISCARD, &IndexBuffer);

	D3DXVertex* Vertices = (D3DXVertex*)VertexBuffer;
	uint32* Indices = (uint32*) IndexBuffer;
	int32 NumVerticesStored = 0;
	int32 NumIndicesStored = 0;

	// Add the triangles to the vertexbuffer and indexbuffer.
	for ( int32 TriangleIndex=0; TriangleIndex < NumTriangles(); ++TriangleIndex )
	{
		const FVector4& P1 = Triangles[TriangleIndex].Vertices[0];
		const FVector4& P2 = Triangles[TriangleIndex].Vertices[1];
		const FVector4& P3 = Triangles[TriangleIndex].Vertices[2];
		const FColor& Color = Triangles[TriangleIndex].Color;
		Vertices[NumVerticesStored+0].Pos[0] = P1[0];
		Vertices[NumVerticesStored+0].Pos[1] = P1[1];
		Vertices[NumVerticesStored+0].Pos[2] = P1[2];
		Vertices[NumVerticesStored+0].Color1 = Color.DWColor();
		Vertices[NumVerticesStored+0].Color2 = 0;
		Vertices[NumVerticesStored+1].Pos[0] = P2[0];
		Vertices[NumVerticesStored+1].Pos[1] = P2[1];
		Vertices[NumVerticesStored+1].Pos[2] = P2[2];
		Vertices[NumVerticesStored+1].Color1 = Color.DWColor();
		Vertices[NumVerticesStored+1].Color2 = 0;
		Vertices[NumVerticesStored+2].Pos[0] = P3[0];
		Vertices[NumVerticesStored+2].Pos[1] = P3[1];
		Vertices[NumVerticesStored+2].Pos[2] = P3[2];
		Vertices[NumVerticesStored+2].Color1 = Color.DWColor();
		Vertices[NumVerticesStored+2].Color2 = 0;

		// Reverse triangle winding order for the .x file.
		Indices[NumIndicesStored+0] = NumVerticesStored + 0;
		Indices[NumIndicesStored+1] = NumVerticesStored + 2;
		Indices[NumIndicesStored+2] = NumVerticesStored + 1;

		NumVerticesStored += 3;
		NumIndicesStored += 3;
	}

	// Add the lines to the vertexbuffer and indexbuffer.
	for ( int32 LineIndex=0; LineIndex < NumLines(); ++LineIndex )
	{
		const FVector4& P1 = Lines[LineIndex].Vertices[0];
		const FVector4& P2 = Lines[LineIndex].Vertices[1];
		const FColor& Color = Lines[LineIndex].Color;
		Vertices[NumVerticesStored+0].Pos[0] = P1[0];
		Vertices[NumVerticesStored+0].Pos[1] = P1[1] - 5.0f;
		Vertices[NumVerticesStored+0].Pos[2] = P1[2];
		Vertices[NumVerticesStored+0].Color1 = 0;
		Vertices[NumVerticesStored+0].Color2 = Color.DWColor();
		Vertices[NumVerticesStored+1].Pos[0] = P1[0];
		Vertices[NumVerticesStored+1].Pos[1] = P1[1] + 5.0f;
		Vertices[NumVerticesStored+1].Pos[2] = P1[2];
		Vertices[NumVerticesStored+1].Color1 = 0;
		Vertices[NumVerticesStored+1].Color2 = Color.DWColor();
		Vertices[NumVerticesStored+2].Pos[0] = P2[0];
		Vertices[NumVerticesStored+2].Pos[1] = P2[1] - 5.0f;
		Vertices[NumVerticesStored+2].Pos[2] = P2[2];
		Vertices[NumVerticesStored+2].Color1 = 0;
		Vertices[NumVerticesStored+2].Color2 = Color.DWColor();
		Vertices[NumVerticesStored+3].Pos[0] = P2[0];
		Vertices[NumVerticesStored+3].Pos[1] = P2[1] + 5.0f;
		Vertices[NumVerticesStored+3].Pos[2] = P2[2];
		Vertices[NumVerticesStored+3].Color1 = 0;
		Vertices[NumVerticesStored+3].Color2 = Color.DWColor();

		Indices[NumIndicesStored+0] = NumVerticesStored+0;
		Indices[NumIndicesStored+1] = NumVerticesStored+2;
		Indices[NumIndicesStored+2] = NumVerticesStored+1;
		Indices[NumIndicesStored+3] = NumVerticesStored+2;
		Indices[NumIndicesStored+4] = NumVerticesStored+3;
		Indices[NumIndicesStored+5] = NumVerticesStored+1;

		NumVerticesStored += 4;
		NumIndicesStored += 6;
	}

	Mesh->UnlockVertexBuffer();
	Mesh->UnlockIndexBuffer();
	Result = D3DXComputeNormals( Mesh, NULL );
	D3DXMATERIAL MeshMaterial;
	MeshMaterial.MatD3D.Ambient.r = 0.1f;
	MeshMaterial.MatD3D.Ambient.g = 0.1f;
	MeshMaterial.MatD3D.Ambient.b = 0.1f;
	MeshMaterial.MatD3D.Ambient.a = 0.0f;
	MeshMaterial.MatD3D.Diffuse.r = 1.0f;
	MeshMaterial.MatD3D.Diffuse.g = 1.0f;
	MeshMaterial.MatD3D.Diffuse.b = 1.0f;
	MeshMaterial.MatD3D.Diffuse.a = 1.0f;
	MeshMaterial.MatD3D.Emissive.r = 1.0f;
	MeshMaterial.MatD3D.Emissive.g = 1.0f;
	MeshMaterial.MatD3D.Emissive.b = 1.0f;
	MeshMaterial.MatD3D.Emissive.a = 1.0f;
	MeshMaterial.MatD3D.Specular.r = 1.0f;
	MeshMaterial.MatD3D.Specular.g = 1.0f;
	MeshMaterial.MatD3D.Specular.b = 1.0f;
	MeshMaterial.MatD3D.Specular.a = 1.0f;
	MeshMaterial.MatD3D.Power = 16.0f;
	MeshMaterial.pTextureFilename = NULL;

	D3DXEFFECTINSTANCE EffectInstance;
	EffectInstance.pEffectFilename = "D3DExport.fx";
	EffectInstance.NumDefaults = 0;
	EffectInstance.pDefaults = NULL;

	// Write out the .x file.
	D3DXSaveMeshToX( Filename, Mesh, NULL, &MeshMaterial, &EffectInstance, 1, D3DXF_FILEFORMAT_BINARY );
	Mesh->Release();

	// Write out the .fx file, if it doesn't always exist.
	HANDLE ShaderFile = CreateFile( TEXT("D3DExport.fx"), GENERIC_WRITE, FILE_SHARE_READ, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
	if (ShaderFile != INVALID_HANDLE_VALUE)
	{
		::DWORD BytesWritten;
		WriteFile(ShaderFile, ShaderFxFile, (uint32)FCStringAnsi::Strlen(ShaderFxFile), &BytesWritten, NULL);
		CloseHandle( ShaderFile );
	}

	// If specified, run the default viewer for .x files and block until it's closed.
	if ( bShow )
	{
		system( TCHAR_TO_ANSI(Filename) );
	}
}
Ejemplo n.º 28
0
//=================================================================================================
void Terrain::Build(bool smooth)
{
	assert(state == 1);

	HRESULT hr = D3DXCreateMeshFVF(n_tris, n_verts, D3DXMESH_MANAGED | D3DXMESH_32BIT, VTerrain::fvf, device, &mesh);
	if(FAILED(hr))
		throw Format("Failed to create new terrain mesh (%d)!", hr);

	VTerrain* v;
	//word* idx;
	uint* idx;
	uint n = 0;
	//uint index = 0;

	V(mesh->LockVertexBuffer(0, (void**)&v));
	V(mesh->LockIndexBuffer(0, (void**)&idx));

#define TRI(xx,zz,uu,vv) v[n++] = VTerrain((x+xx)*tile_size, h[x+xx+(z+zz)*hszer], (z+zz)*tile_size, float(uu)/uv_mod, float(vv)/uv_mod,\
	((float)(x+xx)) / n_tiles, ((float)(z+zz)) / n_tiles)

	for(uint z = 0; z < n_tiles; ++z)
	{
		for(uint x = 0; x < n_tiles; ++x)
		{
			int u1 = (x%uv_mod);
			int u2 = ((x + 1) % uv_mod);
			if(u2 == 0)
				u2 = uv_mod;
			int v1 = (z%uv_mod);
			int v2 = ((z + 1) % uv_mod);
			if(v2 == 0)
				v2 = uv_mod;

			TRI(0, 0, u1, v1);
			TRI(0, 1, u1, v2);
			TRI(1, 0, u2, v1);
			CalculateNormal(v[n - 3], v[n - 2], v[n - 1]);

			TRI(0, 1, u1, v2);
			TRI(1, 1, u2, v2);
			TRI(1, 0, u2, v1);
			CalculateNormal(v[n - 3], v[n - 2], v[n - 1]);
		}
	}
#undef TRI

	for(uint z = 0; z < n_parts; ++z)
	{
		for(uint x = 0; x < n_parts; ++x)
		{
			const uint z_start = z*tiles_per_part,
				z_end = z_start + tiles_per_part,
				x_start = x*tiles_per_part,
				x_end = x_start + tiles_per_part;

			for(uint zz = z_start; zz < z_end; ++zz)
			{
				for(uint xx = x_start; xx < x_end; ++xx)
				{
					for(uint j = 0; j < 6; ++j)
					{
						*idx = (xx + zz*n_tiles) * 6 + j;
						++idx;
					}
				}
			}
		}
	}

	V(mesh->UnlockIndexBuffer());

	state = 2;

	if(smooth)
		SmoothNormals(v);

	V(mesh->UnlockVertexBuffer());
}
//------------------------------------------------------------------------------------------------
// Name:  CreateTerrainMesh
// Desc:  
//------------------------------------------------------------------------------------------------
bool CreateTerrainMesh(LPDIRECT3DDEVICE9 d3dDevice, LPD3DXMESH* terrainMesh)
{
    // Calculate the number of faces and vertices required
    const unsigned int faces = (TMS_COUNT + 3) * 2;
    const unsigned int vertices = (TMS_COUNT + 3) * 4;

    // The internal terrain mesh
    LPD3DXMESH internalTerrainMesh;

    // Create the mesh
    HRESULT hr = D3DXCreateMeshFVF(faces, vertices, D3DXMESH_MANAGED, D3DFVF_GEOMETRYVERTEX, d3dDevice, &internalTerrainMesh);
    if (APP_ERROR(FAILED(hr))("Unable to create the terrain mesh"))
        return false;

    // Lock the mesh buffers
    GeometryVertex* lockedVertices = 0;
    WORD* lockedIndices = 0;
    DWORD* lockedAttributes = 0;
    if (APP_ERROR(FAILED(internalTerrainMesh->LockAttributeBuffer(0, &lockedAttributes)) ||
                   FAILED(internalTerrainMesh->LockVertexBuffer(0, (VOID**)&lockedVertices)) ||
                   FAILED(internalTerrainMesh->LockIndexBuffer(0, (VOID**)&lockedIndices)))("Unable to lock terrain mesh"))
    {
        // Deallocate the mesh
        SAFE_RELEASE(internalTerrainMesh);

        // Exit the method
        return false;
    }

    // Vertices that will be rotated 4x about Y at
    // 90-degree intervals to produce the wall mesh
    GeometryVertex wallSide[] = {
        { -0.5f,  0.0f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f },
        { -0.5f,  0.0f, +0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f },
        { -0.5f, -1.0f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f },
        { -0.5f, -1.0f, +0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f },
    };

    // The flat square with unit size
    GeometryVertex flat[] = {
        { -0.5f,  0.0f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f },
        { +0.5f,  0.0f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f },
        { -0.5f,  0.0f, +0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f },
        { +0.5f,  0.0f, +0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f },
    };

    // Geometry template for the high-corner meshes,
    // with the high corner in the north-west
    GeometryVertex highCorner[] = {
        { -0.5f, +1.0f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f },
        { +0.5f,  0.0f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f },
        { -0.5f,  0.0f, +0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f },
        { +0.5f,  0.0f, +0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f },
    };

    // Geometry template for the low-corner meshes,
    // with the low corner in the north-west
    GeometryVertex lowCorner[] = {
        { -0.5f, -1.0f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f },
        { +0.5f,  0.0f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f },
        { -0.5f,  0.0f, +0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f },
        { +0.5f,  0.0f, +0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f },
    };

    // Geometry template for the high-side meshes,
    // with the high side to the north
    GeometryVertex highSide[] = {
        { -0.5f, +1.0f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f },
        { +0.5f, +1.0f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f },
        { -0.5f,  0.0f, +0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f },
        { +0.5f,  0.0f, +0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f },
    };

    // Geometry template for the low-corner meshes,
    // with the low corner in the north-west
    GeometryVertex raisedLowCorner[] = {
        { -0.5f,  0.0f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f },
        { +0.5f, +1.0f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f },
        { -0.5f, +1.0f, +0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f },
        { +0.5f, +1.0f, +0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f },
    };

    // Geometry template for the low-side meshes,
    // with the low side to the north
    GeometryVertex lowSide[] = {
        { -0.5f, -1.0f, -0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f },
        { +0.5f, -1.0f, -0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f },
        { -0.5f,  0.0f, +0.5f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f },
        { +0.5f,  0.0f, +0.5f, 0.0f, 1.0f, 0.0f, 1.0f, 1.0f },
    };

    // The subset that is currently being written
    unsigned int currentSubset = TMS_WALL_SIDES;

    // Copy the wall first--it does not have any texture rotations
    lockedVertices = CopyYRotatedGeometry(lockedVertices, wallSide, 4, 0.0f * D3DX_PI / 2.0f);
    lockedVertices = CopyYRotatedGeometry(lockedVertices, wallSide, 4, 1.0f * D3DX_PI / 2.0f);
    lockedVertices = CopyYRotatedGeometry(lockedVertices, wallSide, 4, 2.0f * D3DX_PI / 2.0f);
    lockedVertices = CopyYRotatedGeometry(lockedVertices, wallSide, 4, 3.0f * D3DX_PI / 2.0f);

    // Copy four sets of squares
    lockedIndices = PrintSquareIndices(lockedIndices, 0, 4);
    lockedAttributes = PrintAttributes(lockedAttributes, currentSubset, 4);

    // Move to the next subset
    currentSubset++;

    // Write the flat mesh first, since it only has texture rotations
    for (unsigned int textureDirection = 0; textureDirection < 4; ++textureDirection, ++currentSubset)
    {
        SetTerrainTexcoords(flat, textureDirection);
        lockedVertices = CopyYRotatedGeometry(lockedVertices, flat, 4, 0.0f);
        lockedIndices = PrintSquareIndices(lockedIndices, 4 + currentSubset - 1, 1);
        lockedAttributes = PrintAttributes(lockedAttributes, currentSubset, 1);
    }

    // Repeat for all combinations of texture direction and rotation for the remaining types
    for (int type = 0; type < 5; ++type)
    {
        GeometryVertex* sourceGeometry;
        switch(type)
        {
            case 0: sourceGeometry = highCorner; break;
            case 1: sourceGeometry = lowCorner;  break;
            case 2: sourceGeometry = highSide;   break;
            case 3: sourceGeometry = raisedLowCorner; break;
            case 4: sourceGeometry = lowSide;    break;
        }

        // Repeat for all rotations
        for (int rotation = 0; rotation < 4; ++rotation)
        {
            // Calculate the rotation angle
            float rotationAngle = D3DX_PI / 2.0f * rotation;

            // Repeat for all texture directions
            for (unsigned int textureDirection = 0; textureDirection < 4; ++textureDirection, ++currentSubset)
            {
                // Reverse the rotation of the texture by the rotation of the element so that we get
                // consistent texture directions (i.e. north is texture-up on all tiles)
                SetTerrainTexcoords(sourceGeometry, (textureDirection - rotation + 4) % 4);
                lockedVertices = CopyYRotatedGeometry(lockedVertices, sourceGeometry, 4, rotationAngle);
                lockedIndices = PrintSquareIndices(lockedIndices, 4 + currentSubset - 1, 1);
                lockedAttributes = PrintAttributes(lockedAttributes, currentSubset, 1);
            }
        }
    }

    // Unlock the buffers
    internalTerrainMesh->UnlockVertexBuffer();
    internalTerrainMesh->UnlockIndexBuffer();
    internalTerrainMesh->UnlockAttributeBuffer();

    // Normalize
    //CONFIRM(SUCCEEDED(D3DXComputeNormals(internalTerrainMesh, NULL)));

    // Assign the output mesh
    *terrainMesh = internalTerrainMesh;

    // Success
    return true;
}
Ejemplo n.º 30
0
void cASEObject::setup(stASENode& nodeinfo, D3DXMATRIXA16* pmatParentWorld/* = NULL*/){
	m_stNodeInfo = nodeinfo;		
	m_matWorldTM = nodeinfo.LocalMat;
	m_matOriginalWorld = nodeinfo.LocalMat;
	m_stNodeAni = nodeinfo.AnimationInfo;
	
	if (pmatParentWorld){
		D3DXMATRIXA16 mtPrnI;
		D3DXMatrixInverse(&mtPrnI, NULL, pmatParentWorld);
		m_matLocalMat = m_matWorldTM * mtPrnI;
	}
	else {
		D3DXMatrixIdentity(&m_matLocalMat);
	}	
	
	D3DXMATRIXA16 matInverse;
	D3DXMatrixInverse(&matInverse, NULL, &m_matWorldTM);

	for (size_t i = 0; i < m_stNodeInfo.vecVertex.size(); i++){
		D3DXVec3TransformCoord(
			&m_stNodeInfo.vecVertex[i].p,
			&m_stNodeInfo.vecVertex[i].p,
			&matInverse);
		D3DXVec3TransformNormal(
			&m_stNodeInfo.vecVertex[i].n,
			&m_stNodeInfo.vecVertex[i].n,
			&matInverse
			);
	}

	D3DXCreateSphere(g_pD3DDevice, 0.025f, 10, 10, &m_pNodeMesh, NULL);

	if (m_stNodeInfo.nRef != INT_MAX){
		m_pMesh = NULL;
		HRESULT hr = D3DXCreateMeshFVF(m_stNodeInfo.vecVertex.size() / 3,
			m_stNodeInfo.vecVertex.size(),
			D3DXMESH_MANAGED,
			ST_PNT_VERTEX::FVF,
			g_pD3DDevice,
			&m_pMesh);

#ifdef _DEBUG
		_ASSERT(hr == S_OK && "Mesh Not Created");
#endif

		ST_PNT_VERTEX* pV = NULL;
		m_pMesh->LockVertexBuffer(0, (LPVOID*)&pV);
		memcpy(pV, &m_stNodeInfo.vecVertex[0], m_stNodeInfo.vecVertex.size() * sizeof(ST_PNT_VERTEX));
		m_pMesh->UnlockVertexBuffer();

		WORD* pI = NULL;
		m_pMesh->LockIndexBuffer(0, (LPVOID*)&pI);
		for (size_t j = 0; j < m_pMesh->GetNumVertices(); ++j)
		{
			pI[j] = j;
		}
		m_pMesh->UnlockIndexBuffer();

		DWORD* pA = NULL;
		m_pMesh->LockAttributeBuffer(0, &pA);
		for (size_t j = 0; j < m_pMesh->GetNumFaces(); j++){
			pA[j] = m_stNodeInfo.nRef;
		}
		m_pMesh->UnlockAttributeBuffer();

		std::vector<DWORD> vecAdjBuffer(m_stNodeInfo.vecVertex.size());
		m_pMesh->GenerateAdjacency(0.0f, &vecAdjBuffer[0]);

		m_pMesh->OptimizeInplace(
			D3DXMESHOPT_ATTRSORT |
			D3DXMESHOPT_COMPACT |
			D3DXMESHOPT_VERTEXCACHE,
			&vecAdjBuffer[0], 0, 0, 0);
	}
}