GpuWaves::~GpuWaves() { ReleaseCOM(mWavesPrevSolSRV); ReleaseCOM(mWavesCurrSolSRV); ReleaseCOM(mWavesNextSolSRV); ReleaseCOM(mWavesPrevSolUAV); ReleaseCOM(mWavesCurrSolUAV); ReleaseCOM(mWavesNextSolUAV); }
SolarSysDemo::~SolarSysDemo() { delete mGfxStats; ReleaseCOM(mFX); ReleaseCOM(mSphere); ReleaseCOM(mSunTex); ReleaseCOM(mPlanet1Tex); ReleaseCOM(mPlanet2Tex); ReleaseCOM(mPlanet3Tex); ReleaseCOM(mMoonTex); DestroyAllVertexDeclarations(); }
void Scene::BuildFX() { DWORD shaderFlags = D3D10_SHADER_ENABLE_STRICTNESS; #if defined (DEBUG) || (_DEBUG) shaderFlags |= D3D10_SHADER_SKIP_OPTIMIZATION; #endif ID3D10Blob* compilationErrors = 0; HRESULT hr = 0; hr = D3DX10CreateEffectFromFile(L"tex.fx", // The name of the effects file to compile 0, // pDefines 0, // pInlcude "fx_4_0", // The version of the shader we are using shaderFlags, // Specify how the shader code will be complied 0, // FXflags m_Direct3DDevice, // A pointer to the direct device 0, // pEffectPool 0, // pPump &m_FX, // Returns a pointer to the created object &compilationErrors, // Returns a pointer to a string containing the comiplation errors 0 // pttResult, used with pPump ); if( FAILED(hr) ) { if( compilationErrors ) { // Print out any errors MessageBoxA( 0, (char*)compilationErrors->GetBufferPointer(), 0, 0); ReleaseCOM(compilationErrors); } DXTrace(__FILE__, (DWORD)__LINE__, hr, L"D3DX10CreateEffectFromFile", true); } // Set the technique to color tech m_Tech = m_FX->GetTechniqueByName("ColorTech"); // Setup variable pointers to the designated name in effect files m_fxWVPVar = m_FX->GetVariableByName("gWVP")->AsMatrix(); // Set the effect file WVP matrix to m_fxDiffuseMapVar = m_FX->GetVariableByName("gDiffuseMap")->AsShaderResource(); m_FxSpecMapVar = m_FX->GetVariableByName("gSpecMap")->AsShaderResource(); m_FxEyePosVar = m_FX->GetVariableByName("gEyePosW"); m_FxLightVar = m_FX->GetVariableByName("gLight"); m_FxTexMatVar = m_FX->GetVariableByName("gTexMat")->AsMatrix(); m_FxBoxWorldVar = m_FX->GetVariableByName("gBoxWorld")->AsMatrix(); }
void DumpMesh::DumpVertices() { const D3D10_INPUT_ELEMENT_DESC *pDesc; UINT declCount = NULL; m_pMesh->GetVertexDescription(&pDesc, &declCount); m_Dumpfile << "---------IALayout-----------" << std::endl; for (size_t i=0; i<declCount; i++) { m_Dumpfile.width(10); m_Dumpfile << pDesc[i].SemanticName << "\t" << pDesc[i].Format << "\t" << pDesc[i].AlignedByteOffset << "\t" << pDesc[i].InputSlotClass << "\t" << std::endl; } // Hard code the position type, should be consistances with the // IALayout declaration ID3DX10MeshBuffer *vb = NULL; m_pMesh->GetVertexBuffer(0, &vb); VERTEX *vertices = NULL; SIZE_T vbufferSize; vb->Map( (void**)&vertices, &vbufferSize ); m_Position.reserve(m_pMesh->GetVertexBufferCount()); ////m_Dumpfile << "---------Vertices-----------" << std::endl; for (size_t i=0; i<m_pMesh->GetVertexCount(); i++) { //m_Dumpfile.width(10); //m_Dumpfile // << vertices[i].position.x << "\t" // << vertices[i].position.y << "\t" // << vertices[i].position.z << "\t" // << std::endl; m_Position.push_back(vertices[i].position); } vb->Unmap(); ReleaseCOM(vb); }
void Ssao::ReleaseTextureViews() { ReleaseCOM(mNormalDepthRTV); ReleaseCOM(mNormalDepthSRV); ReleaseCOM(mAmbientRTV0); ReleaseCOM(mAmbientSRV0); ReleaseCOM(mAmbientRTV1); ReleaseCOM(mAmbientSRV1); }
TerrainClient::~TerrainClient() { for(UINT i = 0; i < mSubGrids.size(); ++i) ReleaseCOM(mSubGrids[i].mesh); ReleaseCOM(mFX); ReleaseCOM(mTex0); ReleaseCOM(mTex1); ReleaseCOM(mTex2); ReleaseCOM(mBlendMap); }
D3D::~D3D() { ReleaseCOM(m_device); ReleaseCOM(m_deviceContext); ReleaseCOM(m_renderTargetView); ReleaseCOM(m_swapChain); ReleaseCOM(m_depthStencilView); ReleaseCOM(m_depthStencilBuffer); m_enumAdapters.Release(); }
Terrain::~Terrain() { for(UINT i = 0; i < mSubGridMeshes.size(); ++i) ReleaseCOM(mSubGridMeshes[i]); ReleaseCOM(mFX); ReleaseCOM(mTex0); ReleaseCOM(mTex1); ReleaseCOM(mTex2); ReleaseCOM(mBlendMap); }
HRESULT Mesh::AdjustMeshDecl() { HRESULT hr; LPD3DXMESH pInMesh = mMesh; LPD3DXMESH pOutMesh = NULL; D3DVERTEXELEMENT9 vertDecl[ MAX_FVF_DECL_SIZE ] = { {0, 0, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 0}, {0, 12, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_NORMAL, 0}, {0, 24, D3DDECLTYPE_FLOAT2, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_TEXCOORD, 0}, // exact SH-coefficients {0, 32, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 0}, {0, 48, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 1}, {0, 64, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 2}, {0, 80, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 3}, {0, 96, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 4}, {0, 112, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 5}, {0, 128, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 6}, {0, 144, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 7}, {0, 160, D3DDECLTYPE_FLOAT4, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_BLENDWEIGHT, 8}, {0, 176, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 2}, {0, 188, D3DDECLTYPE_FLOAT3, D3DDECLMETHOD_DEFAULT, D3DDECLUSAGE_POSITION, 3}, D3DDECL_END() }; hr = pInMesh->CloneMesh( pInMesh->GetOptions(), vertDecl, mDevice, &pOutMesh ); PD( hr, L"clone mesh" ); if( FAILED(hr) ) return hr; if( !DoesMeshHaveUsage( D3DDECLUSAGE_NORMAL ) ) { hr = D3DXComputeNormals( pOutMesh, NULL ); PD( hr, L"compute normals" ); if( FAILED(hr) ) return hr; } ReleaseCOM( pInMesh ) mMesh = pOutMesh; return D3D_OK; }
ShadowMap::ShadowMap( ID3D11Device* device, UINT width, UINT height ) : mWidth( width ), mHeight( height ), mDepthMapSRV( 0 ), mDepthMapDSV( 0 ) { mViewport.TopLeftX = 0.0f; mViewport.TopLeftY = 0.0f; mViewport.Width = static_cast<float>( width ); mViewport.Height = static_cast<float>( height ); mViewport.MinDepth = 0.0f; mViewport.MaxDepth = 1.0f; // Use typeless format because the DSV is going to interpret // the bits as DXGI_FORMAT_D24_UNORM_S8_UINT, whereas the SRV is going to interpret // the bits as DXGI_FORMAT_R24_UNORM_X8_TYPELESS. D3D11_TEXTURE2D_DESC texDesc; texDesc.Width = mWidth; texDesc.Height = mHeight; texDesc.MipLevels = 1; texDesc.ArraySize = 1; texDesc.Format = DXGI_FORMAT_R24G8_TYPELESS; texDesc.SampleDesc.Count = 1; texDesc.SampleDesc.Quality = 0; texDesc.Usage = D3D11_USAGE_DEFAULT; texDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE; texDesc.CPUAccessFlags = 0; texDesc.MiscFlags = 0; ID3D11Texture2D* depthMap = 0; HR( device->CreateTexture2D( &texDesc, 0, &depthMap ) ); D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; dsvDesc.Flags = 0; dsvDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; dsvDesc.Texture2D.MipSlice = 0; HR( device->CreateDepthStencilView( depthMap, &dsvDesc, &mDepthMapDSV ) ); D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; srvDesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; srvDesc.Texture2D.MipLevels = texDesc.MipLevels; srvDesc.Texture2D.MostDetailedMip = 0; HR( device->CreateShaderResourceView( depthMap, &srvDesc, &mDepthMapSRV ) ); // View saves a reference to the texture so we can release our reference. ReleaseCOM( depthMap ); }
ShadowMap::ShadowMap(ID3D11Device* device, UINT Width, UINT Height) : m_Width(Width), m_Height(Height), m_DepthMapDSV(nullptr), m_DepthMapSRV(nullptr) { m_Viewport.TopLeftX = 0.0f; m_Viewport.TopLeftY = 0.0f; m_Viewport.Width = static_cast<FLOAT>(m_Width); m_Viewport.Height = static_cast<FLOAT>(m_Height); m_Viewport.MinDepth = 0.0f; m_Viewport.MaxDepth = 1.0f; D3D11_TEXTURE2D_DESC td; td.Width = m_Width; td.Height = m_Height; td.MipLevels = 1; td.ArraySize = 1; td.Format = DXGI_FORMAT_R24G8_TYPELESS; td.SampleDesc.Count = 1; td.SampleDesc.Quality = 0; td.Usage = D3D11_USAGE_DEFAULT; td.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE; td.CPUAccessFlags = 0; td.MiscFlags = 0; ID3D11Texture2D* DepthMap = nullptr; HR(device->CreateTexture2D(&td, 0, &DepthMap)); D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; dsvDesc.Flags = 0; dsvDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; dsvDesc.Texture2D.MipSlice = 0; HR(device->CreateDepthStencilView(DepthMap, &dsvDesc, &m_DepthMapDSV)); D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; srvDesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; srvDesc.Texture2D.MipLevels = td.MipLevels; srvDesc.Texture2D.MostDetailedMip = 0; HR(device->CreateShaderResourceView(DepthMap, &srvDesc, &m_DepthMapSRV)); ReleaseCOM(DepthMap); }
/** Dependent on having your depth buffer set **/ void D3D::CreateDepthStencilView() { D3D11_DEPTH_STENCIL_VIEW_DESC depthStencilViewDesc; ReleaseCOM(m_depthStencilView); //Check if we have a depth stencil buffer if(!m_depthStencilBuffer) return; //Initialize depth stencil view ZeroMemory(&depthStencilViewDesc, sizeof(depthStencilViewDesc)); depthStencilViewDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depthStencilViewDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; depthStencilViewDesc.Texture2D.MipSlice = 0; HR(m_device->CreateDepthStencilView(m_depthStencilBuffer, &depthStencilViewDesc, &m_depthStencilView)); }
ShadowMap::ShadowMap(ID3D11Device *device, UINT width, UINT height) :mWidth(width), mHeight(height), mDepthDSV(0), mDepthSRV(0), mEnable4xMsaa(0), m4xMsaaQuality(0) { m_matViewport.TopLeftX = 0.0f; m_matViewport.TopLeftY = 0.0f; m_matViewport.Width = static_cast<float>(width); m_matViewport.Height = static_cast<float>(height); m_matViewport.MinDepth = 0.0f; m_matViewport.MaxDepth = 1.0f; D3D11_TEXTURE2D_DESC texDesc; texDesc.Width = mWidth; texDesc.Height = mHeight; texDesc.MipLevels = 1; texDesc.ArraySize = 1; texDesc.Format = DXGI_FORMAT_R24G8_TYPELESS; texDesc.SampleDesc.Count = 1; texDesc.SampleDesc.Quality = 0; texDesc.Usage = D3D11_USAGE_DEFAULT; texDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL | D3D11_BIND_SHADER_RESOURCE; texDesc.CPUAccessFlags = 0; texDesc.MiscFlags = 0; ID3D11Texture2D * depthMap = 0; HR(device->CreateTexture2D(&texDesc, 0, &depthMap)); D3D11_DEPTH_STENCIL_VIEW_DESC dsvDesc; dsvDesc.Flags = 0; dsvDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; dsvDesc.ViewDimension = D3D11_DSV_DIMENSION_TEXTURE2D; dsvDesc.Texture2D.MipSlice = 0; HR(device->CreateDepthStencilView(depthMap, &dsvDesc, &mDepthDSV)); D3D11_SHADER_RESOURCE_VIEW_DESC srvDesc; srvDesc.Format = DXGI_FORMAT_R24_UNORM_X8_TYPELESS; srvDesc.ViewDimension = D3D11_SRV_DIMENSION_TEXTURE2D; srvDesc.Texture2D.MipLevels = texDesc.MipLevels; srvDesc.Texture2D.MostDetailedMip = 0; HR(device->CreateShaderResourceView(depthMap, &srvDesc, &mDepthSRV)); ReleaseCOM(depthMap); }
void D3D9PixelBuffer::bind( uint32 face, uint32 mip, IDirect3DCubeTexture9* texTarget ) { unbind(); mMipIndex = mip; mCubeTarget = texTarget; switch(face) { case 0: mFaceIndex = D3DCUBEMAP_FACE_POSITIVE_X; break; case 1: mFaceIndex = D3DCUBEMAP_FACE_NEGATIVE_X; break; case 2: mFaceIndex = D3DCUBEMAP_FACE_POSITIVE_Y; break; case 3: mFaceIndex = D3DCUBEMAP_FACE_NEGATIVE_Y; break; case 4: mFaceIndex = D3DCUBEMAP_FACE_POSITIVE_Z; break; case 5: mFaceIndex = D3DCUBEMAP_FACE_NEGATIVE_Z; break; } IDirect3DSurface9* suf = NULL; if (FAILED(texTarget->GetCubeMapSurface(mFaceIndex,mip,&suf))) { unbind(); return; } D3DSURFACE_DESC desc; suf->GetDesc(&desc); mWidth = desc.Width; mHeight = desc.Height; mDepth = 1; mFormat = D3D9Translator::getPixelFormat(desc.Format); mRowPitch = mWidth * DPixelFormatTool::getFormatBytes(mFormat); mSlicePitch = mHeight * mRowPitch; mByteSize = mSlicePitch; ReleaseCOM(suf); }
void MeshGeometry::SetVertices(ID3D11Device* device, const Vertex::NormalTexVertex* verts, UINT count) { ReleaseCOM(mVB); D3D11_BUFFER_DESC vbd; vbd.Usage = D3D11_USAGE_IMMUTABLE; vbd.ByteWidth = sizeof(Vertex::NormalTexVertex) * count; vbd.BindFlags = D3D11_BIND_VERTEX_BUFFER; vbd.CPUAccessFlags = 0; vbd.MiscFlags = 0; vbd.StructureByteStride = 0; D3D11_SUBRESOURCE_DATA vinitData; vinitData.pSysMem = verts; HR(device->CreateBuffer(&vbd, &vinitData, &mVB)); }
Projekt::~Projekt() { SafeDelete(mGenericModel); //SafeDelete(mSkinnedModel); SafeDelete(mPlayerModel); SafeDelete(mSky); SafeDelete(mShadowMap); ReleaseCOM(WireFrameRS); Effects::DestroyAll(); InputLayouts::DestroyAll(); delete GameSettings::Instance(); }
D3DApp::~D3DApp() { ReleaseCOM(mRenderTargetView); ReleaseCOM(mDepthStencilView); ReleaseCOM(mSwapChain); ReleaseCOM(mDepthStencilBuffer); // Restore all default settings. if( md3dImmediateContext ) md3dImmediateContext->ClearState(); ReleaseCOM(md3dImmediateContext); ReleaseCOM(md3dDevice); }
D3DApp::~D3DApp() { ReleaseCOM(m_renderTargetView); ReleaseCOM(m_depthStencilView); ReleaseCOM(m_swapChain); ReleaseCOM(m_depthStencilBuffer); if (m_d3dImmediateContext) m_d3dImmediateContext->ClearState(); ReleaseCOM(m_d3dImmediateContext); ReleaseCOM(m_d3dDevice); UnregisterClass(L"DirectXApplication", application); }
MirrorApp::~MirrorApp() { md3dImmediateContext->ClearState(); ReleaseCOM(mRoomVB); ReleaseCOM(mSkullVB); ReleaseCOM(mSkullIB); ReleaseCOM(mFloorDiffuseMapSRV); ReleaseCOM(mWallDiffuseMapSRV); ReleaseCOM(mMirrorDiffuseMapSRV); Effects::DestroyAll(); InputLayouts::DestroyAll(); RenderStates::DestroyAll(); }
cInitDirect3D::~cInitDirect3D() { ReleaseCOM(m_pRenderTargetView); ReleaseCOM(m_pDepthStencilView); ReleaseCOM(m_pSwapChain); ReleaseCOM(m_pDepthStencilBuffer); // Restore all default settings. if (m_pDeviceContext) m_pDeviceContext->ClearState(); ReleaseCOM(m_pDeviceContext); ReleaseCOM(m_pD3dDevice); }
void RenderContext::FinishRender() { #if defined(USE_IMMEDIATE_CONTEXT) #else #if defined(XCGRAPHICS_DX12) //Cmdlist Close can happen here when in multiple render context. ValidateResult(m_deviceContext->Close()); #elif defined(XCGRAPHICS_DX11) ID3DCommandList* commandList; m_deviceContext->FinishCommandList(false, &commandList); //Execute on main device context m_graphicsSystem->GetDeviceContext()->ExecuteCommandList(commandList, true); ReleaseCOM(commandList); m_shaderContainer->ClearShaderAndRenderStates(*m_deviceContext); #endif #endif }
HRESULT Mesh::LoadMesh(ID3DXMesh* mesh){ HRESULT hr; CleanUpMesh(); D3DVERTEXELEMENT9 decl[MAX_FVF_DECL_SIZE]; hr = mesh->GetDeclaration(decl); hr = mesh->CloneMesh( mesh->GetOptions(), decl, mDevice, &mMesh ); PD(hr, L"clone mesh"); ReleaseCOM(mesh) SetDirectory( L"models/" ); SetName( L"meshlab" ); PD( AdjustMeshDecl(), L"adjust mesh delaration" ); PD( AttribSortMesh(), L"attribute sort mesh" ); return D3D_OK; }
SuperSolarSystemApp::~SuperSolarSystemApp( ) { mD3dImmediateContext->ClearState( ); SafeDelete( mSpace ); ReleaseCOM( mLightTexVB ); ReleaseCOM( mLightTexIB ); ReleaseCOM( mColorIB ); ReleaseCOM( mColorVB ); ReleaseCOM( mDynamicCubeMapDSV ); ReleaseCOM( mDynamicCubeMapSRV ); for ( int i = 0; i < 6; ++i ) ReleaseCOM( mDynamicCubeMapRTV[i] ); for ( int i = 0; i < STARNUMBER; i++ ) ReleaseCOM( mDiffuseMapSRV[i] ); Effects::DestroyAll( ); InputLayouts::DestroyAll( ); RenderStates::DestroyAll( ); }
D3DApp::~D3DApp() { ReleaseCOM(mRenderTargetView); ReleaseCOM(mDepthStencilView); ReleaseCOM(mSwapChain); ReleaseCOM(mDepthStencilBuffer); if (mImmediateContext) { mImmediateContext->ClearState(); } ReleaseCOM(mImmediateContext); ReleaseCOM(mDevice); }
void World::drawToMinimap(RenderTarget* renderTarget) { // Save the current render target to restore it later. LPDIRECT3DSURFACE9 backBuffer; gd3dDevice->GetRenderTarget(0, &backBuffer); gd3dDevice->SetRenderTarget(0, renderTarget->getSurface()); HR(gd3dDevice->Clear(0, 0, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER | D3DCLEAR_STENCIL, 0xffffff00, 1.0f, 0xffff)); // Set the cameras position to bird view. D3DXVECTOR3 position = gCamera->getPosition(); float yaw = gCamera->getYaw(); float pitch = gCamera->getPitch(); gCamera->setPosition(position + D3DXVECTOR3(0, 5000, 0)); gCamera->setPitch(-D3DX_PI/2); gCamera->rotate(); gCamera->updateView(); // Draw the terrain. mTerrain->draw(); // Draw all the enemies with a red box and the player with a green. for(int i = 0; i < mObjectList.size(); i++) { if(!mObjectList[i]->getAlive() || mObjectList[i]->getType() == PARTICLE_SYSTEM || mObjectList[i]->getType() == SPAWNER) continue; // Draw minimap icon. gGraphics->drawBoundingBox(mObjectList[i]->getMinimapTexture(), mObjectList[i]->getPosition() + D3DXVECTOR3(0, 1500, 0), Dimensions(200, 1, 200), WHITE, 1.0f); } // Restore the camera. gCamera->setPosition(position); gCamera->setYaw(yaw); gCamera->setPitch(pitch); gCamera->rotate(); // Change back to the backbuffer. gd3dDevice->SetRenderTarget(0, backBuffer); ReleaseCOM(backBuffer); }
void D3D9PixelBuffer::bind( uint32 mip, IDirect3DVolumeTexture9* texTarget ) { unbind(); mMipIndex = mip; m3DTarget = texTarget; IDirect3DVolume9* vol = NULL; if (FAILED(texTarget->GetVolumeLevel(mip, &vol))) { unbind(); return; } D3DVOLUME_DESC desc; vol->GetDesc(&desc); mWidth = desc.Width; mHeight = desc.Height; mDepth = desc.Depth; mFormat = D3D9Translator::getPixelFormat(desc.Format); mRowPitch = mWidth * DPixelFormatTool::getFormatBytes(mFormat); mSlicePitch = mHeight * mRowPitch; mByteSize = mSlicePitch * mDepth; ReleaseCOM(vol); }
void RenderTexture::BuildTexture(void) { D3D10_TEXTURE2D_DESC texDesc; D3D10_RENDER_TARGET_VIEW_DESC renderTargetViewDesc; D3D10_SHADER_RESOURCE_VIEW_DESC shaderResourceViewDesc; memset(&texDesc, 0 , sizeof(texDesc)); texDesc.Width = m_width; texDesc.Height = m_height; texDesc.MipLevels = 0; texDesc.ArraySize = 1; texDesc.Format = m_format; texDesc.SampleDesc.Count = 1; texDesc.SampleDesc.Quality = 0; texDesc.Usage = D3D10_USAGE_DEFAULT; texDesc.BindFlags = D3D10_BIND_RENDER_TARGET | D3D10_BIND_SHADER_RESOURCE; texDesc.CPUAccessFlags = 0; texDesc.MiscFlags = D3D10_RESOURCE_MISC_GENERATE_MIPS; HR(m_device->CreateTexture2D(&texDesc, 0, &m_tex)); renderTargetViewDesc.Format = texDesc.Format; renderTargetViewDesc.ViewDimension = D3D10_RTV_DIMENSION_TEXTURE2D; renderTargetViewDesc.Texture2D.MipSlice = 0; HR(m_device->CreateRenderTargetView(m_tex, &renderTargetViewDesc, &m_rtv)); shaderResourceViewDesc.Format = texDesc.Format; shaderResourceViewDesc.ViewDimension = D3D10_SRV_DIMENSION_TEXTURE2D; shaderResourceViewDesc .Texture2D.MostDetailedMip = 0; shaderResourceViewDesc .Texture2D.MipLevels =1; HR(m_device->CreateShaderResourceView(m_tex,&shaderResourceViewDesc , &m_srv)); // View saves a reference to the texture so we can release our reference. ReleaseCOM(m_tex); }
void Ssao::BuildRandomVectorTexture() { D3D11_TEXTURE2D_DESC texDesc; texDesc.Width = 256; texDesc.Height = 256; texDesc.MipLevels = 1; texDesc.ArraySize = 1; texDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; texDesc.SampleDesc.Count = 1; texDesc.SampleDesc.Quality = 0; texDesc.Usage = D3D11_USAGE_IMMUTABLE; texDesc.BindFlags = D3D11_BIND_SHADER_RESOURCE; texDesc.CPUAccessFlags = 0; texDesc.MiscFlags = 0; D3D11_SUBRESOURCE_DATA initData = {0}; initData.SysMemPitch = 256*sizeof(XMCOLOR); XMCOLOR color[256*256]; for(int i = 0; i < 256; ++i) { for(int j = 0; j < 256; ++j) { XMFLOAT3 v(MathHelper::RandF(), MathHelper::RandF(), MathHelper::RandF()); color[i*256+j] = XMCOLOR(v.x, v.y, v.z, 0.0f); } } initData.pSysMem = color; ID3D11Texture2D* tex = 0; HR(md3dDevice->CreateTexture2D(&texDesc, &initData, &tex)); HR(md3dDevice->CreateShaderResourceView(tex, 0, &mRandomVectorSRV)); // view saves a reference. ReleaseCOM(tex); }
void D3D::CreateDepthStencilBuffer(int screenWidth, int screenHeight) { D3D11_TEXTURE2D_DESC depthBufferDesc; ReleaseCOM(m_depthStencilBuffer); //Initialize depth stencil buffer ZeroMemory(&depthBufferDesc, sizeof(depthBufferDesc)); depthBufferDesc.Width = screenWidth; depthBufferDesc.Height = screenHeight; depthBufferDesc.MipLevels = 1; depthBufferDesc.ArraySize = 1; depthBufferDesc.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; depthBufferDesc.SampleDesc.Count = 1; depthBufferDesc.SampleDesc.Quality = 0; depthBufferDesc.Usage = D3D11_USAGE_DEFAULT; depthBufferDesc.BindFlags = D3D11_BIND_DEPTH_STENCIL; depthBufferDesc.CPUAccessFlags = 0; depthBufferDesc.MiscFlags = 0; HR(m_device->CreateTexture2D(&depthBufferDesc, 0, &m_depthStencilBuffer)); }
void DrawMorphMesh(D3DXMESHCONTAINER_EX *SourceMesh, D3DXMESHCONTAINER_EX *TargetMesh, float Scalar) { // Get the world, view, and projection matrices D3DXMATRIX matWorld, matView, matProj; g_pD3DDevice->GetTransform(D3DTS_WORLD, &matWorld); g_pD3DDevice->GetTransform(D3DTS_VIEW, &matView); g_pD3DDevice->GetTransform(D3DTS_PROJECTION, &matProj); // Get the world*view*proj matrix and set it D3DXMATRIX matWVP; matWVP = matWorld * matView * matProj; D3DXMatrixTranspose(&matWVP, &matWVP); g_pD3DDevice->SetVertexShaderConstantF(0, (float*)&matWVP, 4); // Set the scalar value to use g_pD3DDevice->SetVertexShaderConstantF(4, (float*)&D3DXVECTOR4(1.0f-Scalar, Scalar, 0.0f, 0.0f), 1); // Set the light direction (convert from model space to view space) D3DXMATRIX matInvWorld; D3DXMatrixInverse(&matInvWorld, NULL, &matWorld); D3DXVECTOR3 vecLight = D3DXVECTOR3(0.0f, 0.0f, 1.0f); D3DXVec3TransformCoord(&vecLight, &vecLight, &matInvWorld); g_pD3DDevice->SetVertexShaderConstantF(5, (float*)&D3DXVECTOR4(vecLight.x, vecLight.y, vecLight.z, 0.0f), 1); // Set the 2nd stream source IDirect3DVertexBuffer9 *pVB = NULL; TargetMesh->MeshData.pMesh->GetVertexBuffer(&pVB); g_pD3DDevice->SetStreamSource(1, pVB, 0, D3DXGetFVFVertexSize(TargetMesh->MeshData.pMesh->GetFVF())); // Draw the mesh in the vertex shader DrawMesh(SourceMesh, g_VS, g_Decl); // Clear the 2nd stream source and free the vertex buffer interface g_pD3DDevice->SetStreamSource(1, NULL, 0, 0); ReleaseCOM(pVB); }