void MirrorDemo::drawTeapot()
{
// Cylindrically interpolate texture coordinates.
HR(gd3dDevice->SetRenderState(D3DRS_WRAP0, D3DWRAPCOORD_0));
HR(mFX->SetMatrix(mhWVP, &(mTeapotWorld*mView*mProj)));
D3DXMATRIX worldInvTrans;
D3DXMatrixInverse(&worldInvTrans, 0, &mTeapotWorld);
D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans);
HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans));
HR(mFX->SetMatrix(mhWorld, &mTeapotWorld));
HR(mFX->SetTexture(mhTex, mTeapotTex));
// Begin passes.
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());
// Disable wrap.
HR(gd3dDevice->SetRenderState(D3DRS_WRAP0, 0));
}
void MirrorDemo::drawMirror()
{
HR(mFX->SetMatrix(mhWVP, &(mRoomWorld*mView*mProj)));
D3DXMATRIX worldInvTrans;
D3DXMatrixInverse(&worldInvTrans, 0, &mRoomWorld);
D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans);
HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans));
HR(mFX->SetMatrix(mhWorld, &mRoomWorld));
HR(mFX->SetTexture(mhTex, mMirrorTex));
HR(gd3dDevice->SetVertexDeclaration(VertexPNT::Decl));
HR(gd3dDevice->SetStreamSource(0, mRoomVB, 0, sizeof(VertexPNT)));
// Begin passes.
UINT numPasses = 0;
HR(mFX->Begin(&numPasses, 0));
for(UINT i = 0; i < numPasses; ++i)
{
HR(mFX->BeginPass(i));
// draw the mirror
HR(gd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 18, 2));
HR(mFX->EndPass());
}
HR(mFX->End());
}
void GateDemo::drawGround()
{
HR(mFX->SetValue(mhAmbientMtrl, &mGroundMtrl.ambient, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhDiffuseMtrl, &mGroundMtrl.diffuse, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecularMtrl, &mGroundMtrl.spec, sizeof(D3DXCOLOR)));
HR(mFX->SetFloat(mhSpecularPower, mGroundMtrl.specPower));
HR(mFX->SetMatrix(mhWVP, &(mGroundWorld*mView*mProj)));
D3DXMATRIX worldInvTrans;
D3DXMatrixInverse(&worldInvTrans, 0, &mGroundWorld);
D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans);
HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans));
HR(mFX->SetMatrix(mhWorld, &mGroundWorld));
HR(mFX->SetTexture(mhTex, mGroundTex));
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());
}
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 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 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 WaterDemo::drawScene()
{
HR(gd3dDevice->BeginScene());
mSky->draw();
HR(mFX->SetValue(mhLight, &mLight, sizeof(DirLight)));
HR(mFX->SetMatrix(mhWVP, &(mSceneWorld*gCamera->viewProj())));
HR(mFX->SetValue(mhEyePosW, &gCamera->pos(), sizeof(D3DXVECTOR3)));
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)));
// If there is a texture, then use.
if(mSceneTextures[j] != 0)
{
HR(mFX->SetTexture(mhTex, mSceneTextures[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->SetTexture(mhNormalMap, mSceneNormalMaps[j]));
HR(mFX->CommitChanges());
HR(mSceneMesh->DrawSubset(j));
}
HR(mFX->EndPass());
HR(mFX->End());
// Draw alpha blended object last.
mWater->draw();
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 GateDemo::drawGate()
{
// Enable alpha test.
HR(gd3dDevice->SetRenderState(D3DRS_ALPHATESTENABLE, true));
HR(gd3dDevice->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATEREQUAL));
HR(gd3dDevice->SetRenderState(D3DRS_ALPHAREF, 100));
// Turn off backface culling so you can see both sides of the gate.
HR(gd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE));
HR(mFX->SetValue(mhAmbientMtrl, &mGateMtrl.ambient, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhDiffuseMtrl, &mGateMtrl.diffuse, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecularMtrl, &mGateMtrl.spec, sizeof(D3DXCOLOR)));
HR(mFX->SetFloat(mhSpecularPower, mGateMtrl.specPower));
HR(mFX->SetMatrix(mhWVP, &(mGateWorld*mView*mProj)));
D3DXMATRIX worldInvTrans;
D3DXMatrixInverse(&worldInvTrans, 0, &mGateWorld);
D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans);
HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans));
HR(mFX->SetMatrix(mhWorld, &mGateWorld));
HR(mFX->SetTexture(mhTex, mGateTex));
HR(gd3dDevice->SetVertexDeclaration(VertexPNT::Decl));
HR(gd3dDevice->SetStreamSource(0, mGateVB, 0, sizeof(VertexPNT)));
HR(gd3dDevice->SetIndices(mGateIB));
// 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, 4, 0, 2));
HR(mFX->EndPass());
}
HR(mFX->End());
// Disable alpha test.
HR(gd3dDevice->SetRenderState(D3DRS_ALPHATESTENABLE, false));
// Turn culling back on.
HR(gd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW));
}
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 CExplodingBullet::Render()
{
if(GetType() == SMASHBULLET)
return;
CAssetManager* pAM = CAssetManager::GetInstance();
D3DXMATRIX ViewProj = CGameplayState::GetInstance()->GetCamera()->GetViewProjMatrix();
CRenderer* pRenderer = CRenderer::GetInstance();
IDirect3DDevice9* pD3D = pRenderer->GetDirect3DDevice();
pD3D->SetRenderState(D3DRS_ALPHABLENDENABLE, true);
pD3D->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
pD3D->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
pD3D->SetVertexDeclaration(pAM->GetVertexDeclaration(BASEOBJECTDECL));
ID3DXEffect* pShader = pAM->GetShader(EFFECT_OBJ_SPHERE);
unsigned passes(0);
pShader->Begin(&passes,0);
for(unsigned i(0);i < passes; i++)
{
pShader->BeginPass(i);
pShader->SetTexture("gDiffuseTexture", pAM->GetTexture(EFFECT_OBJ_SPHERE));
pShader->SetMatrix("gViewProjection", &(ViewProj));
D3DXMATRIX scaleMat, worldMat;
float scale = GetRadius();
D3DXMatrixScaling(&scaleMat, scale, scale, scale);
pShader->SetMatrix("gWorld",&(scaleMat*GetMatrix()));
pShader->SetFloatArray("gColor", GetColor(), 4);
pShader->CommitChanges();
pD3D->SetVertexDeclaration(pAM->GetVertexDeclaration(BASEOBJECTDECL));
pD3D->SetStreamSource(0, pAM->GetVertBuffer(EFFECT_OBJ_SPHERE), 0, sizeof(tVertex));
pD3D->SetIndices(pAM->GetIndexBuffer(EFFECT_OBJ_SPHERE));
pD3D->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, pAM->GetNumVerts(EFFECT_OBJ_SPHERE), 0, pAM->GetNumTriangles(EFFECT_OBJ_SPHERE));
pShader->EndPass();
}
pShader->End();
pD3D->SetRenderState(D3DRS_ALPHABLENDENABLE, false);
}
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 SpotlightDemo::drawScene()
{
// Clear the backbuffer and depth buffer.
HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0));
HR(gd3dDevice->BeginScene());
// Setup the rendering FX
HR(mFX->SetValue(mhAmbientLight, &mAmbientLight, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhDiffuseLight, &mDiffuseLight, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecLight, &mSpecLight, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhAttenuation012, &mAttenuation012, sizeof(D3DXVECTOR3)));
HR(mFX->SetFloat(mhSpotPower, mSpotPower));
// Begin passes.
UINT numPasses = 0;
HR(mFX->Begin(&numPasses, 0));
for(UINT i = 0; i < numPasses; ++i)
{
HR(mFX->BeginPass(i));
drawGrid();
drawCylinders();
drawSpheres();
HR(mFX->EndPass());
}
HR(mFX->End());
mGfxStats->display();
HR(gd3dDevice->EndScene());
// Present the backbuffer.
HR(gd3dDevice->Present(0, 0, 0, 0));
}
void MGEhud::draw()
{
std::map<std::string, MGEhud::hud_id>::const_iterator i;
IDirect3DStateBlock9 *stateSaved;
device->CreateStateBlock(D3DSBT_ALL, &stateSaved);
D3DXVECTOR4 *vbase;
HRESULT hr = vbHUD->Lock(0, 0, (void**)&vbase, D3DLOCK_DISCARD);
if(hr != D3D_OK || vbase == 0)
return;
for(i = element_names.begin(); i != element_names.end(); ++i)
{
const Element *e = &elements[i->second];
if(e->enabled)
{
float x0 = e->x, x1 = e->x + e->xscale * e->w;
float y0 = e->y, y1 = e->y + e->yscale * e->h;
// Correct for D3D9 pixel offset
x0 -= 0.5; y0 -= 0.5; x1 -= 0.5; y1 -= 0.5;
D3DXVECTOR4 *v = vbase + 8 * i->second;
v[0] = D3DXVECTOR4(x0, y1, 0, 1);
v[1] = D3DXVECTOR4(0, 1, 0, 0);
v[2] = D3DXVECTOR4(x0, y0, 0, 1);
v[3] = D3DXVECTOR4(0, 0, 0, 0);
v[4] = D3DXVECTOR4(x1, y1, 0, 1);
v[5] = D3DXVECTOR4(1, 1, 0, 0);
v[6] = D3DXVECTOR4(x1, y0, 0, 1);
v[7] = D3DXVECTOR4(1, 0, 0, 0);
}
}
vbHUD->Unlock();
device->SetFVF(fvfHUD);
device->SetStreamSource(0, vbHUD, 0, 32);
device->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
for(i = element_names.begin(); i != element_names.end(); ++i)
{
const Element *e = &elements[i->second];
if(e->enabled)
{
ID3DXEffect *effect = e->effect ? e->effect : effectStandard;
D3DXHANDLE ehTex = effect->GetParameterByName(0, "tex");
UINT passes;
effect->SetTexture(ehTex, e->texture);
effect->Begin(&passes, D3DXFX_DONOTSAVESTATE);
effect->BeginPass(0);
device->DrawPrimitive(D3DPT_TRIANGLESTRIP, 4 * i->second, 2);
effect->EndPass();
effect->End();
}
}
stateSaved->Apply();
stateSaved->Release();
}
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);
}
HRESULT CXMesh::Render(CXModel* model)
{
if(!m_BlendedMesh) return E_FAIL;
CBRenderD3D* Rend = (CBRenderD3D*)Game->m_Renderer;
HRESULT res = E_FAIL;
// render mesh
LPDIRECT3DVERTEXBUFFER VertexBuffer;
LPDIRECT3DINDEXBUFFER IndexBuffer;
m_BlendedMesh->GetVertexBuffer(&VertexBuffer);
m_BlendedMesh->GetIndexBuffer(&IndexBuffer);
bool NoAttrs = false;
DWORD NumAttrs;
m_BlendedMesh->GetAttributeTable(NULL, &NumAttrs);
if(NumAttrs==0)
{
NoAttrs = true;
NumAttrs = 1;
}
D3DXATTRIBUTERANGE* Attrs = new D3DXATTRIBUTERANGE[NumAttrs];
m_BlendedMesh->GetAttributeTable(Attrs, NULL);
if(NoAttrs)
{
Attrs[0].AttribId = 0;
Attrs[0].VertexStart = Attrs[0].FaceStart = 0;
Attrs[0].VertexCount = m_BlendedMesh->GetNumVertices();
Attrs[0].FaceCount = m_BlendedMesh->GetNumFaces();
}
C3DUtils::SetFixedVertexShader(Rend->m_Device, m_BlendedMesh->GetFVF());
C3DUtils::SetStreamSource(Rend->m_Device, 0, VertexBuffer, D3DXGetFVFVertexSize(m_BlendedMesh->GetFVF()));
C3DUtils::SetIndices(Rend->m_Device, IndexBuffer);
for(int i = 0; i < NumAttrs; i++)
{
C3DMaterial* Mat = m_Materials[Attrs[i].AttribId];
#ifdef WME_D3D9
if(Mat->GetEffect())
{
Rend->m_Device->SetMaterial(&Mat->m_Material);
// set shader parameters
Mat->GetEffect()->UpdateGlobals();
// matrices
D3DXMATRIX matView, matProj, matWorld;
Rend->m_Device->GetTransform(D3DTS_VIEW, &matView);
Rend->m_Device->GetTransform(D3DTS_WORLD, &matWorld);
Rend->m_Device->GetTransform(D3DTS_PROJECTION, &matProj);
Mat->GetEffect()->UpdateMatrices(matView, matProj, matWorld);
// camera
if (Rend->m_Camera) Mat->GetEffect()->UpdateCamera(Rend->m_Camera->m_Position, Rend->m_Camera->m_Target);
// material
Mat->GetEffect()->UpdateMaterial(Mat);
// lights
Mat->GetEffect()->UpdateLights(model->m_Owner);
// custom params
C3DEffectParams* params = Mat->GetEffectParams();
if (params) params->SetEffectParams(Mat->GetEffect()->GetEffect());
ID3DXEffect* effect = Mat->GetEffect()->GetEffect();
unsigned int numPasses;
effect->Begin(&numPasses, 0);
D3DXATTRIBUTERANGE Attr = Attrs[i];
for (int pass = 0; pass < numPasses; pass++)
{
effect->BeginPass(pass);
C3DEffectScript* script = Mat->GetEffect()->GetScriptForPass(pass);
if (script)
{
script->InitFrame();
while (script->Execute())
{
res = C3DUtils::DrawIndexedPrimitive(Rend->m_Device, D3DPT_TRIANGLELIST, Attr.VertexStart, Attr.VertexCount, Attr.FaceStart*3, Attr.FaceCount);
// maintain polycount
Rend->m_NumPolygons += Attr.FaceCount;
}
}
effect->EndPass();
}
effect->End();
}
#else
if(false)
{
}
#endif
else
{
// set material
Rend->m_Device->SetMaterial(&Mat->m_Material);
// set texture (if any)
CBSurfaceD3D* Surf = (CBSurfaceD3D*)Mat->GetSurface();
if(Surf && Surf->m_Texture)
Rend->m_Device->SetTexture(0, Surf->m_Texture);
else
Rend->m_Device->SetTexture(0, NULL);
// render
//res = m_BlendedMesh->DrawSubset(i);
D3DXATTRIBUTERANGE Attr = Attrs[i];
res = C3DUtils::DrawIndexedPrimitive(Rend->m_Device, D3DPT_TRIANGLELIST, Attr.VertexStart, Attr.VertexCount, Attr.FaceStart*3, Attr.FaceCount);
// maintain polycount
Rend->m_NumPolygons += Attr.FaceCount;
}
}
RELEASE(VertexBuffer);
RELEASE(IndexBuffer);
delete [] Attrs;
return res;
}
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());
}
