bool ShadowMappingShader::SetShaderParameters(D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, D3DXMATRIX lightViewMatrix, D3DXMATRIX lightProjectionMatrix, ID3D11ShaderResourceView* texture, ID3D11ShaderResourceView* depthMapTexture, D3DXVECTOR3 lightPosition, D3DXVECTOR4 ambientColor, D3DXVECTOR4 diffuseColor) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; unsigned int bufferNumber; MatrixBufferType* dataPtr; LightBufferType* dataPtr2; LightBufferType2* dataPtr3; // Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); D3DXMatrixTranspose(&lightViewMatrix, &lightViewMatrix); D3DXMatrixTranspose(&lightProjectionMatrix, &lightProjectionMatrix); ID3D11DeviceContext* deviceContext = GraphicsDX::GetDeviceContext(); // Lock the constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; dataPtr->lightView = lightViewMatrix; dataPtr->lightProjection = lightProjectionMatrix; // Unlock the constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the constant buffer in the vertex shader. bufferNumber = 0; // Now set the constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); // Set shader texture resource in the pixel shader. deviceContext->PSSetShaderResources(0, 1, &texture); deviceContext->PSSetShaderResources(1, 1, &depthMapTexture); // Lock the light constant buffer so it can be written to. result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr2 = (LightBufferType*)mappedResource.pData; // Copy the lighting variables into the constant buffer. dataPtr2->ambientColor = ambientColor; dataPtr2->diffuseColor = diffuseColor; // Unlock the constant buffer. deviceContext->Unmap(m_lightBuffer, 0); // Set the position of the light constant buffer in the pixel shader. bufferNumber = 0; // Finally set the light constant buffer in the pixel shader with the updated values. deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer); // Lock the second light constant buffer so it can be written to. result = deviceContext->Map(m_lightBuffer2, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr3 = (LightBufferType2*)mappedResource.pData; // Copy the lighting variables into the constant buffer. dataPtr3->lightPosition = lightPosition; dataPtr3->padding = 0.0f; // Unlock the constant buffer. deviceContext->Unmap(m_lightBuffer2, 0); // Set the position of the light constant buffer in the vertex shader. bufferNumber = 1; // Finally set the light constant buffer in the pixel shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer2); return true; }
void CLcXSkinIns::Render() { HRESULT hr=-1; LPDIRECT3DDEVICE9 pDev = (LPDIRECT3DDEVICE9)LcDev_GetD3Device(); CLcXSkinSrc* pOrg = (CLcXSkinSrc*)m_pOrg; ID3DXEffect* pEft = pOrg->GetEffect(); // Setup the projection matrix D3DXMATRIX matProj; pDev->GetTransform(D3DTS_PROJECTION, &matProj); D3DLIGHT9 light; D3DXVECTOR3 vecLightDirUnnormalized(0.0f, -1.0f, 1.0f); ZeroMemory( &light, sizeof(D3DLIGHT9) ); light.Type = D3DLIGHT_DIRECTIONAL; light.Diffuse.r = 1.0f; light.Diffuse.g = 1.0f; light.Diffuse.b = 1.0f; D3DXVec3Normalize( (D3DXVECTOR3*)&light.Direction, &vecLightDirUnnormalized ); light.Position.x = 0.0f; light.Position.y = -1.0f; light.Position.z = 1.0f; light.Range = 1000.0f; pDev->SetLight(0, &light ); pDev->LightEnable(0, TRUE ); // Set Light for vertex shader D3DXVECTOR4 vLightDir( 0.0f, 1.0f, -1.0f, 0.0f ); D3DXVec4Normalize( &vLightDir, &vLightDir ); // for HLSL { pEft->SetMatrix( "mViewProj", &matProj); pEft->SetVector( "lhtDir", &vLightDir); } // for shader { // set the projection matrix for the vertex shader based skinning method D3DXMatrixTranspose(&matProj, &matProj); pDev->SetVertexShaderConstantF(2, (float*)&matProj, 4); pDev->SetVertexShaderConstantF(1, (float*)&vLightDir, 1); } if(m_pAC) m_pAC->AdvanceTime(m_fElapse, NULL); pOrg->UpdateFrameMatrices(m_pFrameOrg, &m_mtWld); pOrg->DrawFrame(m_pFrameOrg); static D3DXMATRIX mtI(1,0,0,0, 0,1,0,0, 0,0,1,0, 0,0,0,1); pDev->SetTransform(D3DTS_WORLD, &mtI); }
bool TerrainShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, D3DXVECTOR4 ambientColor, D3DXVECTOR4 diffuseColor, D3DXVECTOR3 lightDirection) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; unsigned int bufferNumber; MatrixBufferType* dataPtr; LightBufferType* dataPtr2; // Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); // Lock the constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; // Unlock the constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the constant buffer in the vertex shader. bufferNumber = 0; // Now set the constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); // Lock the light constant buffer so it can be written to. result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr2 = (LightBufferType*)mappedResource.pData; // Copy the lighting variables into the constant buffer. dataPtr2->ambientColor = ambientColor; dataPtr2->diffuseColor = diffuseColor; dataPtr2->lightDirection = lightDirection; dataPtr2->padding = 0.0f; // Unlock the constant buffer. deviceContext->Unmap(m_lightBuffer, 0); // Set the position of the light constant buffer in the pixel shader. bufferNumber = 0; // Finally set the light constant buffer in the pixel shader with the updated values. deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer); return true; }
Matrix Matrix::transpose(const Matrix& matrix) { return *D3DXMatrixTranspose(&tmp, &matrix); }
/** Draws the visual for the given vob */ void GSkeletalMeshVisual::DrawVisual(const RenderInfo& info) { GVisual::DrawVisual(info); // Draw the mesh using immediate states int n=0; for(auto it = VisualInfo.SkeletalMeshes.begin();it != VisualInfo.SkeletalMeshes.end(); it++) { D3DXMATRIX world; D3DXMatrixTranspose(&world, info.WorldMatrix); std::vector<SkeletalMeshInfo*>& meshes = (*it).second; for(int i=0;i<meshes.size();i++) { if(ImmediatePipelineStates[n]->BaseState.TextureIDs[0] == 0xFFFF) { // Only draw if the texture is loaded if((*it).first->GetTexture() && (*it).first->GetTexture()->CacheIn(0.6f) != zRES_CACHED_IN) { n++; continue; } // Get texture ID if everything is allright if((*it).first && (*it).first->GetTexture() && (*it).first->GetTexture()->GetSurface() && (*it).first->GetTexture()->GetSurface()->GetEngineTexture()) { ImmediatePipelineStates[n]->BaseState.TextureIDs[0] = (*it).first->GetTexture()->GetSurface()->GetEngineTexture()->GetID(); // Get Alphatest if((*it).first->GetAlphaFunc() > 1 || (*it).first->GetTexture()->HasAlphaChannel()) ImmediatePipelineStates[n]->BaseState.TranspacenyMode = PipelineState::ETransparencyMode::TM_MASKED; Engine::GraphicsEngine->SetupPipelineForStage(STAGE_DRAW_SKELETAL, ImmediatePipelineStates[n]); } } // Clone the state for this mesh PipelineState* transientState = Engine::GraphicsEngine->CreatePipelineState(ImmediatePipelineStates[n]); transientState->TransientState = true; // Input instanceCB and our bones transientState->BaseState.ConstantBuffersVS[1] = info.InstanceCB; transientState->BaseState.ConstantBuffersVS[2] = BoneConstantBuffer; Engine::GraphicsEngine->FillPipelineStateObject(transientState); // Push to renderlist Engine::GraphicsEngine->PushPipelineState(transientState); n++; } } return; #ifndef DEBUG_DRAW_VISUALS return; #endif std::vector<D3DXMATRIX> trans = *BoneTransforms; for(int i=0;i<trans.size();i++) D3DXMatrixTranspose(&trans[i], &trans[i]); // Debug draw the mesh as line-wireframe for(auto it = VisualInfo.SkeletalMeshes.begin();it != VisualInfo.SkeletalMeshes.end(); it++) { D3DXMATRIX world; D3DXMatrixTranspose(&world, info.WorldMatrix); std::vector<SkeletalMeshInfo*>& meshes = (*it).second; for(int i=0;i<meshes.size();i++) { std::vector<VERTEX_INDEX>& indices = meshes[i]->Indices; std::vector<ExSkelVertexStruct>& vertices = meshes[i]->Vertices; for(int i=0;i<indices.size();i+=3) { D3DXVECTOR3 vx[3]; for(int v=0;v<3;v++) { D3DXVECTOR3 position = D3DXVECTOR3(0,0,0); ExSkelVertexStruct& input = vertices[indices[i + v]]; for(int i=0;i<4;i++) { D3DXVECTOR3 bp; D3DXVec3TransformCoord(&bp, input.Position[i].toD3DXVECTOR3(), &trans[input.boneIndices[i]]); position += input.weights[i] * bp; } D3DXVec3TransformCoord(&position, &position, &world); vx[v] = position; } // Don't draw too far if(D3DXVec3Length(&(vx[0] - Engine::GAPI->GetCameraPosition())) > 2400) continue; Engine::GraphicsEngine->GetLineRenderer()->AddTriangle(vx[0], vx[1], vx[2], D3DXVECTOR4(1,0,0,1)); } //Engine::GraphicsEngine->GetLineRenderer()->AddWireframeMesh(meshes[i]->Vertices, meshes[i]->Indices, D3DXVECTOR4(0,1,0,1), &world); } } }
void RobotArmDemo::drawScene() { // Clear the backbuffer and depth buffer. HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0)); HR(gd3dDevice->BeginScene()); HR(mFX->SetValue(mhLight, &mLight, sizeof(DirLight))); HR(mFX->SetTechnique(mhTech)); UINT numPasses = 0; HR(mFX->Begin(&numPasses, 0)); HR(mFX->BeginPass(0)); // Build the world transforms for each bone, then render them. buildBoneWorldTransforms(); D3DXMATRIX T; D3DXMatrixTranslation(&T, -NUM_BONES, 0.0f, 0.0f); for(int i = 0; i < NUM_BONES; ++i) { // Append the transformation with a slight translation to better // center the skeleton at the center of the scene. mWorld = mBones[i].toWorldXForm * T; HR(mFX->SetMatrix(mhWVP, &(mWorld*mView*mProj))); D3DXMATRIX worldInvTrans; D3DXMatrixInverse(&worldInvTrans, 0, &mWorld); D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans); HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans)); HR(mFX->SetMatrix(mhWorld, &mWorld)); for(int j = 0; j < mMtrl.size(); ++j) { HR(mFX->SetValue(mhMtrl, &mMtrl[j], sizeof(Mtrl))); // If there is a texture, then use. if(mTex[j] != 0) { HR(mFX->SetTexture(mhTex, mTex[j])); } // But if not, then set a pure white texture. When the texture color // is multiplied by the color from lighting, it is like multiplying by // 1 and won't change the color from lighting. else { HR(mFX->SetTexture(mhTex, mWhiteTex)); } HR(mFX->CommitChanges()); HR(mBoneMesh->DrawSubset(j)); } } HR(mFX->EndPass()); HR(mFX->End()); mGfxStats->display(); HR(gd3dDevice->EndScene()); // Present the backbuffer. HR(gd3dDevice->Present(0, 0, 0, 0)); }
bool SpecularMapShader::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView** textureArray, D3DXVECTOR3 lightDirection, D3DXVECTOR4 diffuseColor, D3DXVECTOR3 cameraPosition, D3DXVECTOR4 specularColor, float specularPower) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; MatrixBufferType* dataPtr; unsigned int bufferNumber; LightBufferType* dataPtr2; CameraBufferType* dataPtr3; // Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); // Lock the matrix constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; // Unlock the matrix constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the matrix constant buffer in the vertex shader. bufferNumber = 0; // Now set the matrix constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); // Set shader texture array resource in the pixel shader. deviceContext->PSSetShaderResources(0, 3, textureArray); // Lock the light constant buffer so it can be written to. result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr2 = (LightBufferType*)mappedResource.pData; // Copy the lighting variables into the constant buffer. dataPtr2->diffuseColor = diffuseColor; dataPtr2->lightDirection = lightDirection; dataPtr2->specularColor = specularColor; dataPtr2->specularPower = specularPower; // Unlock the constant buffer. deviceContext->Unmap(m_lightBuffer, 0); // Set the position of the light constant buffer in the pixel shader. bufferNumber = 0; // Finally set the light constant buffer in the pixel shader with the updated values. deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer); // Lock the camera constant buffer so it can be written to. result = deviceContext->Map(m_cameraBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr3 = (CameraBufferType*)mappedResource.pData; // Copy the camera position into the constant buffer. dataPtr3->cameraPosition = cameraPosition; // Unlock the matrix constant buffer. deviceContext->Unmap(m_cameraBuffer, 0); // Set the position of the camera constant buffer in the vertex shader as the second buffer. bufferNumber = 1; // Now set the matrix constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_cameraBuffer); return true; }
void EngineMain::drawScene() { // Clear the backbuffer and depth buffer. HR(g_d3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, 0xffffffff, 1.0f, 0)); HR(g_d3dDevice->BeginScene()); D3DXMATRIX wVPM = camera.GetView()*camera.GetProjection(); // Setup the rendering FX Shaders::BasicFX->SetDirectionalLight(&m_DirLight); Shaders::BasicFX->m_FX->SetTechnique(Shaders::BasicFX->m_hTech); // Begin passes. UINT numPasses = 0; Shaders::BasicFX->m_FX->Begin(&numPasses, 0); Shaders::BasicFX->m_FX->BeginPass(0); skull->DrawModel(wVPM); dwarf->DrawModel(wVPM); tiny->DrawModel(wVPM); Shaders::BasicFX->m_FX->EndPass(); Shaders::BasicFX->m_FX->End(); // Animation Passes // Shaders::VBlendFX->SetDirectionalLight(&m_DirLight); //HR(Shaders::VBlendFX->m_FX->SetValue(Shaders::VBlendFX->m_hLight, &m_DirLight, sizeof(DirectionalLight))); Shaders::VBlendFX->m_FX->SetTechnique(Shaders::VBlendFX->m_hTech); numPasses = 0; Shaders::VBlendFX->m_FX->Begin(&numPasses, 0); Shaders::VBlendFX->m_FX->BeginPass(0); //tiny->draw(wVPM); Shaders::VBlendFX->m_FX->EndPass(); Shaders::VBlendFX->m_FX->End(); // End // #pragma region Draw Grid HR(mFX->SetTechnique(mhTech)); HR(mFX->SetMatrix(mhWVP, &wVPM)); D3DXMATRIX worldInvTrans; D3DXMatrixInverse(&worldInvTrans, 0, &m_World); D3DXMatrixTranspose(&worldInvTrans, &worldInvTrans); HR(mFX->SetMatrix(mhWorldInvTrans, &worldInvTrans)); HR(mFX->SetValue(mhLightVecW, &mLightVecW, sizeof(D3DXVECTOR3))); HR(mFX->SetValue(mhDiffuseMtrl, &mDiffuseMtrl, sizeof(D3DXCOLOR))); HR(mFX->SetValue(mhDiffuseLight, &mDiffuseLight, sizeof(D3DXCOLOR))); HR(mFX->SetValue(mhAmbientMtrl, &mAmbientMtrl, sizeof(D3DXCOLOR))); HR(mFX->SetValue(mhAmbientLight, &mAmbientLight, sizeof(D3DXCOLOR))); HR(mFX->SetValue(mhSpecularLight, &mSpecularLight, sizeof(D3DXCOLOR))); HR(mFX->SetValue(mhSpecularMtrl, &mSpecularMtrl, sizeof(D3DXCOLOR))); HR(mFX->SetFloat(mhSpecularPower, mSpecularPower)); HR(mFX->SetMatrix(mhWorld, &m_World)); HR(mFX->SetTexture(mhTex, mGroundTex)); HR(g_d3dDevice->SetVertexDeclaration(VertexPNT::Decl)); HR(g_d3dDevice->SetStreamSource(0, mGridVB, 0, sizeof(VertexPNT))); HR(g_d3dDevice->SetIndices(mGridIB)); // Begin passes. numPasses = 0; HR(mFX->Begin(&numPasses, 0)); for(UINT i = 0; i < numPasses; ++i) { HR(mFX->BeginPass(i)); HR(g_d3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, mNumGridVertices, 0, mNumGridTriangles)); HR(mFX->EndPass()); } HR(mFX->End()); #pragma endregion m_GfxStats->display(); HR(g_d3dDevice->EndScene()); // Present the backbuffer. HR(g_d3dDevice->Present(0, 0, 0, 0)); }
bool CD3DMGEng::DrawText3D ( float x, float y, float z, D3DMATRIX * pMatView, DWORD dwColor, const TCHAR *wszText, float fTextSize, FONTFLAGS ffFlags, FONTSET fsSet ) { D3DSPRITEVERTEX3D * pVertices = NULL; D3DXMATRIX MatWorld, MatView, MatTranslation, MatTransposed; DWORD dwTriangleCount = 0; float fStartX = 0; //////////////////////////////////////////////////// // Make sure we have a valid vertex buffer. if ( m_pVB == NULL ) { return false; } //////////////////////////////////////////////////// // Make sure our texture and coords are loaded. if ( m_pFontTexture == NULL || m_bFontInfoLoaded == false ) { return false; } /////////////////////////////////////////////////// // Setup the rendering. // Convert our view matrix from D3DMATRIX to D3DXMATRIX MatView = *pMatView; D3DXMatrixTranspose ( &MatTransposed, &MatView ); // Create an Inverse matrix out of the view matrix (go from view to world space). MatTransposed._41 = MatTransposed._42 = MatTransposed._43 = MatTransposed._14 = MatTransposed._24 = MatTransposed._34 = 0.0f; // Create an empty identity matrix. D3DXMatrixIdentity ( &MatWorld ); // Add in our scaling here. float fSize = fTextSize / 100.0f; D3DXMatrixScaling ( &MatWorld, fSize, fSize, fSize ); // Set position of text in world. D3DXMatrixTranslation ( &MatTranslation, x, y, z ); // Apply settings to new world matrix. D3DXMatrixMultiply ( &MatWorld, &MatWorld, &MatTransposed ); D3DXMatrixMultiply ( &MatWorld, &MatWorld, &MatTranslation ); m_pDevice->SetFVF ( D3DFVF_SPRITEVERTEX3DTEX ); m_pDevice->SetStreamSource ( 0, m_pVB, 0, sizeof(D3DSPRITEVERTEX3D) ); m_pDevice->SetTexture ( 0, m_pFontTexture ); m_pDevice->SetTransform ( D3DTS_WORLD, &MatWorld ); x = 0; y = 0; /////////////////////////////////////////////////// // Do flag processing before we go any further. if ( ffFlags ) { SIZE sz; // First, get extent of drawn text. UTIL_GetTextExtent(wszText, &sz, fTextSize); // Do math on x coordinate accordingly. switch ( ffFlags ) { case D3DFF_CENTERED: x -= sz.cx/2; break; case D3DFF_RIGHT: x += sz.cx; break; case D3DFF_LEFT: //x += sz.cx/2; break; default: break; } } fStartX = x; m_pVB->Lock( 0, 0, (void**)&pVertices, D3DLOCK_DISCARD ); while ( *wszText ) { TCHAR c = *wszText++; if ( c == _T('\n') ) { x = fStartX; y += m_aFontCoords[fsSet].fHeight; continue; } if ( c < _T(' ') || c > _T(128) ) { continue; } float tx1 = m_aFontCoords[fsSet+c-32].tx1; float tx2 = m_aFontCoords[fsSet+c-32].tx2; float ty1 = m_aFontCoords[fsSet+c-32].ty1; float ty2 = m_aFontCoords[fsSet+c-32].ty2; float w = m_aFontCoords[fsSet+c-32].fWidth; float h = m_aFontCoords[fsSet+c-32].fHeight; if ( c == _T(' ') ) { x += w; continue; } // First triangle (bottom right) *pVertices++ = InitFont3DVertex ( x+w, y+h, 0.0f, dwColor, tx2, ty1 ); //bottom right. *pVertices++ = InitFont3DVertex ( x+w, y, 0.0f, dwColor, tx2, ty2 ); //top right. *pVertices++ = InitFont3DVertex ( x, y+h, 0.0f, dwColor, tx1, ty1 ); //bottom left. // Second triangle (upper left) *pVertices++ = InitFont3DVertex ( x, y, 0.0f, dwColor, tx1, ty2 ); //top left. *pVertices++ = InitFont3DVertex ( x+w, y, 0.0f, dwColor, tx2, ty2 ); //top right. *pVertices++ = InitFont3DVertex ( x, y+h, 0.0f, dwColor, tx1, ty1 ); //bottom right. x += w; dwTriangleCount += 2; //////////////////////////////////////////////////// // If we've gone over our limit, draw what we have. if ( dwTriangleCount*3 >= D3DSPRITE_NUMVERTS-6 ) { m_pVB->Unlock(); m_pDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwTriangleCount ); m_pVB->Lock( 0, 0, (void**)&(pVertices=NULL), D3DLOCK_DISCARD ); dwTriangleCount = 0L; } } m_pVB->Unlock(); //////////////////////////////////////////////////// // Draw if we have anything. if ( dwTriangleCount > 0 ) { m_pDevice->DrawPrimitive( D3DPT_TRIANGLELIST, 0, dwTriangleCount ); } return true; }
void Matrix::setTranspose( const Matrix& mat ){ D3DXMATRIX a; D3DXMatrixTranspose( &a, &D3DXMATRIX((float*)&mat.m ) ); m.set( a ); }
bool ReflectionShader::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* colorTexture, ID3D11ShaderResourceView* normalTexture, D3DXVECTOR4 lightDiffuseColor, D3DXVECTOR3 lightDirection, float colorTextureBrightness, D3DXVECTOR4 clipPlane) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; unsigned int bufferNumber; MatrixBufferType* dataPtr; ClipPlaneBufferType* dataPtr1; LightBufferType* dataPtr2; // Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); // Lock the constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; // Unlock the constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the constant buffer in the vertex shader. bufferNumber = 0; // Now set the constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); // Lock the clip plane constant buffer so it can be written to. result = deviceContext->Map(m_clipPlaneBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the clip plane constant buffer. dataPtr1 = (ClipPlaneBufferType*)mappedResource.pData; // Copy the clip plane into the clip plane constant buffer. dataPtr1->clipPlane = clipPlane; // Unlock the buffer. deviceContext->Unmap(m_clipPlaneBuffer, 0); // Set the position of the clip plane constant buffer in the vertex shader. bufferNumber = 1; // Now set the clip plane constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_clipPlaneBuffer); // Lock the light constant buffer so it can be written to. result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr2 = (LightBufferType*)mappedResource.pData; // Copy the lighting variables into the constant buffer. dataPtr2->lightDiffuseColor = lightDiffuseColor; dataPtr2->lightDirection = lightDirection; dataPtr2->colorTextureBrightness = colorTextureBrightness; // Unlock the constant buffer. deviceContext->Unmap(m_lightBuffer, 0); // Set the position of the light constant buffer in the pixel shader. bufferNumber = 0; // Finally set the light constant buffer in the pixel shader with the updated values. deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer); // Set the texture resources in the pixel shader. deviceContext->PSSetShaderResources(0, 1, &colorTexture); deviceContext->PSSetShaderResources(1, 1, &normalTexture); return true; }
void Ground::Render() { GetDevice()->SetFVF(D3DFVF_GROUNDCUSTOMVERTEX); // TODO: 행렬 계산 D3DXMATRIXA16 MatWorld; D3DXMATRIXA16 MatTrans; D3DXMATRIXA16 MatScale; D3DXMATRIXA16 MatRotate; D3DXVECTOR3 LookPt = mPosition + mFrontVector; D3DXMatrixIdentity(&MatWorld); //프론트 백터의 값에 따라 회전 D3DXMatrixLookAtLH(&MatRotate, &mPosition, &LookPt, &mUpVec); //뷰행렬을 가져왔기 때문에 로테이션한 것처럼 행렬을 변환할 필요가 있다. //뷰행렬은 자신이 움직이는 것이 아닌 자신을 제외한 모든 좌표들이 움직이도록 되어있는 행렬이다. //(카메라의 좌표계에 맞춰져있다) //뷰행렬의 역행렬은 transpose해준 형태와 동일하다. MatRotate._41 = MatRotate._42 = MatRotate._43 = 0.f; D3DXMatrixTranspose(&MatRotate, &MatRotate); D3DXMatrixTranslation(&MatTrans, mPosition.x, mPosition.y, mPosition.z); D3DXMatrixScaling(&MatScale, mScaleVec.x, mScaleVec.y, mScaleVec.z); MatWorld = MatScale*MatRotate*MatTrans; //mDevice->SetTransform(D3DTS_WORLD, &MatWorld); D3DXMATRIXA16 g_matProj; D3DXMATRIXA16 matView; mDevice->GetTransform(D3DTS_VIEW, &matView); mDevice->GetTransform(D3DTS_PROJECTION, &g_matProj); D3DXMatrixMultiply(&matView, &matView, &g_matProj); mEffect->SetTechnique("t1"); mEffect->SetMatrix("mWorld", &MatWorld); mEffect->SetMatrix("mViewProj", &matView); mEffect->SetTexture("mTexture", mGroundTexture); mEffect->SetTexture("mAlphaMap", mAlphaMap); mEffect->SetTexture("mTexture2", mSandTexture); //디바이스에 버텍스버퍼를 전달 GetDevice()->SetStreamSource(0, mVertexBuffer, 0, sizeof(GROUND_CUSTOM_VERTEX)); //인덱스 설정 GetDevice()->SetIndices(mIndexBuffer); //GetDevice()->SetTexture(0, mGroundTexture); UINT cPasses; mEffect->Begin(&cPasses, 0); for (UINT p = 0; p < cPasses; ++p) { mEffect->BeginPass(p); GetDevice()->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, mVertexCount, 0, mIndexCount); mEffect->EndPass(); } mEffect->End(); }
bool PureLightShader::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, D3DXVECTOR3 lightDirection, D3DXVECTOR4 ambientColor, D3DXVECTOR4 diffuseColor, D3DXVECTOR3 cameraPosition, D3DXVECTOR4 specularColor, float specularPower, float deltavalue) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; unsigned int bufferNumber; MatrixBufferType* dataPtr; LightBufferType* dataPtr2; VariableBufferType* dataPtr3; CameraBufferType* dataPtr4; // Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); // Lock the constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; // Unlock the constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the constant buffer in the vertex shader. bufferNumber = 0; // Now set the constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); //VARIABLE BUFFER result = deviceContext->Map(m_variableBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr3 = (VariableBufferType*)mappedResource.pData; // Copy the variablethe constant buffer. dataPtr3->delta = deltavalue; dataPtr3->padding =lightDirection; //this is just padding so this data isnt used. // Unlock the variable constant buffer. deviceContext->Unmap(m_variableBuffer, 0); // Set the position of the variable constant buffer in the vertex shader. bufferNumber = 1; // Now set the variable constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_variableBuffer); //END VARIABLE BUFFER // Lock the camera constant buffer so it can be written to. result = deviceContext->Map(m_cameraBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr4 = (CameraBufferType*)mappedResource.pData; // Copy the camera position into the constant buffer. dataPtr4->cameraPosition = cameraPosition; dataPtr4->padding1 = 0.0f; // Unlock the camera constant buffer. deviceContext->Unmap(m_cameraBuffer, 0); // Set the position of the camera constant buffer in the vertex shader. bufferNumber = 1; // Now set the camera constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_cameraBuffer); // Lock the light constant buffer so it can be written to. result = deviceContext->Map(m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr2 = (LightBufferType*)mappedResource.pData; // Copy the lighting variables into the constant buffer. dataPtr2->ambientColor = ambientColor; dataPtr2->diffuseColor = diffuseColor; dataPtr2->lightDirection = lightDirection; dataPtr2->specularColor = specularColor; dataPtr2->specularPower = specularPower; // Unlock the constant buffer. deviceContext->Unmap(m_lightBuffer, 0); // Set the position of the light constant buffer in the pixel shader. bufferNumber = 0; // Finally set the light constant buffer in the pixel shader with the updated values. deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_lightBuffer); return true; }
void CNameTags::Draw() { if(!bbfont) { bbfont = new CBBFont(m_pD3DDevice, "vcpfnt"); bbfont->Initialise(); } if(!BarOldStateBlock) { m_pD3DDevice->BeginStateBlock(); m_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE); m_pD3DDevice->SetRenderState(D3DRS_FOGENABLE, FALSE); m_pD3DDevice->SetRenderState(D3DRS_ZENABLE, 1); m_pD3DDevice->SetRenderState(D3DRS_FILLMODE, 3); m_pD3DDevice->SetRenderState(D3DRS_CULLMODE, 1); m_pD3DDevice->SetRenderState(D3DRS_WRAP0, 0); m_pD3DDevice->SetRenderState(D3DRS_CLIPPING, 1); m_pD3DDevice->SetRenderState(D3DRS_VERTEXBLEND, 0); m_pD3DDevice->SetRenderState(D3DRS_CLIPPLANEENABLE, 1); m_pD3DDevice->SetRenderState(D3DRS_INDEXEDVERTEXBLENDENABLE, 0); m_pD3DDevice->SetRenderState(D3DRS_COLORWRITEENABLE, 15); m_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, 1); m_pD3DDevice->SetRenderState(D3DRS_SRCBLEND, 5); m_pD3DDevice->SetRenderState(D3DRS_DESTBLEND, 6); m_pD3DDevice->SetRenderState(D3DRS_BLENDOP, 1); m_pD3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, 4); m_pD3DDevice->SetTextureStageState(0, D3DTSS_COLORARG1, 2); m_pD3DDevice->SetTextureStageState(0, D3DTSS_COLORARG2, 0); m_pD3DDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, 4); m_pD3DDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, 2); m_pD3DDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, 0); m_pD3DDevice->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0); m_pD3DDevice->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, 0); m_pD3DDevice->SetTextureStageState(1, D3DTSS_COLOROP, 1); m_pD3DDevice->SetTextureStageState(1, D3DTSS_ALPHAOP, 1); m_pD3DDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD); m_pD3DDevice->SetVertexShader(D3DFVF_XYZ|D3DFVF_DIFFUSE); m_pD3DDevice->SetStreamSource(0, NULL, 0); m_pD3DDevice->EndStateBlock(&BarOldStateBlock); } if(!BarNewStateBlock) { m_pD3DDevice->BeginStateBlock(); m_pD3DDevice->SetRenderState(D3DRS_LIGHTING, FALSE); m_pD3DDevice->SetRenderState(D3DRS_FOGENABLE, FALSE); m_pD3DDevice->SetRenderState(D3DRS_ZENABLE, 1); m_pD3DDevice->SetRenderState(D3DRS_FILLMODE, 3); m_pD3DDevice->SetRenderState(D3DRS_CULLMODE, 1); m_pD3DDevice->SetRenderState(D3DRS_WRAP0, 0); m_pD3DDevice->SetRenderState(D3DRS_CLIPPING, 1); m_pD3DDevice->SetRenderState(D3DRS_VERTEXBLEND, 0); m_pD3DDevice->SetRenderState(D3DRS_CLIPPLANEENABLE, 1); m_pD3DDevice->SetRenderState(D3DRS_INDEXEDVERTEXBLENDENABLE, 0); m_pD3DDevice->SetRenderState(D3DRS_COLORWRITEENABLE, 15); m_pD3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, 1); m_pD3DDevice->SetRenderState(D3DRS_SRCBLEND, 5); m_pD3DDevice->SetRenderState(D3DRS_DESTBLEND, 6); m_pD3DDevice->SetRenderState(D3DRS_BLENDOP, 1); m_pD3DDevice->SetTextureStageState(0, D3DTSS_COLOROP, 4); m_pD3DDevice->SetTextureStageState(0, D3DTSS_COLORARG1, 2); m_pD3DDevice->SetTextureStageState(0, D3DTSS_COLORARG2, 0); m_pD3DDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, 1); m_pD3DDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, 2); m_pD3DDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, 0); m_pD3DDevice->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0); m_pD3DDevice->SetTextureStageState(0, D3DTSS_TEXTURETRANSFORMFLAGS, 0); m_pD3DDevice->SetTextureStageState(1, D3DTSS_COLOROP, 1); m_pD3DDevice->SetTextureStageState(1, D3DTSS_ALPHAOP, 1); m_pD3DDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD); m_pD3DDevice->SetVertexShader(D3DFVF_XYZ|D3DFVF_DIFFUSE); m_pD3DDevice->EndStateBlock(&BarNewStateBlock); } m_pD3DDevice->CaptureStateBlock(BarOldStateBlock); m_pD3DDevice->ApplyStateBlock(BarNewStateBlock); D3DXMATRIX matTransposed; D3DXMatrixTranspose(&matTransposed, (D3DXMATRIX*)&matView); matTransposed._14 = matTransposed._24 = matTransposed._34 = 0.0f; if(pNetowkManager) { CPlayerManager* pPlayerManager = pNetowkManager->GetPlayerManager(); for(int x = 0; x < MAX_PLAYERS; x++) { if(pPlayerManager->GetSlotState(x) == TRUE) { // Player is in use CRemotePlayer* Player = pPlayerManager->GetAt(x); if(Player->IsActive() && (Player->GetDistanceFromLocalPlayer() <= 80.0f)) { // Active and within reasonable distance CPlayerPed* PlayerPed = Player->GetPlayerPed(); if(PlayerPed->IsOnScreen()) { // They're onscreen // Get their position Vector3 vPos; PlayerPed->GetPosition(&vPos); // Set the matrix position matTransposed._41 = vPos.X; matTransposed._42 = vPos.Y; matTransposed._43 = vPos.Z + 1.0f; // Set the world transformation m_pD3DDevice->SetTransform(D3DTS_WORLD, &matTransposed); // Get their health and armour // TODO: Use the player ped health/armour? float Health = Player->GetReportedHealth(); float Armour = Player->GetReportedArmour(); // Cap their health and armour if needed if(Health > 100.0f) Health = 100.0f; if(Armour > 100.0f) Armour = 100.0f; // Set the health bar offsets BarBGVertices[0].x = BarBGVertices[1].x = (0.0058f * Health) - 0.29f; // Set the health bar color BarVertices[0].c = BarVertices[1].c = BarVertices[2].c = BarVertices[3].c = HEALTH_BAR_COLOR; // Draw the health bar border m_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, BarBDRVertices, sizeof(BarVertices_s)); // Draw the health bar fill m_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, BarVertices, sizeof(BarVertices_s)); // Draw the health bar background m_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, BarBGVertices, sizeof(BarVertices_s)); if(Armour > 0.0f) { // They have armour // Add an offset to the z position matTransposed._43 += 0.1f; // Set the world transformation m_pD3DDevice->SetTransform(D3DTS_WORLD, &matTransposed); // Set the armour bar offsets BarBGVertices[0].x = BarBGVertices[1].x = (0.0058f * Armour) - 0.29f; // Set the armour bar color BarVertices[0].c = BarVertices[1].c = BarVertices[2].c = BarVertices[3].c = ARMOUR_BAR_COLOR; // Draw the armour bar border m_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, BarBDRVertices, sizeof(BarVertices_s)); // Draw the armour bar fill m_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, BarVertices, sizeof(BarVertices_s)); // Draw the armour bar background m_pD3DDevice->DrawPrimitiveUP(D3DPT_TRIANGLEFAN, 2, BarBGVertices, sizeof(BarVertices_s)); } // Draw the name tag if(bbfont) { bbfont->Begin(); //bbfont->Draw(pPlayerManager->GetPlayerName(x), 0.285f, 0xFF000000); bbfont->Draw(pPlayerManager->GetPlayerName(x), 0.300f, Player->GetTeamColorAsARGB()); bbfont->End(); } } } } } } m_pD3DDevice->ApplyStateBlock(BarOldStateBlock); }
//----[ buildAnimatedBones ]------------------------------------------------- void AnimatedMeshRenderer::buildAnimatedBones( const D3DXMATRIX* root_transform, AnimatedMeshIndex animated_mesh, AnimatedMeshAnimationTrack* animation_track, D3DXMATRIX* bone_matrices) const { assert(animated_mesh < animated_meshes_.size()); assert(animation_track); assert(bone_matrices); const RenderableAnimatedMesh& renderable_animated_mesh = animated_meshes_.at(animated_mesh); AnimatedMeshAnimationTrackElement* internal_animation_track = reinterpret_cast<AnimatedMeshAnimationTrackElement*>(animation_track); RenderableAnimatedMesh::Frame* frames = renderable_animated_mesh.frames; size_t number_of_frames = renderable_animated_mesh.number_of_frames; RenderableAnimatedMesh::Bone* bones = renderable_animated_mesh.bones; size_t number_of_bones = renderable_animated_mesh.number_of_bones; // Build the frames using the data in the animation track D3DXMATRIXA16 matrix; for (size_t frame_index = 0; frame_index < number_of_frames; ++frame_index) { RenderableAnimatedMesh::Frame* frame = &frames[frame_index]; AnimatedMeshAnimationTrackElement* track_element = &internal_animation_track[frame_index]; AnimatedMeshAnimationTrackElement::FrameTransform* frame_transform = &track_element->frame_transform; // Build the transform matrix from the scale/rotate/translate settings //D3DXMatrixTransformation(&matrix, // NULL, // NULL, // frame_transform->scaling(), // NULL, // frame_transform->rotation(), // frame_transform->translation()); // This method of constructing the transform matrices is necessary because // it allows us to transpose the quaternion's matrix during the build. D3DXMATRIXA16 cumulative, builder; D3DXMatrixScaling(&cumulative, frame_transform->s[0], frame_transform->s[1], frame_transform->s[2]); D3DXQUATERNION quat; D3DXQuaternionNormalize(&quat, frame_transform->rotation()); D3DXMatrixRotationQuaternion(&builder, &quat); D3DXMatrixTranspose(&builder, &builder); D3DXMatrixMultiply(&cumulative, &cumulative, &builder); D3DXMatrixTranslation(&builder, frame_transform->t[0], frame_transform->t[1], frame_transform->t[2]); D3DXMatrixMultiply(&matrix, &cumulative, &builder); // Use the frame hierarchy to construct this frame's final transformation size_t parent_frame_index = frame->parent_frame_index; assert(!frame_index || (parent_frame_index < frame_index)); const D3DXMATRIX* parent_frame_matrix = frame_index == 0 ? root_transform : internal_animation_track[parent_frame_index] .frameMatrix(); D3DXMatrixMultiply(track_element->frameMatrix(), &matrix, parent_frame_matrix); } // Construct the bone transformations for this framte state for (size_t bone_index = 0; bone_index < number_of_bones; ++bone_index) { D3DXMATRIX* bone_matrix = bone_matrices + bone_index; const RenderableAnimatedMesh::Bone* bone = bones + bone_index; const D3DXMATRIXA16* frame_matrix = (internal_animation_track + bone->frame_index)->frameMatrix(); D3DXMatrixMultiply(bone_matrix, &bone->inverse_offset, frame_matrix); } }
void RenderSSAOEffect( bool lightWeight ) { if ( !r_ssao->GetBool() ) return; PostFX_UpdateResources(); r3dSetRestoreFSQuadVDecl setRestoreVDECL; (void)setRestoreVDECL; #if R3D_ALLOW_TEMPORAL_SSAO int doSSAOTemporalOptimize = R3D_SSAO_TEMPORAL_OPTIMIZE == r_ssao_temporal_filter->GetInt() ; if( ++g_SSAO_ResetCount >= r_ssao_temporal_reset_freq->GetInt() ) { g_SSAO_ResetCount = 0 ; doSSAOTemporalOptimize = 0 ; } #else int doSSAOTemporalOptimize = 0 ; #endif const SSAOSettings& sts = g_SSAOSettings[ lightWeight ? SSM_DEFAULT : SSM_HQ ]; int detailEnable = sts.DetailPathEnable ; r3dRenderer->SetVertexShader( "VS_SSAO" ) ; SSAOPShaderId psid ; psid.num_rays = !lightWeight ; psid.optimized = !!r_optimized_ssao->GetInt() ; psid.detail_radius = detailEnable ; #if R3D_ALLOW_TEMPORAL_SSAO psid.temporal_optimisation = doSSAOTemporalOptimize ; psid.temporal_show_passed = g_SSAO_Temporal_Reveal ; psid.output_stability_mask = r_ssao_temporal_filter->GetInt() == R3D_SSAO_TEMPORAL_FILTER ; #endif r3dRenderer->SetPixelShader( gSSAOPSIds[ psid.Id ] ) ; r3dRenderer->SetRenderingMode(R3D_BLEND_NOALPHA | R3D_BLEND_NZ); r3dRenderer->pd3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP ); r3dRenderer->pd3ddev->SetSamplerState( 0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP ); r3dRenderer->pd3ddev->SetSamplerState( 1, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP ); r3dRenderer->pd3ddev->SetSamplerState( 1, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP ); r3dRenderer->pd3ddev->SetSamplerState( 2, D3DSAMP_ADDRESSU, D3DTADDRESS_WRAP ); r3dRenderer->pd3ddev->SetSamplerState( 2, D3DSAMP_ADDRESSV, D3DTADDRESS_WRAP ); float noiseScaleK = r_half_scale_ssao->GetInt() ? 0.5f : 1.0f; D3DXVECTOR4 vconst = D3DXVECTOR4( 0.5f / r3dRenderer->ScreenW, 0.5f / r3dRenderer->ScreenH, r3dRenderer->ScreenW * 0.25f * noiseScaleK, r3dRenderer->ScreenH * 0.25f * noiseScaleK ); r3dRenderer->pd3ddev->SetVertexShaderConstantF( 0, (float *)&vconst, 1 ); // mat proj float fNear = -r3dRenderer->ProjMatrix._43/(r3dRenderer->ProjMatrix._33); float fFar = fNear / ( 1.0f - 1.0f/(r3dRenderer->ProjMatrix._33) ); const int RAYS_START = 7 + 3 + 3 + 3 ; #define SSAO_ALT_DETAIL_NUM_RAYS 24 TL_STATIC_ASSERT( SSAO_ALT_DETAIL_NUM_RAYS > SSAO_ALT_NUM_RAYS ); const int RADIUS_SPLIT = SSAO_ALT_NUM_RAYS; // NOTE: sync with ssao_alt_ps.hls const int NUM_RAYS = lightWeight ? SSAO_LW_NUM_RAYS : ( detailEnable ? SSAO_ALT_DETAIL_NUM_RAYS : SSAO_ALT_NUM_RAYS ); if( !g_PrevSSAO_Valid ) { D3DXMatrixIdentity( &g_PrevSSAO_View ) ; } float aspect = 1.0f ; D3DXVECTOR4 pconsts[ RAYS_START + SSAO_ALT_DETAIL_NUM_RAYS ]; // float4 g_vZScale0_ColorControl : register ( c0 ); pconsts[ 0 ] = D3DXVECTOR4( sts.DepthRange / sts.Radius, 128.0f / sts.Radius, sts.Contrast, sts.Brightness * sts.Contrast - 1.5f * sts.Contrast + 0.5f ); // float4 g_vProjScaleTrans : register ( c1 ); pconsts[ 1 ] = D3DXVECTOR4( 0.5f*r3dRenderer->ProjMatrix._11, -0.5f*r3dRenderer->ProjMatrix._22, 0.5f, 0.5f ); // float4 g_vInvProjScaleTrans : register ( c2 ); pconsts[ 2 ] = D3DXVECTOR4( 2.0f / r3dRenderer->ProjMatrix._11, -2.0f / r3dRenderer->ProjMatrix._22, -1.0f / r3dRenderer->ProjMatrix._11, 1.0f / r3dRenderer->ProjMatrix._22 ); // float4 g_vInvRes_DepthFadeRange : register ( c3 ); pconsts[ 3 ] = D3DXVECTOR4( 1.0f / r3dRenderer->ScreenW, 1.0f / r3dRenderer->ScreenH, 0.985f * fFar, 0.99f * fFar ); // float4 g_vExpandRanges : register ( c4 ); pconsts[ 4 ] = D3DXVECTOR4( sts.RadiusExpandStart, sts.DetailRadiusExpandStart, sts.RadiusExpandCoef, sts.DetailRadiusExpandCoef ); // float4 g_vDetail_Fade_ZScale1 : register ( c5 ); pconsts[ 5 ] = D3DXVECTOR4( sts.DetailStrength, sts.DetailFadeOut * sts.DetailRadius, sts.DetailDepthRange / sts.DetailRadius, 128.0f / sts.DetailRadius ); // float4 g_vTempoCtrl : register ( c6 ); pconsts[ 6 ] = D3DXVECTOR4( 0.00125f * sts.TemporalTolerance, 1.f / 512.f, aspect / 512.f, 0.f ); if( doSSAOTemporalOptimize ) { pconsts[ 6 ].w = r_half_scale_ssao->GetInt() ? 0.5f : 1.0f ; } // float4x3 g_mViewMtx : register ( c7 ); D3DXMatrixTranspose( (D3DXMATRIX*)&pconsts[7], &r3dRenderer->ViewMatrix ); // ^^^^ // NOTE : last row is overwritten below D3DXMATRIX toPrevViewMtx = r3dRenderer->InvViewMatrix * g_PrevSSAO_View ; // float4x3 g_mToPrevViewMtx : register ( c10 ); D3DXMatrixTranspose( (D3DXMATRIX*)&pconsts[10], &toPrevViewMtx ); // ^^^^ // NOTE : last row is overwritten below // float4x3 g_mFromPrevViewMtx : register ( c13 ); D3DXMATRIX fromPrevViewMtx ; D3DXMatrixInverse( &fromPrevViewMtx, NULL, &toPrevViewMtx ) ; D3DXMatrixTranspose( (D3DXMATRIX*)&pconsts[13], &fromPrevViewMtx ); // ^^^^ // NOTE : last row is overwritten below int r = 0; if( !lightWeight ) { pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.18486f, 0.32808f, 0.00708f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.22890f, 0.93380f,-0.09171f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.36097f, 0.18230f,-0.38227f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.06232f, 0.32664f, 0.21049f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.68342f, 0.25225f,-0.06311f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.05478f, 0.09994f, 0.34463f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.01732f, 0.36483f,-0.49192f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.72131f, 0.22451f,-0.09716f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.32283f, 0.33296f, 0.11536f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.27977f, 0.18833f, 0.16797f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.50663f, 0.08494f, 0.63250f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.35578f, 0.11564f, 0.50909f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.54817f, 0.23470f,-0.61668f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.15970f, 0.08904f,-0.66253f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.73055f, 0.08323f, 0.30949f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.68126f, 0.50000f, 0.10878f, 0 ); } if( detailEnable || lightWeight ) { pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.01209f, 0.95443f, 0.11314f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.79393f, 0.23041f, 0.11043f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.77869f, 0.26835f,-0.35691f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.24429f, 0.15942f, 0.46862f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.32674f, 0.51379f,-0.52337f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4( 0.34767f, 0.07975f, 0.67386f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.13244f, 0.06251f,-0.58013f, 0 ); pconsts[ RAYS_START + r++ ] = D3DXVECTOR4(-0.30083f, 0.50000f, 0.09436f, 0 ); } r3d_assert( r == NUM_RAYS ); for( int i = 0, e = RADIUS_SPLIT; i < e; i ++ ) { pconsts[ RAYS_START + i ] *= sts.Radius; } for( int i = RADIUS_SPLIT, e = NUM_RAYS; i < e; i ++ ) { pconsts[ RAYS_START + i ] *= sts.DetailRadius; } if( !r_optimized_ssao->GetInt() ) { for( int i = 0, e = NUM_RAYS; i < e; i ++ ) { D3DXVec4Transform( pconsts + RAYS_START + i, pconsts + RAYS_START + i, &r3dRenderer->ViewMatrix ); } } r3dRenderer->pd3ddev->SetPixelShaderConstantF( 0, (float*)pconsts, RAYS_START + NUM_RAYS ); r3dSetFiltering( R3D_POINT, 0 ); r3dSetFiltering( R3D_POINT, 1 ); r3dSetFiltering( R3D_POINT, 2 ); r3dRenderer->SetMipMapBias( -6, 2 ); extern r3dScreenBuffer* gBuffer_Normal; r3dRenderer->SetTex( DepthBuffer->Tex , 0 ); r3dRenderer->SetTex( gBuffer_Normal->Tex , 1 ); r3dRenderer->SetTex( SSAO_RotTex2D , 2 ); if( doSSAOTemporalOptimize ) { r3dRenderer->pd3ddev->SetSamplerState( 3, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP ); r3dRenderer->pd3ddev->SetSamplerState( 3, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP ); r3dRenderer->pd3ddev->SetSamplerState( 4, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP ); r3dRenderer->pd3ddev->SetSamplerState( 4, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP ); r3dSetFiltering( R3D_BILINEAR, 3 ); r3dSetFiltering( R3D_POINT, 4 ); r3dRenderer->SetTex( PrevDepthBuffer->Tex , 3 ); r3dRenderer->SetTex( PrevSSAOBuffer->Tex , 4 ); } #if R3D_ALLOW_TEMPORAL_SSAO if( r_ssao_temporal_filter->GetInt() == R3D_SSAO_TEMPORAL_FILTER ) r3dRenderer->pd3ddev->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED | D3DCOLORWRITEENABLE_GREEN ); else #endif r3dRenderer->pd3ddev->SetRenderState( D3DRS_COLORWRITEENABLE, D3DCOLORWRITEENABLE_RED ); r3dDrawFullScreenQuad(!!r_half_scale_ssao->GetInt()); r3dRenderer->SetMipMapBias(0, 2); r3dRenderer->SetVertexShader(); r3dRenderer->SetPixelShader(); r3dRenderer->pd3ddev->SetRenderState(D3DRS_COLORWRITEENABLE, 0xffffffff ); }
void DistantLand::renderWaterReflection(const D3DXMATRIX *view, const D3DXMATRIX *proj) { DECLARE_MWBRIDGE // Switch to render target RenderTargetSwitcher rtsw(texReflection, surfReflectionZ); device->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER, horizonCol, 1.0, 0); // Calculate reflected view matrix, mirror plane at water mesh level D3DXMATRIX reflView; D3DXPLANE plane(0, 0, 1.0, -(mwBridge->WaterLevel() - 1.0)); D3DXMatrixReflect(&reflView, &plane); D3DXMatrixMultiply(&reflView, &reflView, view); effect->SetMatrix(ehView, &reflView); // Calculate new projection D3DXMATRIX reflProj = *proj; editProjectionZ(&reflProj, 4.0, Configuration.DL.DrawDist * kCellSize); effect->SetMatrix(ehProj, &reflProj); // Clipping setup D3DXMATRIX clipMat; // Clip geometry on opposite side of water plane plane *= mwBridge->IsUnderwater(eyePos.z) ? -1.0 : 1.0; // If using dynamic ripples, the water level can be lowered by up to 0.5 * waveheight // so move clip plane downwards at the cost of some reflection errors if(Configuration.MGEFlags & DYNAMIC_RIPPLES) plane.d += 0.5 * Configuration.DL.WaterWaveHeight; // Doing inverses separately is a lot more numerically stable D3DXMatrixInverse(&clipMat, 0, &reflView); D3DXMatrixTranspose(&clipMat, &clipMat); D3DXPlaneTransform(&plane, &plane, &clipMat); D3DXMatrixInverse(&clipMat, 0, &reflProj); D3DXMatrixTranspose(&clipMat, &clipMat); D3DXPlaneTransform(&plane, &plane, &clipMat); if(visDistant.size() == 0) { // Workaround for a Direct3D bug with clipping planes, where SetClipPlane // has no effect on the shader pipeline if the last rendered draw call was using // the fixed function pipeline. This is usually covered by distant statics, but // not in compact interiors where all distant statics may be culled. // Provoking a DrawPrimitive with shader here makes the following SetClipPlane work. effect->BeginPass(PASS_WORKAROUND); device->SetVertexDeclaration(WaterDecl); device->SetStreamSource(0, vbFullFrame, 0, 12); device->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2); effect->EndPass(); } device->SetClipPlane(0, plane); device->SetRenderState(D3DRS_CLIPPLANEENABLE, 1); // Rendering if(mwBridge->IsExterior() && (Configuration.MGEFlags & REFLECTIVE_WATER)) { // Draw land reflection, with opposite culling effect->BeginPass(PASS_RENDERLANDREFL); device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); renderDistantLand(effect, &reflView, &reflProj); effect->EndPass(); } if(isDistantCell() && (Configuration.MGEFlags & REFLECT_NEAR)) { // Draw statics reflection, with opposite culling and no dissolve DWORD p = (mwBridge->CellHasWeather() && !mwBridge->IsUnderwater(eyePos.z)) ? PASS_RENDERSTATICSEXTERIOR : PASS_RENDERSTATICSINTERIOR; effect->SetFloat(ehNearViewRange, 0); effect->BeginPass(p); device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); renderReflectedStatics(&reflView, &reflProj); effect->EndPass(); effect->SetFloat(ehNearViewRange, nearViewRange); } if((Configuration.MGEFlags & REFLECT_SKY) && !recordSky.empty() && !mwBridge->IsUnderwater(eyePos.z)) { // Draw sky reflection, with opposite culling effect->BeginPass(PASS_RENDERSKY); device->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW); renderReflectedSky(); effect->EndPass(); } // Restore view state device->SetRenderState(D3DRS_CLIPPLANEENABLE, 0); effect->SetMatrix(ehView, view); effect->SetMatrix(ehProj, proj); }
void CompositeSSAO( r3dScreenBuffer* currSSAO ) { D3DPERF_BeginEvent( 0, L"CompositeSSAO" ) ; const SSAOSettings& sts = g_SSAOSettings[ R3D_MIN( R3D_MAX( r_ssao_method->GetInt(), 0 ), SSM_COUNT - 1 ) ] ; r3dRenderer->SetRenderingMode(R3D_BLEND_NOALPHA); r3dSetRestoreFSQuadVDecl setRestoreVDECL; (void)setRestoreVDECL; float resK ; int HalfScale ; resK = r_half_scale_ssao->GetInt() ? 0.5f : 1.0f ; HalfScale = !!r_half_scale_ssao->GetInt() ; r3dRenderer->SetVertexShader( "VS_SSAO" ) ; r3dRenderer->SetPixelShader( "PS_SSAO_COMPOSITE" ) ; const float HISTORY_DEPTH = sts.TemporalHistoryDepth ; r3dTL::TFixedArray< D3DXVECTOR4, 10 > psConsts ; // float4 gSettings : register ( c0 ) ; psConsts[ 0 ] = D3DXVECTOR4( HISTORY_DEPTH / ( HISTORY_DEPTH + 1.f ), 1.0f / ( HISTORY_DEPTH + 1.f ), 0.f, 0.125f * sts.TemporalTolerance ) ; // float4 g_vProjScaleTrans : register ( c1 ) ; psConsts[ 1 ] = D3DXVECTOR4( 0.5f*r3dRenderer->ProjMatrix._11, -0.5f*r3dRenderer->ProjMatrix._22, 0.5f, 0.5f ); // float4 g_vInvProjScaleTrans : register ( c2 ) ; psConsts[ 2 ] = D3DXVECTOR4( 2.0f / r3dRenderer->ProjMatrix._11, -2.0f / r3dRenderer->ProjMatrix._22, -1.0f / r3dRenderer->ProjMatrix._11, 1.0f / r3dRenderer->ProjMatrix._22 ); // float4x3 g_vToPrevViewMtx : register ( c3 ) ; D3DXMATRIX toPrevViewMtx = r3dRenderer->InvViewMatrix * g_PrevSSAO_View ; D3DXMatrixTranspose( (D3DXMATRIX*)&psConsts[3], &toPrevViewMtx ); // float4x3 g_vFromPrevViewMtx : register ( c6 ) ; D3DXMATRIX fromPrevViewMtx ; D3DXMatrixInverse( &fromPrevViewMtx, NULL, &toPrevViewMtx ) ; D3DXMatrixTranspose( (D3DXMATRIX*)&psConsts[6], &fromPrevViewMtx ); D3D_V( r3dRenderer->pd3ddev->SetPixelShaderConstantF( 0, &psConsts[ 0 ].x, psConsts.COUNT ) ) ; extern r3dScreenBuffer* gBuffer_Depth ; r3dRenderer->SetTex( PrevSSAOBuffer->Tex, 0 ) ; r3dRenderer->SetTex( currSSAO->Tex, 1 ) ; r3dRenderer->SetTex( PrevDepthBuffer->Tex, 2 ) ; r3dRenderer->SetTex( gBuffer_Depth->Tex, 3 ) ; for( int i = 0 ; i < 4 ; i ++ ) { r3dSetFiltering( R3D_BILINEAR, i ) ; D3D_V( r3dRenderer->pd3ddev->SetSamplerState( i, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP ) ); D3D_V( r3dRenderer->pd3ddev->SetSamplerState( i, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP ) ); } D3DXVECTOR4 vconst = D3DXVECTOR4( 0.5f / r3dRenderer->ScreenW, 0.5f / r3dRenderer->ScreenH, resK, resK ) ; r3dRenderer->pd3ddev->SetVertexShaderConstantF( 0, (float *)&vconst, 1 ) ; r3dDrawFullScreenQuad( !!HalfScale ) ; D3DPERF_EndEvent() ; }
bool RefractionShaderClass::SetShaderParameters(ID3D11DeviceContext* context, D3DXMATRIX world, D3DXMATRIX view, D3DXMATRIX proj, ID3D11ShaderResourceView* tex, D3DXVECTOR3 lightdir, D3DXVECTOR4 ambient, D3DXVECTOR4 diffuse, D3DXVECTOR4 clipplane) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; unsigned int bufferNum; MatrixBufferType* dataPtr; LightBufferType* dataPtr2; ClipPlaneBufferType* dataPtr3; D3DXMatrixTranspose(&world, &world); D3DXMatrixTranspose(&view, &view); D3DXMatrixTranspose(&proj, &proj); result = context->Map(_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { return false; } dataPtr = (MatrixBufferType*)mappedResource.pData; dataPtr->world = world; dataPtr->view = view; dataPtr->proj = proj; context->Unmap(_matrixBuffer, 0); bufferNum = 0; context->VSSetConstantBuffers(bufferNum, 1, &_matrixBuffer); context->PSSetShaderResources(0, 1, &tex); result = context->Map(_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { return false; } dataPtr2 = (LightBufferType*)mappedResource.pData; dataPtr2->ambientColor = ambient; dataPtr2->diffuse = diffuse; dataPtr2->lightdir = lightdir; context->Unmap(_lightBuffer, 0); bufferNum = 1; context->PSSetConstantBuffers(bufferNum, 1, &_lightBuffer); result = context->Map(_clipPlaneBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { return false; } dataPtr3 = (ClipPlaneBufferType*)mappedResource.pData; dataPtr3->clipPlane = clipplane; context->Unmap(_clipPlaneBuffer, 0); bufferNum = 2; context->VSSetConstantBuffers(bufferNum, 1, &_clipPlaneBuffer); return true; }
bool CLightShader::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX wMatrix, D3DXMATRIX vMatrix, D3DXMATRIX pMatrix, ID3D11ShaderResourceView* texture, D3DXVECTOR3 lightDirection, D3DXVECTOR4 ambientColor, D3DXVECTOR4 diffuseColor, D3DXVECTOR3 cameraPosition, D3DXVECTOR4 specularColor, float specularPower) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; unsigned int bufferNumber; MatrixBufferType* matrixData; LightBufferType* lightData; CameraBufferType* cameraData; D3DXMatrixTranspose(&wMatrix, &wMatrix); D3DXMatrixTranspose(&vMatrix, &vMatrix); D3DXMatrixTranspose(&pMatrix, &pMatrix); // Lock the taskba- constant buffer result = deviceContext->Map(matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { CLog::Write("CLightShader::SetShaderParameters() : could not lock the matrix buffer"); return false; } matrixData = (MatrixBufferType*)mappedResource.pData; // copy the matrices in the constant buffer matrixData->world = wMatrix; matrixData->view = vMatrix; matrixData->projection = pMatrix; // Unlock the taskba- constant buffer deviceContext->Unmap(matrixBuffer, 0); bufferNumber = 0; deviceContext->VSSetConstantBuffers(bufferNumber, 1, &matrixBuffer); result = deviceContext->Map(cameraBuffer, 0,D3D11_MAP_WRITE_DISCARD ,0, &mappedResource); if (FAILED(result)) { CLog::Write("CLightShader::SetShaderParameters() : could not lock the camera buffer"); return false; } cameraData = (CameraBufferType*)mappedResource.pData; cameraData->cameraPosition = cameraPosition; cameraData->padding = 0.0f; deviceContext->Unmap(cameraBuffer, 0); bufferNumber = 1; deviceContext->VSSetConstantBuffers(bufferNumber, 1, &cameraBuffer); deviceContext->PSSetShaderResources(0, 1, &texture); // Lock the taskba- light constant buffer (ok i'll stop) result = deviceContext->Map(lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { CLog::Write("CLightShader::SetShaderParameters() : could not lock the light buffer"); return false; } lightData = (LightBufferType*)mappedResource.pData; lightData->ambientColor = ambientColor; lightData->diffuseColor = diffuseColor; lightData->lightDirection = lightDirection; lightData->specularColor = specularColor; lightData->specularPower = specularPower; // Unlock the taskba- light constant buffer (I lied) deviceContext->Unmap(lightBuffer, 0); // Just in case VSSetConstantBuffers did some stupid stuff bufferNumber = 0; deviceContext->PSSetConstantBuffers(bufferNumber, 1, &lightBuffer); return true; }
void CObject3D::_renderSkin(const GMObject& obj, const D3DXMATRIX* world, int alpha) { D3DXMATRIX* bones, *invBones; D3DXMATRIX mat; int i, nID, j; if (m_externBones) { bones = m_externBones; invBones = m_externInvBones; } else { bones = m_baseBones; invBones = m_baseInvBones; } if (obj.usedBoneCount) { for (i = 0; i < obj.usedBoneCount; i++) { nID = obj.usedBones[i]; mat = invBones[nID] * bones[nID]; D3DXMatrixTranspose(&mat, &mat); m_device->SetVertexShaderConstantF(i * 3, (float*)&mat, 3); } } m_device->SetVertexDeclaration(s_skinVertexDeclaration); m_device->SetVertexShader(s_skinVS); m_device->SetStreamSource(0, obj.VB, 0, sizeof(SkinVertex)); m_device->SetIndices(obj.IB); m_device->SetTransform(D3DTS_WORLD, world); for (i = 0; i < obj.materialBlockCount; i++) { const MaterialBlock& block = obj.materialBlocks[i]; if (block.usedBoneCount) { for (j = 0; j < block.usedBoneCount; j++) { nID = block.usedBones[j]; mat = invBones[nID] * bones[nID]; D3DXMatrixTranspose(&mat, &mat); m_device->SetVertexShaderConstantF(j * 3, (float*)&mat, 3); } } _setState(block, alpha); if (obj.material) { const CTexture* texture = obj.materials[block.materialID].textures[m_group->currentTextureEx]; if (texture) m_device->SetTexture(0, *texture); else m_device->SetTexture(0, null); } else m_device->SetTexture(0, null); m_device->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, obj.vertexCount, block.startVertex, block.primitiveCount); _resetState(block, alpha); } m_device->SetVertexShader(null); m_device->SetVertexDeclaration(null); }
bool LightShaderClass::setShaderParameters( ID3D11DeviceContext *aD3DDeviceContext, D3DXMATRIX aWorldMatrix, D3DXMATRIX aViewMatrix, D3DXMATRIX aProjectionMatrix, ID3D11ShaderResourceView *aShaderResourceView, D3DXVECTOR3 aLightDirection, D3DXVECTOR4 aAmbientColor, D3DXVECTOR4 aDiffuseColor ) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; unsigned int bufferNumber; MatrixBufferType* dataPtr; LightBufferType* dataPtr2; D3DXMatrixTranspose(&aWorldMatrix, &aWorldMatrix); D3DXMatrixTranspose(&aViewMatrix, &aViewMatrix); D3DXMatrixTranspose(&aProjectionMatrix, &aProjectionMatrix); result = aD3DDeviceContext->Map( m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } dataPtr = (MatrixBufferType*)mappedResource.pData; dataPtr->world = aWorldMatrix; dataPtr->view = aViewMatrix; dataPtr->projection = aProjectionMatrix; aD3DDeviceContext->Unmap(m_matrixBuffer, 0); bufferNumber = 0; aD3DDeviceContext->VSSetConstantBuffers( bufferNumber, 1, &m_matrixBuffer); aD3DDeviceContext->PSSetShaderResources( 0, 1, &aShaderResourceView); result = aD3DDeviceContext->Map( m_lightBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } dataPtr2 = (LightBufferType*)mappedResource.pData; dataPtr2->ambientColor = aAmbientColor; dataPtr2->diffuseColor = aDiffuseColor; dataPtr2->lightDirection = aLightDirection; dataPtr2->padding = 0.0f; aD3DDeviceContext->Unmap(m_lightBuffer, 0); bufferNumber = 0; aD3DDeviceContext->PSSetConstantBuffers( bufferNumber, 1, &m_lightBuffer); return true; }
bool CloudsShader::SetShaderParameters(ID3D11DeviceContext* deviceContext, int indexCount, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* cloudTexture1, ID3D11ShaderResourceView* cloudTexture2, ID3D11ShaderResourceView* perturbTexture, D3DXVECTOR2 translation, D3DXVECTOR2 scale, D3DXVECTOR2 brightness) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; MatrixBufferType* dataPtr; SkyBufferType* dataPtr2; unsigned int bufferNumber; // Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); // Lock the constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; // Unlock the constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the constant buffer in the vertex shader. bufferNumber = 0; // Finally set the constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); // Lock the sky constant buffer so it can be written to. result = deviceContext->Map(m_skyBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if(FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr2 = (SkyBufferType*)mappedResource.pData; // Copy the sky variables into the constant buffer. dataPtr2->translation = translation; dataPtr2->scale = scale; dataPtr2->brightness = brightness; dataPtr2->padding = D3DXVECTOR2(0.0f, 0.0f); // Unlock the constant buffer. deviceContext->Unmap(m_skyBuffer, 0); // Set the position of the sky constant buffer in the pixel shader. bufferNumber = 0; // Finally set the sky constant buffer in the pixel shader with the updated values. deviceContext->PSSetConstantBuffers(bufferNumber, 1, &m_skyBuffer); // Set the shader texture resource in the pixel shader. deviceContext->PSSetShaderResources(0, 1, &cloudTexture1); deviceContext->PSSetShaderResources(1, 1, &cloudTexture2); deviceContext->PSSetShaderResources(2, 1, &perturbTexture); return true; }
void r3dLight :: SetShaderConstants(r3dCamera &Cam) { const int MAX_CONSTANTS = 10; const int COLOR_INDEX = 1; D3DXVECTOR4 vColor; vColor = D3DXVECTOR4( (R/255.0f), (G/255.0f), (B/255.0f), 1 ); vColor.x = powf( vColor.x, 2.2f ) ; vColor.y = powf( vColor.y, 2.2f ) ; vColor.z = powf( vColor.z, 2.2f ) ; vColor = vColor * Intensity; // Common params D3DXVECTOR4 vConsts[ MAX_CONSTANTS ] = { D3DXVECTOR4( Cam.X, Cam.Y, Cam.Z, 0 ), D3DXVECTOR4( vColor ) }; int NUM_CONSTANTS = 2; float invFadeDistance = 1.0f / (GetOuterRadius() - GetInnerRadius()); switch (Type) { case R3D_DIRECT_LIGHT: { r3dColor Amb = r3dRenderer->AmbientColor; r3d_assert( NUM_CONSTANTS == 2 ); // float4 vAmbientColor : register(c2); D3DXVECTOR4 amb ( Amb.R/255.0f, Amb.G/255.0f, Amb.B/255.0f, 1.0f ) ; amb.x = powf( amb.x, 2.2f ) ; amb.y = powf( amb.y, 2.2f ) ; amb.z = powf( amb.z, 2.2f ) ; vConsts[ NUM_CONSTANTS ++ ] = amb ; } break; case R3D_OMNI_LIGHT: { r3d_assert( NUM_CONSTANTS == 2 ); // float4 vLightPos: register(c2); vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4( X, Y, Z, 0 ); // float4 vLightDistanceParams: register(c3); vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4(invFadeDistance, GetInnerRadius() * invFadeDistance, 0, 0); } break; case R3D_SPOT_LIGHT: { Direction.Normalize(); float spotAngleOuter = SpotAngleOuter; float spotAngleInner = R3D_MIN( SpotAngleInner, SpotAngleOuter - 0.33f ); float cosInner = cosf( R3D_DEG2RAD( spotAngleInner ) ); float cosOuter = cosf ( R3D_DEG2RAD( spotAngleOuter ) ); float fallofX = 1.f / ( cosInner - cosOuter ); float fallofY = - cosOuter * fallofX; r3d_assert( NUM_CONSTANTS == 2 ); // float4 vLightPos_RcpRad : register(c2); vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4( X, Y, Z, 0 ); // float3 vLightDir : register(c3); vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4( Direction.x, Direction.y, Direction.z, 0 ); // float4 vLightFalloff : register(c4); vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4( fallofX, fallofY, SpotAngleFalloffPow, 0 ); // float4 vLightDistanceParams : register(c5); vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4(invFadeDistance, GetInnerRadius() * invFadeDistance, 0, 0);; } break; case R3D_TUBE_LIGHT: { r3d_assert( NUM_CONSTANTS == 2 ); // float4 vLightDistanceParams: register(c2); vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4( 0.5f * 0.03125f * Radius2 * Radius2 * Radius2 * Radius2 / Length , 0.5f * Length , 0, 0 ); // float4x3 mLightMtx : register(c3); D3DXMATRIX lightMtx ; GetTubeLightMatrix( &lightMtx ) ; D3DXMatrixTranspose( &lightMtx, &lightMtx ) ; vConsts[ NUM_CONSTANTS ++ ] = *(D3DXVECTOR4*)lightMtx.m[0] ; vConsts[ NUM_CONSTANTS ++ ] = *(D3DXVECTOR4*)lightMtx.m[1] ; vConsts[ NUM_CONSTANTS ++ ] = *(D3DXVECTOR4*)lightMtx.m[2] ; vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4( X, Y, Z, 1 ) ; } break ; case R3D_PLANE_LIGHT: { r3d_assert( NUM_CONSTANTS == 2 ); // float4 vLightDistanceParams: register(c2); vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4( -1.f / Radius2 , 1.f, 0.5f * Length, 0.5f * Width ); // float4x3 mLightMtx : register(c3); D3DXMATRIX lightMtx ; GetTubeLightMatrix( &lightMtx ) ; D3DXMatrixTranspose( &lightMtx, &lightMtx ) ; vConsts[ NUM_CONSTANTS ++ ] = *(D3DXVECTOR4*)lightMtx.m[0] ; vConsts[ NUM_CONSTANTS ++ ] = *(D3DXVECTOR4*)lightMtx.m[1] ; vConsts[ NUM_CONSTANTS ++ ] = *(D3DXVECTOR4*)lightMtx.m[2] ; vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4( X, Y, Z, 1 ) ; vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4( bDoubleSided ? 0.f : FLT_MAX, 0.f, 0.f, 0.f ); vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4( 0.f, 0.f, 0.f, 0.f ); } break ; case R3D_VOLUME_LIGHT: { vConsts[COLOR_INDEX] = D3DXVECTOR4( (R/255.0f), (G/255.0f), (B/255.0f), Intensity ); r3d_assert( NUM_CONSTANTS == 2 ); float DepthZ = r3dRenderer->FarClip * 0.9375f; // float4 vLightPos: register(c2); vConsts[ NUM_CONSTANTS ++ ] = D3DXVECTOR4( X, Y, Z, 1.0f / DepthZ ); } break; case R3D_PROJECTOR_LIGHT: r3d_assert( false && "not implemented" ); #if 0 LightVec = D3DXVECTOR4(X,Y,Z,0); r3dRenderer->pd3ddev->SetVertexShaderConstantF( 15, (float *)&LightVec, 1 ); r3dRenderer->pd3ddev->SetPixelShaderConstantF( 4, (float *)&LightVec, 1 ); Direction.Normalize(); LightVec = D3DXVECTOR4(Direction.X,Direction.Y,Direction.Z,0); r3dVector vTo = r3dPoint3D(X,Y,Z) + Direction *100.0f; r3dRenderer->pd3ddev->SetPixelShaderConstantF( 5, (float *)&LightVec, 1 ); r3dRenderer->pd3ddev->SetVertexShaderConstantF( 16, (float *)&LightVec, 1 ); r3dRenderer->SetTex(ProjectMap,3); r3dRenderer->pd3ddev->SetSamplerState( 3, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP ); r3dRenderer->pd3ddev->SetSamplerState( 3, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP ); SetupProjectiveTransform(D3DXVECTOR3(X,Y,Z),D3DXVECTOR3(vTo.x,vTo.y, vTo.Z), SpotAngle); break; #endif } r3d_assert( NUM_CONSTANTS < MAX_CONSTANTS ); r3dRenderer->pd3ddev->SetPixelShaderConstantF( 0, (float *)vConsts, NUM_CONSTANTS ); }
void Viewer::onRender() { static char s[40]; // clear the vertex and face counters m_vertexCount = 0; m_faceCount = 0; // clear all the buffers g_pD3DDevice->Clear( 0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB(0,0,77), 1.0f, 0 ); // Setup Prespective matrix g_pD3DDevice->BeginScene(); D3DXMATRIX matProj,matWorld,matView, matViewInv; D3DXMatrixPerspectiveFovRH( &matProj, D3DX_PI/4, (float)m_width / (float)m_height, m_scale * 50.0f, m_scale * 1000.0f ); g_pD3DDevice->SetTransform( D3DTS_PROJECTION, &matProj ); D3DXMATRIX Mat1,Mat2; // tmp matrix D3DXMatrixIdentity(&Mat1); D3DXMatrixTranslation(&Mat2,0.0f,0.0f,-m_distance * m_scale); D3DXMatrixMultiply(&Mat1,&Mat2,&Mat1); D3DXMatrixRotationX(&Mat2, m_tiltAngle/180.0f*3.14159f); D3DXMatrixMultiply(&Mat1,&Mat2,&Mat1); D3DXMatrixRotationZ(&Mat2, m_twistAngle/180.0f*3.14159f); D3DXMatrixMultiply(&Mat1,&Mat2,&Mat1); D3DXMatrixTranslation(&Mat2,0.0f,0.0f,-90.0f * m_scale); //I have done à 1/1 translation D3DXMatrixMultiply(&matView,&Mat2,&Mat1); //of the OpenGL version g_pD3DDevice->SetTransform( D3DTS_VIEW, &matView ); D3DXMatrixIdentity(&matWorld); g_pD3DDevice->SetTransform( D3DTS_WORLD, &matWorld ); // setup the light attributes D3DLIGHT9 light; ZeroMemory( &light, sizeof(D3DLIGHT9) ); light.Type = D3DLIGHT_DIRECTIONAL; light.Ambient.r=0.2f;light.Ambient.g=0.2f;light.Ambient.b=0.2f;light.Ambient.a=1.0f; light.Diffuse.r=1.0f;light.Diffuse.g=1.0f;light.Diffuse.b=1.0f;light.Diffuse.a=1.0f; light.Specular.r=0.1f;light.Specular.g=0.1f;light.Specular.b=0.1f;light.Specular.a=1.0f; //light.Direction= D3DXVECTOR3(0.0f,0.70f,0.70f); light.Direction= D3DXVECTOR3(sinf(Tick::getTick()/1000.0f),cosf(Tick::getTick()/1000.0f),-0.5f); float r=light.Direction.x*light.Direction.x +light.Direction.y*light.Direction.y +light.Direction.z*light.Direction.z; light.Direction.x/=r; light.Direction.y/=r; light.Direction.z/=r; g_pD3DDevice->SetLight( 0, &light ); g_pD3DDevice->LightEnable( 0, TRUE ); g_pD3DDevice->SetRenderState( D3DRS_LIGHTING, TRUE ); if(m_bBump) { g_pD3DDevice->SetVertexShaderConstantF(13, (float*)&light.Diffuse, 1 ); g_pD3DDevice->SetVertexShaderConstantF(14, (float*)&light.Specular, 1 ); g_pD3DDevice->SetVertexShaderConstantF(15, (float*)&light.Ambient, 1 ); g_pD3DDevice->SetVertexShaderConstantF(16, (float*)&(-((D3DXVECTOR3)light.Direction)), 1 ); D3DXMatrixTranspose( &Mat1, &matWorld ); g_pD3DDevice->SetVertexShaderConstantF( 0, (float*)&Mat1, 4 ); D3DXMatrixMultiply( &Mat1, &matView, &matProj ); D3DXMatrixMultiply( &Mat1, &matWorld, &Mat1 ); D3DXMatrixTranspose( &Mat1, &Mat1 ); g_pD3DDevice->SetVertexShaderConstantF( 4, (float*)&Mat1, 4 ); float Const[4] = {0.5f,0.5f,0.5f,0.5f}; g_pD3DDevice->SetVertexShaderConstantF( 20,Const, 1 ); } // render the model renderModel(); g_pD3DDevice->SetRenderState( D3DRS_LIGHTING, FALSE ); // render the cursor renderCursor(); RECT FontPosition; FontPosition.top = 0; FontPosition.left = 0; FontPosition.right = m_width; FontPosition.bottom = 100; sprintf(s,"%d fps, press 'b' to toggle bump mapping",m_fps); // // There are changes here between Direct3D SDK 9 and Direct3D SDK 9 summer 2003 update // /* Original SDK m_pFont->Begin(); m_pFont->DrawText(s,-1,&FontPosition,DT_CENTER,0xffffffff); m_pFont->End(); */ ///* Update m_pFont->DrawText(NULL,s,-1,&FontPosition,DT_CENTER,0xffffffff); //*/ g_pD3DDevice->EndScene(); // swap the front- and back-buffer g_pD3DDevice->Present( NULL, NULL, NULL, NULL ); // increase frame counter m_fpsFrames++; }
/** Draws the surrounding scene into the cubemap */ void D3D11PointLight::RenderCubemap(bool forceUpdate) { if(!InitDone) return; //if(!GetAsyncKeyState('X')) // return; D3D11GraphicsEngineBase* engineBase = (D3D11GraphicsEngineBase *)Engine::GraphicsEngine; D3D11GraphicsEngine* engine = (D3D11GraphicsEngine *) engineBase; // TODO: Remove and use newer system! D3DXVECTOR3 vEyePt = LightInfo->Vob->GetPositionWorld(); //vEyePt += D3DXVECTOR3(0,1,0) * 20.0f; // Move lightsource out of the ground or other objects (torches!) // TODO: Move the actual lightsource up too! /*if(WantsUpdate()) { // Move lights with colorchanges around a bit to make it look more light torches vEyePt.y += (float4(LastUpdateColor).x - 0.5f) * LIGHT_COLORCHANGE_POS_MOD; vEyePt.x += (float4(LastUpdateColor).y - 0.5f) * LIGHT_COLORCHANGE_POS_MOD; vEyePt.z += (float4(LastUpdateColor).y - 0.5f) * LIGHT_COLORCHANGE_POS_MOD; }*/ D3DXVECTOR3 vLookDir; D3DXVECTOR3 vUpDir; if(!NeedsUpdate() && !WantsUpdate()) { if(!forceUpdate) return; // Don't update when we don't need to }else { if(LightInfo->Vob->GetPositionWorld() != LastUpdatePosition) { // Position changed, refresh our caches VobCache.clear(); SkeletalVobCache.clear(); // Invalidate worldcache WorldCacheInvalid = true; } } // Update indoor/outdoor-state LightInfo->IsIndoorVob = LightInfo->Vob->IsIndoorVob(); D3DXMATRIX proj; const bool dbg = false; // Generate cubemap view-matrices vLookDir = D3DXVECTOR3( 1.0f, 0.0f, 0.0f ) + vEyePt; vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f ); if(dbg)Engine::GraphicsEngine->GetLineRenderer()->AddLine(LineVertex(vEyePt, float4(1.0f,0,0,1)), LineVertex((vLookDir - vEyePt) * 50.0f + vEyePt, float4(1.0f,1.0f,0,1))); D3DXMatrixLookAtLH( &CubeMapViewMatrices[0], &vEyePt, &vLookDir, &vUpDir ); vLookDir = D3DXVECTOR3( -1.0f, 0.0f, 0.0f ) + vEyePt; vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f ); if(dbg)Engine::GraphicsEngine->GetLineRenderer()->AddLine(LineVertex(vEyePt, float4(1.0f,0,0,1)), LineVertex((vLookDir - vEyePt) * 50.0f + vEyePt, float4(1.0f,1.0f,0,1))); D3DXMatrixLookAtLH( &CubeMapViewMatrices[1], &vEyePt, &vLookDir, &vUpDir ); vLookDir = D3DXVECTOR3( 0.0f, 0.0f + 1.0f, 0.0f ) + vEyePt; vUpDir = D3DXVECTOR3( 0.0f, 0.0f, -1.0f ); if(dbg)Engine::GraphicsEngine->GetLineRenderer()->AddLine(LineVertex(vEyePt, float4(1.0f,0,0,1)), LineVertex((vLookDir - vEyePt) * 50.0f + vEyePt, float4(1.0f,1.0f,0,1))); D3DXMatrixLookAtLH( &CubeMapViewMatrices[2], &vEyePt, &vLookDir, &vUpDir ); vLookDir = D3DXVECTOR3( 0.0f, 0.0f - 1.0f, 0.0f ) + vEyePt; vUpDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f ); if(dbg)Engine::GraphicsEngine->GetLineRenderer()->AddLine(LineVertex(vEyePt, float4(1.0f,0,0,1)), LineVertex((vLookDir - vEyePt) * 50.0f + vEyePt, float4(1.0f,1.0f,0,1))); D3DXMatrixLookAtLH( &CubeMapViewMatrices[3], &vEyePt, &vLookDir, &vUpDir ); vLookDir = D3DXVECTOR3( 0.0f, 0.0f, 1.0f ) + vEyePt; vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f ); if(dbg)Engine::GraphicsEngine->GetLineRenderer()->AddLine(LineVertex(vEyePt, float4(1.0f,0,0,1)), LineVertex((vLookDir - vEyePt) * 50.0f + vEyePt, float4(1.0f,1.0f,0,1))); D3DXMatrixLookAtLH( &CubeMapViewMatrices[4], &vEyePt, &vLookDir, &vUpDir ); vLookDir = D3DXVECTOR3( 0.0f, 0.0f, -1.0f ) + vEyePt; vUpDir = D3DXVECTOR3( 0.0f, 1.0f, 0.0f ); if(dbg)Engine::GraphicsEngine->GetLineRenderer()->AddLine(LineVertex(vEyePt, float4(1.0f,0,0,1)), LineVertex((vLookDir - vEyePt) * 50.0f + vEyePt, float4(1.0f,1.0f,0,1))); D3DXMatrixLookAtLH( &CubeMapViewMatrices[5], &vEyePt, &vLookDir, &vUpDir ); for(int i=0;i<6;i++) D3DXMatrixTranspose(&CubeMapViewMatrices[i], &CubeMapViewMatrices[i]); // Create the projection matrix float zNear = 15.0f; float zFar = LightInfo->Vob->GetLightRange() * 2.0f; D3DXMatrixPerspectiveFovLH( &proj, ((float)D3DX_PI * 0.5f), 1.0f, zNear, zFar ); D3DXMatrixTranspose(&proj, &proj); // Setup near/far-planes. We need linear viewspace depth for the cubic shadowmaps. Engine::GAPI->GetRendererState()->GraphicsState.FF_zNear = zNear; Engine::GAPI->GetRendererState()->GraphicsState.FF_zFar = zFar; Engine::GAPI->GetRendererState()->GraphicsState.SetGraphicsSwitch(GSWITCH_LINEAR_DEPTH, true); bool oldDepthClip = Engine::GAPI->GetRendererState()->RasterizerState.DepthClipEnable; Engine::GAPI->GetRendererState()->RasterizerState.DepthClipEnable = true; // Upload view-matrices to the GPU CubemapGSConstantBuffer gcb; for(int i=0;i<6;i++) { gcb.PCR_View[i] = CubeMapViewMatrices[i]; gcb.PCR_ViewProj[i] = proj * CubeMapViewMatrices[i]; } ViewMatricesCB->UpdateBuffer(&gcb); ViewMatricesCB->BindToGeometryShader(2); //for(int i=0;i<6;i++) // RenderCubemapFace(CubeMapViewMatrices[i], proj, i); RenderFullCubemap(); if(dbg) { for(auto it = VobCache.begin();it!=VobCache.end();it++) Engine::GraphicsEngine->GetLineRenderer()->AddLine(LineVertex(vEyePt, float4(1.0f,0,0,1)), LineVertex((*it)->Vob->GetPositionWorld(), float4(1.0f,1.0f,0,1))); } Engine::GAPI->GetRendererState()->RasterizerState.DepthClipEnable = oldDepthClip; Engine::GAPI->GetRendererState()->GraphicsState.SetGraphicsSwitch(GSWITCH_LINEAR_DEPTH, false); LastUpdateColor = LightInfo->Vob->GetLightColor(); LastUpdatePosition = vEyePt; DrawnOnce = true; }
void sdk_mesh::render(ID3D11DeviceContext* context, D3DXMATRIX* to_clip) { D3D11_PRIMITIVE_TOPOLOGY PrimType = D3D11_PRIMITIVE_TOPOLOGY_UNDEFINED; assert(context); context->IASetInputLayout(vertex_layout_); context->VSSetShader(vs_, nullptr, 0); context->GSSetShader(nullptr, nullptr, 0); context->PSSetShader(ps_, nullptr, 0); //context->PSSetSamplers(0, 1, &ss_); context->OMSetBlendState(nullptr, nullptr, 0xFF); auto cbvs = cb_mesh_data_vs_.map(context); { D3DXMatrixTranspose(&cbvs->world, &world); } cb_mesh_data_vs_.unmap_vs(1); #define MAX_D3D11_VERTEX_STREAMS D3D11_IA_VERTEX_INPUT_RESOURCE_SLOT_COUNT if(sdk_mesh_->GetOutstandingBufferResources()) return; //sdk_mesh_->RenderMesh(0, false, context, diffuse_tex_slot_, normal_tex_slot_, specular_tex_slot_); for(UINT m = 0; m < sdk_mesh_->GetNumMeshes(); m++) { SDKMESH_MESH* mesh = sdk_mesh_->GetMesh(m); UINT strides[MAX_D3D11_VERTEX_STREAMS]; UINT offsets[MAX_D3D11_VERTEX_STREAMS]; ID3D11Buffer* vb[MAX_D3D11_VERTEX_STREAMS]; if(mesh->NumVertexBuffers > MAX_D3D11_VERTEX_STREAMS) return; for(UINT i = 0; i < mesh->NumVertexBuffers; ++i) { vb[i] = sdk_mesh_->GetVB11(m, i); strides[i] = sdk_mesh_->GetVertexStride(m, i); offsets[i] = 0; } ID3D11Buffer* index_buffer = sdk_mesh_->GetIB11(m); DXGI_FORMAT format = sdk_mesh_->GetIBFormat11(m); context->IASetVertexBuffers(0, mesh->NumVertexBuffers, vb, strides, offsets); context->IASetIndexBuffer(index_buffer, format, 0); for(UINT s = 0; s < mesh->NumSubsets; s++) { SDKMESH_SUBSET* subset = sdk_mesh_->GetSubset(m, s); auto pt = sdk_mesh_->GetPrimitiveType11(static_cast<SDKMESH_PRIMITIVE_TYPE>(subset->PrimitiveType)); context->IASetPrimitiveTopology(pt); SDKMESH_MATERIAL* material = sdk_mesh_->GetMaterial(subset->MaterialID); auto cb = cb_mesh_data_ps_.map(context); { cb->diffuse_color = material->Diffuse; cb->has_diffuse_tex = material->pDiffuseRV11 != nullptr && diffuse_tex_slot_ != -1 && !IsErrorResource(material->pDiffuseRV11); cb->has_normal_tex = material->pNormalRV11 != nullptr && normal_tex_slot_ != -1 && !IsErrorResource(material->pNormalRV11); cb->has_specular_tex = material->pSpecularRV11 != nullptr && specular_tex_slot_ != -1 && !IsErrorResource(material->pSpecularRV11); cb->has_alpha_tex = false; } cb_mesh_data_ps_.unmap_ps(0); if (cb->has_diffuse_tex) context->PSSetShaderResources(diffuse_tex_slot_, 1, &material->pDiffuseRV11); if (cb->has_normal_tex) context->PSSetShaderResources(normal_tex_slot_, 1, &material->pNormalRV11); if (cb->has_specular_tex) context->PSSetShaderResources(specular_tex_slot_, 1, &material->pSpecularRV11); UINT index_count = static_cast<UINT>(subset->IndexCount); UINT index_start = static_cast<UINT>(subset->IndexStart); UINT vertex_start = static_cast<UINT>(subset->VertexStart); context->DrawIndexed(index_count, index_start, vertex_start); } } }
//Set Shader Parameters Function bool CParticleShader::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* textures[4], vector<CLight*> lightList, CCamera* mainCamera) { //Define Variables HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; MatrixBufferType* dataPtr; CameraBufferType* dataPtr1; unsigned int bufferNumber; //Transpose Matrices for Shader D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); ////////////////////////////////////////////////// //Vertex Shader Code Below //Lock Constant Buffer result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { return false; } //Get Pointer to Constant Buffer Data dataPtr = (MatrixBufferType*)mappedResource.pData; //Copy Matrices into Constant Buffer dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; //Unlock Constant Buffer deviceContext->Unmap(m_matrixBuffer, 0); //Set Position of Constant Buffer in Vertex Shader bufferNumber = 0; //Set Constant Buffer with Updated Values deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); //Lock Camera Constant Buffer result = deviceContext->Map(m_cameraBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { return false; } //Get Pointer to data in Constant Buffer dataPtr1 = (CameraBufferType*)mappedResource.pData; dataPtr1->cameraPosition = mainCamera->GetPosition(); dataPtr1->padding = 0.0f; //Unlock Constant Buffer deviceContext->Unmap(m_cameraBuffer, 0); //Increase Buffer number bufferNumber++; //Set Camera Constant Buffer in Vertex Shader deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_cameraBuffer); /////////////////////////////////////////////////// //Geometry Shader Code Below ////////////////////////////////////////////////// ////////////////////////////////////////////////// //Pixel Shader Code Below: // Set shader texture resource in the pixel shader. deviceContext->PSSetShaderResources(0, 4, textures); //Set position of Constant Buffers in Pixel Shader bufferNumber = 0; //Set the Light Constant Buffer in the Pixel Shader with the updated Values deviceContext->PSSetConstantBuffers(bufferNumber, 0, &m_matrixBuffer); ////////////////////////////////////////////////// return true; }
bool VerticalBlurShaderClass::SetShaderParameters(ID3D11DeviceContext* deviceContext, D3DXMATRIX worldMatrix, D3DXMATRIX viewMatrix, D3DXMATRIX projectionMatrix, ID3D11ShaderResourceView* texture, float screenHeight) { HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; MatrixBufferType* dataPtr; unsigned int bufferNumber; ScreenSizeBufferType* dataPtr2; // Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); // Lock the matrix constant buffer so it can be written to. result = deviceContext->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr = (MatrixBufferType*)mappedResource.pData; // Copy the matrices into the constant buffer. dataPtr->world = worldMatrix; dataPtr->view = viewMatrix; dataPtr->projection = projectionMatrix; // Unlock the constant buffer. deviceContext->Unmap(m_matrixBuffer, 0); // Set the position of the constant buffer in the vertex shader. bufferNumber = 0; // Now set the constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_matrixBuffer); // Lock the screen size constant buffer so it can be written to. result = deviceContext->Map(m_screenSizeBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) { return false; } // Get a pointer to the data in the constant buffer. dataPtr2 = (ScreenSizeBufferType*)mappedResource.pData; // Copy the data into the constant buffer. dataPtr2->screenHeight = screenHeight; dataPtr2->padding = D3DXVECTOR3(0.0f, 0.0f, 0.0f); // Unlock the constant buffer. deviceContext->Unmap(m_screenSizeBuffer, 0); // Set the position of the constant buffer in the vertex shader. bufferNumber = 1; // Now set the constant buffer in the vertex shader with the updated values. deviceContext->VSSetConstantBuffers(bufferNumber, 1, &m_screenSizeBuffer); // Set shader texture resource in the pixel shader. deviceContext->PSSetShaderResources(0, 1, &texture); return true; }
/* * \brief Render the gizmo */ void CGizmo::Render( D3DXMATRIX worldMatrix, //!< D3DXMATRIX viewMatrix, //!< D3DXMATRIX projectionMatrix, //!< CCamera *camera ) { m_gizmoMesh->PrepareRender(m_renderer); // move to the position, but offset the y coordinate by one, to compensate for it been drawn around 0, 0, 0 local space IBrush *const brush = m_brush[m_currentBrush]; D3DXMATRIX xformmat, scalemat; D3DXMatrixTranslation(&xformmat, m_position.x, m_position.y < 2.0f ? 2.0f : m_position.y + 2.0f, m_position.z); D3DXMatrixScaling(&scalemat, static_cast<float>(brush->GetSize()) * 0.4f, 1.0f, static_cast<float>(brush->GetSize()) * 0.4f); D3DXMatrixMultiply (&worldMatrix, &scalemat, &xformmat); // Transpose the matrices to prepare them for the shader. D3DXMatrixTranspose(&worldMatrix, &worldMatrix); D3DXMatrixTranspose(&viewMatrix, &viewMatrix); D3DXMatrixTranspose(&projectionMatrix, &projectionMatrix); // Lock the constant buffer so it can be written to. HRESULT result; D3D11_MAPPED_SUBRESOURCE mappedResource; result = m_renderer->GetDeviceContext()->Map(m_matrixBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) return; // Get a pointer to the data in the constant buffer. CGizmo::MatrixBuffer *const matrixDataPtr = (CGizmo::MatrixBuffer*)mappedResource.pData; // Copy the matrices into the constant buffer. matrixDataPtr->world = worldMatrix; matrixDataPtr->view = viewMatrix; matrixDataPtr->projection = projectionMatrix; // Unlock the constant buffer. m_renderer->GetDeviceContext()->Unmap(m_matrixBuffer, 0); result = m_renderer->GetDeviceContext()->Map(m_gizmoBuffer, 0, D3D11_MAP_WRITE_DISCARD, 0, &mappedResource); if (FAILED(result)) return; // Get a pointer to the data in the constant buffer. CGizmo::GizmoBuffer *const gizmoDataPtr = (CGizmo::GizmoBuffer*)mappedResource.pData; // Copy the data into the constant buffer. // color based upon gizmo state if (m_gizmoState == GizmoState::Free) { // green gizmoDataPtr->color = D3DXVECTOR4(0.25f * (brush->GetStrength() * brush->GetStrength()), 0.6f * brush->GetStrength(), 0.1f * (3.0f - brush->GetStrength()), 0.01f); } else { // red gizmoDataPtr->color = D3DXVECTOR4(0.6f, 0.0f, 0.0f, 0.01f); } // Unlock the constant buffer. m_renderer->GetDeviceContext()->Unmap(m_gizmoBuffer, 0); // Finally set the constant buffer in the vertex shader with the updated values. m_renderer->GetDeviceContext()->VSSetConstantBuffers(0, 1, &m_matrixBuffer); m_renderer->GetDeviceContext()->VSSetConstantBuffers(1, 1, &m_gizmoBuffer); // Set the vertex input layout. m_renderer->GetDeviceContext()->IASetInputLayout(m_layout); // Set the vertex and pixel shaders that will be used to render this triangle. m_renderer->GetDeviceContext()->VSSetShader(m_vertexShader, NULL, 0); m_renderer->GetDeviceContext()->PSSetShader(m_pixelShader, NULL, 0); m_renderer->EnableAlphaBlending(true); // Render the triangle. m_gizmoMesh->Draw(m_renderer); m_renderer->EnableAlphaBlending(false); }