void D3DPBRApp::DrawLUT()
{
ID3DX11EffectTechnique* activeMeshTech = Effects::CommonPassFX->LUTSTech;
Effects::CommonPassFX->PrefilterMap->SetResource(mLUTSRV);
UINT stride = sizeof(Vertex::Basic32);
UINT offset = 0;
D3DX11_TECHNIQUE_DESC techDesc;
activeMeshTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
// Draw the Mesh.
md3dImmediateContext->IASetVertexBuffers(0, 1, &mQuadVB, &stride, &offset);
md3dImmediateContext->IASetIndexBuffer(mQuadIB, DXGI_FORMAT_R32_UINT, 0);
activeMeshTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
md3dImmediateContext->DrawIndexed(mQuadIndexNum, 0, 0);
//m_pSky->Draw(md3dImmediateContext, camera);
// Restore default
md3dImmediateContext->RSSetState(0);
}
}
void XM_CALLCONV Lava::Draw( FXMMATRIX viewProj, ID3D11DeviceContext* context ) {
context->IASetInputLayout( InputLayouts::Lava );
context->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
UINT stride = sizeof( Vertex::LavaVertex );
UINT offset = 0;
ID3D11Buffer* buffers[1] = { mesh->VB() };
context->IASetVertexBuffers( 0, 1, &buffers[0], &stride, &offset );
context->IASetIndexBuffer( mesh->IB(), mesh->IndexFormat(), 0 );
XMMATRIX world = XMMatrixIdentity();
XMMATRIX worldInvTranspose = MathUtils::InverseTranspose( world );
XMMATRIX worldViewProj = world*viewProj;
MyEffects::LavaFX->SetWorld( world );
MyEffects::LavaFX->SetWorldInvTranspose( worldInvTranspose );
MyEffects::LavaFX->SetWorldViewProj( worldViewProj );
MyEffects::LavaFX->SetDiffuseMap( diffuseView );
ID3DX11EffectTechnique* tech = MyEffects::LavaFX->lavaTechnique;
D3DX11_TECHNIQUE_DESC td;
tech->GetDesc( &td );
for( UINT p = 0; p<td.Passes; ++p ) {
tech->GetPassByIndex( p )->Apply( 0, context );
context->DrawIndexed( mesh->IndexCount(), 0, 0 );
}
}
void DuckHuntMain::DrawScreenQuad(ID3D11ShaderResourceView* srv)
{
UINT stride = sizeof(Vertex::Basic32);
UINT offset = 0;
md3dImmediateContext->IASetInputLayout(InputLayouts::Basic32);
md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
md3dImmediateContext->IASetVertexBuffers(0, 1, &mScreenQuadVB, &stride, &offset);
md3dImmediateContext->IASetIndexBuffer(mScreenQuadIB, DXGI_FORMAT_R32_UINT, 0);
// Scale and shift quad to lower-right corner.
XMMATRIX world(
0.5f, 0.0f, 0.0f, 0.0f,
0.0f, 0.5f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.5f, -0.5f, 0.0f, 1.0f);
ID3DX11EffectTechnique* tech = Effects::DebugTexFX->ViewRedTech;
D3DX11_TECHNIQUE_DESC techDesc;
tech->GetDesc(&techDesc);
for (UINT p = 0; p < techDesc.Passes; ++p)
{
Effects::DebugTexFX->SetWorldViewProj(world);
Effects::DebugTexFX->SetTexture(srv);
tech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
md3dImmediateContext->DrawIndexed(6, 0, 0);
}
}
void Effect::ExtractPassData(D3DX11_EFFECT_DESC& effectDesc) {
for(U32 g = 0; g < effectDesc.Groups; ++g) {
ID3DX11EffectGroup* group = dx11Effect->GetGroupByIndex(g);
D3DX11_GROUP_DESC groupDesc;
DXCall(group->GetDesc(&groupDesc));
for(U32 t = 0; t < groupDesc.Techniques; ++t) {
ID3DX11EffectTechnique* pTechnique = group->GetTechniqueByIndex(t);
D3DX11_TECHNIQUE_DESC techniqueDesc;
DXCall(pTechnique->GetDesc(&techniqueDesc));
for(U32 p = 0; p < techniqueDesc.Passes; ++p) {
ID3DX11EffectPass* pass = pTechnique->GetPassByIndex(p);
D3DX11_PASS_DESC passDesc;
DXCall(pass->GetDesc(&passDesc));
D3DX11_PASS_SHADER_DESC passShaderDesc;
DXCall(pass->GetVertexShaderDesc(&passShaderDesc));
D3DX11_EFFECT_SHADER_DESC shaderDesc;
DXCall(passShaderDesc.pShaderVariable->GetShaderDesc(passShaderDesc.ShaderIndex, &shaderDesc));
for(U32 i = 0; i < shaderDesc.NumInputSignatureEntries; ++i) {
D3D11_SIGNATURE_PARAMETER_DESC signatureDesc;
DXCall(passShaderDesc.pShaderVariable->GetInputSignatureElementDesc(passShaderDesc.ShaderIndex, i, &signatureDesc));
}
groups[groupDesc.Name].techniques[techniqueDesc.Name].passes[passDesc.Name].data.pass = pass;
groups[groupDesc.Name].techniques[techniqueDesc.Name].passes[passDesc.Name].data.inputSignature = passDesc.pIAInputSignature;
groups[groupDesc.Name].techniques[techniqueDesc.Name].passes[passDesc.Name].data.inputSignatureSize = passDesc.IAInputSignatureSize;
}
}
}
}
void BoxApp::DrawScene()
{
md3dImmediateContext->ClearRenderTargetView(mRenderTargetView, reinterpret_cast<const float*>(&Colors::LightSteelBlue));
md3dImmediateContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
md3dImmediateContext->IASetInputLayout(mInputLayout);
md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
UINT stride = sizeof(Vertex);
UINT offset = 0;
md3dImmediateContext->IASetVertexBuffers(0, 1, &mBoxVB, &stride, &offset);
md3dImmediateContext->IASetIndexBuffer(mBoxIB, DXGI_FORMAT_R32_UINT, 0);
// Set constants
XMMATRIX world = XMLoadFloat4x4(&mWorld);
XMMATRIX view = XMLoadFloat4x4(&mView);
XMMATRIX proj = XMLoadFloat4x4(&mProj);
XMMATRIX worldViewProj = world*view*proj;
mfxWorldViewProj->SetMatrix(reinterpret_cast<float*>(&worldViewProj));
D3DX11_TECHNIQUE_DESC techDesc;
mTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
mTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
// 36 indices for the box.
md3dImmediateContext->DrawIndexed(36, 0, 0);
}
HR(mSwapChain->Present(0, 0));
}
void cGridMesh::Draw()
{
// Set Layout And Topology
g_pD3DDC->IASetInputLayout(cInputLayouts::Simple);
g_pD3DDC->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// Set VertexBuffer And IndexBuffer
UINT stride = sizeof(Vertex::Simple);
UINT offset = 0;
g_pD3DDC->IASetVertexBuffers(0, 1, &m_VB, &stride, &offset);
g_pD3DDC->IASetIndexBuffer(m_IB, DXGI_FORMAT_R32_UINT, 0);
// worldViewProj Çà·ÄÀ» ±¸ÇÑ´Ù.
XMMATRIX world = XMLoadFloat4x4(&GetTransformMatrix());
XMMATRIX view = g_pCameraManager->GetView();
XMMATRIX proj = g_pCameraManager->GetProj();
XMMATRIX worldViewProj = world * view * proj;
// ¼ÎÀÌ´õ¿¡ »ó¼ö°ª ¼³Á¤.
cEffects::SimpleFX->SetWorldViewProj(worldViewProj);
ID3DX11EffectTechnique* tech = cEffects::SimpleFX->ColorTech;
D3DX11_TECHNIQUE_DESC techDesc;
tech->GetDesc(&techDesc);
for (UINT p = 0; p < techDesc.Passes; ++p)
{
tech->GetPassByIndex(p)->Apply(0, g_pD3DDC);
// »öÀÎÀ» »ç¿ëÇؼ ±×¸°´Ù.
g_pD3DDC->DrawIndexed(m_GridIndexCount, 0, 0);
}
HR(g_pD3DSC->Present(0, 0));
}
void ForwardRenderer::DrawScreenQuad()
{
float blendFactor[] = { 0.0f, 0.0f, 0.0f, 0.0f };
XMMATRIX view = XMLoadFloat4x4( RendererCore::Instance()->GetView() );
XMMATRIX proj = XMLoadFloat4x4( RendererCore::Instance()->GetProj() );
int iCount = m_vDrawScreenElements.size();
for ( int i = 0; i < iCount; ++i )
{
DrawElement* pElem = m_vDrawScreenElements[i];
if ( !pElem )
continue;
UINT stride = pElem->stride;
UINT offset = pElem->offset;
ID3D11Buffer* pVB = pElem->m_spVB->GetVB();
GetD3D11DeviceImmContext()->IASetInputLayout( pElem->m_pInputLayout );
GetD3D11DeviceImmContext()->IASetPrimitiveTopology( pElem->ePrimitiveTopology );
GetD3D11DeviceImmContext()->IASetVertexBuffers( 0, 1, &pVB, &stride, &offset );
GetD3D11DeviceImmContext()->IASetIndexBuffer( pElem->m_spIB->GetIB(), DXGI_FORMAT_R32_UINT, 0 );
if ( pElem->m_pRasterS )
GetD3D11DeviceImmContext()->RSSetState( pElem->m_pRasterS );
if ( pElem->m_pBlendS )
GetD3D11DeviceImmContext()->OMSetBlendState( pElem->m_pBlendS, blendFactor, 0xffffffff );
if ( pElem->m_pDepthStencilS )
GetD3D11DeviceImmContext()->OMSetDepthStencilState( pElem->m_pDepthStencilS, pElem->m_uiStencilRef );
for ( auto itor = pElem->m_vecSubElement.begin(); itor != pElem->m_vecSubElement.end(); ++itor )
{
ID3DX11EffectTechnique* pTech = pElem->m_spShader->GetTech( (*itor).m_iTechIndex );
if ( !pTech )
continue;
D3DX11_TECHNIQUE_DESC techDesc;
pTech->GetDesc( &techDesc );
TexturePtr spDiffuseMap = (*itor).m_spDiffuseMap;
for ( UINT p = 0; p < techDesc.Passes; ++p )
{
XMMATRIX worldViewProj = XMLoadFloat4x4( &(*itor).m_World );
pElem->m_spShader->SetWorldViewProj( worldViewProj );
pElem->m_spShader->SetDiffuseMap( spDiffuseMap->GetSRV() );
pTech->GetPassByIndex( p )->Apply( 0, GetD3D11DeviceImmContext() );
GetD3D11DeviceImmContext()->DrawIndexed( 6, 0, 0 );
}
}
}
}
void Terrain::Draw(ID3D11DeviceContext* dc, const Camera& cam, DirectionalLight lights[3])
{
dc->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_4_CONTROL_POINT_PATCHLIST);
dc->IASetInputLayout(InputLayouts::Terrain);
UINT stride = sizeof(Vertex::Terrain);
UINT offset = 0;
dc->IASetVertexBuffers(0, 1, &mQuadPatchVB, &stride, &offset);
dc->IASetIndexBuffer(mQuadPatchIB, DXGI_FORMAT_R16_UINT, 0);
XMMATRIX viewProj = cam.ViewProj();
XMMATRIX world = XMLoadFloat4x4(&mWorld);
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);
XMMATRIX worldViewProj = world*viewProj;
XMMATRIX ShadowTransform = world * XMLoadFloat4x4(&d3d->m_ShadowTransform);
XMFLOAT4 worldPlanes[6];
ExtractFrustumPlanes(worldPlanes, viewProj);
// Set per frame constants.
Effects::TerrainFX->SetViewProj(viewProj);
Effects::TerrainFX->SetEyePosW(cam.GetPosition());
Effects::TerrainFX->SetDirLights(lights);
Effects::TerrainFX->SetFogColor(Colors::Silver);
Effects::TerrainFX->SetFogStart(15.0f);
Effects::TerrainFX->SetFogRange(175.0f);
Effects::TerrainFX->SetMinDist(20.0f);
Effects::TerrainFX->SetMaxDist(400.0f);
Effects::TerrainFX->SetMinTess(0.0f);
Effects::TerrainFX->SetMaxTess(6.0f);
Effects::TerrainFX->SetTexelCellSpaceU(1.0f / mInfo.HeightmapWidth);
Effects::TerrainFX->SetTexelCellSpaceV(1.0f / mInfo.HeightmapHeight);
Effects::TerrainFX->SetWorldCellSpace(mInfo.CellSpacing);
Effects::TerrainFX->SetWorldFrustumPlanes(worldPlanes);
Effects::TerrainFX->SetLayerMapArray(mLayerMapArraySRV);
Effects::TerrainFX->SetBlendMap(mBlendMapSRV);
Effects::TerrainFX->SetHeightMap(mHeightMapSRV);
Effects::TerrainFX->SetShadowMap(d3d->GetShadowMap());
Effects::TerrainFX->SetShadowTransform(ShadowTransform);
Effects::TerrainFX->SetMaterial(mMat);
ID3DX11EffectTechnique* tech = Effects::TerrainFX->Light1Tech;
D3DX11_TECHNIQUE_DESC techDesc;
tech->GetDesc( &techDesc );
for(UINT i = 0; i < techDesc.Passes; ++i)
{
ID3DX11EffectPass* pass = tech->GetPassByIndex(i);
pass->Apply(0, dc);
dc->DrawIndexed(mNumPatchQuadFaces*4, 0, 0);
}
dc->HSSetShader(0, 0, 0);
dc->DSSetShader(0, 0, 0);
}
void D3DPBRApp::DrawScene(Camera& camera)
{
md3dImmediateContext->IASetInputLayout(InputLayouts::Basic32);
md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
md3dImmediateContext->RSSetViewports(1, &mScreenViewport);
UINT stride = sizeof(Vertex::Basic32);
UINT offset = 0;
//
XMMATRIX view = camera.View();
XMMATRIX proj = camera.Proj();
XMMATRIX viewProj = camera.ViewProj();
// Set per frame constants.
Effects::CommonPassFX->SetDirLights(mDirLights);
Effects::CommonPassFX->SetEyePosW(mCam.GetPosition());
Effects::CommonPassFX->SetEnvMap(mDynamicCubeMapSRV);
ID3DX11EffectTechnique* activeMeshTech = Effects::CommonPassFX->Light1Tech;
D3DX11_TECHNIQUE_DESC techDesc;
activeMeshTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
// Draw the Mesh.
if( GetAsyncKeyState('1') & 0x8000 )
md3dImmediateContext->RSSetState(RenderStates::WireframeRS);
md3dImmediateContext->IASetVertexBuffers(0, 1, &m_pVB, &stride, &offset);
md3dImmediateContext->IASetIndexBuffer(m_pIB, DXGI_FORMAT_R32_UINT, 0);
XMMATRIX world = XMLoadFloat4x4(&mMeshWorld);
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);
XMMATRIX worldViewProj = world*view*proj;
Effects::CommonPassFX->SetWorld(world);
Effects::CommonPassFX->SetWorldInvTranspose(worldInvTranspose);
Effects::CommonPassFX->SetWorldViewProj(worldViewProj);
Effects::CommonPassFX->SetMaterial(mMeshMat);
activeMeshTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
md3dImmediateContext->DrawIndexed(m_indexnum, 0, 0);
//m_pSky->Draw(md3dImmediateContext, camera);
// Restore default
md3dImmediateContext->RSSetState(0);
}
}
void JF::Component::ColisionBox::Render()
{
// Declear)
float blendFactors[] = { 0.0f, 0.0f, 0.0f, 0.0f };
// Get)
auto* pTransform = GetOwner()->GetComponent<JF::Component::Transform>();
// Check)
RETURN_IF(pTransform == nullptr, );
// Set Layout And Topology
gRENDERER->DeviceContext()->IASetInputLayout(InputLayouts::PosColor);
gRENDERER->DeviceContext()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINELIST);
// Set VertexBuffer And IndexBuffer
UINT stride = sizeof(JF::Vertex::PosColor);
UINT offset = 0;
gRENDERER->DeviceContext()->IASetVertexBuffers(0, 1, &m_VertBuff, &stride, &offset);
gRENDERER->DeviceContext()->IASetIndexBuffer(m_IndexBuff, DXGI_FORMAT_R32_UINT, 0);
// worldViewProj 행렬을 구한다.
XMFLOAT3 rPosition = XMFLOAT3(pTransform->GetPosition().x + m_Center.x, pTransform->GetPosition().y + m_Center.y, pTransform->GetPosition().z + m_Center.z);
XMFLOAT3 rScale = XMFLOAT3(pTransform->GetScale().x * m_Size.x, pTransform->GetScale().y * m_Size.y, pTransform->GetScale().z * m_Size.z);
XMFLOAT4 rRotation = pTransform->GetRotation();
XMMATRIX scl, rot, tsl;
scl = XMMatrixScalingFromVector(XMLoadFloat3(&rScale));
rot = XMMatrixRotationQuaternion(XMLoadFloat4(&rRotation));
tsl = XMMatrixTranslationFromVector(XMLoadFloat3(&rPosition));
XMMATRIX world = scl*rot*tsl;
XMMATRIX view = Camera::g_pMainCamera->GetView();
XMMATRIX proj = Camera::g_pMainCamera->GetProj();
XMMATRIX worldViewProj = world * view * proj;
Effects::SimpleFX->SetWorldViewProj(worldViewProj);
// 노말맵이 있는지에따라 FX Tech 설정 변경.
ID3DX11EffectTechnique* Tech;
Tech = Effects::SimpleFX->ColorTech;
D3DX11_TECHNIQUE_DESC techDesc;
Tech->GetDesc(&techDesc);
for (UINT p = 0; p < techDesc.Passes; ++p)
{
Tech->GetPassByIndex(p)->Apply(0, gRENDERER->DeviceContext());
gRENDERER->DeviceContext()->DrawIndexed(m_indexCnt, 0, 0);
}
// 기본 랜더상태로 복원한다.
gRENDERER->DeviceContext()->RSSetState(0);
gRENDERER->DeviceContext()->OMSetBlendState(0, blendFactors, 0xffffffff);
}
void cPillar::Render()
{
cFBXObject::Render();
m_pDeviceContext->RSSetState(m_RS);
m_pDeviceContext->IASetInputLayout(mInputLayout);
m_pDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
UINT stride = sizeof(PNT_Vertex);
UINT offset = 0;
//set per frame constants
DirLights->SetRawValue(mDirLights, 0, 3 * sizeof(DirectionalLight));
EyePosW->SetRawValue(&g_CameraPos, 0, sizeof(XMFLOAT3));
ID3DX11EffectTechnique* activeTech;
if (m_isTooned)
activeTech = Light2TexToonedTech;
else
activeTech = Light3TexTech;
D3DX11_TECHNIQUE_DESC techDesc;
activeTech->GetDesc(&techDesc);
for (UINT p = 0; p < techDesc.Passes; ++p)
{
m_pDeviceContext->IASetVertexBuffers(0, 1, &m_VB, &stride, &offset);
m_pDeviceContext->IASetIndexBuffer(m_IB, DXGI_FORMAT_R32_UINT, 0);
XMMATRIX TEMPworld = XMLoadFloat4x4(&m_WorldMatrix);
XMMATRIX TEMPworldInvTranspose = MathHelper::InverseTranspose(TEMPworld);
XMMATRIX TEMPview = XMLoadFloat4x4(&g_View4X4);
XMMATRIX TEMPproj = XMLoadFloat4x4(&g_Proj4X4);
XMMATRIX TEMPworldViewProj = TEMPworld*TEMPview*TEMPproj;
World->SetMatrix(reinterpret_cast<float*>(&TEMPworld));
WorldInvTranspose->SetMatrix(reinterpret_cast<float*>(&TEMPworldInvTranspose));
WorldViewProj->SetMatrix(reinterpret_cast<float*>(&TEMPworldViewProj));
TexTransform->SetMatrix(reinterpret_cast<float*>(&mTexTransform));
Mat->SetRawValue(&mObjectMat, 0, sizeof(Material));
DiffuseMap->SetResource(mDiffuseMapSRV);
activeTech->GetPassByIndex(p)->Apply(0, m_pDeviceContext);
// 36 indices for the box.
m_pDeviceContext->Draw(vertices.size(), 0);
}
}
void ZombieForce::DrawScene()
{
md3dImmediateContext->ClearRenderTargetView(mRenderTargetView, reinterpret_cast<const float*>(&Colors::Blue));
md3dImmediateContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
md3dImmediateContext->IASetInputLayout(InputLayouts::Basic32);
md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
UINT stride = sizeof(Vertex::Basic32);
UINT offset = 0;
mCam.UpdateViewMatrix();
XMMATRIX view = mCam.View();
XMMATRIX proj = mCam.Proj();
XMMATRIX viewProj = mCam.ViewProj();
// Set per frame constants.
Effects::BillboardFX->SetDirLights(mDirLights);
Effects::BillboardFX->SetEyePosW(mCam.GetPosition());
Effects::BillboardFX->SetCubeMap(mSky->CubeMapSRV());
//ID3DX11EffectTechnique* activeTech = Effects::BasicFX->Light2TexTech;
ID3DX11EffectTechnique* activeTech = Effects::BillboardFX->Light2TexTech;
D3DX11_TECHNIQUE_DESC techDesc;
activeTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
pyramid->DrawPyramid(md3dImmediateContext,activeTech, mCam);
//myFirstSphere->DrawSphere(md3dImmediateContext,activeTech, mCam);
myFirstPlane->DrawPlane(md3dImmediateContext,activeTech, mCam);
//myFirstGeoSphere->DrawGeoSphere(md3dImmediateContext,activeTech, mCam);
//myFirstCylinder->DrawCylinder(md3dImmediateContext,activeTech, mCam);
for(unsigned int i = 0; i < spheres.size(); ++i)
{
spheres[i]->DrawSphere(md3dImmediateContext,activeTech, mCam);
}
for(unsigned int i = 0; i < boxes.size(); ++i)
{
boxes[i]->DrawBox(md3dImmediateContext,activeTech, mCam);
}
CMESHMANAGER->Render(md3dImmediateContext, activeTech, mCam);
}
mSky->Draw(md3dImmediateContext, mCam);
// restore default states, as the SkyFX changes them in the effect file.
md3dImmediateContext->RSSetState(0);
md3dImmediateContext->OMSetDepthStencilState(0, 0);
HR(mSwapChain->Present(0, 0));
}
void BoxApp::DrawScene()
{
md3dImmediateContext->ClearRenderTargetView(mRenderTargetView, reinterpret_cast<const float*>(&Colors::LightSteelBlue));
md3dImmediateContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
md3dImmediateContext->IASetInputLayout(mInputLayout);
md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// Press the Left Mouse Button to activate Wireframe mode, a simple if statement was made to show both work
if (GetAsyncKeyState(VK_LBUTTON)){
md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_LINESTRIP);
}
UINT stride = sizeof(Vertex);
UINT offset = 0;
md3dImmediateContext->IASetVertexBuffers(0, 1, &mBoxVB, &stride, &offset);
md3dImmediateContext->IASetIndexBuffer(mBoxIB, DXGI_FORMAT_R32_UINT, 0);
// Set constants
XMMATRIX world = XMLoadFloat4x4(&mWorld);
XMMATRIX view = XMLoadFloat4x4(&mView);
XMMATRIX proj = XMLoadFloat4x4(&mProj);
XMMATRIX worldViewProj = world*view*proj;
XMMATRIX viewProj = view*proj;
mfxWorldViewProj->SetMatrix(reinterpret_cast<float*>(&worldViewProj));
D3DX11_TECHNIQUE_DESC techDesc;
mTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
mTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
// 114 indices for the box and Octagonal.
md3dImmediateContext->DrawIndexed(2048, 0, 0);
for (int i = 0; i < 5; ++i)
{
world = XMLoadFloat4x4(&mCylWorld[i]);
mfxWorldViewProj->SetMatrix(reinterpret_cast<float*>(&(world*viewProj)));
mTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
md3dImmediateContext->DrawIndexed(mCylinderIndexCount, mCylinderIndexOffset, mCylinderVertexOffset);
}
}
HR(mSwapChain->Present(0, 0));
}
void Triangle::draw(ID3D11DeviceContext* a_Context, CXMMATRIX a_ViewProjection)
{
bind(a_Context);
XMMATRIX modelViewProjection = XMLoadFloat4x4(&m_Transform) * a_ViewProjection;
m_ShaderMVP->SetMatrix(reinterpret_cast<float*>(&modelViewProjection));
ID3DX11EffectTechnique* technique = m_Shader->GetTechniqueByIndex(0);
D3DX11_TECHNIQUE_DESC techDesc;
technique->GetDesc(&techDesc);
for(UINT p = 0; p < techDesc.Passes; ++p)
{
technique->GetPassByIndex(p)->Apply(0, a_Context);
a_Context->Draw(3, 0);
}
}
void Billboard::DrawHPSprites(CXMMATRIX viewProj)
{
Effects::HPSpriteFX->SetDirLights(mDirLights);
Effects::HPSpriteFX->SetEyePosW(mEyePosW);
Effects::HPSpriteFX->SetFogColor(Colors::Silver);
Effects::HPSpriteFX->SetFogStart(15.0f);
Effects::HPSpriteFX->SetFogRange(175.0f);
Effects::HPSpriteFX->SetViewProj(viewProj);
Effects::HPSpriteFX->SetMaterial(m_HPMat);
Effects::HPSpriteFX->SetHPTextureMapArray(m_HPTextureMapArraySRV);
m_pDeviceContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
m_pDeviceContext->IASetInputLayout(InputLayouts::HPPointSprite);
UINT stride = sizeof(Vertex::HPPointSprite);
UINT offset = 0;
ID3DX11EffectTechnique* HPTech;
switch (mRenderOptions)
{
case RenderOptions::Lighting:
HPTech = Effects::HPSpriteFX->Light3Tech;
break;
case RenderOptions::Textures:
HPTech = Effects::HPSpriteFX->Light3TexAlphaClipTech;
break;
case RenderOptions::TexturesAndFog:
HPTech = Effects::HPSpriteFX->Light3TexAlphaClipFogTech;
break;
}
D3DX11_TECHNIQUE_DESC techDesc;
HPTech->GetDesc(&techDesc);
for (UINT p = 0; p < techDesc.Passes; ++p)
{
m_pDeviceContext->IASetVertexBuffers(0, 1, &m_HPSpritesVB, &stride, &offset);
float blendFactor[4] = { 0.0f, 0.0f, 0.0f, 0.0f };
if (mAlphaToCoverageOn)
{
m_pDeviceContext->OMSetBlendState(RenderStates::AlphaToCoverageBS, blendFactor, 0xffffffff);
}
HPTech->GetPassByIndex(p)->Apply(0, m_pDeviceContext);
m_pDeviceContext->Draw(HP_Count, 0);
m_pDeviceContext->OMSetBlendState(0, blendFactor, 0xffffffff);
}
}
void TreeBillboardApp::DrawTreeSprites(CXMMATRIX viewProj)
{
Effects::TreeSpriteFX->SetDirLights(m_dirLight);
Effects::TreeSpriteFX->SetEyePosW(m_camPosition);
Effects::TreeSpriteFX->SetFogColor(oc::Colors::Silver);
Effects::TreeSpriteFX->SetFogStart(15.0f);
Effects::TreeSpriteFX->SetFogRange(175.0f);
Effects::TreeSpriteFX->SetViewProj(viewProj);
Effects::TreeSpriteFX->SetMaterial(m_treeMat);
Effects::TreeSpriteFX->SetTreeTextureMapArray(m_treeTextureMapArraySRV.Get());
m_dxImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_POINTLIST);
m_dxImmediateContext->IASetInputLayout(InputLayouts::TreePointSprite.Get());
uint32 stride = sizeof(Vertex::TreePointSprite);
uint32 offset = 0;
ID3DX11EffectTechnique* treeTech = nullptr;
switch(m_renderOptions)
{
case RenderOptions::Lighting:
treeTech = Effects::TreeSpriteFX->Light3Tech;
break;
case RenderOptions::Textures:
treeTech = Effects::TreeSpriteFX->Light3TexAlphaClipTech;
break;
case RenderOptions::TexturesAndFog:
treeTech = Effects::TreeSpriteFX->Light3TexAlphaClipFogTech;
break;
}
D3DX11_TECHNIQUE_DESC techDesc;
treeTech->GetDesc( &techDesc );
for(uint32 p = 0; p < techDesc.Passes; ++p)
{
m_dxImmediateContext->IASetVertexBuffers(0, 1, m_treeSpritesVB.GetAddressOf(), &stride, &offset);
float blendFactor[4] = {0.0f, 0.0f, 0.0f, 0.0f};
if(m_alphaToCoverageOn)
{
m_dxImmediateContext->OMSetBlendState(RenderStates::AlphaToCoverageBS.Get(), blendFactor, 0xffffffff);
}
treeTech->GetPassByIndex(p)->Apply(0, m_dxImmediateContext.Get());
m_dxImmediateContext->Draw(TreeCount, 0);
m_dxImmediateContext->OMSetBlendState(0, blendFactor, 0xffffffff);
}
}
void JF::Component::SkyBox::Render()
{
// Declear)
float blendFactors[] = { 0.0f, 0.0f, 0.0f, 0.0f };
// 컴포넌트에 카메라가 없거나 메인카메라가 아니라면 패스.
Camera* pCamera = GetOwner()->GetComponent<Camera>();
if (pCamera == nullptr || Camera::g_pMainCamera != pCamera)
return;
//
Transform* pTransform = GetOwner()->GetComponent<Transform>();
if (pTransform == nullptr)
return;
// Set Layout And Topology
gRENDERER->DeviceContext()->IASetInputLayout(m_pInputLayout);
gRENDERER->DeviceContext()->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// Set VertexBuffer And IndexBuffer
UINT stride = m_Stride;
UINT offset = 0;
gRENDERER->DeviceContext()->IASetVertexBuffers(0, 1, &m_pVB, &stride, &offset);
gRENDERER->DeviceContext()->IASetIndexBuffer(m_pIB, DXGI_FORMAT_R32_UINT, 0);
// center Sky about eye in world space
XMFLOAT3 eyePos = pTransform->GetPosition();
XMMATRIX T = XMMatrixTranslation(eyePos.x, eyePos.y, eyePos.z);
XMMATRIX WVP = XMMatrixMultiply(T, pCamera->GetViewProj());
Effects::CubeMapFX->SetWorldViewProj(WVP);
Effects::CubeMapFX->SetCubeMap(m_pMainTexture->GetTexture());
ID3DX11EffectTechnique* tech = Effects::CubeMapFX->SkyTech;
D3DX11_TECHNIQUE_DESC techDesc;
tech->GetDesc(&techDesc);
for (UINT p = 0; p < techDesc.Passes; ++p)
{
tech->GetPassByIndex(p)->Apply(0, gRENDERER->DeviceContext());
gRENDERER->DeviceContext()->DrawIndexed(m_IndexCount, 0, 0);
}
// 기본 랜더상태로 복원한다.
gRENDERER->DeviceContext()->RSSetState(0);
gRENDERER->DeviceContext()->OMSetBlendState(0, blendFactors, 0xffffffff);
}
void CrateApp::DrawScene()
{
md3dImmediateContext->ClearRenderTargetView(mRenderTargetView,reinterpret_cast<const float*>(&Colors::LightSteelBlue));
md3dImmediateContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
md3dImmediateContext->IASetInputLayout(InputLayouts::Basic32);
md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
UINT stride = sizeof(Vertex::Basic32);
UINT offset = 0;
XMMATRIX view = XMLoadFloat4x4(&mView);
XMMATRIX proj = XMLoadFloat4x4(&mProj);
XMMATRIX viewProj = view*proj;
//set cbuffer per frame
Effects::BasicFX->SetDirLights(mDirLights);
Effects::BasicFX->SetEyePosW(mEyePosW);
ID3DX11EffectTechnique *activeTech = Effects::BasicFX->Light2TexTech;
D3DX11_TECHNIQUE_DESC techDesc;
activeTech->GetDesc(&techDesc);
for(UINT p = 0; p < techDesc.Passes; ++p)
{
md3dImmediateContext->IASetVertexBuffers(0,1,&mBoxVB,&stride,&offset);
md3dImmediateContext->IASetIndexBuffer(mBoxIB,DXGI_FORMAT_R32_UINT,0);
XMMATRIX world = XMLoadFloat4x4(&mBoxWorld);
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);
XMMATRIX worldViewProj = world*view*proj;
XMMATRIX texTransform = XMLoadFloat4x4(&mTexTransform);
Effects::BasicFX->SetWorld(world);
Effects::BasicFX->SetWorldInvTranspose(worldInvTranspose);
Effects::BasicFX->SetWorldViewProj(worldViewProj);
Effects::BasicFX->SetTexTransform(texTransform);
Effects::BasicFX->SetMaterial(mBoxMat);
Effects::BasicFX->SetDiffuseMap(mDiffuseMapSRV);
activeTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
md3dImmediateContext->DrawIndexed(mBoxIndexCount, mBoxIndexOffset, mBoxVertexOffset);
}
HR(mSwapChain->Present(0, 0));
}
void InstancingAndCullingApp::DrawScene()
{
md3dImmediateContext->ClearRenderTargetView(mRenderTargetView, reinterpret_cast<const float*>(&Colors::Silver));
md3dImmediateContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
md3dImmediateContext->IASetInputLayout(InputLayouts::InstancedBasic32);
md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
UINT stride[2] = {sizeof(Vertex::Basic32), sizeof(InstancedData)};
UINT offset[2] = {0,0};
ID3D11Buffer* vbs[2] = {mSkullVB, mInstancedBuffer};
XMMATRIX view = mCam.View();
XMMATRIX proj = mCam.Proj();
XMMATRIX viewProj = mCam.ViewProj();
// Set per frame constants.
Effects::InstancedBasicFX->SetDirLights(mDirLights);
Effects::InstancedBasicFX->SetEyePosW(mCam.GetPosition());
ID3DX11EffectTechnique* activeTech = Effects::InstancedBasicFX->Light3Tech;
D3DX11_TECHNIQUE_DESC techDesc;
activeTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
// Draw the skull.
md3dImmediateContext->IASetVertexBuffers(0, 2, vbs, stride, offset);
md3dImmediateContext->IASetIndexBuffer(mSkullIB, DXGI_FORMAT_R32_UINT, 0);
XMMATRIX world = XMLoadFloat4x4(&mSkullWorld);
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);
Effects::InstancedBasicFX->SetWorld(world);
Effects::InstancedBasicFX->SetWorldInvTranspose(worldInvTranspose);
Effects::InstancedBasicFX->SetViewProj(viewProj);
Effects::InstancedBasicFX->SetMaterial(mSkullMat);
activeTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
md3dImmediateContext->DrawIndexedInstanced(mSkullIndexCount, mVisibleObjectCount, 0, 0, 0);
}
HR(mSwapChain->Present(0, 0));
}
void Ssao::ComputeSsao(const Camera& camera)
{
// Bind the ambient map as the render target. Observe that this pass does not bind
// a depth/stencil buffer--it does not need it, and without one, no depth test is
// performed, which is what we want.
ID3D11RenderTargetView* renderTargets[1] = {mAmbientRTV0};
mDC->OMSetRenderTargets(1, renderTargets, 0);
mDC->ClearRenderTargetView(mAmbientRTV0, reinterpret_cast<const float*>(&Colors::Black));
mDC->RSSetViewports(1, &mAmbientMapViewport);
// Transform NDC space [-1,+1]^2 to texture space [0,1]^2
static const XMMATRIX T(
0.5f, 0.0f, 0.0f, 0.0f,
0.0f, -0.5f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.5f, 0.5f, 0.0f, 1.0f);
XMMATRIX P = camera.Proj();
XMMATRIX PT = XMMatrixMultiply(P, T);
Effects::SsaoFX->SetViewToTexSpace(PT);
Effects::SsaoFX->SetOffsetVectors(mOffsets);
Effects::SsaoFX->SetFrustumCorners(mFrustumFarCorner);
Effects::SsaoFX->SetNormalDepthMap(mNormalDepthSRV);
Effects::SsaoFX->SetRandomVecMap(mRandomVectorSRV);
UINT stride = sizeof(Vertex::Basic32);
UINT offset = 0;
mDC->IASetInputLayout(InputLayouts::Basic32);
mDC->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
mDC->IASetVertexBuffers(0, 1, &mScreenQuadVB, &stride, &offset);
mDC->IASetIndexBuffer(mScreenQuadIB, DXGI_FORMAT_R16_UINT, 0);
ID3DX11EffectTechnique* tech = Effects::SsaoFX->SsaoTech;
D3DX11_TECHNIQUE_DESC techDesc;
tech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
tech->GetPassByIndex(p)->Apply(0, mDC);
mDC->DrawIndexed(6, 0, 0);
}
}
void Ssao::BlurAmbientMap(ID3D11ShaderResourceView* inputSRV, ID3D11RenderTargetView* outputRTV, bool horzBlur)
{
ID3D11RenderTargetView* renderTargets[1] = {outputRTV};
mDC->OMSetRenderTargets(1, renderTargets, 0);
mDC->ClearRenderTargetView(outputRTV, reinterpret_cast<const float*>(&Colors::Black));
mDC->RSSetViewports(1, &mAmbientMapViewport);
Effects::SsaoBlurFX->SetTexelWidth(1.0f / mAmbientMapViewport.Width );
Effects::SsaoBlurFX->SetTexelHeight(1.0f / mAmbientMapViewport.Height );
Effects::SsaoBlurFX->SetNormalDepthMap(mNormalDepthSRV);
Effects::SsaoBlurFX->SetInputImage(inputSRV);
ID3DX11EffectTechnique* tech;
if(horzBlur)
{
tech = Effects::SsaoBlurFX->HorzBlurTech;
}
else
{
tech = Effects::SsaoBlurFX->VertBlurTech;
}
UINT stride = sizeof(Vertex::Basic32);
UINT offset = 0;
mDC->IASetInputLayout(InputLayouts::Basic32);
mDC->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
mDC->IASetVertexBuffers(0, 1, &mScreenQuadVB, &stride, &offset);
mDC->IASetIndexBuffer(mScreenQuadIB, DXGI_FORMAT_R16_UINT, 0);
D3DX11_TECHNIQUE_DESC techDesc;
tech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
tech->GetPassByIndex(p)->Apply(0, mDC);
mDC->DrawIndexed(6, 0, 0);
// Unbind the input SRV as it is going to be an output in the next blur.
Effects::SsaoBlurFX->SetInputImage(0);
tech->GetPassByIndex(p)->Apply(0, mDC);
}
}
void AmbientOcclusionApp::DrawScene()
{
md3dImmediateContext->ClearRenderTargetView(mRenderTargetView, reinterpret_cast<const float*>(&Colors::Silver));
md3dImmediateContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
md3dImmediateContext->IASetInputLayout(InputLayouts::AmbientOcclusion);
md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
UINT stride = sizeof(Vertex::AmbientOcclusion);
UINT offset = 0;
mCam.UpdateViewMatrix();
XMMATRIX view = mCam.View();
XMMATRIX proj = mCam.Proj();
XMMATRIX viewProj = mCam.ViewProj();
ID3DX11EffectTechnique* activeSkullTech = Effects::AmbientOcclusionFX->AmbientOcclusionTech;
D3DX11_TECHNIQUE_DESC techDesc;
activeSkullTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
// Draw the skull.
md3dImmediateContext->IASetVertexBuffers(0, 1, &mSkullVB, &stride, &offset);
md3dImmediateContext->IASetIndexBuffer(mSkullIB, DXGI_FORMAT_R32_UINT, 0);
XMMATRIX world = XMLoadFloat4x4(&mSkullWorld);
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);
XMMATRIX worldViewProj = world*view*proj;
Effects::AmbientOcclusionFX->SetWorldViewProj(worldViewProj);
activeSkullTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
md3dImmediateContext->DrawIndexed(mSkullIndexCount, 0, 0);
}
HR(mSwapChain->Present(0, 0));
}
void Map::Draw()
{
UINT stride = sizeof(GeometryGenerator::Vertex);
UINT offset = 0;
ID3DX11EffectTechnique* activeTech = Effects::BasicFX->Light2TexTech;
D3DX11_TECHNIQUE_DESC techDesc;
activeTech->GetDesc(&techDesc);
for (UINT y = 0; y < Md_.height; y++)
{
for (UINT x = 0; x < Md_.width; x++)
{
for (UINT p = 0; p < techDesc.Passes; ++p)
{
pDevCon_->IASetVertexBuffers(0, 1, &mBoxVB[x + (y * Md_.width)], &stride, &offset);
pDevCon_->IASetIndexBuffer(mBoxIB[x + (y * Md_.width)], DXGI_FORMAT_R32_UINT, 0);
// Draw the box.
//XMMATRIX world = XMLoadFloat4x4(&mBoxWorld);
//XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);
//XMMATRIX worldViewProj = world*view*proj;
//Effects::BasicFX->SetWorld(world);
//Effects::BasicFX->SetWorldInvTranspose(worldInvTranspose);
//Effects::BasicFX->SetWorldViewProj(worldViewProj);
//Scaling 1/Rows and 1/Cols
//Effects::BasicFX->SetTexTransform(XMMatrixTranslation(1.0f, 1.0f, 1.0f) * XMMatrixScaling(1.0f, 1.0f, 1.0f));
Effects::BasicFX->SetTexTransform(XMLoadFloat4x4(&mTexTransform[x + (y*Md_.width)]));
Effects::BasicFX->SetMaterial(mBoxMat);
Effects::BasicFX->SetDiffuseMap(mDiffuseMapSRV);
activeTech->GetPassByIndex(p)->Apply(0, pDevCon_);
pDevCon_->DrawIndexed(mBoxIndexCount, mBoxIndexOffset, mBoxVertexOffset);
}
}
}
}
void cCylinder::Draw()
{
//g_pD3DDC->RSSetState(cRenderStates::m_WireframeRS);
// Set Layout And Topology
g_pD3DDC->IASetInputLayout(cInputLayouts::Simple);
g_pD3DDC->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
// Set VertexBuffer And IndexBuffer
UINT stride = sizeof(Vertex::Simple);
UINT offset = 0;
g_pD3DDC->IASetVertexBuffers(0, 1, &m_VB, &stride, &offset);
g_pD3DDC->IASetIndexBuffer(m_IB, DXGI_FORMAT_R32_UINT, 0);
// worldViewProj 행렬을 구한다.
XMMATRIX world = XMLoadFloat4x4(&GetTransformMatrix());
XMMATRIX view = g_pCameraManager->GetView();
XMMATRIX proj = g_pCameraManager->GetProj();
XMMATRIX worldViewProj = world * view * proj;
// 셰이더에 상수값 설정.
cEffects::SimpleFX->SetWorldViewProj(worldViewProj);
ID3DX11EffectTechnique* tech = cEffects::SimpleFX->ColorTech;
D3DX11_TECHNIQUE_DESC techDesc;
tech->GetDesc(&techDesc);
for (UINT p = 0; p < techDesc.Passes; ++p)
{
tech->GetPassByIndex(p)->Apply(0, g_pD3DDC);
// 색인을 사용해서 그린다.
g_pD3DDC->DrawIndexed(m_GridIndexCount, 0, 0);
}
HR(g_pD3DSC->Present(0, 0));
}
void InitDirect3DApp::DrawScene()
{
assert(md3dImmediateContext);
assert(mSwapChain);
// Clear all the old stuff before rendering the new stuff
md3dImmediateContext->ClearRenderTargetView(mRenderTargetView, reinterpret_cast<const float*>(&Colors::LightSteelBlue));
md3dImmediateContext->ClearDepthStencilView(mDepthStencilView, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
// Set the input layout for vertices before drawing
md3dImmediateContext->IASetInputLayout(inputLayout);
md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
UINT stride = sizeof(Vertex);
UINT offset = 0;
md3dImmediateContext->IASetVertexBuffers(0, 1, &vertexBuffer, &stride, &offset);
md3dImmediateContext->IASetIndexBuffer(indexBuffer, DXGI_FORMAT_R32_UINT, offset);
// Update the worldViewProjMtx and set up
XMMATRIX worldViewProjMtx = worldMtx * viewMtx * projMtx;
worldViewProj->SetMatrix(reinterpret_cast<float*>(&worldViewProjMtx));
// Draw the indices
D3DX11_TECHNIQUE_DESC techniqueDesc;
technique->GetDesc(&techniqueDesc);
for (unsigned int i = 0; i < techniqueDesc.Passes; ++i)
{
technique->GetPassByIndex(i)->Apply(0, md3dImmediateContext);
md3dImmediateContext->DrawIndexed(36, 0, 0);
}
// Present the back buffer to the screen
HR(mSwapChain->Present(0, 0));
}
void Entity::DrawShadow(ID3DX11EffectTechnique* activeTech, ID3D11DeviceContext* context, const Camera& camera, XMFLOAT4X4 lightView, XMFLOAT4X4 lightProj)
{
XMMATRIX view = XMLoadFloat4x4(&lightView);
XMMATRIX proj = XMLoadFloat4x4(&lightProj);
XMMATRIX viewProj = XMMatrixMultiply(view, proj);
ID3DX11EffectTechnique* smapTech = Effects::BuildShadowMapFX->BuildShadowMapAlphaClipTech;
D3DX11_TECHNIQUE_DESC techDesc;
smapTech->GetDesc(&techDesc);
for (UINT p = 0; p < techDesc.Passes; ++p)
{
ID3DX11EffectPass* pass = activeTech->GetPassByIndex(p);
XMMATRIX world = XMLoadFloat4x4(&mWorld);
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose(world);
XMMATRIX worldViewProj = world*view*proj;
Effects::BuildShadowMapFX->SetWorld(world);
Effects::BuildShadowMapFX->SetWorldInvTranspose(worldInvTranspose);
Effects::BuildShadowMapFX->SetWorldViewProj(worldViewProj);
Effects::BuildShadowMapFX->SetDiffuseMap(mTexSRV);
if (!useTexTrans){ Effects::BuildShadowMapFX->SetTexTransform(XMMatrixScaling(origTexScale.x, origTexScale.y, origTexScale.z)); }
if (mBasicTexTrans)
{
Effects::BuildShadowMapFX->SetTexTransform(XMMatrixTranslation(texTrans.x, texTrans.y, texTrans.z)*XMMatrixScaling(origTexScale.x, origTexScale.y, origTexScale.z));
}
if (mUseAnimation)
{
XMMATRIX Scale;
mAnim->Flipped() ? Scale = XMMatrixScaling(-origTexScale.x, origTexScale.y, origTexScale.z) : Scale = XMMatrixScaling(origTexScale.x, origTexScale.y, origTexScale.z);
Effects::BuildShadowMapFX->SetTexTransform(XMMatrixTranslation(mAnim->GetX(), mAnim->GetY(), texTrans.z)*Scale);
}
pass->Apply(0, context);
context->DrawIndexed(mIndexCount, mIndexOffset, mVertexOffset);
}
}
void WavesApp::DrawScene()
{
assert(m_pD3dImmediateContext);
assert(m_pSwapChain);
m_pD3dImmediateContext->ClearRenderTargetView(m_pRenderTargetView, reinterpret_cast<const float *>(&Colors::LightSteelBlue));
m_pD3dImmediateContext->ClearDepthStencilView(m_pDepthStencilView, D3D11_CLEAR_DEPTH | D3D11_CLEAR_STENCIL, 1.0f, 0);
//设置顶点输入数据流格式
m_pD3dImmediateContext->IASetInputLayout(m_pInputLayout);
//设置顶点拼装方式
m_pD3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
UINT stride = sizeof(Vertex);
UINT offset = 0;
//Update Constants before drawcall
XMMATRIX view = XMLoadFloat4x4(&m_viewMatrix);
XMMATRIX proj = XMLoadFloat4x4(&m_projMaxtrix);
//Draw all the passes
D3DX11_TECHNIQUE_DESC techDesc;
m_pShaderTech->GetDesc(&techDesc);
for (UINT i = 0; i < techDesc.Passes;++i)
{
{
//
//Draw the land.
//
m_pD3dImmediateContext->IASetVertexBuffers(0, 1, &m_pLandVB, &stride, &offset);
m_pD3dImmediateContext->IASetIndexBuffer(m_pLandIB, DXGI_FORMAT_R32_UINT, 0);
XMMATRIX world = XMLoadFloat4x4(&m_GridWorldMatrix);
XMMATRIX worldViewProj = world*view*proj;
m_pShaderMVP->SetMatrix(reinterpret_cast<float *>(&worldViewProj));
m_pShaderTech->GetPassByIndex(i)->Apply(0, m_pD3dImmediateContext);//首参数无意义，已被放弃
m_pD3dImmediateContext->DrawIndexed(m_uLandGridIndexCount, 0, 0);
}
{
//
//Draw the Waves.
//
m_pD3dImmediateContext->RSSetState(m_pWireframeRS);
m_pD3dImmediateContext->IASetVertexBuffers(0, 1, &m_pWavesVB, &stride, &offset);
m_pD3dImmediateContext->IASetIndexBuffer(m_pWavesIB, DXGI_FORMAT_R32_UINT, 0);
XMMATRIX world = XMLoadFloat4x4(&m_WavesWorldMatrix);
XMMATRIX worldViewProj = world*view*proj;
m_pShaderMVP->SetMatrix(reinterpret_cast<float *>(&worldViewProj));
m_pShaderTech->GetPassByIndex(i)->Apply(0, m_pD3dImmediateContext);//首参数无意义，已被放弃
m_pD3dImmediateContext->DrawIndexed(3 * m_waves.GetTriangleCount(), 0, 0);
m_pD3dImmediateContext->RSSetState(nullptr);
}
}
HR(m_pSwapChain->Present(0,0));
}
//--------------------------------------------------------------------------------------
void SoftParticles::OnD3D11FrameRender( ID3D11DeviceContext* context, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix,D3DXVECTOR3 spaceshipPos)
{
//////////////////////////////////////////////////////////////////////////
//On Frame Move
//////////////////////////////////////////////////////////////////////////
CameraClass* cc = CameraManager::getInstance()->getCamera("mainCamera");
const float dt = 1.0f/60.0f;
m_time += dt;
D3DXVECTOR3 vEye = cc->GetPosition();
D3DXVECTOR3 vDir = - vEye;
D3DXVec3Normalize( &vDir, &vDir );
AdvanceParticles( m_time, dt );
SortParticleBuffer( vEye, vDir );
UpdateParticleBuffers( context );
// Update the movement of the noise octaves
D3DXVECTOR4 OctaveOffsets[4];
for( int i=0; i<4; i++ )
{
OctaveOffsets[i].x = -(float)(m_time*0.05);
OctaveOffsets[i].y = 0;
OctaveOffsets[i].z = 0;
OctaveOffsets[i].w = 0;
}
g_pvOctaveOffsets->SetFloatVectorArray( (float*)OctaveOffsets, 0, 4 );
//////////////////////////////////////////////////////////////////////////
//On Frame Move End
//////////////////////////////////////////////////////////////////////////
ID3D11RenderTargetView* pRTV;
ID3D11DepthStencilView* pDSV;
context->OMGetRenderTargets(1,&pRTV,&pDSV);
// Get the projection & view matrix from the camera class
D3DXMATRIX mWorld;
D3DXMATRIX mView;
D3DXMATRIX mProj;
D3DXMATRIX mInvView;
D3DXMATRIX mInvProj;
D3DXMatrixIdentity( &mWorld );
//D3DXMATRIX mScale;
//float mScaleValue = 1.0f;
//D3DXMatrixScaling(&mScale,mScaleValue,mScaleValue,mScaleValue);
D3DXMatrixTranslation(&mWorld,spaceshipPos.x - 15.0f,spaceshipPos.y + 3.5f,spaceshipPos.z);
//mWorld = mScale * mWorld;
mProj = projectionMatrix;
mView = viewMatrix;
D3DXMATRIX mWorldViewProj = mWorld*mView*mProj;
D3DXMATRIX mWorldView = mWorld*mView;
D3DXMatrixInverse( &mInvView, NULL, &mView );
D3DXMatrixInverse( &mInvProj, NULL, &mProj);
D3DXVECTOR4 vViewLightDir1;
D3DXVECTOR4 vWorldLightDir1;
D3DXVECTOR4 vViewLightDir2;
D3DXVECTOR4 vWorldLightDir2;
D3DXVec3Normalize( (D3DXVECTOR3*)&vWorldLightDir1, &g_vLightDir1 );
D3DXVec3TransformNormal( (D3DXVECTOR3*)&vViewLightDir1, &g_vLightDir1, &mView );
D3DXVec3Normalize( (D3DXVECTOR3*)&vViewLightDir1, (D3DXVECTOR3*)&vViewLightDir1 );
D3DXVec3Normalize( (D3DXVECTOR3*)&vWorldLightDir2, &g_vLightDir2 );
D3DXVec3TransformNormal( (D3DXVECTOR3*)&vViewLightDir2, &g_vLightDir2, &mView );
D3DXVec3Normalize( (D3DXVECTOR3*)&vViewLightDir2, (D3DXVECTOR3*)&vViewLightDir2 );
D3DXVECTOR3 viewDir = - cc->GetPosition();
D3DXVec3Normalize( &viewDir, &viewDir );
D3DXVECTOR3 vec3 = cc->GetPosition();
D3DXVECTOR4 vEyePt;
vEyePt.x = vec3.x;
vEyePt.y = vec3.y;
vEyePt.z = vec3.z;
FLOAT fScreenSize[ 2 ] = { (FLOAT)g_iWidth, (FLOAT)g_iHeight };
g_pmWorldViewProj->SetMatrix( (float*)&mWorldViewProj );
g_pmWorldView->SetMatrix( (float*)&mWorldView );
g_pmWorld->SetMatrix( (float*)&mWorld );
g_pmInvView->SetMatrix( (float*)&mInvView );
g_pmInvProj->SetMatrix( (float*)&mInvProj );
g_pvViewLightDir1->SetFloatVector( (float*)&vViewLightDir1 );
g_pvWorldLightDir1->SetFloatVector( (float*)&vWorldLightDir1);
g_pvViewLightDir2->SetFloatVector( (float*)&vViewLightDir2 );
g_pvWorldLightDir2->SetFloatVector( (float*)&vWorldLightDir2);
g_pvViewDir->SetFloatVector( (float*)&viewDir );
g_pvEyePt->SetFloatVector( (float*)&vEyePt );
g_pvScreenSize->SetFloatVector( fScreenSize );
ID3DX11EffectTechnique* pParticleTech = NULL;
if( 1 == g_iSampleCount ) {
switch( g_ParticleTechnique )
{
case PT_BILLBOARD_HARD:
pParticleTech = g_pRenderBillboardParticlesHard;
break;
case PT_BILLBOARD_ODEPTH:
pParticleTech = g_pRenderBillboardParticlesODepth;
break;
case PT_BILLBOARD_SOFT:
pParticleTech = g_pRenderBillboardParticlesSoft;
break;
case PT_BILLBOARD_ODEPTHSOFT:
pParticleTech = g_pRenderBillboardParticlesODepthSoft;
break;
case PT_VOLUME_HARD:
pParticleTech = g_pRenderVolumeParticlesHard;
break;
case PT_VOLUME_SOFT:
pParticleTech = g_pRenderVolumeParticlesSoft;
break;
};
} else {
switch( g_ParticleTechnique )
{
case PT_BILLBOARD_HARD:
pParticleTech = g_pRenderBillboardParticlesHard;
break;
case PT_BILLBOARD_ODEPTH:
pParticleTech = g_pRenderBillboardParticlesODepth;
break;
case PT_BILLBOARD_SOFT:
pParticleTech = g_pRenderBillboardParticlesSoftMSAA;
break;
case PT_BILLBOARD_ODEPTHSOFT:
pParticleTech = g_pRenderBillboardParticlesODepthSoftMSAA;
break;
case PT_VOLUME_HARD:
pParticleTech = g_pRenderVolumeParticlesHardMSAA;
break;
case PT_VOLUME_SOFT:
pParticleTech = g_pRenderVolumeParticlesSoftMSAA;
break;
};
}
if( PT_BILLBOARD_HARD != g_ParticleTechnique &&
PT_BILLBOARD_ODEPTH != g_ParticleTechnique )
{
// Unbind the depth stencil texture from the device
context->OMSetRenderTargets( 1, &pRTV, NULL );
// Bind it instead as a shader resource view
if( 1 == g_iSampleCount ) {
g_pDepthTex->SetResource( g_pDepthStencilSRV );
} else {
g_pDepthMSAATex->SetResource( g_pDepthStencilSRV );
}
}
// Render the particles
context->IASetInputLayout( g_pParticleVertexLayout );
ID3D11Buffer *pBuffers[1] = { g_pParticleVB };
UINT stride[1] = { sizeof(PARTICLE_VERTEX) };
UINT offset[1] = { 0 };
context->IASetVertexBuffers( 0, 1, pBuffers, stride, offset );
context->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_POINTLIST );
context->IASetIndexBuffer( g_pParticleIB, DXGI_FORMAT_R32_UINT, 0 );
if( PT_VOLUME_HARD == g_ParticleTechnique ||
PT_VOLUME_SOFT == g_ParticleTechnique )
{
g_pVolumeDiffTex->SetResource( g_pNoiseVolumeRV );
g_pVolumeNormTex->SetResource( NULL );
}
else
{
g_pVolumeDiffTex->SetResource( g_pParticleTexRV );
}
g_pColorGradient->SetResource( g_pColorGradTexRV );
D3DX11_TECHNIQUE_DESC techDesc;
pParticleTech->GetDesc( &techDesc );
for( UINT p = 0; p < techDesc.Passes; ++p )
{
pParticleTech->GetPassByIndex( p )->Apply(0,context);
context->DrawIndexed( MAX_PARTICLES, 0, 0 );
}
// unbind the depth from the resource so we can set it as depth next time around
ID3D11ShaderResourceView* Nulls[2] = {NULL,NULL};
context->PSSetShaderResources( 0, 2, Nulls );
}
void D3DPBRApp::CreateLUT()
{
D3D11_TEXTURE2D_DESC texDesc;
texDesc.Width = 512;
texDesc.Height = 512;
texDesc.MipLevels = 0;
texDesc.ArraySize = 1;
texDesc.SampleDesc.Count = 1;
texDesc.SampleDesc.Quality = 0;
texDesc.Format = DXGI_FORMAT_R16G16_FLOAT;
texDesc.Usage = D3D11_USAGE_DEFAULT;
texDesc.BindFlags = D3D11_BIND_RENDER_TARGET | D3D11_BIND_SHADER_RESOURCE;
texDesc.CPUAccessFlags = 0;
texDesc.MiscFlags = 0;
ID3D11Texture2D* LUTTex = 0;
HR(md3dDevice->CreateTexture2D(&texDesc, 0, &LUTTex));
//
// Create a render target view to each cube map face
// (i.e., each element in the texture array).
//
D3D11_RENDER_TARGET_VIEW_DESC rtvDesc;
rtvDesc.Format = texDesc.Format;
rtvDesc.ViewDimension = D3D11_RTV_DIMENSION_TEXTURE2D;
rtvDesc.Texture2D.MipSlice = 0;
HR(md3dDevice->CreateRenderTargetView(LUTTex, &rtvDesc, &mLUTRTV));
//
// Create a shader resource view to the cube map.
//
D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc;
srvDesc.Format = texDesc.Format;
srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D;
srvDesc.Texture2D.MipLevels = -1;
srvDesc.Texture2D.MostDetailedMip = 0;
HR(md3dDevice->CreateShaderResourceView(LUTTex, &srvDesc, &mLUTSRV));
D3D11_TEXTURE2D_DESC depthTexDesc;
depthTexDesc.Width = 512;
depthTexDesc.Height = 512;
depthTexDesc.MipLevels = 1;
depthTexDesc.ArraySize = 1;
depthTexDesc.SampleDesc.Count = 1;
depthTexDesc.SampleDesc.Quality = 0;
depthTexDesc.Format = DXGI_FORMAT_D32_FLOAT;
depthTexDesc.Usage = D3D11_USAGE_DEFAULT;
depthTexDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL;
depthTexDesc.CPUAccessFlags = 0;
depthTexDesc.MiscFlags = 0;
ID3D11Texture2D* depthTex = 0;
HR(md3dDevice->CreateTexture2D(&depthTexDesc, 0, &depthTex));
D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc;
dsvDesc.Format = depthTexDesc.Format;
dsvDesc.Flags = 0;
dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D;
dsvDesc.Texture2D.MipSlice = 0;
HR(md3dDevice->CreateDepthStencilView(depthTex, &dsvDesc, &mLUTDSV));
ReleaseCOM(depthTex);
//
// Viewport for drawing into cubemap.
//
mLUTViewport.TopLeftX = 0.0f;
mLUTViewport.TopLeftY = 0.0f;
mLUTViewport.Width = (float)512;
mLUTViewport.Height = (float)512;
mLUTViewport.MinDepth = 0.0f;
mLUTViewport.MaxDepth = 1.0f;
GeometryGenerator::MeshData quad;
GeometryGenerator geoGen;
geoGen.CreateFullscreenQuad(quad);
mQuadIndexNum = quad.Indices.size();
std::vector<Vertex::Basic32> vertices(quad.Vertices.size());
for (int i = 0; i < vertices.size(); i++)
{
vertices[i].Normal = quad.Vertices[i].Normal;
vertices[i].Pos = quad.Vertices[i].Position;
vertices[i].Tangent = quad.Vertices[i].TangentU;
vertices[i].Tex = quad.Vertices[i].TexC;
}
D3D11_BUFFER_DESC dbd;
dbd.BindFlags = D3D11_BIND_VERTEX_BUFFER;
dbd.ByteWidth = sizeof(Vertex::Basic32) * vertices.size();
dbd.CPUAccessFlags = 0;
dbd.StructureByteStride = 0;
dbd.MiscFlags = 0;
dbd.Usage = D3D11_USAGE_DEFAULT;
D3D11_SUBRESOURCE_DATA vinitdata;
vinitdata.pSysMem = &vertices[0];
HR(md3dDevice->CreateBuffer(&dbd, &vinitdata, &mQuadVB));
std::vector<UINT> indeces(quad.Indices.begin(), quad.Indices.end());
dbd.BindFlags = D3D11_BIND_INDEX_BUFFER;
dbd.ByteWidth = sizeof(UINT) * mQuadIndexNum;
vinitdata.pSysMem = &indeces[0];
HR(md3dDevice->CreateBuffer(&dbd, &vinitdata, &mQuadIB));
md3dImmediateContext->IASetPrimitiveTopology(D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST);
md3dImmediateContext->ClearRenderTargetView(mLUTRTV, reinterpret_cast<const float*>(&Colors::Black));
md3dImmediateContext->ClearDepthStencilView(mLUTDSV, D3D11_CLEAR_DEPTH|D3D11_CLEAR_STENCIL, 1.0f, 0);
md3dImmediateContext->OMSetRenderTargets(1, &mLUTRTV, mLUTDSV);
md3dImmediateContext->RSSetViewports(1, &mLUTViewport);
md3dImmediateContext->IASetInputLayout(InputLayouts::Basic32);
ID3DX11EffectTechnique* activeMeshTech = Effects::CommonPassFX->LUTTech;
UINT stride = sizeof(Vertex::Basic32);
UINT offset = 0;
D3DX11_TECHNIQUE_DESC techDesc;
activeMeshTech->GetDesc( &techDesc );
for(UINT p = 0; p < techDesc.Passes; ++p)
{
// Draw the Mesh.
md3dImmediateContext->IASetVertexBuffers(0, 1, &mQuadVB, &stride, &offset);
md3dImmediateContext->IASetIndexBuffer(mQuadIB, DXGI_FORMAT_R32_UINT, 0);
activeMeshTech->GetPassByIndex(p)->Apply(0, md3dImmediateContext);
md3dImmediateContext->DrawIndexed(mQuadIndexNum, 0, 0);
//m_pSky->Draw(md3dImmediateContext, camera);
// Restore default
md3dImmediateContext->RSSetState(0);
}
HR(D3DX11SaveTextureToFile(md3dImmediateContext, LUTTex, D3DX11_IFF_DDS, _T("lut.dds")));
ReleaseCOM(LUTTex);
}
void SuperSolarSystemApp::DrawIceCube( )
{
float blendFactor[] ={ 0.0f, 0.0f, 0.0f, 0.0f };
ID3DX11EffectTechnique *activeTech;
D3DX11_TECHNIQUE_DESC techDesc;
//
// 画冰立方, 仅将其渲染到模板缓冲
//
mD3dImmediateContext->IASetInputLayout( InputLayouts::NormalObjLayout );
mD3dImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
activeTech = Effects::NormalObjFX->NormalObjTech;
activeTech->GetDesc( &techDesc );
UINT stride = sizeof( Vertex::NormalObjVertex );
UINT offset = 0;
mD3dImmediateContext->IASetVertexBuffers( 0, 1, &mLightTexVB, &stride, &offset );
mD3dImmediateContext->IASetIndexBuffer( mLightTexIB, DXGI_FORMAT_R32_UINT, 0 );
for ( UINT p = 0; p < techDesc.Passes; p++ )
{
XMMATRIX world = XMLoadFloat4x4( &mWorld[ICECUBE] );
XMMATRIX worldViewProj = XMMatrixMultiply( world, mCamera.GetViewProj( ) );
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose( world );
// 设置effect中的常量缓冲
Effects::NormalObjFX->SetWorldViewProj( worldViewProj );
Effects::NormalObjFX->SetWorld( world );
Effects::NormalObjFX->SetWorldInvTranspose( worldInvTranspose );
Effects::NormalObjFX->SetTexTransform( XMLoadFloat4x4( &mTexTransform[ICECUBE] ) );
// 设置纹理和材质
Effects::NormalObjFX->SetDiffuseMap( mDiffuseMapSRV[ICECUBE] );
Effects::NormalObjFX->SetMaterial( mMat[ICECUBE] );
// 禁止对缓冲目标写操作
mD3dImmediateContext->OMSetBlendState( RenderStates::NoRenderTargetWritesBS,
blendFactor, 0xffffffff );
// 将镜子的可见像素渲染到模板缓冲
// 但是不能将镜子的深度信息写到深度缓存, 否则将阻塞镜像
// 这里将镜子可见像素的 stencil value 设置为1, 当做标记了镜子像素
mD3dImmediateContext->OMSetDepthStencilState( RenderStates::MirrorDSS, 1 );
activeTech->GetPassByIndex( p )->Apply( 0, mD3dImmediateContext );
mD3dImmediateContext->DrawIndexed(
mLTIndexCount[LTVT_ICECUBE],
mLTIndexOffset[LTVT_ICECUBE],
mLTVertexOffset[LTVT_ICECUBE]
);
//
// 恢复措施
//
mD3dImmediateContext->OMSetDepthStencilState( 0, 0 );
mD3dImmediateContext->OMSetBlendState( 0, blendFactor, 0xffffffff );
}
//
// 画天体的镜像
//
stride = sizeof( Vertex::NormalObjVertex );
offset = 0;
mD3dImmediateContext->IASetVertexBuffers( 0, 1, &mLightTexVB, &stride, &offset );
mD3dImmediateContext->IASetIndexBuffer( mLightTexIB, DXGI_FORMAT_R32_UINT, 0 );
activeTech = Effects::NormalObjFX->NormalObjTech;
activeTech->GetDesc( &techDesc );
for ( UINT p = 0; p < techDesc.Passes; ++p )
{
// 对每一个冰面镜面确定成像内容
for ( int planeID = 0; planeID < 6; planeID++ )
{
// 未经过世界坐标变换的镜面
XMVECTOR mirrorPlane = XMVectorSet(
mIceCubeNormals[planeID].x,
mIceCubeNormals[planeID].y,
mIceCubeNormals[planeID].z,
1.0f
);
// 将平面依据世界矩阵做变换
mirrorPlane = XMPlaneNormalize( mirrorPlane );
mirrorPlane = XMPlaneTransform( mirrorPlane, MathHelper::InverseTranspose( XMLoadFloat4x4( &mWorld[ICECUBE] ) ) );
XMMATRIX R = XMMatrixReflect( mirrorPlane );
for ( int starID = SUN; starID < STARNUMBER; starID++ )
{
if ( ICECUBE == starID )
{
continue;
}
XMVECTOR target = XMVectorSet( mWorld[starID]._41, mWorld[starID]._42, mWorld[starID]._43, 1.0f );
// 在镜子后面的物体不做镜像
if ( MathHelper::PointPlanePosRelation( target, mirrorPlane ) == MathHelper::BEHIND_THE_PLANE )
{
continue;
}
// 设置转换矩阵
XMMATRIX world = XMLoadFloat4x4( &mWorld[starID] ) * R;
XMMATRIX worldViewProj = XMMatrixMultiply( world, mCamera.GetViewProj( ) );
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose( world );
// 设置effect中的常量缓冲
Effects::NormalObjFX->SetWorldViewProj( worldViewProj );
Effects::NormalObjFX->SetWorld( world );
Effects::NormalObjFX->SetWorldInvTranspose( worldInvTranspose );
Effects::NormalObjFX->SetTexTransform( XMLoadFloat4x4( &mTexTransform[starID] ) );
// 设置纹理和材质
Effects::NormalObjFX->SetDiffuseMap( mDiffuseMapSRV[starID] );
Effects::NormalObjFX->SetMaterial( mMat[starID] );
// 设置RenderStates
if ( WIREFENCE == starID )
{
mD3dImmediateContext->RSSetState( RenderStates::NoCullRS );
}
// 处理镜面反射的光线方向, 待解决
// 改变正面的判定方式
mD3dImmediateContext->RSSetState( RenderStates::CullClockwiseRS );
// 只在模板缓冲中标记为可见的镜面像素中写入镜像信息
mD3dImmediateContext->OMSetDepthStencilState( RenderStates::DrawReflectionDSS, 1 );
activeTech->GetPassByIndex( p )->Apply( 0, mD3dImmediateContext );
mD3dImmediateContext->DrawIndexed(
mLTIndexCount[LTVT_STAR],
mLTIndexOffset[LTVT_STAR],
mLTVertexOffset[LTVT_STAR]
);
//
// 恢复措施
//
mD3dImmediateContext->RSSetState( 0 );
mD3dImmediateContext->OMSetDepthStencilState( 0, 0 );
}
}
}
//
// 最后将冰立方渲染至背面缓存, 但是要经过 blending 透明化处理
//
mD3dImmediateContext->IASetInputLayout( InputLayouts::NormalObjLayout );
mD3dImmediateContext->IASetPrimitiveTopology( D3D11_PRIMITIVE_TOPOLOGY_TRIANGLELIST );
activeTech = Effects::NormalObjFX->NormalObjTech;
activeTech->GetDesc( &techDesc );
stride = sizeof( Vertex::NormalObjVertex );
offset = 0;
mD3dImmediateContext->IASetVertexBuffers( 0, 1, &mLightTexVB, &stride, &offset );
mD3dImmediateContext->IASetIndexBuffer( mLightTexIB, DXGI_FORMAT_R32_UINT, 0 );
for ( UINT p = 0; p < techDesc.Passes; p++ )
{
XMMATRIX world = XMLoadFloat4x4( &mWorld[ICECUBE] );
XMMATRIX worldViewProj = XMMatrixMultiply( world, mCamera.GetViewProj( ) );
XMMATRIX worldInvTranspose = MathHelper::InverseTranspose( world );
// 设置effect中的常量缓冲
Effects::NormalObjFX->SetWorldViewProj( worldViewProj );
Effects::NormalObjFX->SetWorld( world );
Effects::NormalObjFX->SetWorldInvTranspose( worldInvTranspose );
Effects::NormalObjFX->SetTexTransform( XMLoadFloat4x4( &mTexTransform[ICECUBE] ) );
// 设置纹理和材质
Effects::NormalObjFX->SetDiffuseMap( mDiffuseMapSRV[ICECUBE] );
Effects::NormalObjFX->SetMaterial( mMat[ICECUBE] );
mD3dImmediateContext->OMSetBlendState( RenderStates::TransparentBS, blendFactor, 0xffffffff );
activeTech->GetPassByIndex( p )->Apply( 0, mD3dImmediateContext );
mD3dImmediateContext->DrawIndexed(
mLTIndexCount[LTVT_ICECUBE],
mLTIndexOffset[LTVT_ICECUBE],
mLTVertexOffset[LTVT_ICECUBE]
);
//恢复设置
mD3dImmediateContext->OMSetDepthStencilState( 0, 0 );
mD3dImmediateContext->OMSetBlendState( 0, blendFactor, 0xffffffff );
}
}
