void WaterDemo::buildFX()
{
// Create the FX from a .fx file.
ID3DXBuffer* errors = 0;
HR(D3DXCreateEffectFromFile(gd3dDevice, "NormalMap.fx",
0, 0, D3DXSHADER_DEBUG, 0, &mFX, &errors));
if( errors )
MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);
// Obtain handles.
mhTech = mFX->GetTechniqueByName("NormalMapTech");
mhWVP = mFX->GetParameterByName(0, "gWVP");
mhWorldInv = mFX->GetParameterByName(0, "gWorldInv");
mhMtrl = mFX->GetParameterByName(0, "gMtrl");
mhLight = mFX->GetParameterByName(0, "gLight");
mhEyePosW = mFX->GetParameterByName(0, "gEyePosW");
mhTex = mFX->GetParameterByName(0, "gTex");
mhNormalMap = mFX->GetParameterByName(0, "gNormalMap");
// Set parameters that do not vary:
// World is the identity, so inverse is also identity.
HR(mFX->SetMatrix(mhWorldInv, &mSceneWorldInv));
HR(mFX->SetTechnique(mhTech));
}
void Game::drawScene()
{
// Clear the backbuffer and depth buffer.
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, gMyGameWorld->Background(), 1.0f, 0));
HR(gd3dDevice->BeginScene());
// Setup the rendering FX
HR(mFX->SetTechnique(mhTech));
//gMyGameWorld->Render(mFX, mhWVP, mView, mProj);
gMyGameWorld->Render(mFX, mhWVP, DXCI->getView(), mProj);
displayGfxStats();
//sprite
mSprite->Begin(D3DXSPRITE_ALPHABLEND);
mSprite->Flush();
mSprite->End();
HR(gd3dDevice->EndScene());
// Present the backbuffer.
HR(gd3dDevice->Present(0, 0, 0, 0));
}
void AmbientDiffuseDemo::drawScene()
{
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(255,255,255), 1.0f, 0));
HR(gd3dDevice->BeginScene());
HR(mFX->SetTechnique(mhTech));
HR(mFX->SetMatrix(mhWVP, &(mWorld*mView*mProj)));
D3DXMATRIX worldInverseTranspose;
D3DXMatrixInverse(&worldInverseTranspose, 0, &mWorld);
D3DXMatrixTranspose(&worldInverseTranspose, &worldInverseTranspose);
HR(mFX->SetMatrix(mhWorldInverseTranspose, &worldInverseTranspose));
HR(mFX->SetValue(mhLightVecW, &mLightVecW, sizeof(D3DXVECTOR3)));
HR(mFX->SetValue(mhDiffuseMtrl, &mDiffuseMtrl, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhDiffuseLight, &mDiffuseLight, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhAmbientMtrl, &mAmbientMtrl, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhAmbientLight, &mAmbientLight, sizeof(D3DXCOLOR)));
UINT numPasses = 0;
HR(mFX->Begin(&numPasses, 0));
for (UINT i = 0; i < numPasses; ++i)
{
HR(mFX->BeginPass(i));
HR(mTeapot->DrawSubset(0));
HR(mFX->EndPass());
}
HR(mFX->End());
mGfxStats->display(D3DCOLOR_XRGB(0,0,0));
HR(gd3dDevice->EndScene());
HR(gd3dDevice->Present(0, 0, 0, 0));
}
void MeshNode::Draw(IDirect3DDevice9* device) const{
if(!initialized)
return;
assert(NULL != device);
// set the transform
device->SetTransform(D3DTS_WORLDMATRIX(0), &transform_);
//FIXME Should not be accessed directly
ID3DXEffect* effect = GraphicsLayer::GetInstance().m_pEffect;
effect->SetMatrix( "g_WorldMatrix", &transform_);
effect->SetValue( "g_ColorTint", &m_colorMtrlTint, sizeof( D3DXCOLOR ) );
effect->SetValue( "g_TexOffset", &m_texOffset, sizeof( Vector2 ) );
assert(SUCCEEDED(effect->SetTechnique( "RenderSceneWithTextureDefault" )));
UINT cPasses = 1;
assert(SUCCEEDED(effect->Begin( &cPasses, 0 )));
for(UINT iPass = 0; iPass < cPasses; iPass++ )
{
effect->BeginPass( iPass ) ;
mesh_->Draw(device);
assert(SUCCEEDED(effect->EndPass()));
}
assert(SUCCEEDED(effect->End()));
if(NULL != boundsMesh_){
Matrix t = CreateMatrix(worldBounds_.center);
device->SetTransform(D3DTS_WORLDMATRIX(0), &t);
boundsMesh_->DrawSubset(0);
}
}
void TriGridDemo::drawScene()
{
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(255,255,255), 1.0f, 0));
HR(gd3dDevice->BeginScene());
HR(gd3dDevice->SetStreamSource(0, mVB, 0, sizeof(VertexPos)));
HR(gd3dDevice->SetIndices(mIB));
HR(gd3dDevice->SetVertexDeclaration(VertexPos::Decl));
HR(mFX->SetTechnique(mhTech));
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));
HR(gd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, mNumVertices, 0, mNumTriangles));
HR(mFX->EndPass());
}
HR(mFX->End());
mGfxStats->display(D3DCOLOR_XRGB(0,0,0));
HR(gd3dDevice->EndScene());
HR(gd3dDevice->Present(0, 0, 0, 0));
}
void MirrorDemo::drawScene()
{
// Clear the backbuffer and depth buffer.
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER |
D3DCLEAR_STENCIL, 0xffeeeeee, 1.0f, 0));
HR(gd3dDevice->BeginScene());
HR(mFX->SetTechnique(mhTech));
HR(mFX->SetValue(mhLightVecW, &mLightVecW, sizeof(D3DXVECTOR3)));
HR(mFX->SetValue(mhDiffuseLight, &mDiffuseLight, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhAmbientLight, &mAmbientLight, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecularLight, &mSpecularLight, sizeof(D3DXCOLOR)));
// All objects use the same material.
HR(mFX->SetValue(mhAmbientMtrl, &mWhiteMtrl.ambient, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhDiffuseMtrl, &mWhiteMtrl.diffuse, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecularMtrl, &mWhiteMtrl.spec, sizeof(D3DXCOLOR)));
HR(mFX->SetFloat(mhSpecularPower, mWhiteMtrl.specPower));
drawRoom();
drawMirror();
drawTeapot();
drawReflectedTeapot();
mGfxStats->display();
HR(gd3dDevice->EndScene());
// Present the backbuffer.
HR(gd3dDevice->Present(0, 0, 0, 0));
}
void MultiTexDemo::drawScene()
{
// Clear the backbuffer and depth buffer.
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffeeeeee, 1.0f, 0));
HR(gd3dDevice->BeginScene());
// Setup the rendering FX
HR(mFX->SetTechnique(mhTech));
HR(mFX->SetMatrix(mhWVP, &(mWorld*mView*mProj)));
D3DXMATRIX worldInvTrans;
D3DXMatrixInverse(&worldInvTrans, 0, &mWorld);
D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans);
HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans));
HR(mFX->SetValue(mhLightVecW, &mLightVecW, sizeof(D3DXVECTOR3)));
HR(mFX->SetValue(mhDiffuseMtrl, &mDiffuseMtrl, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhDiffuseLight, &mDiffuseLight, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhAmbientMtrl, &mAmbientMtrl, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhAmbientLight, &mAmbientLight, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecularLight, &mSpecularLight, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecularMtrl, &mSpecularMtrl, sizeof(D3DXCOLOR)));
HR(mFX->SetFloat(mhSpecularPower, mSpecularPower));
HR(mFX->SetMatrix(mhWorld, &mWorld));
HR(mFX->SetTexture(mhTex0, mTex0));
HR(mFX->SetTexture(mhTex1, mTex1));
HR(mFX->SetTexture(mhTex2, mTex2));
HR(mFX->SetTexture(mhBlendMap, mBlendMap));
HR(gd3dDevice->SetVertexDeclaration(VertexPNT::Decl));
HR(gd3dDevice->SetStreamSource(0, mGridVB, 0, sizeof(VertexPNT)));
HR(gd3dDevice->SetIndices(mGridIB));
// Begin passes.
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, mNumGridVertices, 0, mNumGridTriangles));
HR(mFX->EndPass());
}
HR(mFX->End());
mGfxStats->display();
HR(gd3dDevice->EndScene());
// Present the backbuffer.
HR(gd3dDevice->Present(0, 0, 0, 0));
}
void SolarSysDemo::drawScene()
{
// Clear the backbuffer and depth buffer.
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff000000, 1.0f, 0));
HR(gd3dDevice->BeginScene());
HR(mFX->SetValue(mhLight, &mLight, sizeof(DirLight)));
HR(mFX->SetTechnique(mhTech));
UINT numPasses = 0;
HR(mFX->Begin(&numPasses, 0));
HR(mFX->BeginPass(0));
// Wrap the texture coordinates that get assigned to TEXCOORD2 in the pixel shader.
HR(gd3dDevice->SetRenderState(D3DRS_WRAP2, D3DWRAP_U));
// Build the world transforms for each frame, then render them.
buildObjectWorldTransforms();
D3DXMATRIX S;
for(int i = 0; i < NUM_OBJECTS; ++i)
{
float s = mObject[i].size;
D3DXMatrixScaling(&S, s, s, s);
// Prefix the frame matrix with a scaling transformation to
// size it relative to the world.
mWorld = S * mObject[i].toWorldXForm;
HR(mFX->SetMatrix(mhWVP, &(mWorld*mView*mProj)));
D3DXMATRIX worldInvTrans;
D3DXMatrixInverse(&worldInvTrans, 0, &mWorld);
D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans);
HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans));
HR(mFX->SetMatrix(mhWorld, &mWorld));
HR(mFX->SetValue(mhMtrl, &mWhiteMtrl, sizeof(Mtrl)));
HR(mFX->SetTexture(mhTex, mObject[i].tex));
HR(mFX->CommitChanges());
mSphere->DrawSubset(0);
}
HR(gd3dDevice->SetRenderState(D3DRS_WRAP2, 0));
HR(mFX->EndPass());
HR(mFX->End());
mGfxStats->display();
HR(gd3dDevice->EndScene());
// Present the backbuffer.
HR(gd3dDevice->Present(0, 0, 0, 0));
}
void DiffusePyramidDemo::drawScene()
{
// Clear the backbuffer and depth buffer.
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffeeeeee, 1.0f, 0));
HR(gd3dDevice->BeginScene());
// Let Direct3D know the vertex buffer, index buffer and vertex
// declaration we are using.
HR(gd3dDevice->SetStreamSource(0, mVB, 0, sizeof(VertexPN)));
HR(gd3dDevice->SetVertexDeclaration(VertexPN::Decl));
// Setup the rendering FX
HR(mFX->SetTechnique(mhTech));
HR(mFX->SetMatrix(mhWVP, &(mWorld*mView*mProj)));
D3DXMATRIX worldInverseTranspose , tmp1;
D3DXMatrixInverse(&worldInverseTranspose, 0, &mWorld);
D3DXMatrixTranspose(&tmp1, &worldInverseTranspose);
////! debug
//if (worldInverseTranspose!=tmp1)
//{
// DebugBreak();
//}
HR(mFX->SetMatrix(mhWorldInverseTranspose, &worldInverseTranspose));
HR(mFX->SetValue(mhLightVecW, &mLightVecW, sizeof(D3DXVECTOR3)));
HR(mFX->SetValue(mhDiffuseMtrl, &mDiffuseMtrl, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhDiffuseLight, &mDiffuseLight, sizeof(D3DXCOLOR)));
// Begin passes.
UINT numPasses = 0;
HR(mFX->Begin(&numPasses, 0));
for(UINT i = 0; i < numPasses; ++i)
{
HR(mFX->BeginPass(i));
HR(gd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 4));
HR(mFX->EndPass());
}
HR(mFX->End());
mGfxStats->display();
HR(gd3dDevice->EndScene());
// Present the backbuffer.
HR(gd3dDevice->Present(0, 0, 0, 0));
}
void RCBindEffect::execute( Renderer& renderer )
{
DX9Renderer& dxRenderer = static_cast< DX9Renderer& >( renderer );
ID3DXEffect* dxEffect = dxRenderer.getEffect( m_shader );
if ( !dxEffect )
{
return;
}
// set the shader parameters
dxEffect->SetTechnique( m_techniqueName.c_str() );
setParams( renderer, dxEffect );
// begin the rendering process
unsigned int passesCount;
dxEffect->Begin( &passesCount, 0 );
}
void XFileDemo::drawScene()
{
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffeeeeee, 1.0f, 0));
HR(gd3dDevice->BeginScene());
HR(mFX->SetValue(mhLight, &mLight, sizeof(DirLight)));
HR(mFX->SetMatrix(mhWVP, &(mWorld*mView*mProj)));
D3DXMATRIX worldInvTrans;
D3DXMatrixInverse(&worldInvTrans, 0, &mWorld);
D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans);
HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans));
HR(mFX->SetMatrix(mhWorld, &mWorld));
HR(mFX->SetTechnique(mhTech));
UINT numPasses = 0;
HR(mFX->Begin(&numPasses, 0));
HR(mFX->BeginPass(0));
for (int j = 0; j < mMtrl.size(); ++j)
{
HR(mFX->SetValue(mhMtrl, &mMtrl[j], sizeof(Material)));
if (mTex[j] != 0)
{
HR(mFX->SetTexture(mhTex, mTex[j]));
}
else
{
HR(mFX->SetTexture(mhTex, mWhiteTex));
}
HR(mFX->CommitChanges());
HR(mMesh->DrawSubset(j));
}
HR(mFX->EndPass());
HR(mFX->End());
mGfxStats->display(D3DCOLOR_XRGB(0,0,0));
HR(gd3dDevice->EndScene());
HR(gd3dDevice->Present(0, 0, 0, 0));
}
void ProjTexDemo::drawScene()
{
HR(gd3dDevice->BeginScene());
// Draw sky first--this also replaces our gd3dDevice->Clear call.
//mSky->draw();
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0));
// Draw the scene mesh.
HR(mFX->SetTechnique(mhTech));
HR(mFX->SetMatrix(mhWorldInvTrans, &mSceneWorld));
HR(mFX->SetMatrix(mhWorld, &mSceneWorld));
HR(mFX->SetValue(mhLight, &mLight, sizeof(SpotLight)));
HR(mFX->SetMatrix(mhWVP, &(mSceneWorld*gCamera->viewProj())));
HR(mFX->SetValue(mhEyePosW, &gCamera->pos(), sizeof(D3DXVECTOR3)));
HR(mFX->SetTexture(mhTex, mSkullTex));
HR(mFX->SetMatrix(mhLightWVP, &mLightWVP));
UINT numPasses = 0;
HR(mFX->Begin(&numPasses, 0));
HR(mFX->BeginPass(0));
for(UINT j = 0; j < mSceneMtrls.size(); ++j)
{
HR(mFX->SetValue(mhMtrl, &mSceneMtrls[j], sizeof(Mtrl)));
HR(mFX->CommitChanges());
HR(mSceneMesh->DrawSubset(j));
}
HR(mFX->EndPass());
HR(mFX->End());
mGfxStats->display();
HR(gd3dDevice->EndScene());
// Present the backbuffer.
HR(gd3dDevice->Present(0, 0, 0, 0));
}
void PropsDemo::buildFX()
{
// Create the generic Light & Tex FX from a .fx file.
ID3DXBuffer* errors = 0;
HR(D3DXCreateEffectFromFile(gd3dDevice, "DirLightTex.fx",
0, 0, 0, 0, &mFX, &errors));
if( errors )
MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);
// Obtain handles.
mhTech = mFX->GetTechniqueByName("DirLightTexTech");
mhWVP = mFX->GetParameterByName(0, "gWVP");
mhWorldInvTrans = mFX->GetParameterByName(0, "gWorldInvTrans");
mhMtrl = mFX->GetParameterByName(0, "gMtrl");
mhLight = mFX->GetParameterByName(0, "gLight");
mhEyePosW = mFX->GetParameterByName(0, "gEyePosW");
mhWorld = mFX->GetParameterByName(0, "gWorld");
mhTex = mFX->GetParameterByName(0, "gTex");
// Create the grass FX from a .fx file.
HR(D3DXCreateEffectFromFile(gd3dDevice, "grass.fx",
0, 0, 0, 0, &mGrassFX, &errors));
if( errors )
MessageBox(0, (char*)errors->GetBufferPointer(), 0, 0);
// Obtain handles.
mhGrassTech = mGrassFX->GetTechniqueByName("GrassTech");
mhGrassViewProj = mGrassFX->GetParameterByName(0, "gViewProj");
mhGrassTex = mGrassFX->GetParameterByName(0, "gTex");
mhGrassTime = mGrassFX->GetParameterByName(0, "gTime");
mhGrassEyePosW = mGrassFX->GetParameterByName(0, "gEyePosW");
mhGrassDirToSunW= mGrassFX->GetParameterByName(0, "gDirToSunW");
HR(mGrassFX->SetTechnique(mhGrassTech));
HR(mGrassFX->SetTexture(mhGrassTex, mGrassTex));
}
void GateDemo::drawScene()
{
// Clear the backbuffer and depth buffer.
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffeeeeee, 1.0f, 0));
HR(gd3dDevice->BeginScene());
// Setup the rendering FX
HR(mFX->SetTechnique(mhTech));
HR(mFX->SetValue(mhLightVecW, &mLightVecW, sizeof(D3DXVECTOR3)));
HR(mFX->SetValue(mhDiffuseLight, &mDiffuseLight, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhAmbientLight, &mAmbientLight, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecularLight, &mSpecularLight, sizeof(D3DXCOLOR)));
drawGround();
drawGate();
mGfxStats->display();
HR(gd3dDevice->EndScene());
// Present the backbuffer.
HR(gd3dDevice->Present(0, 0, 0, 0));
}
bool Action(IDirect3DDevice9 *d3dev, IDirect3DTexture9 *src, IDirect3DTexture9 *dst, float w, float h, float power, dword color)
{
CUSTOMVERTEX vertices[] =
{
{ 0.0f, 0.0f, 0.5f, 1.f, 0xffffffff, 0.f, 0.f},
{ 320.0f, 0.0f, 0.5f, 1.f, 0xffffffff, 1.f, 0.f},
{ 320.0f, 240.0f, 0.5f, 1.f, 0xffffffff, 1.f, 1.f},
{ 0.0f, 0.0f, 0.5f, 1.f, 0xffffffff, 0.f, 0.f},
{ 320.0f, 240.0f, 0.5f, 1.f, 0xffffffff, 1.f, 1.f},
{ 0.0f, 240.0f, 0.5f, 1.f, 0xffffffff, 0.f, 1.f}
};
HRESULT r;
VOID *pVertices;
int texType;
float texCx,texCy;
vertices[0].x=0;
vertices[0].y=0;
vertices[1].x=w;
vertices[1].y=0;
vertices[2].x=w;
vertices[2].y=h;
vertices[3].x=0;
vertices[3].y=0;
vertices[4].x=w;
vertices[4].y=h;
vertices[5].x=0;
vertices[5].y=h;
/*
vertices[0].color=0xFFFFFFFF;
vertices[1].color=0xFFFFFFFF;
vertices[2].color=0xFFFFFFFF;
vertices[3].color=0xFFFFFFFF;
vertices[4].color=0xFFFFFFFF;
vertices[5].color=0xFFFFFFFF;
*/
assert(VBUFSIZE==sizeof(vertices));
if(vb->Lock(0, VBUFSIZE, (void**)&pVertices, 0)==D3D_OK)
{
memcpy(pVertices, vertices, VBUFSIZE);
vb->Unlock();
}
IDirect3DSurface9 *renderO=null;
IDirect3DSurface9 *renderS=null;
d3dev->GetRenderTarget(0, &renderO);
if(dst->GetSurfaceLevel(0, &renderS)==D3D_OK)
{
d3dev->BeginScene();
d3dev->SetRenderTarget(0, renderS);
if(effect)
{
effect->SetTechnique("elektronika");
effect->SetTexture("texture0", src);
if(hColor)
{
D3DXVECTOR4 v;
byte rc,gc,bc;
colorRGB(&rc,&gc, &bc, (dword)color);
v.x=(float)rc/255.f;
v.y=(float)gc/255.f;
v.z=(float)bc/255.f;
v.w=1.f;
effect->SetVector(hColor, &v);
}
if(hPower)
effect->SetFloat(hPower, (FLOAT)power);
r=d3dev->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
r=d3dev->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);
r=d3dev->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_TEXTURE);
r=d3dev->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
r=d3dev->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
r=d3dev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_ONE);
r=d3dev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_ZERO);
r=d3dev->SetRenderState(D3DRS_BLENDOP, D3DBLENDOP_ADD);
{
UINT uPasses;
effect->Begin( &uPasses, 0 );
for( UINT uPass = 0; uPass < uPasses; ++uPass )
{
effect->BeginPass( uPass );
r=d3dev->SetStreamSource(0, vb, 0, sizeof(CUSTOMVERTEX));
r=d3dev->SetFVF(D3DFVF_CUSTOMVERTEX);
r=d3dev->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);
effect->EndPass();
}
effect->End();
}
}
d3dev->EndScene();
renderS->Release();
}
d3dev->SetRenderTarget(0, renderO);
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;
}
// NOTE: The texture list needs to change to be device independent...
void CD3DRigidMesh::Render(D3DMATRIX& WorldTransform,CD3DRenderStyle* pRenderStyle,vector<LPDXTexture>& TextureList)
{
if (pRenderStyle == NULL) return;
g_RenderStateMgr.SetTransform(D3DTS_WORLDMATRIX(0), &WorldTransform);
PD3DDEVICE->SetRenderState(D3DRS_VERTEXBLEND,D3DVBF_DISABLE);
PD3DDEVICE->SetRenderState(D3DRS_LIGHTING,TRUE);
PD3DDEVICE->SetRenderState(D3DRS_NORMALIZENORMALS,FALSE);
//m_VBController.SetStreamSources();
if( (g_EffectMgr.GetEnabled()) && (g_EffectMgr.GetEffect() != NULL) )
{
ID3DXEffect *pEffect = g_EffectMgr.GetEffect();
g_EffectMgr.UploadVertexDecl();
m_VBController.SetStreamSources();
// This is a temp HACK
//g_RenderStateMgr.SetRenderStyleStates(pRenderStyle,0,TextureList);
pEffect->SetTechnique(g_EffectMgr.GetTechnique());
D3DXMATRIX matD3DX( *g_RenderStateMgr.GetTransform(D3DTS_WORLD));
D3DXMATRIX MatWorld;
D3DXMatrixTranspose(&MatWorld, &matD3DX);
pEffect->SetMatrix("worldMatrix", &MatWorld);
//view proj
D3DXMATRIX MatView;
PD3DDEVICE->GetTransform(D3DTS_VIEW, &MatView);
pEffect->SetMatrix("viewMatrix", &MatView);
D3DXMATRIX MatProj;
PD3DDEVICE->GetTransform(D3DTS_PROJECTION, &MatProj);
pEffect->SetMatrix("projMatrix", &MatProj);
D3DXMATRIX MatViewProj;
D3DXMatrixMultiply(&MatViewProj, &MatView, &MatProj);
D3DXMatrixTranspose(&MatViewProj, &MatViewProj);
D3DXMATRIX matD3DX2( MatViewProj);
pEffect->SetMatrix("viewProjMatrix", &matD3DX2);
float fTemp[4];
fTemp[0] = g_EffectMgr.GetPosition()->x;
fTemp[1] = g_EffectMgr.GetPosition()->y;
fTemp[2] = g_EffectMgr.GetPosition()->z;
fTemp[3] = 0.0f;
pEffect->SetFloatArray("CameraPosition", fTemp, 4);
char szBuf[32];
ZeroMemory(szBuf, 32);
for (uint32 iTexStage = 0; iTexStage < 4; ++iTexStage)
{
if(TextureList[iTexStage])
{
PD3DDEVICE->SetTexture(iTexStage, TextureList[iTexStage]->GetTexture());
sprintf(szBuf, "texture%d", iTexStage);
D3DXHANDLE hHandle = pEffect->GetParameterByName(NULL, szBuf);
HRESULT hrTex = pEffect->SetTexture(hHandle, TextureList[iTexStage]->GetTexture());
if(FAILED(hrTex))
{
OutputDebugString("Error sending texture to Effect!");
}
}
}
UINT nPasses;
pEffect->Begin(&nPasses, 0);
for(int n = 0; n < (int)nPasses; ++n)
{
pEffect->BeginPass(n);
m_VBController.Render(0,0,m_iVertCount,m_iPolyCount);
pEffect->EndPass();
}
pEffect->End();
PD3DDEVICE->SetTexture(0, NULL);
PD3DDEVICE->SetTexture(1, NULL);
PD3DDEVICE->SetTexture(2, NULL);
PD3DDEVICE->SetTexture(3, NULL);
}
else
{
g_EffectMgr.UploadVertexDecl();
m_VBController.SetStreamSources();
for (uint32 iRenderPass = 0; iRenderPass < pRenderStyle->GetRenderPassCount(); ++iRenderPass)
{
LPDIRECT3DVERTEXSHADER9 VertexShader = pRenderStyle->GetVertexShader(iRenderPass,0);
RSD3DRenderPass D3DRenderPass;
if (VertexShader)
{ // Using a custom vertex shader...
if (FAILED(g_RenderStateMgr.SetVertexShader(VertexShader))) { assert(0); return; }
if (!pRenderStyle->GetRenderPass_D3DOptions(iRenderPass,&D3DRenderPass)) { assert(0); return; }
// if (!g_RenderStateMgr.SetVertexShaderConstants(pRenderStyle, &D3DRenderPass,0)) { assert(0); return; }
}
else
{
// Using the standand pipe...
/*
if (!m_VBController.getVertexFormat(0)) return; // This is a non fixed function pipe VB - bail out...
if (FAILED(g_RenderStateMgr.SetFVF(m_VBController.getVertexFormat(0))))
{
assert(0);
return;
}
*/
}
g_RenderStateMgr.SetRenderStyleStates(pRenderStyle,iRenderPass,TextureList); // Set your render states with the render state mgr...
//g_EffectMgr.UploadVertexDecl();
m_VBController.Render(0,0,m_iVertCount,m_iPolyCount);
}
}
D3DXMATRIX mIdentity; D3DXMatrixIdentity(&mIdentity); // Reset our World Matrix...
g_RenderStateMgr.SetTransform(D3DTS_WORLDMATRIX(0),&mIdentity);
PD3DDEVICE->SetRenderState(D3DRS_LIGHTING,FALSE);
PD3DDEVICE->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
PD3DDEVICE->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
PD3DDEVICE->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
PD3DDEVICE->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_MODULATE);
PD3DDEVICE->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_MODULATE);
}
////////////////////////////////////////////////////////////////
//
// CEffectTemplateImpl::CreateUnderlyingData
//
//
//
////////////////////////////////////////////////////////////////
void CEffectTemplateImpl::CreateUnderlyingData ( const SString& strFilename, const SString& strRootPath, SString& strOutStatus, bool bDebug )
{
assert ( !m_pD3DEffect );
// Make defines
bool bUsesRAWZ = CGraphics::GetSingleton ().GetRenderItemManager ()->GetDepthBufferFormat () == RFORMAT_RAWZ;
std::vector < D3DXMACRO > macroList;
macroList.push_back ( D3DXMACRO () );
macroList.back ().Name = "IS_DEPTHBUFFER_RAWZ";
macroList.back ().Definition = bUsesRAWZ ? "1" : "0";
macroList.push_back ( D3DXMACRO () );
macroList.back ().Name = NULL;
macroList.back ().Definition = NULL;
// Compile effect
DWORD dwFlags = 0; // D3DXSHADER_PARTIALPRECISION, D3DXSHADER_DEBUG, D3DXFX_NOT_CLONEABLE;
if ( bDebug )
dwFlags |= D3DXSHADER_DEBUG;
SString strMetaPath = strFilename.Right ( strFilename.length () - strRootPath.length () );
CIncludeManager IncludeManager ( strRootPath, ExtractPath ( strMetaPath ) );
LPD3DXBUFFER pBufferErrors = NULL;
HRESULT hr = D3DXCreateEffectFromFile( m_pDevice, ExtractFilename ( strMetaPath ), ¯oList[0], &IncludeManager, dwFlags, NULL, &m_pD3DEffect, &pBufferErrors );
// Handle compile errors
strOutStatus = "";
if( pBufferErrors != NULL )
{
strOutStatus = SStringX ( (CHAR*)pBufferErrors->GetBufferPointer() ).TrimEnd ( "\n" );
// Error messages sometimes contain the current directory. Remove that here.
SString strCurrentDirectory = GetSystemCurrentDirectory();
strOutStatus = strOutStatus.ReplaceI ( strCurrentDirectory + "\\", "" );
strOutStatus = strOutStatus.ReplaceI ( strCurrentDirectory, "" );
}
SAFE_RELEASE( pBufferErrors );
if( !m_pD3DEffect )
{
if ( strOutStatus.empty () )
strOutStatus = SString ( "[D3DXCreateEffectFromFile failed (%08x)%s]", hr, *IncludeManager.m_strReport );
return;
}
// Find first valid technique
D3DXHANDLE hTechnique = NULL;
D3DXEFFECT_DESC EffectDesc;
m_pD3DEffect->GetDesc ( &EffectDesc );
for ( uint uiAttempt = 0 ; true ; uiAttempt++ )
{
SString strProblemInfo = "";
for ( uint i = 0 ; i < EffectDesc.Techniques ; i++ )
{
SString strErrorExtra;
D3DXHANDLE hTemp = m_pD3DEffect->GetTechnique ( i );
HRESULT hr = m_pD3DEffect->ValidateTechnique ( hTemp );
if ( SUCCEEDED( hr ) )
{
// Check depth buffer rules
if ( ValidateDepthBufferUsage ( hTemp, strErrorExtra ) )
{
hTechnique = hTemp;
break;
}
}
// Update problem string
D3DXTECHNIQUE_DESC TechniqueDesc;
m_pD3DEffect->GetTechniqueDesc( hTemp, &TechniqueDesc );
strProblemInfo += SString ( "['%s' (%d/%d) failed (%08x)%s]", TechniqueDesc.Name, i, EffectDesc.Techniques, hr, *strErrorExtra );
}
// Found valid technique
if ( hTechnique )
break;
// Error if can't find a valid technique after 2nd attempt
if ( uiAttempt > 0 )
{
strOutStatus = SString ( "No valid technique; [Techniques:%d %s]%s", EffectDesc.Techniques, *strProblemInfo, *IncludeManager.m_strReport );
SAFE_RELEASE ( m_pD3DEffect );
return;
}
// Try resetting samplers if 1st attempt failed
LPDIRECT3DDEVICE9 pDevice;
m_pD3DEffect->GetDevice ( &pDevice );
for ( uint i = 0 ; i < 16 ; i++ )
{
pDevice->SetSamplerState ( i, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR );
pDevice->SetSamplerState ( i, D3DSAMP_MINFILTER, D3DTEXF_LINEAR );
pDevice->SetSamplerState ( i, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR );
}
}
// Set technique
m_pD3DEffect->SetTechnique( hTechnique );
// Inform user of technique name
D3DXTECHNIQUE_DESC TechniqueDesc;
m_pD3DEffect->GetTechniqueDesc( hTechnique, &TechniqueDesc );
strOutStatus = TechniqueDesc.Name;
if ( bDebug )
{
// Disassemble effect
LPD3DXBUFFER pDisassembly = NULL;
if ( SUCCEEDED( D3DXDisassembleEffect( m_pD3DEffect, false, &pDisassembly ) ) && pDisassembly )
{
LPVOID pData = pDisassembly->GetBufferPointer();
DWORD Size = pDisassembly->GetBufferSize();
if( pData && Size )
{
SString strDisassemblyContents;
strDisassemblyContents.assign ( (const char*)pData, Size - 1 );
FileSave ( strFilename + ".dis", strDisassemblyContents );
}
SAFE_RELEASE( pDisassembly );
}
}
// Copy MD5s of all loaded files
m_FileMD5Map = IncludeManager.m_FileMD5Map;
dassert ( !HaveFilesChanged() );
}
void RobotArmDemo::drawScene()
{
// Clear the backbuffer and depth buffer.
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0));
HR(gd3dDevice->BeginScene());
HR(mFX->SetValue(mhLight, &mLight, sizeof(DirLight)));
HR(mFX->SetTechnique(mhTech));
UINT numPasses = 0;
HR(mFX->Begin(&numPasses, 0));
HR(mFX->BeginPass(0));
// Build the world transforms for each bone, then render them.
buildBoneWorldTransforms();
D3DXMATRIX T;
D3DXMatrixTranslation(&T, -NUM_BONES, 0.0f, 0.0f);
for(int i = 0; i < NUM_BONES; ++i)
{
// Append the transformation with a slight translation to better
// center the skeleton at the center of the scene.
mWorld = mBones[i].toWorldXForm * T;
HR(mFX->SetMatrix(mhWVP, &(mWorld*mView*mProj)));
D3DXMATRIX worldInvTrans;
D3DXMatrixInverse(&worldInvTrans, 0, &mWorld);
D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans);
HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans));
HR(mFX->SetMatrix(mhWorld, &mWorld));
for(int j = 0; j < mMtrl.size(); ++j)
{
HR(mFX->SetValue(mhMtrl, &mMtrl[j], sizeof(Mtrl)));
// If there is a texture, then use.
if(mTex[j] != 0)
{
HR(mFX->SetTexture(mhTex, mTex[j]));
}
// But if not, then set a pure white texture. When the texture color
// is multiplied by the color from lighting, it is like multiplying by
// 1 and won't change the color from lighting.
else
{
HR(mFX->SetTexture(mhTex, mWhiteTex));
}
HR(mFX->CommitChanges());
HR(mBoneMesh->DrawSubset(j));
}
}
HR(mFX->EndPass());
HR(mFX->End());
mGfxStats->display();
HR(gd3dDevice->EndScene());
// Present the backbuffer.
HR(gd3dDevice->Present(0, 0, 0, 0));
}
void PropsDemo::drawScene()
{
// Clear the backbuffer and depth buffer.
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xff888888, 1.0f, 0));
HR(gd3dDevice->BeginScene());
HR(mFX->SetValue(mhEyePosW, &gCamera->pos(), sizeof(D3DXVECTOR3)));
HR(mFX->SetTechnique(mhTech));
UINT numPasses = 0;
HR(mFX->Begin(&numPasses, 0));
HR(mFX->BeginPass(0));
drawObject(mCastle, mCastleWorld);
// Use alpha test to block non leaf pixels from being rendered in the
// trees (i.e., use alpha mask).
HR(gd3dDevice->SetRenderState(D3DRS_ALPHATESTENABLE, true));
HR(gd3dDevice->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL));
HR(gd3dDevice->SetRenderState(D3DRS_ALPHAREF, 200));
// Draw the trees: NUM_TREES/4 of each of the four types.
for(int i = 0; i < NUM_TREES; ++i)
{
if( i < NUM_TREES/4 )
drawObject(mTrees[0], mTreeWorlds[i]);
else if( i < 2*NUM_TREES/4 )
drawObject(mTrees[1], mTreeWorlds[i]);
else if( i < 3*NUM_TREES/4 )
drawObject(mTrees[2], mTreeWorlds[i]);
else
drawObject(mTrees[3], mTreeWorlds[i]);
}
HR(gd3dDevice->SetRenderState(D3DRS_ALPHATESTENABLE, false));
HR(mFX->EndPass());
HR(mFX->End());
HR(mGrassFX->SetValue(mhGrassEyePosW, &gCamera->pos(), sizeof(D3DXVECTOR3)));
HR(mGrassFX->SetMatrix(mhGrassViewProj, &(gCamera->viewProj())));
HR(mGrassFX->SetFloat(mhGrassTime, mTime));
HR(mGrassFX->Begin(&numPasses, 0));
HR(mGrassFX->BeginPass(0));
// Draw to depth buffer only.
HR(mGrassMesh->DrawSubset(0));
HR(mGrassFX->EndPass());
HR(mGrassFX->End());
mTerrain->draw();
mWater->draw(); // draw alpha blended objects last.
mGfxStats->display();
HR(gd3dDevice->EndScene());
// Present the backbuffer.
HR(gd3dDevice->Present(0, 0, 0, 0));
}
//------------------------------------------------------------------------------
//this is a check function
//------------------------------------------------------------------------------
void TriPickDemo::checkPick(LPD3DXMESH mesh, D3DXMATRIX matWorld)
{
HRESULT hr;
D3DXMATRIX mWorldViewProjection;
mWorldViewProjection = matWorld * g_Camera->viewProj();
HR(m_FX->SetTechnique("RenderScene"));
// send matrix to shader
HR(m_FX->SetMatrix("g_mWorldViewProjection", &mWorldViewProjection));
HR(m_FX->SetMatrix("g_mWorld", &matWorld));
UINT uPasses;
V(m_FX->Begin(&uPasses, 0));
g_pDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID);
V(m_FX->BeginPass(0));
//get select ray
D3DXVECTOR3 originW(0.0f, 0.0f, 0.0f);
D3DXVECTOR3 dirW(0.0f, 0.0f, 0.0f);
if (gDInput->mouseButtonDown(0))
{
getWorldPickingRay(originW, dirW, matWorld);
LPD3DXMESH pMesh;
mesh->CloneMeshFVF(D3DXMESH_MANAGED, D3DVERTEX::FVF, g_pDevice, &pMesh);
BOOL hit = 0;
DWORD faceIndex = -1;
float u = 0.0f;
float v = 0.0f;
float dist = 0.0f;
ID3DXBuffer* allhits = 0;
DWORD numHits = 0;
HR(D3DXIntersect(pMesh, &originW, &dirW, &hit,
&faceIndex, &u, &v, &dist, &allhits, &numHits));
SAFE_RELEASE(allhits);
//if hit
if (hit)
{
IDirect3DVertexBuffer9* vb = 0;
IDirect3DIndexBuffer9* ib = 0;
HR(pMesh->GetVertexBuffer(&vb));
HR(pMesh->GetIndexBuffer(&ib));
HR(g_pDevice->SetIndices(ib));
HR(g_pDevice->SetFVF(D3DVERTEX::FVF));
HR(g_pDevice->SetStreamSource(0, vb, 0, sizeof(D3DVERTEX)));
//render hit surface
HR(g_pDevice->DrawIndexedPrimitive(
D3DPT_TRIANGLELIST, 0, 0, pMesh->GetNumVertices(), faceIndex * 3, 1))
g_pDevice->SetRenderState(D3DRS_LIGHTING, FALSE);
SAFE_RELEASE(vb);
SAFE_RELEASE(ib);
SAFE_RELEASE(pMesh);
}
}
HR(m_FX->EndPass());
HR(m_FX->End());
}
