bool CIndexBuffer::Cache(CDisplayDevice *poDisplayDevice) {
#if RENDER == DX9
IDirect3DIndexBuffer9* IB;
int len = sizeof(unsigned short) * m_iNumIndices;
HRESULT result = poDisplayDevice->m_pDevice->CreateIndexBuffer(
len,
D3DUSAGE_WRITEONLY,
D3DFMT_INDEX16,
D3DPOOL_SYSTEMMEM,
&IB,
0);
if (result != D3D_OK)
return false;
char *buffer;
IB->Lock(0, 0, (void **)&buffer, 0);
memcpy(buffer, GetIndexBuffer(), len);
IB->Unlock();
m_pCachedData = IB;
#endif
return true;
}
void CubeDemo::buildIndexBuffer()
{
HR(gd3dDevice->CreateIndexBuffer(36*sizeof(WORD), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_MANAGED, &mIB, 0));
WORD *k = 0;
HR(mIB->Lock(0, 0, (void**)&k, 0));
// front
k[0] = 0; k[1] = 1; k[2] = 2;
k[3] = 0; k[4] = 2; k[5] = 3;
// back
k[6] = 4; k[7] = 6; k[8] = 5;
k[9] = 4; k[10] = 7; k[11] = 6;
// left
k[12] = 4; k[13] = 5; k[14] = 1;
k[15] = 4; k[16] = 1; k[17] = 0;
// right
k[18] = 3; k[19] = 2; k[20] = 6;
k[21] = 3; k[22] = 6; k[23] = 7;
// top
k[24] = 1; k[25] = 5; k[26] = 6;
k[27] = 1; k[28] = 6; k[29] = 2;
k[30] = 4; k[31] = 0; k[32] = 3;
k[33] = 4; k[34] = 3; k[35] = 7;
HR(mIB->Unlock());
}
void TriGridDemo::buildGeoBuffers()
{
std::vector<D3DXVECTOR3> verts;
std::vector<DWORD> indices;
GenTriGrid(100, 100, 1.0f, 1.0f, D3DXVECTOR3(0.0f, 0.0f, 0.0f), verts, indices);
mNumVertices = 100*100;
mNumTriangles = 99*99*2;
HR(gd3dDevice->CreateVertexBuffer(mNumVertices * sizeof(VertexPos),
D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mVB, 0));
VertexPos *v = 0;
HR(mVB->Lock(0, 0, (void**)&v, 0));
for (DWORD i = 0; i < mNumVertices; ++i) v[i] = verts[i];
HR(mVB->Unlock());
HR(gd3dDevice->CreateIndexBuffer(mNumTriangles*3*sizeof(WORD), D3DUSAGE_WRITEONLY,
D3DFMT_INDEX16, D3DPOOL_MANAGED, &mIB, 0));
WORD *k = 0;
HR(mIB->Lock(0, 0, (void**)&k, 0));
for (DWORD i = 0; i < mNumTriangles*3; ++i) k[i] = (WORD)indices[i];
HR(mIB->Unlock());
}
void Impl::Unlock(BytesPtr srcBytes, BytesPtr dstBytes)
{
bytes::read_proc rp(srcBytes);
ProxyId id;
rp(id);
IDirect3DIndexBuffer9 *self = procMap_->getPtr<IDirect3DIndexBuffer9>(id);
UINT offset, size;
DWORD flags;
rp(offset);
rp(size);
rp(flags);
char *ptr = nullptr;
HRESULT res;
res = self->Lock(offset, size, reinterpret_cast<void**>(&ptr), flags);
if (SUCCEEDED(res))
{
rp.array(ptr, size);
res = self->Unlock();
Assert(SUCCEEDED(res));
}
else
{
vector<char> dump(size);
rp.array(dump.data(), size);
Assert(false);
}
bytes::write_proc wp(dstBytes);
wp(res);
}
void MultiTexDemo::buildGridGeometry()
{
std::vector<D3DXVECTOR3> verts;
std::vector<DWORD> indices;
GenTriGrid(100, 100, 1.0f, 1.0f,
D3DXVECTOR3(0.0f, 0.0f, 0.0f), verts, indices);
// Save vertex count and triangle count for DrawIndexedPrimitive arguments.
mNumGridVertices = 100*100;
mNumGridTriangles = 99*99*2;
// Obtain a pointer to a new vertex buffer.
HR(gd3dDevice->CreateVertexBuffer(mNumGridVertices * sizeof(VertexPNT),
D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mGridVB, 0));
// Now lock it to obtain a pointer to its internal data, and write the
// grid's vertex data.
VertexPNT* v = 0;
HR(mGridVB->Lock(0, 0, (void**)&v, 0));
float w = 99.0f;
float d = 99.0f;
for(int i = 0; i < 100; ++i)
{
for(int j = 0; j < 100; ++j)
{
DWORD index = i * 100 + j;
v[index].pos = verts[index];
v[index].normal = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
v[index].tex0.x = (v[index].pos.x + (0.5f*w)) / w;
v[index].tex0.y = (v[index].pos.z - (0.5f*d)) / -d;
}
}
HR(mGridVB->Unlock());
// Obtain a pointer to a new index buffer.
HR(gd3dDevice->CreateIndexBuffer(mNumGridTriangles*3*sizeof(WORD), D3DUSAGE_WRITEONLY,
D3DFMT_INDEX16, D3DPOOL_MANAGED, &mGridIB, 0));
// Now lock it to obtain a pointer to its internal data, and write the
// grid's index data.
WORD* k = 0;
HR(mGridIB->Lock(0, 0, (void**)&k, 0));
for(DWORD i = 0; i < mNumGridTriangles*3; ++i)
k[i] = (WORD)indices[i];
HR(mGridIB->Unlock());
}
MF_API void MFVertex_LockIndexBuffer(MFIndexBuffer *pIndexBuffer, uint16 **ppIndices)
{
MFDebug_Assert(!pIndexBuffer->bLocked, "Index buffer already locked!");
IDirect3DIndexBuffer9 *pIB = (IDirect3DIndexBuffer9*)pIndexBuffer->pPlatformData;
HRESULT hr = pIB->Lock(0, sizeof(uint16)*pIndexBuffer->numIndices, &pIndexBuffer->pLocked, 0);
MFDebug_Assert(SUCCEEDED(hr), "Failed to lock index buffer");
if(ppIndices)
*ppIndices = (uint16*)pIndexBuffer->pLocked;
pIndexBuffer->bLocked = true;
}
void SpotlightDemo::buildGeoBuffers()
{
std::vector<D3DXVECTOR3> verts;
std::vector<DWORD> indices;
GenTriGrid(100, 100, 1.0f, 1.0f,
D3DXVECTOR3(0.0f, 0.0f, 0.0f), verts, indices);
// Save vertex count and triangle count for DrawIndexedPrimitive arguments.
mNumGridVertices = 100*100;
mNumGridTriangles = 99*99*2;
// Obtain a pointer to a new vertex buffer.
HR(gd3dDevice->CreateVertexBuffer(mNumGridVertices * sizeof(VertexPN),
D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mVB, 0));
// Now lock it to obtain a pointer to its internal data, and write the
// grid's vertex data.
VertexPN* v = 0;
HR(mVB->Lock(0, 0, (void**)&v, 0));
for(DWORD i = 0; i < mNumGridVertices; ++i)
{
v[i].pos = verts[i];
v[i].normal = D3DXVECTOR3(0.0f, 1.0f, 0.0f);
}
HR(mVB->Unlock());
// Obtain a pointer to a new index buffer.
HR(gd3dDevice->CreateIndexBuffer(mNumGridTriangles*3*sizeof(WORD), D3DUSAGE_WRITEONLY,
D3DFMT_INDEX16, D3DPOOL_MANAGED, &mIB, 0));
// Now lock it to obtain a pointer to its internal data, and write the
// grid's index data.
WORD* k = 0;
HR(mIB->Lock(0, 0, (void**)&k, 0));
for(DWORD i = 0; i < mNumGridTriangles*3; ++i)
k[i] = (WORD)indices[i];
HR(mIB->Unlock());
}
IndexBufferLock Gfx_IndexBuffer_Lock(RenderDevice* dev, IndexBufferHandle h, uint32 offset, uint32 size)
{
IndexBufferLock lock;
if( h.valid() )
{
lock.size = size;
lock.handle = h;
uint32 flags = buffer_mode_to_d3d_lock_flags(dev->resources->index_buffers[h].desc.mode);
IDirect3DIndexBuffer9* ib = dev->resources->index_buffers[h].native;
HRESULT hr = ib->Lock(offset, size, &lock.data, flags);
validate_d3d_result(hr);
}
return lock;
};
bool MFVertex_CreateIndexBufferPlatformSpecific(MFIndexBuffer *pIndexBuffer, uint16 *pIndexBufferMemory)
{
IDirect3DIndexBuffer9 *pIB;
HRESULT hr = pd3dDevice->CreateIndexBuffer(sizeof(uint16)*pIndexBuffer->numIndices, 0, D3DFMT_INDEX16, D3DPOOL_MANAGED, &pIB, NULL);
MFDebug_Assert(SUCCEEDED(hr), "Failed to create index buffer");
if(FAILED(hr))
return false;
if(pIndexBuffer->pName)
MFRenderer_D3D9_SetDebugName(pIB, pIndexBuffer->pName);
pIndexBuffer->pPlatformData = pIB;
if(pIndexBufferMemory)
{
void *pData;
pIB->Lock(0, 0, &pData, 0);
MFCopyMemory(pData, pIndexBufferMemory, sizeof(uint16)*pIndexBuffer->numIndices);
pIB->Unlock();
}
return true;
}
void DiffuseCubeDemo::buildIndexBuffer()
{
// Obtain a pointer to a new index buffer.
HR(gd3dDevice->CreateIndexBuffer(36 * sizeof(WORD), D3DUSAGE_WRITEONLY,
D3DFMT_INDEX16, D3DPOOL_MANAGED, &mIB, 0));
// Now lock it to obtain a pointer to its internal data, and write the
// cube's index data.
WORD* k = 0;
HR(mIB->Lock(0, 0, (void**)&k, 0));
// fill in the front face index data
k[0] = 0; k[1] = 1; k[2] = 2;
k[3] = 0; k[4] = 2; k[5] = 3;
// fill in the back face index data
k[6] = 4; k[7] = 5; k[8] = 6;
k[9] = 4; k[10] = 6; k[11] = 7;
// fill in the top face index data
k[12] = 8; k[13] = 9; k[14] = 10;
k[15] = 8; k[16] = 10; k[17] = 11;
// fill in the bottom face index data
k[18] = 12; k[19] = 13; k[20] = 14;
k[21] = 12; k[22] = 14; k[23] = 15;
// fill in the left face index data
k[24] = 16; k[25] = 17; k[26] = 18;
k[27] = 16; k[28] = 18; k[29] = 19;
// fill in the right face index data
k[30] = 20; k[31] = 21; k[32] = 22;
k[33] = 20; k[34] = 22; k[35] = 23;
HR(mIB->Unlock());
}
void GateDemo::buildGateGeometry()
{
// Gate is just a rectangle aligned with the xy-plane.
// Obtain a pointer to a new vertex buffer.
HR(gd3dDevice->CreateVertexBuffer(4* sizeof(VertexPNT),
D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mGateVB, 0));
// Now lock it to obtain a pointer to its internal data, and write the
// grid's vertex data.
VertexPNT* v = 0;
HR(mGateVB->Lock(0, 0, (void**)&v, 0));
// Scale texture coordinates by 4 units in the v-direction for tiling.
v[0] = VertexPNT(-20.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 1.0f);
v[1] = VertexPNT(-20.0f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 0.0f, 0.0f);
v[2] = VertexPNT( 20.0f, 5.0f, 0.0f, 0.0f, 0.0f, -1.0f, 4.0f, 0.0f);
v[3] = VertexPNT( 20.0f, 0.0f, 0.0f, 0.0f, 0.0f, -1.0f, 4.0f, 1.0f);
HR(mGateVB->Unlock());
// Obtain a pointer to a new index buffer.
HR(gd3dDevice->CreateIndexBuffer(6*sizeof(WORD), D3DUSAGE_WRITEONLY,
D3DFMT_INDEX16, D3DPOOL_MANAGED, &mGateIB, 0));
// Now lock it to obtain a pointer to its internal data, and write the
// grid's index data.
WORD* k = 0;
HR(mGateIB->Lock(0, 0, (void**)&k, 0));
k[0] = 0; k[1] = 1; k[2] = 2; // Triangle 0
k[3] = 0; k[4] = 2; k[5] = 3; // Triangle 1
HR(mGateIB->Unlock());
}
bool StripifyMeshSubset(ID3DXMesh* mesh,
DWORD attribId,
ostream& meshfile)
{
// TODO: Fall back to tri lists if the strip size is too small
// TODO: Detect when a tri fan should be used instead of a tri list
// Convert to tri strips
IDirect3DIndexBuffer9* indices = NULL;
DWORD numIndices = 0;
ID3DXBuffer* strips = NULL;
DWORD numStrips = 0;
HRESULT hr;
hr = D3DXConvertMeshSubsetToStrips(mesh,
attribId,
0,
&indices,
&numIndices,
&strips,
&numStrips);
if (FAILED(hr))
{
cout << "Stripify failed\n";
return false;
}
cout << "Converted to " << numStrips << " strips\n";
cout << "Strip buffer size: " << strips->GetBufferSize() << '\n';
if (numStrips != strips->GetBufferSize() / 4)
{
cout << "Strip count is incorrect!\n";
return false;
}
bool index32 = false;
{
D3DINDEXBUFFER_DESC desc;
indices->GetDesc(&desc);
if (desc.Format == D3DFMT_INDEX32)
{
index32 = true;
}
else if (desc.Format == D3DFMT_INDEX16)
{
index32 = false;
}
else
{
cout << "Bad index format. Strange.\n";
return false;
}
}
void* indexData = NULL;
hr = indices->Lock(0, 0, &indexData, D3DLOCK_READONLY);
if (FAILED(hr))
{
cout << "Failed to lock index buffer: " << D3DErrorString(hr) << '\n';
return false;
}
{
DWORD* stripLengths = reinterpret_cast<DWORD*>(strips->GetBufferPointer());
int k = 0;
for (int i = 0; i < numStrips; i++)
{
if (stripLengths[i] == 0)
{
cout << "Bad triangle strip (length == 0) in mesh!\n";
return false;
}
if (index32)
{
DWORD* indices = reinterpret_cast<DWORD*>(indexData) + k;
int fanStart = checkForFan(stripLengths[i], indices);
if (fanStart != 1)
{
DumpTriStrip(stripLengths[i], indices, (int) attribId,
meshfile);
}
else
{
DumpTriStripAsFan(stripLengths[i], indices, (int) attribId,
fanStart, meshfile);
}
}
else
{
WORD* indices = reinterpret_cast<WORD*>(indexData) + k;
int fanStart = checkForFan(stripLengths[i], indices);
if (fanStart != 1)
{
DumpTriStrip(stripLengths[i], indices, (int) attribId,
meshfile);
}
else
{
DumpTriStripAsFan(stripLengths[i], indices, (int) attribId,
fanStart, meshfile);
}
}
k += stripLengths[i] + 2;
}
cout << "k=" << k << ", numIndices=" << numIndices;
if (index32)
cout << ", 32-bit indices\n";
else
cout << ", 16-bit indices\n";
}
return true;
}
void Evolution::drawLifeforms()
{
if (!mbLStart)
{
mLVB->Release();
mLIB->Release();
}
int Number = 0;
int LNumber = 0;
const D3DXVECTOR3 baseV[4] = {D3DXVECTOR3(-1.00000f, -1.00000f, 0.0f),
D3DXVECTOR3(-1.00000f, 1.00000f, 0.0f),
D3DXVECTOR3( 1.00000f, 1.00000f, 0.0f),
D3DXVECTOR3( 1.00000f, -1.00000f, 0.0f)
};
const D3DXVECTOR2 baseT[4] = {D3DXVECTOR2(0.0f, 1.0f),
D3DXVECTOR2(0.0f, 0.0f),
D3DXVECTOR2(1.0f, 0.0f),
D3DXVECTOR2(1.0f, 1.0f)
};
HR(gd3dDevice->CreateVertexBuffer((lifeformList.size()) *4* sizeof(VertexPTL), D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mLVB, 0));
VertexPTL * lv = 0;
HR(mLVB->Lock(0, 0, (void**)&lv, 0));
for (std::list<Lifeform>::iterator it = lifeformList.begin(); it != lifeformList.end(); ++it)
{
Stat stat = it->getStat();
float cParts = (float)(stat.carnivoreParts)/10.0f;
if (stat.carnivoreParts >= 10)
cParts = 1.0f;
float sightDist = (stat.sightDistance)/10.0f;
if (stat.sightDistance >= 10.0f)
sightDist = 1.0f;
if (stat.sightDistance >= 10.0f && !(stat.carnivore))
cParts = 0.0f;
D3DXVECTOR3 pos = it->getPosition();
D3DXMATRIX T, R, S, F;
D3DXMatrixRotationZ(&R, it->getRotation());
D3DXVECTOR3 V[4];
D3DXMatrixTranslation(&T, pos.x, pos.y, pos.z);
D3DXMatrixScaling(&S, 8.0f, 8.0f, 0.0f);
F = S*(R*T);
for (int k=0; k<4; ++k)
D3DXVec3TransformCoord(&V[k], &baseV[k], &F);
for (int k=0; k<4; ++k)
lv[Number+k] = VertexPTL( V[k], baseT[k], cParts, sightDist);
/*v[Number] = VertexPTID(-1.0f, -1.0f, 0.0f, 0.0f, 1.0f, F, 2.0f);
v[Number+1] = VertexPTID(-1.0f, 1.0f, 0.0f, 0.0f, 0.0f, F, 2.0f);
v[Number+2] = VertexPTID( 1.0f, 1.0f, 0.0f, 1.0f, 0.0f, F, 2.0f);
v[Number+3] = VertexPTID( 1.0f, -1.0f, 0.0f, 1.0f, 1.0f, F, 2.0f);*/
//++lv;
Number+=4;
++LNumber;
}
HR(mLVB->Unlock());
//Number = 0;
HR(gd3dDevice->CreateIndexBuffer(lifeformList.size() *6* sizeof(WORD), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_MANAGED, &mLIB, 0));
WORD* lind = 0;
HR(mLIB->Lock(0, 0, (void**)&lind, 0));
int k=0;
int g=0;
for (int n=0; n<LNumber; ++n)
{
lind[k] = g;
lind[k+1] = g+1;
lind[k+2] = g+2;
lind[k+3] = g;
lind[k+4] = g+2;
lind[k+5] = g+3;
k+=6;
g+=4;
}
HR(mLIB->Unlock());
HR(mFX->SetTechnique(mhLTech));
HR(mFX->SetTexture(mhTex, mLifeformTex));
HR(mFX->SetTexture(mhTex2, mCarnTex));
HR(mFX->SetTexture(mhTex3, mSightTex));
HR(mFX->SetMatrix(mhWVP, &(mView*mProj)));
HR(gd3dDevice->SetVertexDeclaration(VertexPTL::Decl));
HR(gd3dDevice->SetStreamSource(0, mLVB, 0, sizeof(VertexPTL)));
HR(gd3dDevice->SetIndices(mLIB));
UINT numPasses = 0;
HR(mFX->Begin(&numPasses, 0));
for (UINT i=0; i<numPasses; ++i)
{
HR(mFX->BeginPass(i));
HR(gd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4*LNumber, 0, 2*LNumber));
HR(mFX->EndPass());
}
HR(mFX->End());
if (mbLStart)
mbLStart = false;
}
void Evolution::drawEggsFood()
{
if (!mbEFStart)
{
mEFVB->Release();
mEFIB->Release();
}
int Number = 0;
int FNumber = 0;
int ENumber = 0;
const D3DXVECTOR3 baseV[4] = {D3DXVECTOR3(-1.00000f, -1.00000f, 0.0f),
D3DXVECTOR3(-1.00000f, 1.00000f, 0.0f),
D3DXVECTOR3( 1.00000f, 1.00000f, 0.0f),
D3DXVECTOR3( 1.00000f, -1.00000f, 0.0f)
};
const D3DXVECTOR2 baseT[4] = {D3DXVECTOR2(0.0f, 1.0f),
D3DXVECTOR2(0.0f, 0.0f),
D3DXVECTOR2(1.0f, 0.0f),
D3DXVECTOR2(1.0f, 1.0f)
};
HR(gd3dDevice->CreateVertexBuffer((foodList.size()+eggList.size()) *4* sizeof(VertexPTEF), D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mEFVB, 0));
VertexPTEF * efv = 0;
HR(mEFVB->Lock(0, 0, (void**)&efv, 0));
for (std::list<Food>::iterator it = foodList.begin(); it != foodList.end(); ++it)
{
D3DXVECTOR3 pos = it->getPosition();
D3DXMATRIX T, S, F;
D3DXVECTOR3 V[4];
D3DXMatrixTranslation(&T, pos.x, pos.y, pos.z);
D3DXMatrixScaling(&S, 2.0f, 2.0f, 0.0f);
F = S*(T);
for (int k=0; k<4; ++k)
D3DXVec3TransformCoord(&V[k], &baseV[k], &F);
for (int k=0; k<4; ++k)
efv[Number+k] = VertexPTEF( V[k], baseT[k]);
//*v = iv;
//++fv;
Number+=4;
++FNumber;
}
/*if (eggList.size() != 0)
{
HR(gd3dDevice->CreateVertexBuffer(eggList.size() * sizeof(VertexPTEF), D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &mEVB, 0));
VertexPTEF * ev = 0;
HR(mEVB->Lock(0, 0, (void**)&ev, 0));*/
ENumber=FNumber;
for (std::list<Egg>::iterator it = eggList.begin(); it != eggList.end(); ++it)
{
D3DXVECTOR3 pos = it->getPosition();
D3DXMATRIX T, S, F;
D3DXVECTOR3 V[4];
D3DXMatrixTranslation(&T, pos.x, pos.y, pos.z);
D3DXMatrixScaling(&S, 2.0f, 2.0f, 0.0f);
F = S*(T);
for (int k=0; k<4; ++k)
D3DXVec3TransformCoord(&V[k], &baseV[k], &F);
for (int k=0; k<4; ++k)
efv[Number+k] = VertexPTEF( V[k], baseT[k]);
//*v = iv;
//++ev;
Number+=4;
++ENumber;
}
HR(mEFVB->Unlock());
Number = 0;
HR(gd3dDevice->CreateIndexBuffer((foodList.size()+eggList.size()) *6* sizeof(WORD), D3DUSAGE_WRITEONLY, D3DFMT_INDEX16, D3DPOOL_MANAGED, &mEFIB, 0));
WORD* find = 0;
HR(mEFIB->Lock(0, 0, (void**)&find, 0));
int k=0;
int m=0;
int g=0;
while (m<FNumber)
{
find[k] = g;
find[k+1] = g+1;
find[k+2] = g+2;
find[k+3] = g;
find[k+4] = g+2;
find[k+5] = g+3;
k+=6;
g+=4;
++m;
}
int j=k;
int n=m;
int h=g;
while (n<ENumber)
{
find[j] = h;
find[j+1] = h+1;
find[j+2] = h+2;
find[j+3] = h;
find[j+4] = h+2;
find[j+5] = h+3;
j+=6;
h+=4;
++n;
}
HR(mEFIB->Unlock());
// Set up the geometry data stream
HR(mFX->SetTechnique(mhEFTech));
HR(mFX->SetTexture(mhTex, mFoodTex));
HR(gd3dDevice->SetStreamSource(0, mEFVB, 0, sizeof(VertexPTEF)));
HR(gd3dDevice->SetIndices(mEFIB));
HR(gd3dDevice->SetVertexDeclaration(VertexPTEF::Decl));
HR(mFX->SetMatrix(mhWVP, &(mView*mProj)));
UINT numPasses = 0;
HR(mFX->Begin(&numPasses, 0));
for (UINT i=0; i<numPasses; ++i)
{
HR(mFX->BeginPass(i));
if (foodList.size() != 0)
HR(gd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4*FNumber, 0, 2*FNumber));
if (eggList.size() != 0)
{
HR(mFX->SetTexture(mhTex, mEggTex));
HR(mFX->CommitChanges());
HR(gd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, FNumber*4, 4*(ENumber-FNumber), FNumber*6, 2*(ENumber-FNumber)));
}
HR(mFX->EndPass());
}
HR(mFX->End());
if (mbEFStart)
mbEFStart = false;
}
void build_submodel( SubModel& m )
{
const std::vector< model_vertex_type >& vsrc = m.vertex_source;
const std::vector< WORD >& isrc = m.index_source;
if( vsrc.empty() || isrc.empty() ) {
return;
}
// triangle vb
{
IDirect3DVertexBuffer9* vb = NULL;
if( FAILED( device_->CreateVertexBuffer(
UINT( vsrc.size() ) *
sizeof( model_vertex_type ),
0,
0,
D3DPOOL_MANAGED,
&vb,
NULL ) ) ) {
onError( "create vertex buffer failed\n" );
return;
}
model_vertex_type* p;
if( FAILED( vb->Lock( 0, 0, (void**)&p, 0 ) ) ) {
onError( "Lock vertexbuffer failed\n" );
vb->Release();
return;
}
int mm = int(vsrc.size());
for( int j = 0 ; j < mm ; j++ ){
*p++ = vsrc[j];
}
vb->Unlock();
m.vb = vb;
}
// triangle ib
{
IDirect3DIndexBuffer9* ib = NULL;
if( FAILED( device_->CreateIndexBuffer(
UINT( isrc.size() ) *
sizeof( WORD ),
0,
D3DFMT_INDEX16,
D3DPOOL_MANAGED,
&ib,
NULL ) ) ) {
onError( "create index buffer failed\n" );
m.vb->Release();
return;
}
WORD* p;
if( FAILED( ib->Lock( 0, 0, (void**)&p, 0 ) ) ) {
onError( "Lock vertexbuffer failed\n" );
m.vb->Release();
ib->Release();
return;
}
int mm = int(isrc.size());
for( int j = 0 ; j < mm ; j++ ){
*p++ = isrc[j];
}
ib->Unlock();
m.ib = ib;
}
}
BYTE KScene::Draw(
IDirect3DDevice9* piDevice,
KVertexEx* pVertex, int nVertexCount,
KTriangleEx* pTriangle, int nTriangleCount,
BOOL bSolid,
BOOL bWireframe
)
{
BOOL bResult = false;
HRESULT hRetCode = E_FAIL;
IDirect3DVertexBuffer9* piVertexBuffer = NULL;
IDirect3DIndexBuffer9* piIndexBuffer = NULL;
void* pvBuffer = NULL;
hRetCode = piDevice->CreateVertexBuffer(
sizeof(KVertex) * nVertexCount, 0,
VERTEX_FVF, D3DPOOL_MANAGED, &piVertexBuffer, 0
);
KG_PROCESS_ERROR(!FAILED(hRetCode));
hRetCode = piVertexBuffer->Lock(0, 0, &pvBuffer, D3DLOCK_DISCARD);
KG_PROCESS_ERROR(!FAILED(hRetCode));
for (int i = 0; i < nVertexCount; i++)
{
KVertex* pV = (KVertex*)pvBuffer + i;
pV->vPos = pVertex[i].vPos;
pV->vNormal = pVertex[i].vNormal;
}
piVertexBuffer->Unlock();
hRetCode = piDevice->CreateIndexBuffer(
sizeof(KTriangle) * nTriangleCount, 0,
D3DFMT_INDEX32, D3DPOOL_MANAGED, &piIndexBuffer, 0
);
KG_PROCESS_ERROR(!FAILED(hRetCode));
hRetCode = piIndexBuffer->Lock(0, 0, &pvBuffer, D3DLOCK_DISCARD);
KG_PROCESS_ERROR(!FAILED(hRetCode));
for (int i = 0; i < nTriangleCount; i++)
{
KTriangle* pT = (KTriangle*)pvBuffer + i;
if (!pTriangle[i].pVertexA)
pT->nA = 0;
else
pT->nA = (int)(pTriangle[i].pVertexA - pVertex);
if (!pTriangle[i].pVertexB)
pT->nB = 0;
else
pT->nB = (int)(pTriangle[i].pVertexB - pVertex);
if (!pTriangle[i].pVertexC)
pT->nC = 0;
else
pT->nC = (int)(pTriangle[i].pVertexC - pVertex);
}
piIndexBuffer->Unlock();
piDevice->SetStreamSource(0, piVertexBuffer, 0, sizeof(KVertex));
piDevice->SetIndices(piIndexBuffer);
piDevice->SetFVF(VERTEX_FVF);
if (bSolid)
{
piDevice->SetRenderState(D3DRS_LIGHTING, true);
piDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
piDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, nVertexCount, 0, nTriangleCount);
}
if (bWireframe)
{
piDevice->SetRenderState(D3DRS_LIGHTING, false);
piDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
piDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, nVertexCount, 0, nTriangleCount);
}
bResult = true;
Exit0:
KG_COM_RELEASE(piIndexBuffer);
KG_COM_RELEASE(piVertexBuffer);
return bResult;
}
Map::Map(std::string RAW_File_Name,
int Vertex_Length,
int Vertex_Width,
int Cell_Spacing,
float Height_Scale)
{
vertex_length = Vertex_Length;
vertex_width = Vertex_Width;
total_vertices = vertex_length * vertex_width; //Total = L * W
cell_length = vertex_length - 1;
cell_width = vertex_width - 1;
cell_spacing = Cell_Spacing;
height_scale = Height_Scale;
length = cell_length * cell_spacing;
width = cell_width * cell_spacing;
total_triangles = cell_length * cell_width * 2;
D3DXCreateMeshFVF(cell_length * cell_width * 2,
vertex_length * vertex_width,
D3DXMESH_MANAGED,
Terrain_Vertex::FVF,
d3ddev,
&mesh);
if (!Raw_To_Int_Vector(RAW_File_Name))
{
MessageBox(0, "Raw_To_Int_Vector - FAILED", 0, 0);
PostQuitMessage(0);
}
for (int i = 0; i < height_int_vector.size(); i++)
{
height_float_vector.push_back((float)height_int_vector[i]);
height_float_vector[i] = height_float_vector[i] * height_scale;
}
if (!Create_Normals(&LightDirectionThree))
{
MessageBox(0, "Create_Normals - FAILED", 0, 0);
PostQuitMessage(0);
}
Generate_Vertex_Normals();
if (!Generate_Vertices())
{
MessageBox(0, "Generate_Vertices - FAILED", 0, 0);
PostQuitMessage(0);
}
if (!Generate_Indices()) //Also Generates Mesh
{
MessageBox(0, "Generate_Indices - FAILED", 0, 0);
PostQuitMessage(0);
}
adjacency_buffer = new DWORD[cell_width * cell_length * 2 * 3];
mesh->GenerateAdjacency(0.001f, adjacency_buffer);
mesh->OptimizeInplace(D3DXMESH_MANAGED |
D3DXMESHOPT_COMPACT |
D3DXMESHOPT_ATTRSORT |
D3DXMESHOPT_VERTEXCACHE,
adjacency_buffer,
adjacency_buffer,
0,
0);
IDirect3DVertexBuffer9* bufvert;
Terrain_Vertex* tempvert;
mesh->GetVertexBuffer(&bufvert);
bufvert->Lock(0, 0, (void**)&tempvert, 0);
vertexdata = tempvert;
bufvert->Unlock();
IDirect3DIndexBuffer9* bufind;
WORD* tempind;
mesh->GetIndexBuffer(&bufind);
bufind->Lock(0, 0, (void**)&tempind, 0);
indexdata = tempind;
bufind->Unlock();
SafeRelease(bufvert);
SafeRelease(bufind);
}