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 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 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 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 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 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 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));
}
//-----------------------------------------------------------------------------
// Name: CTiny::Draw()
// Desc: Renders this CTiny instace using the current animation frames.
//-----------------------------------------------------------------------------
HRESULT CTiny::Draw(D3DXMATRIXA16 *mxViewProj, bool bRenderShadow)
{
LPDIRECT3DDEVICE9 pDevice = this->m_pMA->GetDevice();
D3DLIGHT9 light;
pDevice->GetLight(0, &light);
// update the ViewProjection matric for the animation
ID3DXEffect* pMAEffect = m_pMA->GetEffect();
if( pMAEffect )
{
pMAEffect->SetMatrix( "g_mViewProj", mxViewProj );
pMAEffect->SetVector( "lhtDir", (D3DXVECTOR4 *)&(light.Direction));
}
SAFE_RELEASE( pMAEffect );
SAFE_RELEASE( pDevice);
if(bRenderShadow)
{
m_pMA->SetTechnique( "ShadowPass" );
}
else
{
m_pMA->SetTechnique( "Skinning20" );
// translate player
}
return m_pAI->Draw();
}
//-------------------------------------------------------------------------------
int CMaterialManager::SetupMaterial (
AssetHelper::MeshHelper* pcMesh,
const aiMatrix4x4& pcProj,
const aiMatrix4x4& aiMe,
const aiMatrix4x4& pcCam,
const aiVector3D& vPos)
{
ai_assert(NULL != pcMesh);
if (!pcMesh->piEffect)return 0;
ID3DXEffect* piEnd = pcMesh->piEffect;
piEnd->SetMatrix("WorldViewProjection",
(const D3DXMATRIX*)&pcProj);
piEnd->SetMatrix("World",(const D3DXMATRIX*)&aiMe);
piEnd->SetMatrix("WorldInverseTranspose",
(const D3DXMATRIX*)&pcCam);
D3DXVECTOR4 apcVec[5];
memset(apcVec,0,sizeof(apcVec));
apcVec[0].x = g_avLightDirs[0].x;
apcVec[0].y = g_avLightDirs[0].y;
apcVec[0].z = g_avLightDirs[0].z;
apcVec[0].w = 0.0f;
apcVec[1].x = g_avLightDirs[0].x * -1.0f;
apcVec[1].y = g_avLightDirs[0].y * -1.0f;
apcVec[1].z = g_avLightDirs[0].z * -1.0f;
apcVec[1].w = 0.0f;
D3DXVec4Normalize(&apcVec[0],&apcVec[0]);
D3DXVec4Normalize(&apcVec[1],&apcVec[1]);
piEnd->SetVectorArray("afLightDir",apcVec,5);
apcVec[0].x = ((g_avLightColors[0] >> 16) & 0xFF) / 255.0f;
apcVec[0].y = ((g_avLightColors[0] >> 8) & 0xFF) / 255.0f;
apcVec[0].z = ((g_avLightColors[0]) & 0xFF) / 255.0f;
apcVec[0].w = 1.0f;
if( g_sOptions.b3Lights)
{
apcVec[1].x = ((g_avLightColors[1] >> 16) & 0xFF) / 255.0f;
apcVec[1].y = ((g_avLightColors[1] >> 8) & 0xFF) / 255.0f;
apcVec[1].z = ((g_avLightColors[1]) & 0xFF) / 255.0f;
apcVec[1].w = 0.0f;
} else
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 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::drawCylinders()
{
D3DXMATRIX T, R, W, WIT;
D3DXMatrixRotationX(&R, D3DX_PI*0.5f);
HR(mFX->SetValue(mhAmbientMtrl, &mCylinderMtrl.ambient, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhDiffuseMtrl, &mCylinderMtrl.diffuse, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecMtrl, &mCylinderMtrl.spec, sizeof(D3DXCOLOR)));
HR(mFX->SetFloat(mhSpecPower, mCylinderMtrl.specPower));
for(int z = -30; z <= 30; z+= 10)
{
D3DXMatrixTranslation(&T, -10.0f, 3.0f, (float)z);
W = R*T;
D3DXMatrixInverse(&WIT, 0, &W);
D3DXMatrixTranspose(&WIT, &WIT);
HR(mFX->SetMatrix(mhWVP, &(W*mView*mProj)));
HR(mFX->SetMatrix(mhWorld, &W));
HR(mFX->SetMatrix(mhWorldInvTrans, &WIT));
HR(mFX->CommitChanges());
HR(mCylinder->DrawSubset(0));
D3DXMatrixTranslation(&T, 10.0f, 3.0f, (float)z);
W = R*T;
D3DXMatrixInverse(&WIT, 0, &W);
D3DXMatrixTranspose(&WIT, &WIT);
HR(mFX->SetMatrix(mhWVP, &(W*mView*mProj)));
HR(mFX->SetMatrix(mhWorld, &W));
HR(mFX->SetMatrix(mhWorldInvTrans, &WIT));
HR(mFX->CommitChanges());
HR(mCylinder->DrawSubset(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 PropsDemo::drawObject(Object3D& obj, const D3DXMATRIX& toWorld)
{
// Transform AABB into the world space.
AABB box;
obj.box.xform(toWorld, box);
// Only draw if AABB is visible.
if( gCamera->isVisible( box ) )
{
HR(mFX->SetMatrix(mhWVP, &(toWorld*gCamera->viewProj())));
D3DXMATRIX worldInvTrans;
D3DXMatrixInverse(&worldInvTrans, 0, &toWorld);
D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans);
HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans));
HR(mFX->SetMatrix(mhWorld, &toWorld));
for(UINT j = 0; j < obj.mtrls.size(); ++j)
{
HR(mFX->SetValue(mhMtrl, &obj.mtrls[j], sizeof(Mtrl)));
// If there is a texture, then use.
if(obj.textures[j] != 0)
{
HR(mFX->SetTexture(mhTex, obj.textures[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(obj.mesh->DrawSubset(j));
}
}
}
void SpotlightDemo::drawSpheres()
{
D3DXMATRIX W, WIT;
HR(mFX->SetValue(mhAmbientMtrl, &mSphereMtrl.ambient, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhDiffuseMtrl, &mSphereMtrl.diffuse, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecMtrl, &mSphereMtrl.spec, sizeof(D3DXCOLOR)));
HR(mFX->SetFloat(mhSpecPower, mSphereMtrl.specPower));
for(int z = -30; z <= 30; z+= 10)
{
D3DXMatrixTranslation(&W, -10.0f, 7.5f, (float)z);
D3DXMatrixInverse(&WIT, 0, &W);
D3DXMatrixTranspose(&WIT, &WIT);
HR(mFX->SetMatrix(mhWVP, &(W*mView*mProj)));
HR(mFX->SetMatrix(mhWorld, &W));
HR(mFX->SetMatrix(mhWorldInvTrans, &WIT));
HR(mFX->CommitChanges());
HR(mSphere->DrawSubset(0));
D3DXMatrixTranslation(&W, 10.0f, 7.5f, (float)z);
D3DXMatrixInverse(&WIT, 0, &W);
D3DXMatrixTranspose(&WIT, &WIT);
HR(mFX->SetMatrix(mhWVP, &(W*mView*mProj)));
HR(mFX->SetMatrix(mhWorld, &W));
HR(mFX->SetMatrix(mhWorldInvTrans, &WIT));
HR(mFX->CommitChanges());
HR(mSphere->DrawSubset(0));
}
}
void SpotlightDemo::drawGrid()
{
HR(gd3dDevice->SetStreamSource(0, mVB, 0, sizeof(VertexPN)));
HR(gd3dDevice->SetIndices(mIB));
HR(gd3dDevice->SetVertexDeclaration(VertexPN::Decl));
D3DXMATRIX W, WIT;
D3DXMatrixIdentity(&W);
D3DXMatrixInverse(&WIT, 0, &W);
D3DXMatrixTranspose(&WIT, &WIT);
HR(mFX->SetMatrix(mhWorld, &W));
HR(mFX->SetMatrix(mhWVP, &(W*mView*mProj)));
HR(mFX->SetMatrix(mhWorldInvTrans, &WIT));
HR(mFX->SetValue(mhAmbientMtrl, &mGridMtrl.ambient, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhDiffuseMtrl, &mGridMtrl.diffuse, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecMtrl, &mGridMtrl.spec, sizeof(D3DXCOLOR)));
HR(mFX->SetFloat(mhSpecPower, mGridMtrl.specPower));
HR(mFX->CommitChanges());
HR(gd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, mNumGridVertices, 0, mNumGridTriangles));
}
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 SphereCylDemo::drawCylinders()
{
HR(gd3dDevice->SetRenderState(D3DRS_WRAP0, D3DWRAP_U));
D3DXMATRIX T, R, W, WIT;
D3DXMatrixRotationX(&R, -D3DX_PI*0.5f);
HR(mFX->SetValue(mhAmbientMtrl, &mCylinderMtrl.ambient, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhDiffuseMtrl, &mCylinderMtrl.diffuse, sizeof(D3DXCOLOR)));
HR(mFX->SetValue(mhSpecMtrl, &mCylinderMtrl.spec, sizeof(D3DXCOLOR)));
HR(mFX->SetFloat(mhSpecPower, mCylinderMtrl.specPower));
HR(mFX->SetTexture(mhTex, mCylTex));
for(int z = -30; z <= 30; z+= 10)
{
D3DXMatrixTranslation(&T, -10.0f, 3.0f, (float)z);
W = R*T;
D3DXMatrixInverse(&WIT, 0, &W);
D3DXMatrixTranspose(&WIT, &WIT);
HR(mFX->SetMatrix(mhWVP, &(W*mView*mProj)));
HR(mFX->SetMatrix(mhWorld, &W));
HR(mFX->SetMatrix(mhWorldInvTrans, &WIT));
HR(mFX->CommitChanges());
HR(mCylinder->DrawSubset(0));
D3DXMatrixTranslation(&T, 10.0f, 3.0f, (float)z);
W = R*T;
D3DXMatrixInverse(&WIT, 0, &W);
D3DXMatrixTranspose(&WIT, &WIT);
HR(mFX->SetMatrix(mhWVP, &(W*mView*mProj)));
HR(mFX->SetMatrix(mhWorld, &W));
HR(mFX->SetMatrix(mhWorldInvTrans, &WIT));
HR(mFX->CommitChanges());
HR(mCylinder->DrawSubset(0));
}
// Disable.
HR(gd3dDevice->SetRenderState(D3DRS_WRAP0, 0));
}
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);
}
void ShaderParamMtx< EffectShader >::setParam( Renderer& renderer, void* shaderPtr )
{
ID3DXEffect* dxEffect = reinterpret_cast< ID3DXEffect* >( shaderPtr );
dxEffect->SetMatrix( m_name.c_str(), ( const D3DXMATRIX* )&m_val );
}
void CLcXSkinIns::Render()
{
HRESULT hr=-1;
LPDIRECT3DDEVICE9 pDev = (LPDIRECT3DDEVICE9)LcDev_GetD3Device();
CLcXSkinSrc* pOrg = (CLcXSkinSrc*)m_pOrg;
ID3DXEffect* pEft = pOrg->GetEffect();
// Setup the projection matrix
D3DXMATRIX matProj;
pDev->GetTransform(D3DTS_PROJECTION, &matProj);
D3DLIGHT9 light;
D3DXVECTOR3 vecLightDirUnnormalized(0.0f, -1.0f, 1.0f);
ZeroMemory( &light, sizeof(D3DLIGHT9) );
light.Type = D3DLIGHT_DIRECTIONAL;
light.Diffuse.r = 1.0f;
light.Diffuse.g = 1.0f;
light.Diffuse.b = 1.0f;
D3DXVec3Normalize( (D3DXVECTOR3*)&light.Direction, &vecLightDirUnnormalized );
light.Position.x = 0.0f;
light.Position.y = -1.0f;
light.Position.z = 1.0f;
light.Range = 1000.0f;
pDev->SetLight(0, &light );
pDev->LightEnable(0, TRUE );
// Set Light for vertex shader
D3DXVECTOR4 vLightDir( 0.0f, 1.0f, -1.0f, 0.0f );
D3DXVec4Normalize( &vLightDir, &vLightDir );
// for HLSL
{
pEft->SetMatrix( "mViewProj", &matProj);
pEft->SetVector( "lhtDir", &vLightDir);
}
// for shader
{
// set the projection matrix for the vertex shader based skinning method
D3DXMatrixTranspose(&matProj, &matProj);
pDev->SetVertexShaderConstantF(2, (float*)&matProj, 4);
pDev->SetVertexShaderConstantF(1, (float*)&vLightDir, 1);
}
if(m_pAC)
m_pAC->AdvanceTime(m_fElapse, NULL);
pOrg->UpdateFrameMatrices(m_pFrameOrg, &m_mtWld);
pOrg->DrawFrame(m_pFrameOrg);
static D3DXMATRIX mtI(1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1);
pDev->SetTransform(D3DTS_WORLD, &mtI);
}
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 TriPickDemo::drawScene()
{
HR(g_pDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0));
HR(g_pDevice->BeginScene());
//rendering characters
{
ID3DXEffect* pMAEffect = m_pCharacter->GetEffect();
if (pMAEffect)
{
pMAEffect->SetMatrix("g_mViewProj", &(g_Camera->viewProj()));
}
//set lighting
D3DXVECTOR4 v(m_Light.dirW.x, m_Light.dirW.y, m_Light.dirW.z, 1.0f);
if (pMAEffect)
{
pMAEffect->SetVector("lhtDir", &v);
}
SAFE_RELEASE(pMAEffect);
/*/ compute reorientation matrix based on default orientation and bounding radius
D3DXMATRIX mx, Orientation;
//float fScale = 1.f / g_Character.GetBoundingRadius() / 7.f;
//D3DXMatrixScaling(&mx, fScale, fScale, fScale);
D3DXMatrixScaling(&mx, 1.0f, 1.0f, 1.0f);
Orientation = mx;
//D3DXMatrixRotationX(&mx, -D3DX_PI / 2.0f);
D3DXMatrixRotationX(&mx, 0.0f);
D3DXMatrixMultiply(&Orientation, &Orientation, &mx);
//D3DXMatrixRotationY(&mx, D3DX_PI);
D3DXMatrixRotationY(&mx, 0.0f);
D3DXMatrixMultiply(&Orientation, &Orientation, &mx);
D3DXMATRIX mxWorld;
// compute world matrix based on pos/face
D3DXMatrixRotationY(&mxWorld, 0.0f);
D3DXMatrixTranslation(&mx, 0.0f, 0.0f, 0.0f);
D3DXMatrixMultiply(&mxWorld, &mxWorld, &mx);
D3DXMatrixMultiply(&mxWorld, &Orientation, &mxWorld);*/
m_pCharacter->SetPose(m_matWorld);
//check seclection
D3DXVECTOR3 mouseMV;
if (gDInput->mouseButtonDown(0))
{
if (L_Hand->isPick == false)
L_Hand->isPick = checkBonePick(L_Hand->pCylinder, L_Hand->curWorld);
if (R_Hand->isPick == false)
R_Hand->isPick = checkBonePick(R_Hand->pCylinder, R_Hand->curWorld);
if (L_Leg->isPick == false)
L_Leg->isPick = checkBonePick(L_Leg->pCylinder, L_Leg->curWorld);
if (R_Leg->isPick == false)
R_Leg->isPick = checkBonePick(R_Leg->pCylinder, R_Leg->curWorld);
//get move vector
if (L_Hand->isPick)
{
mouseMV = getMouseMoveVector(1.0f);
m_pIK->addLHMove(mouseMV);
}
else
if (R_Hand->isPick)
{
mouseMV = getMouseMoveVector(1.0f);
m_pIK->addRHMove(mouseMV);
}
else
if (L_Leg->isPick)
{
mouseMV = getMouseMoveVector(1.0f);
m_pIK->addLLMove(mouseMV);
}
else
if (R_Leg->isPick)
{
mouseMV = getMouseMoveVector(1.0f);
m_pIK->addRLMove(mouseMV);
}
}
else
{
L_Hand->isPick = false;
R_Hand->isPick = false;
L_Leg->isPick = false;
R_Leg->isPick = false;
}
// wireframe
//g_pDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
//Update IK
if (m_pIK)
{
m_pIK->UpdateHeadIK();
m_pIK->UpdateIK();
}
//m_pCharacter->DrawBoneCylinder(m_pCharacter->getPBone(), NULL, m_matWorld);
m_pCharacter->Render(NULL);
}
HR(g_pDevice->EndScene());
HR(g_pDevice->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());
}
