void InstancedBasic::Initialize() { assert(_fx != nullptr); SetInputLayout(); _world = _fx->GetVariableByName("gWorld")->AsMatrix(); _viewProjection = _fx->GetVariableByName("gViewProjection")->AsMatrix(); _lightDirection = _fx->GetVariableByName("gWorldLightPosition")->AsVector(); }
void SubGeometry::FillVertexBuffer(void* vertices, size_t count, InputElementDesc descs[], size_t descCount) { if (m_pVertexBuffer) delete m_pVertexBuffer; SetInputLayout(descs, descCount); size_t vertexTypeSize = GetVertexTypeSize(); size_t vertexCount = count; m_pVertexBuffer = new VertexBuffer(vertexTypeSize, vertexCount); m_pVertexBuffer->SetData(vertices, 0, vertexCount); m_vertexCount = vertexCount; m_vertexTypeSize = vertexTypeSize; }
SubGeometry::SubGeometry() { m_pVertexBuffer = nullptr; m_pIndexBuffer = nullptr; InputElementDesc descs[3] = { { VMember_POSITION, 0, FORMAT_R32G32B32_FLOAT, 0 }, { VMember_NORMAL, 1, FORMAT_R32G32B32_FLOAT, 0 }, { VMember_TEXCOORD, 2, FORMAT_R32G32_FLOAT, 0 }, }; SetInputLayout(descs, 3); m_vertexCount = 0; m_vertexTypeSize = GetVertexTypeSize(); }
//============================================================================================================================== bool ShadowMapBuildShader::Render(int indexCount, XMMATRIX world, LightCamera* lightCamera) { cbShadowMapConst cSMB; //m_pD3DSystem->SetRasterizerState(m_pD3DSystem->RSDepth()); cSMB.g_World = ZShadeSandboxMath::ZMath::GMathMF(XMMatrixTranspose(world)); cSMB.g_LightView = lightCamera->LightView4x4(); cSMB.g_LightProj = lightCamera->LightProj4x4(); // Map matrix constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pShadowMapCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(cbShadowMapConst*)mapped_res.pData = cSMB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pShadowMapCB, 0); } // Set the shadow map constant buffer into the Vertex Shader ID3D11Buffer* vs_cbs[1] = { m_pShadowMapCB }; m_pD3DSystem->GetDeviceContext()->VSSetConstantBuffers(0, 1, vs_cbs); // Tell the shader what input layout to use SetInputLayout("ShadowMapBuildShader"); // Assign the shaders to render the mesh SetVertexShader(); //SetPixelShader(); m_pD3DSystem->GetDeviceContext()->PSSetShader(NULL, NULL, 0); //Perform Drawing RenderIndex11(indexCount); return true; }
//============================================================================================================================== bool OBJMeshShader::Render ( int startIndex , int indexCount , ZShadeSandboxMesh::MeshRenderParameters mrp , ZShadeSandboxLighting::ShaderMaterial* material ) { ID3D11ShaderResourceView* diffuseArrayTexture = 0; ID3D11ShaderResourceView* diffuseTexture = 0; ID3D11ShaderResourceView* ambientTexture = 0; ID3D11ShaderResourceView* specularTexture = 0; ID3D11ShaderResourceView* emissiveTexture = 0; ID3D11ShaderResourceView* normalMapTexture = 0; ID3D11ShaderResourceView* blendMapTexture = 0; ID3D11ShaderResourceView* detailMapTexture = 0; ID3D11ShaderResourceView* alphaMapTexture = 0; ID3D11ShaderResourceView* shadowMapTexture = 0; ID3D11ShaderResourceView* ssaoTexture = 0; ID3D11ShaderResourceView* displacementMapTexture = 0; material->GetTextures( diffuseArrayTexture, diffuseTexture, ambientTexture, specularTexture, emissiveTexture, normalMapTexture, blendMapTexture, detailMapTexture, alphaMapTexture, shadowMapTexture, ssaoTexture, displacementMapTexture ); material->BuildMaterialConstantBuffer(m_pShadingCB, mrp.camera->Position(), mrp.clipplane); mrp.camera->BuildCameraConstantBuffer(m_pD3DSystem, m_pMatrixCB, mrp.world, mrp.reflection); ZShadeSandboxLighting::LightManager::Instance()->BuildFinalLightBuffers(m_pLightCB, m_pSunCB); // Set the shading constant buffer and matrix constant buffer into the Vertex Shader ID3D11Buffer* vs_cbs[2] = { m_pShadingCB, m_pMatrixCB }; m_pD3DSystem->GetDeviceContext()->VSSetConstantBuffers(2, 2, vs_cbs); // Set the shading constant buffer into the Pixel Shader ID3D11Buffer* ps_cbs[3] = { m_pLightCB, m_pSunCB, m_pShadingCB }; m_pD3DSystem->GetDeviceContext()->PSSetConstantBuffers(0, 3, ps_cbs); ID3D11ShaderResourceView* ps_srvs[11] = { diffuseArrayTexture, diffuseTexture, ambientTexture, specularTexture, emissiveTexture, normalMapTexture, blendMapTexture, detailMapTexture, alphaMapTexture, shadowMapTexture, ssaoTexture }; ID3D11SamplerState* ps_samp[1] = { m_pD3DSystem->Linear() }; if (!m_Wireframe) { m_pD3DSystem->TurnOffCulling(); // Set the texture into the Pixel Shader m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 11, ps_srvs); m_pD3DSystem->GetDeviceContext()->PSSetSamplers(0, 1, ps_samp); SwitchTo("OBJMeshPS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); } else { SwitchTo("OBJMeshWireframePS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); } // Tell the shader what input layout to use SetInputLayout("OBJMeshShader"); // Assign the shaders to render the mesh SetVertexShader(); SetPixelShader(); //Perform Drawing RenderIndex11(startIndex, indexCount); // Unbind if (!m_Wireframe) { m_pD3DSystem->TurnOnCulling(); ps_samp[0] = NULL; m_pD3DSystem->GetDeviceContext()->PSSetSamplers(0, 1, ps_samp); for (int i = 0; i < 11; i++) ps_srvs[i] = NULL; m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 11, ps_srvs); } return true; }
//============================================================================================================================== bool MaterialTessellationShader::Render11 ( int indexCount , int instanceCount , ZShadeSandboxMesh::MeshRenderParameters mrp , ZShadeSandboxLighting::ShaderMaterial* material ) { ID3D11ShaderResourceView* diffuseArrayTexture = 0; ID3D11ShaderResourceView* diffuseTexture = 0; ID3D11ShaderResourceView* ambientTexture = 0; ID3D11ShaderResourceView* specularTexture = 0; ID3D11ShaderResourceView* emissiveTexture = 0; ID3D11ShaderResourceView* normalMapTexture = 0; ID3D11ShaderResourceView* blendMapTexture = 0; ID3D11ShaderResourceView* detailMapTexture = 0; ID3D11ShaderResourceView* alphaMapTexture = 0; ID3D11ShaderResourceView* shadowMapTexture = 0; ID3D11ShaderResourceView* ssaoTexture = 0; ID3D11ShaderResourceView* displacementMapTexture = 0; material->GetTextures( diffuseArrayTexture, diffuseTexture, ambientTexture, specularTexture, emissiveTexture, normalMapTexture, blendMapTexture, detailMapTexture, alphaMapTexture, shadowMapTexture, ssaoTexture, displacementMapTexture ); material->BuildMaterialTessellationBuffer(m_pTessellationCB, mrp.camera->Position()); material->BuildMaterialDomainBuffer(m_pDomainCB, mrp.world, mrp.camera, mrp.clipplane, mrp.reflection); material->BuildMaterialConstantBuffer(m_pShadingCB, mrp.camera->Position(), mrp.clipplane); ZShadeSandboxLighting::LightManager::Instance()->BuildFinalLightBuffers(m_pLightCB, m_pSunCB); ID3D11Buffer* vs_cbs[1] = { m_pShadingCB }; m_pD3DSystem->GetDeviceContext()->VSSetConstantBuffers(4, 1, vs_cbs); // Set the tessellation constant buffer into the Hull Shader ID3D11Buffer* hs_cbs[1] = { m_pTessellationCB }; m_pD3DSystem->GetDeviceContext()->HSSetConstantBuffers(2, 1, hs_cbs); // Set the matrix constant buffer into the Domain Shader ID3D11Buffer* ds_cbs[2] = { m_pDomainCB, m_pShadingCB }; m_pD3DSystem->GetDeviceContext()->DSSetConstantBuffers(3, 2, ds_cbs); ID3D11Buffer* ps_cbs[5] = { m_pLightCB, m_pSunCB, m_pTessellationCB, m_pDomainCB, m_pShadingCB }; m_pD3DSystem->GetDeviceContext()->PSSetConstantBuffers(0, 5, ps_cbs); ID3D11ShaderResourceView* ps_srvs[11] = { diffuseArrayTexture, diffuseTexture, ambientTexture, specularTexture, emissiveTexture, normalMapTexture, blendMapTexture, detailMapTexture, alphaMapTexture, shadowMapTexture, ssaoTexture }; ID3D11SamplerState* ps_samp[2] = { m_pD3DSystem->Point(), m_pD3DSystem->Linear() }; ID3D11ShaderResourceView* disp_srvs[1] = { displacementMapTexture }; if (!m_Wireframe) { // Assign Texture m_pD3DSystem->GetDeviceContext()->VSSetSamplers(0, 2, ps_samp); m_pD3DSystem->GetDeviceContext()->DSSetSamplers(0, 2, ps_samp); m_pD3DSystem->GetDeviceContext()->PSSetSamplers(0, 2, ps_samp); m_pD3DSystem->GetDeviceContext()->VSSetShaderResources(11, 1, disp_srvs); m_pD3DSystem->GetDeviceContext()->DSSetShaderResources(11, 1, disp_srvs); m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 11, ps_srvs); switch (mType) { case ZShadeSandboxLighting::EMaterialTessellationType::Type::eQuad: SwitchTo("QuadMaterialTessellationPS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); break; case ZShadeSandboxLighting::EMaterialTessellationType::Type::eTri: SwitchTo("TriMaterialTessellationPS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); break; } } else { switch (mType) { case ZShadeSandboxLighting::EMaterialTessellationType::Type::eQuad: SwitchTo("QuadMaterialTessellationWireframePS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); break; case ZShadeSandboxLighting::EMaterialTessellationType::Type::eTri: SwitchTo("TriMaterialTessellationWireframePS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); break; } } if (mrp.useInstancing) { SetInputLayout("MaterialTessellationShaderInstance"); switch (mType) { case ZShadeSandboxLighting::EMaterialTessellationType::Type::eQuad: SwitchTo("QuadMaterialTessellationInstanceVS", ZShadeSandboxShader::EShaderTypes::ST_VERTEX); break; case ZShadeSandboxLighting::EMaterialTessellationType::Type::eTri: SwitchTo("TriMaterialTessellationInstanceVS", ZShadeSandboxShader::EShaderTypes::ST_VERTEX); break; } } else { SetInputLayout("MaterialTessellationShader"); switch (mType) { case ZShadeSandboxLighting::EMaterialTessellationType::Type::eQuad: SwitchTo("QuadMaterialTessellationVS", ZShadeSandboxShader::EShaderTypes::ST_VERTEX); break; case ZShadeSandboxLighting::EMaterialTessellationType::Type::eTri: SwitchTo("TriMaterialTessellationVS", ZShadeSandboxShader::EShaderTypes::ST_VERTEX); break; } } SetVertexShader(); SetHullShader(); SetDomainShader(); SetPixelShader(); //Perform Drawing if (mrp.useInstancing) { RenderIndexInstanced11(indexCount, instanceCount); } else { RenderIndex11(indexCount); } // Unbind if (!m_Wireframe) { ps_samp[0] = NULL; m_pD3DSystem->GetDeviceContext()->VSSetSamplers(0, 2, ps_samp); m_pD3DSystem->GetDeviceContext()->DSSetSamplers(0, 2, ps_samp); m_pD3DSystem->GetDeviceContext()->PSSetSamplers(0, 2, ps_samp); disp_srvs[0] = NULL; m_pD3DSystem->GetDeviceContext()->VSSetShaderResources(11, 1, disp_srvs); m_pD3DSystem->GetDeviceContext()->DSSetShaderResources(11, 1, disp_srvs); for (int i = 0; i < 11; i++) ps_srvs[i] = NULL; m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 11, ps_srvs); } // Set Hull, Domain and Geometry Shaders to null in case they are not needed m_pD3DSystem->GetDeviceContext()->HSSetShader(NULL, NULL, 0); m_pD3DSystem->GetDeviceContext()->DSSetShader(NULL, NULL, 0); m_pD3DSystem->GetDeviceContext()->GSSetShader(NULL, NULL, 0); return true; }
//============================================================================================================================== bool MaterialShader::Render11 ( int indexCount , int instanceCount , ZShadeSandboxMesh::MeshRenderParameters mrp , ZShadeSandboxLighting::ShaderMaterial* material ) { ID3D11ShaderResourceView* diffuseArrayTexture = 0; ID3D11ShaderResourceView* diffuseTexture = 0; ID3D11ShaderResourceView* ambientTexture = 0; ID3D11ShaderResourceView* specularTexture = 0; ID3D11ShaderResourceView* emissiveTexture = 0; ID3D11ShaderResourceView* normalMapTexture = 0; ID3D11ShaderResourceView* blendMapTexture = 0; ID3D11ShaderResourceView* detailMapTexture = 0; ID3D11ShaderResourceView* alphaMapTexture = 0; ID3D11ShaderResourceView* shadowMapTexture = 0; ID3D11ShaderResourceView* ssaoTexture = 0; ID3D11ShaderResourceView* displacementMapTexture = 0; if (material == 0) return false; material->GetTextures( diffuseArrayTexture, diffuseTexture, ambientTexture, specularTexture, emissiveTexture, normalMapTexture, blendMapTexture, detailMapTexture, alphaMapTexture, shadowMapTexture, ssaoTexture, displacementMapTexture ); material->fBlendAmount = mrp.blendAmount; material->BuildMaterialConstantBuffer(m_pShadingCB, mrp.camera->Position(), mrp.clipplane); // Use the default light if there is no light if (mrp.light == 0) { MaterialShader::mDefaultLight->Update(); mrp.light = MaterialShader::mDefaultLight; } mrp.camera->BuildCameraConstantBuffer(m_pD3DSystem, m_pMatrixCB, mrp.light, mrp.world, mrp.reflection); if (m_pD3DSystem->GetEngineOptions()->m_DimType == DimType::ZSHADE_3D) ZShadeSandboxLighting::LightManager::Instance()->BuildFinalLightBuffers(m_pLightCB, m_pSunCB); else { material->bEnableLighting = false; material->bHasDetailMapTexture = false; } ID3D11Buffer* vs_cbs[2] = { m_pShadingCB, m_pMatrixCB }; m_pD3DSystem->GetDeviceContext()->VSSetConstantBuffers(2, 2, vs_cbs); ID3D11Buffer* ps_cbs[3] = { m_pLightCB, m_pSunCB, m_pShadingCB }; m_pD3DSystem->GetDeviceContext()->PSSetConstantBuffers(0, 3, ps_cbs); ID3D11ShaderResourceView* ps_srvs[11] = { diffuseArrayTexture, diffuseTexture, ambientTexture, specularTexture, emissiveTexture, normalMapTexture, blendMapTexture, detailMapTexture, alphaMapTexture, shadowMapTexture, ssaoTexture }; ID3D11SamplerState* ps_samp[2] = { m_pD3DSystem->Point(), m_pD3DSystem->Linear() }; ID3D11ShaderResourceView* vs_srvs[1] = { displacementMapTexture }; if (!m_Wireframe) { // Assign Texture m_pD3DSystem->GetDeviceContext()->VSSetSamplers(0, 2, ps_samp); m_pD3DSystem->GetDeviceContext()->PSSetSamplers(0, 2, ps_samp); m_pD3DSystem->GetDeviceContext()->VSSetShaderResources(11, 1, vs_srvs); m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 11, ps_srvs); SwitchTo("MaterialShaderPS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); } else { SwitchTo("MaterialShaderWireframePS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); } if (mrp.useInstancing) { SetInputLayout("MaterialShaderInstance"); SwitchTo("MaterialShaderInstanceVS", ZShadeSandboxShader::EShaderTypes::ST_VERTEX); } else { SetInputLayout("MaterialShader"); SwitchTo("MaterialShaderVS", ZShadeSandboxShader::EShaderTypes::ST_VERTEX); } SetVertexShader(); SetPixelShader(); //Perform Drawing if (mrp.useInstancing) { RenderIndexInstanced11(indexCount, instanceCount); } else { RenderIndex11(indexCount); } // Unbind if (!m_Wireframe) { ps_samp[0] = NULL; ps_samp[1] = NULL; m_pD3DSystem->GetDeviceContext()->VSSetSamplers(0, 2, ps_samp); m_pD3DSystem->GetDeviceContext()->PSSetSamplers(0, 2, ps_samp); vs_srvs[0] = NULL; m_pD3DSystem->GetDeviceContext()->VSSetShaderResources(11, 1, vs_srvs); for (int i = 0; i < 11; i++) ps_srvs[i] = NULL; m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 11, ps_srvs); } return true; }
//============================================================================================================================== bool TerrainTessellationQuadShadowShader::Render(int indexCount, LightCamera* lightcamera, ZShadeSandboxTerrain::TerrainShadingConst terrainShadingConst, ID3D11ShaderResourceView* heightMapSRV) { cTessellationBuffer cTB; cMatrixBuffer cMB; cDomainConstBuffer cDCB; m_pD3DSystem->SetRasterizerState(m_pD3DSystem->RSDepth()); //if (m_UseCustomWorld) // cMB.g_WorldMatrix = ZShadeSandboxMath::ZMath::GMathMF(XMMatrixTranspose(mWorld.Get())); //else // cMB.g_WorldMatrix = ZShadeSandboxMath::ZMath::GMathMF(XMMatrixTranspose(XMMatrixIdentity())); cMB.g_ViewMatrix = lightcamera->LightView4x4(); cMB.g_ProjMatrix = lightcamera->LightProj4x4(); cMB.g_ShadowMatrix = lightcamera->ShadowTransform4x4(); XMMATRIX toTexSpace = XMMatrixScaling(0.5f, -0.5f, 1.0f) * XMMatrixTranslation(0.5f, 0.5f, 0); cMB.g_TexSpaceMatrix = ZShadeSandboxMath::ZMath::GMathMF(XMMatrixTranspose(toTexSpace)); cTB.g_EyePosW = terrainShadingConst.g_EyePosW; cTB.g_MinDist = terrainShadingConst.g_MinDist; cTB.g_MaxDist = terrainShadingConst.g_MaxDist; cTB.g_MinTess = terrainShadingConst.g_MinTess; cTB.g_MaxTess = terrainShadingConst.g_MaxTess; cTB.g_FrustumCull = terrainShadingConst.g_FrustumCull; cTB.padding = XMFLOAT2(0, 0); cTB.g_TerrSize = terrainShadingConst.g_MapSize; cTB.g_TerrScale = terrainShadingConst.g_TerrSize; cDCB.g_TexScale = XMFLOAT2(66.0f, 66.0f); cDCB.g_HeightScale = terrainShadingConst.g_HeightScale; cDCB.g_TerrainZScale = terrainShadingConst.g_TerrSize; cDCB.g_ClipPlane = terrainShadingConst.g_ClipPlane; cDCB.g_tpadding = XMFLOAT3(0, 0, 0); cDCB.g_FarPlane = terrainShadingConst.g_FarPlane; // Map tessellation constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pTessellationCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(cTessellationBuffer*)mapped_res.pData = cTB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pTessellationCB, 0); } // Map domain shader constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pDomainCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(cDomainConstBuffer*)mapped_res.pData = cDCB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pDomainCB, 0); } // Map matrix constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pMatrixBufferCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(cMatrixBuffer*)mapped_res.pData = cMB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pMatrixBufferCB, 0); } // Set the tessellation constant buffer into the Hull Shader ID3D11Buffer* hs_cbs[1] = { m_pTessellationCB }; m_pD3DSystem->GetDeviceContext()->HSSetConstantBuffers(0, 1, hs_cbs); // Set the domain and matrix constant buffer into the Domain Shader ID3D11Buffer* ds_cbs[2] = { m_pDomainCB, m_pMatrixBufferCB }; m_pD3DSystem->GetDeviceContext()->DSSetConstantBuffers(0, 2, ds_cbs); // Set the heightmap texture into the vertex shader ID3D11ShaderResourceView* vs_srvs[1] = { heightMapSRV }; m_pD3DSystem->GetDeviceContext()->VSSetShaderResources(0, 1, vs_srvs); // Set the heightmap texture into the domain shader ID3D11ShaderResourceView* ds_srvs[1] = { heightMapSRV }; m_pD3DSystem->GetDeviceContext()->DSSetShaderResources(0, 1, ds_srvs); // Tell the shader what input layout to use SetInputLayout("TerrainTessellationQuadShadowShader"); // Assign the shaders to render the mesh SetVertexShader(); SetHullShader(); SetDomainShader(); SetPixelShader(); //m_pD3DSystem->GetDeviceContext()->PSSetShader(NULL, NULL, 0); //Perform Drawing RenderIndex11(indexCount); return true; }
//============================================================================================================================== bool DeferredShader::Render11 ( int indexCount , Camera* camera , XMMATRIX world , XMFLOAT2 specularPowerRange , float specularIntensity , float specularPower , ID3D11ShaderResourceView* texture ) { cbPackBuffer cPB; cPB.g_SpecularPowerRange = specularPowerRange; cPB.g_SpecularIntensity = specularIntensity; cPB.g_SpecularPower = specularPower; // Map the pack buffer { D3D11_MAPPED_SUBRESOURCE mapped_res2; m_pD3DSystem->GetDeviceContext()->Map(m_pPackCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res2); { assert(mapped_res2.pData); *(cbPackBuffer*)mapped_res2.pData = cPB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pPackCB, 0); } cbMatrixBuffer cMB; cMB.g_matWorld = ZShadeSandboxMath::ZMath::GMathMF(XMMatrixTranspose(world)); cMB.g_matView = camera->View4x4(); cMB.g_matProj = camera->Proj4x4(); // Map the matrix buffer { D3D11_MAPPED_SUBRESOURCE mapped_res2; m_pD3DSystem->GetDeviceContext()->Map(m_pMatrixCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res2); { assert(mapped_res2.pData); *(cbMatrixBuffer*)mapped_res2.pData = cMB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pMatrixCB, 0); } ID3D11Buffer* vs_cbs[1] = { m_pMatrixCB }; m_pD3DSystem->GetDeviceContext()->VSSetConstantBuffers(1, 1, vs_cbs); ID3D11Buffer* ps_cbs[1] = { m_pPackCB }; m_pD3DSystem->GetDeviceContext()->PSSetConstantBuffers(0, 1, ps_cbs); // Assign Texture ID3D11ShaderResourceView* ps_srvs[1] = { texture }; ID3D11SamplerState* ps_samp[1] = { m_pD3DSystem->Linear() }; if (!m_Wireframe) { m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 1, ps_srvs); m_pD3DSystem->GetDeviceContext()->PSSetSamplers(0, 1, ps_samp); SwitchTo("DeferredShaderPS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); } else { SwitchTo("DeferredShaderWireframePS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); } SetInputLayout("DeferredShader"); SetVertexShader(); SetPixelShader(); //Perform Drawing RenderIndex11(indexCount); // Unbind if (!m_Wireframe) { m_pD3DSystem->TurnOnCulling(); ps_samp[0] = NULL; m_pD3DSystem->GetDeviceContext()->PSSetSamplers(0, 1, ps_samp); ps_srvs[0] = NULL; m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 1, ps_srvs); } return true; }
//============================================================================================================================== bool TriMaterialTessellationShader::Render11(int indexCount, ZShadeSandboxMath::XMMath4 clipplane, Camera* camera, float tessFactor, ZShadeSandboxLighting::ShaderMaterial* material) { int useDiffuseArrayTexture = 0; int useDiffuseTexture = 0; int useNormalMapTexture = 0; int useBlendMapTexture = 0; int useDetailMapTexture = 0; int useAlphaMapTexture = 0; ID3D11ShaderResourceView* diffuseArrayTexture = 0; ID3D11ShaderResourceView* diffuseTexture = 0; ID3D11ShaderResourceView* normalMapTexture = 0; ID3D11ShaderResourceView* blendMapTexture = 0; ID3D11ShaderResourceView* detailMapTexture = 0; ID3D11ShaderResourceView* alphaMapTexture = 0; for (int i = 0; i < material->TextureCount(); i++) { switch (material->GetMaterialTextureType(i)) { case ZShadeSandboxLighting::EMaterialTextureType::eDiffuseArray: useDiffuseArrayTexture = 1; diffuseArrayTexture = material->GetTexture(i)->getTexture11(); break; case ZShadeSandboxLighting::EMaterialTextureType::eDiffuse: useDiffuseTexture = 1; diffuseTexture = material->GetTexture(i)->getTexture11(); break; case ZShadeSandboxLighting::EMaterialTextureType::eNormal: useNormalMapTexture = 1; normalMapTexture = material->GetTexture(i)->getTexture11(); break; case ZShadeSandboxLighting::EMaterialTextureType::eBlend: useBlendMapTexture = 1; blendMapTexture = material->GetTexture(i)->getTexture11(); break; case ZShadeSandboxLighting::EMaterialTextureType::eDetail: useDetailMapTexture = 1; detailMapTexture = material->GetTexture(i)->getTexture11(); break; case ZShadeSandboxLighting::EMaterialTextureType::eAlpha: useAlphaMapTexture = 1; alphaMapTexture = material->GetTexture(i)->getTexture11(); break; } } Const_Per_Frame per_frame; per_frame.g_EyePosW = camera->Position(); per_frame.g_ClipPlane = XMFLOAT4(clipplane.x, clipplane.y, clipplane.z, clipplane.w); per_frame.g_MaterialDiffuseColor = material->DiffuseColor(); per_frame.g_MaterialAmbientColor = material->AmbientColor(); per_frame.g_MaterialSpecularPower = material->SpecularPower(); per_frame.g_MaterialSpecularIntensity = material->SpecularIntensity(); per_frame.g_UsingDiffuseArrayTexture = useDiffuseArrayTexture; per_frame.g_UsingDiffuseTexture = useDiffuseArrayTexture; per_frame.g_UsingNormalMapTexture = useNormalMapTexture; per_frame.g_UsingBlendMapTexture = useBlendMapTexture; per_frame.g_UsingDetailMapTexture = useDetailMapTexture; per_frame.g_UseAlphaMapTexture = useAlphaMapTexture; per_frame.g_EnableTransparency = material->EnableTransparency(); per_frame.g_EnableLighting = material->EnableLighting(); per_frame.g_DetailBrightness = material->DetailBrightness(); per_frame.g_AlphaToCoverageValue = material->AlphaToCoverageValue(); // Value that clips pixel during alpha blending per_frame.g_FlipTextureH = (bFlipHorizontally == true) ? 1 : 0; per_frame.g_FlipTextureV = (bFlipVertically == true) ? 1 : 0; per_frame.padding = 0; Const_Per_Object per_object; if (m_UseCustomWorld) { XMFLOAT4X4 world = ZShadeSandboxMath::ZMath::GMathMF(XMMatrixTranspose(mWorld.Get())); per_object.g_matWorld = world; } else per_object.g_matWorld = camera->World4x4(); if (m_UseCustomView) { per_object.g_matView = mView; } else per_object.g_matView = camera->View4x4(); if (m_pD3DSystem->GetEngineOptions()->m_DimType == DimType::ZSHADE_2D) per_object.g_matProj = camera->Ortho4x4(); else if (m_pD3DSystem->GetEngineOptions()->m_DimType == DimType::ZSHADE_3D) per_object.g_matProj = camera->Proj4x4(); if (m_UseOrtho) { per_object.g_matProj = camera->Ortho4x4(); } ZShadeSandboxLighting::cbLightBuffer cLB; ZShadeSandboxLighting::cbAmbientLightBuffer alb; ZShadeSandboxLighting::cbDirectionalLightBuffer dlb; ZShadeSandboxLighting::cbSpotLightBuffer slb; ZShadeSandboxLighting::cbPointLightBuffer plb; ZShadeSandboxLighting::cbCapsuleLightBuffer clb; for (int i = 0; i < material->GetLightBuffer()->g_AmbientLightCount; i++) { alb.g_AmbientColor = material->GetLightBuffer()->g_AmbientLight[i].g_AmbientColor; cLB.g_AmbientLight[i] = alb; } for (int i = 0; i < material->GetLightBuffer()->g_DirectionalLightCount; i++) { dlb.g_Direction = material->GetLightBuffer()->g_DirectionalLight[i].g_LightDirection; dlb.padding = 0; dlb.g_Ambient = material->GetLightBuffer()->g_DirectionalLight[i].g_AmbientColor; dlb.g_Diffuse = material->GetLightBuffer()->g_DirectionalLight[i].g_DiffuseColor; cLB.g_DirectionalLight[i] = dlb; } for (int i = 0; i < material->GetLightBuffer()->g_SpotLightCount; i++) { slb.g_AmbientColor = material->GetLightBuffer()->g_SpotLight[i].g_AmbientColor; slb.g_DiffuseColor = material->GetLightBuffer()->g_SpotLight[i].g_DiffuseColor; slb.g_LightPosition = material->GetLightBuffer()->g_SpotLight[i].g_LightPosition; slb.padding = 0; slb.g_LightRange = material->GetLightBuffer()->g_SpotLight[i].g_LightRange; slb.g_SpotCosOuterCone = material->GetLightBuffer()->g_SpotLight[i].g_SpotCosOuterCone; slb.g_SpotInnerConeReciprocal = material->GetLightBuffer()->g_SpotLight[i].g_SpotInnerConeReciprocal; slb.g_CosineAngle = material->GetLightBuffer()->g_SpotLight[i].g_CosineAngle; cLB.g_SpotLight[i] = slb; } for (int i = 0; i < material->GetLightBuffer()->g_PointLightCount; i++) { plb.g_LightPosition = material->GetLightBuffer()->g_PointLight[i].g_LightPosition; plb.g_LightRange = material->GetLightBuffer()->g_PointLight[i].g_LightRange; plb.g_Attenuation = material->GetLightBuffer()->g_PointLight[i].g_Attenuation; plb.padding = 0; plb.g_AmbientColor = material->GetLightBuffer()->g_PointLight[i].g_AmbientColor; plb.g_DiffuseColor = material->GetLightBuffer()->g_PointLight[i].g_DiffuseColor; cLB.g_PointLight[i] = plb; } for (int i = 0; i < material->GetLightBuffer()->g_CapsuleLightCount; i++) { clb.g_LightPosition = material->GetLightBuffer()->g_CapsuleLight[i].g_LightPosition; clb.g_LightRange = material->GetLightBuffer()->g_CapsuleLight[i].g_LightRange; clb.g_LightDirection = material->GetLightBuffer()->g_CapsuleLight[i].g_LightDirection; clb.g_DiffuseColor = material->GetLightBuffer()->g_CapsuleLight[i].g_DiffuseColor; clb.g_LightLength = material->GetLightBuffer()->g_CapsuleLight[i].g_LightLength; clb.g_CapsuleDirectionLength = material->GetLightBuffer()->g_CapsuleLight[i].g_CapsuleDirectionLength; clb.g_CapsuleIntensity = material->GetLightBuffer()->g_CapsuleLight[i].g_CapsuleIntensity; cLB.g_CapsuleLight[i] = clb; } cLB.g_AmbientLightCount = material->GetLightBuffer()->g_AmbientLightCount; cLB.g_DirectionalLightCount = material->GetLightBuffer()->g_DirectionalLightCount; cLB.g_SpotLightCount = material->GetLightBuffer()->g_SpotLightCount; cLB.g_PointLightCount = material->GetLightBuffer()->g_PointLightCount; cLB.g_CapsuleLightCount = material->GetLightBuffer()->g_CapsuleLightCount; cLB.g_AmbientDown = material->GetLightBuffer()->g_AmbientDown; cLB.g_AmbientUp = material->GetLightBuffer()->g_AmbientUp; cLB.padding = 0; ZShadeSandboxLighting::cbSunLightBuffer cSLB; cSLB.g_SunDir = material->GetSunLightBuffer()->g_SunDir; cSLB.g_EnableSun = material->GetSunLightBuffer()->g_EnableSun; cSLB.g_SunDiffuseColor = material->GetSunLightBuffer()->g_SunDiffuseColor; cSLB.padding = XMFLOAT3(0, 0, 0); cSLB.g_SunShineness = material->GetSunLightBuffer()->g_SunShineness; cTessellationBuffer cTB; cTB.g_TessellationFactor = tessFactor; cTB.padding = XMFLOAT3(0, 0, 0); // Map tessellation constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pTessellationCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(cTessellationBuffer*)mapped_res.pData = cTB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pTessellationCB, 0); } // Map the per frame constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pPerFrameCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(Const_Per_Frame*)mapped_res.pData = per_frame; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pPerFrameCB, 0); } // Map the matrix constants { D3D11_MAPPED_SUBRESOURCE mapped_res2; m_pD3DSystem->GetDeviceContext()->Map(m_pPerObjectCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res2); { assert(mapped_res2.pData); *(Const_Per_Object*)mapped_res2.pData = per_object; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pPerObjectCB, 0); } // Map light shading constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pLightCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(ZShadeSandboxLighting::cbLightBuffer*)mapped_res.pData = cLB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pLightCB, 0); } // Map sun light shading constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pSunCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(ZShadeSandboxLighting::cbSunLightBuffer*)mapped_res.pData = cSLB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pSunCB, 0); } // Set the tessellation constant buffer into the Hull Shader ID3D11Buffer* hs_cbs[1] = { m_pTessellationCB }; m_pD3DSystem->GetDeviceContext()->HSSetConstantBuffers(0, 1, hs_cbs); // Set the matrix constant buffer into the Domain Shader ID3D11Buffer* ds_cbs[2] = { m_pPerFrameCB, m_pPerObjectCB }; m_pD3DSystem->GetDeviceContext()->DSSetConstantBuffers(0, 2, ds_cbs); //ID3D11Buffer* vs_cbs[2] = { m_pPerFrameCB, m_pPerObjectCB }; //m_pD3DSystem->GetDeviceContext()->VSSetConstantBuffers(0, 2, vs_cbs); ID3D11Buffer* ps_cbs[3] = { m_pPerFrameCB, m_pLightCB, m_pSunCB }; m_pD3DSystem->GetDeviceContext()->PSSetConstantBuffers(0, 3, ps_cbs); ID3D11ShaderResourceView* ps_srvs[6] = { diffuseArrayTexture, diffuseTexture, normalMapTexture, blendMapTexture, detailMapTexture, alphaMapTexture }; if (!m_Wireframe) { // Assign Texture m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 6, ps_srvs); SwitchTo("MaterialTessellationShaderPS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); } else { SwitchTo("MaterialTessellationShaderWireframePS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); } SetVertexShader(); SetHullShader(); SetDomainShader(); SetPixelShader(); SetInputLayout("TriMaterialTessellationShader"); //Perform Drawing RenderIndex11(indexCount); // Unbind if (!m_Wireframe) { for (int i = 0; i < 6; i++) ps_srvs[i] = NULL; m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 6, ps_srvs); } // Set Hull, Domain and Geometry Shaders to null in case they are not needed m_pD3DSystem->GetDeviceContext()->HSSetShader(NULL, NULL, 0); m_pD3DSystem->GetDeviceContext()->DSSetShader(NULL, NULL, 0); m_pD3DSystem->GetDeviceContext()->GSSetShader(NULL, NULL, 0); return true; }
//============================================================================================================================== bool TerrainTessellationQuadSSAOShader::Render(int indexCount, Camera* camera, LightCamera* lightcamera, ZShadeSandboxTerrain::TerrainShadingConst terrainShadingConst, ID3D11ShaderResourceView* heightMapSRV) { cTessellationBuffer cTB; cMatrixBuffer cMB; cDomainConstBuffer cDCB; cShadingConstBuffer cSCB; //if (m_UseCustomWorld) // cMB.g_WorldMatrix = ZShadeSandboxMath::ZMath::GMathMF(XMMatrixTranspose(mWorld.Get())); //else // cMB.g_WorldMatrix = camera->World4x4(); cMB.g_ViewMatrix = camera->View4x4(); cMB.g_ProjMatrix = camera->Proj4x4(); XMMATRIX toTexSpace = XMMatrixScaling(0.5f, -0.5f, 1.0f) * XMMatrixTranslation(0.5f, 0.5f, 0); cMB.g_TexSpaceMatrix = ZShadeSandboxMath::ZMath::GMathMF(XMMatrixTranspose(toTexSpace)); // Need to create the shadow matrix cMB.g_ShadowMatrix = lightcamera->ShadowTransform4x4(); cTB.g_EyePosW = terrainShadingConst.g_EyePosW; cTB.g_MinDist = terrainShadingConst.g_MinDist; cTB.g_MaxDist = terrainShadingConst.g_MaxDist; cTB.g_MinTess = terrainShadingConst.g_MinTess; cTB.g_MaxTess = terrainShadingConst.g_MaxTess; cTB.g_FrustumCull = terrainShadingConst.g_FrustumCull; cTB.padding = XMFLOAT2(0, 0); cTB.g_TerrSize = terrainShadingConst.g_MapSize; cTB.g_TerrScale = terrainShadingConst.g_TerrSize; cDCB.g_TexScale = XMFLOAT2(66.0f, 66.0f); cDCB.g_HeightScale = terrainShadingConst.g_HeightScale; cDCB.g_TerrainZScale = terrainShadingConst.g_TerrSize; cDCB.g_ClipPlane = terrainShadingConst.g_ClipPlane; cDCB.g_tpadding = XMFLOAT3(0, 0, 0); cDCB.g_FarPlane = terrainShadingConst.g_FarPlane; cSCB.g_EyePosW = terrainShadingConst.g_EyePosW; cSCB.g_DetailBrightness = terrainShadingConst.g_DetailBrightness; cSCB.g_fogThinning = terrainShadingConst.g_fogThinning; cSCB.g_fogAltitude = terrainShadingConst.g_fogAltitude; cSCB.g_fogNear = terrainShadingConst.g_fogNear; cSCB.g_fogFar = terrainShadingConst.g_fogFar; cSCB.g_fogColor = terrainShadingConst.g_fogColor; cSCB.g_TextureAmount = terrainShadingConst.g_TextureAmount; cSCB.g_TextureWidth = terrainShadingConst.g_TextureWidth; cSCB.g_TextureHeight = terrainShadingConst.g_TextureHeight; cSCB.g_seaLevel = terrainShadingConst.g_seaLevel; cSCB.g_waterBodyColor = terrainShadingConst.g_waterBodyColor; //cSCB.g_SunDir = terrainShadingConst.g_SunDir; //cSCB.g_EnableSun = terrainShadingConst.g_EnableSun; //cSCB.g_SunDiffuseColor = terrainShadingConst.g_SunDiffuseColor; cSCB.g_MaterialDiffuseColor = terrainShadingConst.g_MaterialDiffuseColor; cSCB.g_MaterialAmbientColor = terrainShadingConst.g_MaterialAmbientColor; cSCB.g_TexelCellSpaceU = terrainShadingConst.g_TexelCellSpaceU; cSCB.g_TexelCellSpaceV = terrainShadingConst.g_TexelCellSpaceV; cSCB.g_MaterialSpecularPower = terrainShadingConst.g_MaterialSpecularPower; cSCB.g_MaterialSpecularIntensity = terrainShadingConst.g_MaterialSpecularIntensity; cSCB.g_useClippingPlane = terrainShadingConst.g_useClippingPlane; cSCB.g_useNormalMap = terrainShadingConst.g_useNormalMap; cSCB.g_UseSobelFilter = terrainShadingConst.g_UseSobelFilter; cSCB.g_useShadowMap = terrainShadingConst.g_useShadowMap; cSCB.tpadding = XMFLOAT3(0, 0, 0); cSCB.g_useSSAO = terrainShadingConst.g_useSSAO; cSCB.g_ViewMatrix = cMB.g_ViewMatrix; ZShadeSandboxLighting::LightManager::Instance()->BuildFinalLightBuffers(m_pLightCB, m_pSunCB); // Map tessellation constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pTessellationCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(cTessellationBuffer*)mapped_res.pData = cTB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pTessellationCB, 0); } // Map domain shader constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pDomainCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(cDomainConstBuffer*)mapped_res.pData = cDCB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pDomainCB, 0); } // Map matrix constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pMatrixBufferCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(cMatrixBuffer*)mapped_res.pData = cMB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pMatrixBufferCB, 0); } // Map pixel shading constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pShadingCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(cShadingConstBuffer*)mapped_res.pData = cSCB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pShadingCB, 0); } // Set the tessellation constant buffer into the Hull ZShadeSandboxShader::Shader ID3D11Buffer* hs_cbs[1] = { m_pTessellationCB }; m_pD3DSystem->GetDeviceContext()->HSSetConstantBuffers(0, 1, hs_cbs); // Set the domain constant buffer into the Domain ZShadeSandboxShader::Shader // Set the matrix constant buffer into the Domain ZShadeSandboxShader::Shader ID3D11Buffer* ds_cbs[2] = { m_pDomainCB, m_pMatrixBufferCB }; m_pD3DSystem->GetDeviceContext()->DSSetConstantBuffers(0, 2, ds_cbs); // Set the shading constant buffer into the Pixel ZShadeSandboxShader::Shader ID3D11Buffer* ps_cbs[3] = { m_pShadingCB, m_pLightCB, m_pSunCB }; m_pD3DSystem->GetDeviceContext()->PSSetConstantBuffers(0, 3, ps_cbs); // Set the heightmap texture into the vertex shader ID3D11ShaderResourceView* vs_srvs[1] = { heightMapSRV }; m_pD3DSystem->GetDeviceContext()->VSSetShaderResources(0, 1, vs_srvs); // Set the heightmap texture into the domain shader ID3D11ShaderResourceView* ds_srvs[1] = { heightMapSRV }; m_pD3DSystem->GetDeviceContext()->DSSetShaderResources(0, 1, ds_srvs); // Set the textures into the Pixel Shader ID3D11ShaderResourceView* ps_srvs[1] = { heightMapSRV }; m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 1, ps_srvs); // Tell the shader what input layout to use SetInputLayout("TerrainTessellationQuadSSAOShader"); // Assign the shaders to render the mesh SetVertexShader(); SetHullShader(); SetDomainShader(); SetPixelShader(); //Perform Drawing RenderIndex11(indexCount); return true; }
//============================================================================================================================== bool OBJMeshShader::Render(int startIndex, int indexCount, Camera* camera, XMMATRIX wvp, XMFLOAT4 clipplane, XMFLOAT4 difColor, bool hasTexture, ID3D11ShaderResourceView* texture) { cbOBJShadingConst cSC; cbMatrixBuffer cMB; cMB.g_WVPMatrix = ZShadeSandboxMath::ZMath::GMathMF(XMMatrixTranspose(wvp)); //if (m_UseCustomWorld) // cMB.g_WorldMatrix = ZShadeSandboxMath::ZMath::GMathMF(XMMatrixTranspose(mWorld.Get())); //else // cMB.g_WorldMatrix = camera->World4x4(); cSC.g_ClipPlane = clipplane; cSC.g_DifColor = difColor; cSC.padding = XMFLOAT2(0, 0); cSC.g_FarPlane = fFarPlane; cSC.g_hasTexture = (hasTexture == true) ? 1 : 0; // Map shading constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pOBJShadingCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(cbOBJShadingConst*)mapped_res.pData = cSC; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pOBJShadingCB, 0); } // Map matrix constants { D3D11_MAPPED_SUBRESOURCE mapped_res; m_pD3DSystem->GetDeviceContext()->Map(m_pMatrixBufferCB, 0, D3D11_MAP_WRITE_DISCARD, 0, &mapped_res); { assert(mapped_res.pData); *(cbMatrixBuffer*)mapped_res.pData = cMB; } m_pD3DSystem->GetDeviceContext()->Unmap(m_pMatrixBufferCB, 0); } // Set the shading constant buffer and matrix constant buffer into the Vertex ZShadeSandboxShader::Shader ID3D11Buffer* vs_cbs[2] = { m_pOBJShadingCB, m_pMatrixBufferCB }; m_pD3DSystem->GetDeviceContext()->VSSetConstantBuffers(0, 2, vs_cbs); // Set the shading constant buffer into the Pixel Shader ID3D11Buffer* ps_cbs[1] = { m_pOBJShadingCB }; m_pD3DSystem->GetDeviceContext()->PSSetConstantBuffers(0, 1, ps_cbs); ID3D11ShaderResourceView* ps_srvs[1] = { texture }; ID3D11SamplerState* ps_samp[1] = { m_pD3DSystem->Linear() }; if (!m_Wireframe) { m_pD3DSystem->TurnOffCulling(); // Set the texture into the Pixel Shader if (hasTexture) { m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 1, ps_srvs); m_pD3DSystem->GetDeviceContext()->PSSetSamplers(0, 1, ps_samp); } SwitchTo("OBJMeshPS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); } else { SwitchTo("OBJMeshWireframePS", ZShadeSandboxShader::EShaderTypes::ST_PIXEL); } // Tell the shader what input layout to use SetInputLayout("OBJMeshShader"); // Assign the shaders to render the mesh SetVertexShader(); SetPixelShader(); //Perform Drawing RenderIndex11(startIndex, indexCount); if (!m_Wireframe) { m_pD3DSystem->TurnOnCulling(); } // Unbind if (!m_Wireframe && hasTexture) { ps_samp[0] = NULL; m_pD3DSystem->GetDeviceContext()->PSSetSamplers(0, 1, ps_samp); ps_srvs[0] = NULL; m_pD3DSystem->GetDeviceContext()->PSSetShaderResources(0, 1, ps_srvs); } return true; }