XFBEncoder::XFBEncoder() { ID3D12Resource* texture; CheckHR(D3D::device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_R8G8B8A8_UNORM, XFB_TEXTURE_WIDTH, XFB_TEXTURE_HEIGHT, 1, 1, 1, 0, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET), D3D12_RESOURCE_STATE_RENDER_TARGET, nullptr, IID_PPV_ARGS(&texture))); m_yuyv_texture = new D3DTexture2D(texture, TEXTURE_BIND_FLAG_SHADER_RESOURCE | TEXTURE_BIND_FLAG_RENDER_TARGET, DXGI_FORMAT_R8G8B8A8_UNORM, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_R8G8B8A8_UNORM); SAFE_RELEASE(texture); CheckHR(D3D::device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_READBACK), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(ROUND_UP(XFB_TEXTURE_WIDTH * sizeof(u32), D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) * MAX_XFB_HEIGHT), D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&m_readback_buffer))); m_upload_buffer = std::make_unique<D3DStreamBuffer>(XFB_UPLOAD_BUFFER_SIZE, XFB_UPLOAD_BUFFER_SIZE, nullptr); m_encode_params_buffer = std::make_unique<D3DStreamBuffer>(XFB_ENCODER_PARAMS_BUFFER_SIZE, XFB_ENCODER_PARAMS_BUFFER_SIZE, nullptr); }
void DX12Texture::Upload() { CD3DX12_RESOURCE_DESC textureDesc = CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_R8G8B8A8_UNORM, m_Width, m_Height, 1U, 1U); ThrowIfFailed(m_Renderer.GetDevice().CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &textureDesc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&m_GPUResource))); const uint32 subresourceCount = textureDesc.DepthOrArraySize * textureDesc.MipLevels; const uint64 uploadBufferSize = GetRequiredIntermediateSize(m_GPUResource.Get(), 0, subresourceCount); ThrowIfFailed(m_Renderer.GetDevice().CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(uploadBufferSize), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_UploadResource))); // Copy data to the intermediate upload heap and then schedule a copy // from the upload heap to the Texture2D. D3D12_SUBRESOURCE_DATA textureData = {}; textureData.pData = m_Data.get(); textureData.RowPitch = m_Width * 4; textureData.SlicePitch = m_Width * m_Height * 4; UpdateSubresources(&m_Renderer.GetCommandList().GetCommandList(), m_GPUResource.Get(), m_UploadResource.Get(), 0, 0, subresourceCount, &textureData); m_Renderer.GetCommandList().GetCommandList().ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_GPUResource.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE)); }
void Application::CreateVertexBuffer() { struct Vertex { float position[2]; float texcoord[2]; }; // Define the geometry for a quad. float screenAspectRatio = static_cast<float>(window->GetWidth()) / window->GetHeight(); Vertex quadVertices[] = { { { -0.25f, -0.25f * screenAspectRatio }, { 0.0f, 0.0f } }, { { -0.25f, 0.25f * screenAspectRatio },{ 0.0f, 1.0f } }, { { 0.25f, -0.25f * screenAspectRatio },{ 1.0f, 0.0f } }, { { 0.25f, 0.25f * screenAspectRatio },{ 1.0f, 1.0f } } }; const unsigned int vertexBufferSize = sizeof(quadVertices); // Create an upload heap for the ComPtr<ID3D12Resource> uploadHeap; if (FAILED(device->GetD3D12Device()->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(sizeof(quadVertices)), D3D12_RESOURCE_STATE_GENERIC_READ, // D3D12_RESOURCE_STATE_GENERIC_READ is the only possible for D3D12_HEAP_TYPE_UPLOAD. nullptr, IID_PPV_ARGS(&uploadHeap)))) { CRITICAL_ERROR("Failed to create upload heap."); } // Copy the triangle data to the vertex buffer. UINT8* pVertexDataBegin; if (FAILED(uploadHeap->Map(0, nullptr, reinterpret_cast<void**>(&pVertexDataBegin)))) CRITICAL_ERROR("Failed to map vertex buffer"); memcpy(pVertexDataBegin, quadVertices, sizeof(quadVertices)); uploadHeap->Unmap(0, nullptr); // Create vertex buffer. if (FAILED(device->GetD3D12Device()->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(sizeof(quadVertices)), D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&vertexBuffer)))) { CRITICAL_ERROR("Failed to create vertex buffer."); } // Copy over and wait until its done. commandList->Reset(commandAllocator[0].Get(), nullptr); commandList->CopyResource(vertexBuffer.Get(), uploadHeap.Get()); commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(vertexBuffer.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER)); commandList->Close(); ID3D12CommandList* ppCommandLists[] = { commandList.Get() }; device->GetDirectCommandQueue()->ExecuteCommandLists(_countof(ppCommandLists), ppCommandLists); device->WaitForIdleGPU(); // Initialize the vertex buffer view. vertexBufferView.BufferLocation = vertexBuffer->GetGPUVirtualAddress(); vertexBufferView.StrideInBytes = sizeof(Vertex); vertexBufferView.SizeInBytes = vertexBufferSize; }
void PSTextureEncoder::Init() { // Create output texture RGBA format D3D12_RESOURCE_DESC out_tex_desc = CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_B8G8R8A8_UNORM, EFB_WIDTH * 4, EFB_HEIGHT / 4, 1, 0, 1, 0, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET); D3D12_CLEAR_VALUE optimized_clear_value = {DXGI_FORMAT_B8G8R8A8_UNORM, {0.0f, 0.0f, 0.0f, 1.0f}}; CheckHR(D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &out_tex_desc, D3D12_RESOURCE_STATE_COPY_SOURCE, &optimized_clear_value, IID_PPV_ARGS(&m_out))); D3D::SetDebugObjectName12(m_out, "efb encoder output texture"); // Create output render target view D3D12_RENDER_TARGET_VIEW_DESC tex_rtv_desc = { DXGI_FORMAT_B8G8R8A8_UNORM, // DXGI_FORMAT Format; D3D12_RTV_DIMENSION_TEXTURE2D // D3D12_RTV_DIMENSION ViewDimension; }; tex_rtv_desc.Texture2D.MipSlice = 0; D3D::rtv_descriptor_heap_mgr->Allocate(&m_out_rtv_cpu); D3D::device12->CreateRenderTargetView(m_out, &tex_rtv_desc, m_out_rtv_cpu); // Create output staging buffer CheckHR(D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_READBACK), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer( D3D::AlignValue(static_cast<unsigned int>(out_tex_desc.Width) * 4, D3D12_TEXTURE_DATA_PITCH_ALIGNMENT) * out_tex_desc.Height), D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&m_out_readback_buffer))); D3D::SetDebugObjectName12(m_out_readback_buffer, "efb encoder output staging buffer"); // Create constant buffer for uploading data to shaders. Need to align to 256 bytes. unsigned int encode_params_buffer_size = (sizeof(EFBEncodeParams) + 0xff) & ~0xff; CheckHR(D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(encode_params_buffer_size), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_encode_params_buffer))); D3D::SetDebugObjectName12(m_encode_params_buffer, "efb encoder params buffer"); // NOTE: This upload buffer is okay to overwrite each time, since we block until completion when // it's used anyway. D3D12_RANGE read_range = {}; CheckHR(m_encode_params_buffer->Map(0, &read_range, &m_encode_params_buffer_data)); m_ready = true; }
void ae3d::VertexBuffer::UploadVB( void* faces, void* vertices, unsigned ibSize ) { auto uploadProp = CD3DX12_HEAP_PROPERTIES( D3D12_HEAP_TYPE_UPLOAD ); auto bufferProp = CD3DX12_RESOURCE_DESC::Buffer( ibOffset + ibSize ); HRESULT hr = GfxDeviceGlobal::device->CreateCommittedResource( &uploadProp, D3D12_HEAP_FLAG_NONE, &bufferProp, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS( &vb ) ); if (FAILED( hr )) { ae3d::System::Assert( false, "Unable to create vertex buffer!\n" ); return; } vb->SetName( L"VertexBuffer" ); Global::vbs.push_back( vb ); char* vbUploadPtr = nullptr; hr = vb->Map( 0, nullptr, reinterpret_cast<void**>(&vbUploadPtr) ); if (FAILED( hr )) { ae3d::System::Assert( false, "Unable to map vertex buffer!\n" ); return; } memcpy_s( vbUploadPtr, ibOffset, vertices, ibOffset ); memcpy_s( vbUploadPtr + ibOffset, ibSize, faces, ibSize ); vb->Unmap( 0, nullptr ); }
BitonicSort::BitonicSort(ID3D12Device *pDevice, UINT nodeMask) { auto defaultHeapProperties = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT); auto indirectArgBufferDesc = CD3DX12_RESOURCE_DESC::Buffer(cIndirectArgStride * 22 * 23 / 2, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS); ThrowInternalFailure(pDevice->CreateCommittedResource( &defaultHeapProperties, D3D12_HEAP_FLAG_NONE, &indirectArgBufferDesc, D3D12_RESOURCE_STATE_INDIRECT_ARGUMENT, nullptr, IID_PPV_ARGS(&m_pDispatchArgs))); CD3DX12_ROOT_PARAMETER1 parameters[NumParameters]; parameters[ShaderSpecificConstants].InitAsConstants(2, 0); parameters[OutputUAV].InitAsUnorderedAccessView(0); parameters[IndexBufferUAV].InitAsUnorderedAccessView(1); parameters[GenericConstants].InitAsConstants(2, 1); auto rootSignatureDesc = CD3DX12_VERSIONED_ROOT_SIGNATURE_DESC(ARRAYSIZE(parameters), parameters); CreateRootSignatureHelper(pDevice, rootSignatureDesc, &m_pRootSignature); CreatePSOHelper(pDevice, nodeMask, m_pRootSignature, COMPILED_SHADER(g_pBitonicIndirectArgsCS),&m_pBitonicIndirectArgsCS); CreatePSOHelper(pDevice, nodeMask, m_pRootSignature, COMPILED_SHADER(g_pBitonicInnerSortCS), &m_pBitonicInnerSortCS); CreatePSOHelper(pDevice, nodeMask, m_pRootSignature, COMPILED_SHADER(g_pBitonicOuterSortCS), &m_pBitonicOuterSortCS); CreatePSOHelper(pDevice, nodeMask, m_pRootSignature, COMPILED_SHADER(g_pBitonicPreSortCS), &m_pBitonicPreSortCS); D3D12_INDIRECT_ARGUMENT_DESC indirectArgDesc = {}; indirectArgDesc.Type = D3D12_INDIRECT_ARGUMENT_TYPE_DISPATCH; D3D12_COMMAND_SIGNATURE_DESC commandSignatureDesc; commandSignatureDesc.NodeMask = nodeMask; commandSignatureDesc.pArgumentDescs = &indirectArgDesc; commandSignatureDesc.ByteStride = sizeof(D3D12_DISPATCH_ARGUMENTS); commandSignatureDesc.NumArgumentDescs = 1; pDevice->CreateCommandSignature(&commandSignatureDesc, nullptr, IID_PPV_ARGS(&m_pCommandSignature)); }
void ShadowMap::BuildResource() { // Note, compressed formats cannot be used for UAV. We get error like: // ERROR: ID3D11Device::CreateTexture2D: The format (0x4d, BC3_UNORM) // cannot be bound as an UnorderedAccessView, or cast to a format that // could be bound as an UnorderedAccessView. Therefore this format // does not support D3D11_BIND_UNORDERED_ACCESS. D3D12_RESOURCE_DESC texDesc; ZeroMemory(&texDesc, sizeof(D3D12_RESOURCE_DESC)); texDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; texDesc.Alignment = 0; texDesc.Width = mWidth; texDesc.Height = mHeight; texDesc.DepthOrArraySize = 1; texDesc.MipLevels = 1; texDesc.Format = mFormat; texDesc.SampleDesc.Count = 1; texDesc.SampleDesc.Quality = 0; texDesc.Layout = D3D12_TEXTURE_LAYOUT_UNKNOWN; texDesc.Flags = D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; D3D12_CLEAR_VALUE optClear; optClear.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; optClear.DepthStencil.Depth = 1.0f; optClear.DepthStencil.Stencil = 0; ThrowIfFailed(md3dDevice->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &texDesc, D3D12_RESOURCE_STATE_GENERIC_READ, &optClear, IID_PPV_ARGS(&mShadowMap))); }
FrameResource::FrameResource(ID3D12Device* pDevice, UINT cityRowCount, UINT cityColumnCount) : m_fenceValue(0), m_cityRowCount(cityRowCount), m_cityColumnCount(cityColumnCount) { m_modelMatrices.resize(m_cityRowCount * m_cityColumnCount); // The command allocator is used by the main sample class when // resetting the command list in the main update loop. Each frame // resource needs a command allocator because command allocators // cannot be reused until the GPU is done executing the commands // associated with it. ThrowIfFailed(pDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_DIRECT, IID_PPV_ARGS(&m_commandAllocator))); ThrowIfFailed(pDevice->CreateCommandAllocator(D3D12_COMMAND_LIST_TYPE_BUNDLE, IID_PPV_ARGS(&m_bundleAllocator))); // Create an upload heap for the constant buffers. ThrowIfFailed(pDevice->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(sizeof(SceneConstantBuffer) * m_cityRowCount * m_cityColumnCount), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_cbvUploadHeap))); // Map the constant buffers. Note that unlike D3D11, the resource // does not need to be unmapped for use by the GPU. In this sample, // the resource stays 'permenantly' mapped to avoid overhead with // mapping/unmapping each frame. CD3DX12_RANGE readRange(0, 0); // We do not intend to read from this resource on the CPU. ThrowIfFailed(m_cbvUploadHeap->Map(0, &readRange, reinterpret_cast<void**>(&m_pConstantBuffers))); // Update all of the model matrices once; our cities don't move so // we don't need to do this ever again. SetCityPositions(8.0f, -8.0f); }
TextureCacheBase::TCacheEntryBase* TextureCache::CreateTexture(const TCacheEntryConfig& config) { if (config.rendertarget) { D3DTexture2D* texture = D3DTexture2D::Create(config.width, config.height, static_cast<D3D11_BIND_FLAG>((static_cast<int>(D3D11_BIND_RENDER_TARGET) | static_cast<int>(D3D11_BIND_SHADER_RESOURCE))), D3D11_USAGE_DEFAULT, DXGI_FORMAT_R8G8B8A8_UNORM, 1, config.layers); TCacheEntry* entry = new TCacheEntry(config, texture); entry->m_texture_srv_cpu_handle = texture->GetSRV12CPU(); entry->m_texture_srv_gpu_handle = texture->GetSRV12GPU(); entry->m_texture_srv_gpu_handle_cpu_shadow = texture->GetSRV12GPUCPUShadow(); return entry; } else { ID3D12Resource* texture_resource = nullptr; D3D12_RESOURCE_DESC texture_resource_desc = CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_R8G8B8A8_UNORM, config.width, config.height, 1, config.levels); CheckHR( D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC(texture_resource_desc), D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, nullptr, IID_PPV_ARGS(&texture_resource) ) ); D3DTexture2D* texture = new D3DTexture2D( texture_resource, D3D11_BIND_SHADER_RESOURCE, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, false, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE ); TCacheEntry* const entry = new TCacheEntry( config, texture ); entry->m_texture_srv_cpu_handle = texture->GetSRV12CPU(); entry->m_texture_srv_gpu_handle = texture->GetSRV12GPU(); entry->m_texture_srv_gpu_handle_cpu_shadow = texture->GetSRV12GPUCPUShadow(); // EXISTINGD3D11TODO: better debug names D3D::SetDebugObjectName12(entry->m_texture->GetTex12(), "a texture of the TextureCache"); SAFE_RELEASE(texture_resource); return entry; } }
SRVID afCreateTexture2D(AFDTFormat format, const IVec2& size, void *image) { D3D12_RESOURCE_DESC textureDesc = {}; textureDesc.MipLevels = 1; textureDesc.Format = DXGI_FORMAT_R8G8B8A8_UNORM; textureDesc.Width = size.x; textureDesc.Height = size.y; textureDesc.Flags = D3D12_RESOURCE_FLAG_NONE; textureDesc.DepthOrArraySize = 1; textureDesc.SampleDesc.Count = 1; textureDesc.SampleDesc.Quality = 0; textureDesc.Dimension = D3D12_RESOURCE_DIMENSION_TEXTURE2D; SRVID id; HRESULT hr = deviceMan.GetDevice()->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &textureDesc, D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&id)); TexDesc texDesc; texDesc.size = size; afWriteTexture(id, texDesc, image); return id; }
timestamp_query::timestamp_query(device const& dvc, dx12u::cmd_queue const& q, int gpu_ordinal, std::size_t max_num_query) : num_query(max_num_query) { if (!dvc.Get()) { throw error{ "null device" }; } std::uint32_t gpu_mask = gpu_ordinal < 0 ? 1 : (1u << static_cast<std::uint32_t>(gpu_ordinal)); // alloc query buffer size_t buf_aligned_sz = (num_query * sizeof(std::uint64_t) + 4095) & ~4095; // page aligned auto heap_read_back = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_READBACK, gpu_mask, gpu_mask); auto buffer_desc = CD3DX12_RESOURCE_DESC::Buffer(buf_aligned_sz); auto r = dvc->CreateCommittedResource(&heap_read_back, D3D12_HEAP_FLAG_NONE, &buffer_desc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&buffer)); dx12u::throw_if_error(r, "timestamp resource creation failure"); // query heap D3D12_QUERY_HEAP_DESC heap_desc{}; heap_desc.Type = D3D12_QUERY_HEAP_TYPE_TIMESTAMP; heap_desc.Count = static_cast<std::uint32_t>(num_query); heap_desc.NodeMask = gpu_mask; r = dvc->CreateQueryHeap(&heap_desc, IID_PPV_ARGS(&qh)); dx12u::throw_if_error(r, "timestamp query heap creation failure"); // clock frequency dvc->SetStablePowerState(true); q.get_com_ptr()->GetTimestampFrequency(&clock_freq); }
D3D12GpuTexture::D3D12GpuTexture(Device::Ptr pDevice, rhi::TextureDesc const & Desc) : D3D12RHIDeviceChild(pDevice) { if (Desc.IsTex2D()) { m_Desc.Dimension = D3D12_RESOURCE_DIMENSION::D3D12_RESOURCE_DIMENSION_TEXTURE2D; } else if (Desc.IsTex1D()) { m_Desc.Dimension = D3D12_RESOURCE_DIMENSION::D3D12_RESOURCE_DIMENSION_TEXTURE1D; } else if (Desc.IsTex3D()) { m_Desc.Dimension = D3D12_RESOURCE_DIMENSION::D3D12_RESOURCE_DIMENSION_TEXTURE3D; } m_Desc.Width = Desc.Width; m_Desc.Height = Desc.Height; m_Desc.DepthOrArraySize = static_cast<const UINT16>(Desc.Depth); m_Desc.MipLevels = static_cast<const UINT16>(Desc.MipLevels); m_Desc.Format = g_DXGIFormatTable[Desc.Format]; m_Desc.SampleDesc.Count = 1; m_Desc.SampleDesc.Quality = 0; CD3DX12_HEAP_PROPERTIES HeapProp = CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT); ThrowIfFailed(GetParentDeviceRef().Get()->CreateCommittedResource(&HeapProp, D3D12_HEAP_FLAG_NONE, &m_Desc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(m_Resource.GetAddressOf()))); }
void KRenderTarget::CreateRenderTargetArray(uint32 num_slices, DXGI_FORMAT tex_format, int32 width, int32 height, const float clear_color[4] /*= 0*/) { // Create the renderTargetTexture CD3DX12_RESOURCE_DESC texDesc( D3D12_RESOURCE_DIMENSION_TEXTURE2D, 0, // alignment width, height, num_slices, 1, // mip levels tex_format, 1, 0, // sample count/quality D3D12_TEXTURE_LAYOUT_UNKNOWN, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET); // Performance tip: Tell the runtime at resource creation the desired clear value. D3D12_CLEAR_VALUE clearValue; clearValue.Format = tex_format; if (clear_color == 0) { float clearColor[] = { 0, 0, 0, 1 }; memcpy(&clearValue.Color[0], &clearColor[0], 4 * sizeof(float)); } else memcpy(&clearValue.Color[0], &clear_color[0], 4 * sizeof(float)); shared_context.gfx_device->GetDevice()->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT, 0, 0), D3D12_HEAP_FLAG_NONE, &texDesc, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, &clearValue, IID_PPV_ARGS(&m_RTResource)); D3D12_RENDER_TARGET_VIEW_DESC RTVDesc; ZeroMemory(&RTVDesc, sizeof(RTVDesc)); RTVDesc.Format = tex_format; RTVDesc.ViewDimension = D3D12_RTV_DIMENSION_TEXTURE2DARRAY; RTVDesc.Texture2DArray.ArraySize = num_slices; m_RTVCPUHandle = shared_context.gfx_device->GetDescHeapRTV()->GetNewCPUHandle(); m_RTVGPUHandle = shared_context.gfx_device->GetDescHeapRTV()->GetGPUHandleAtHead(); shared_context.gfx_device->GetDevice()->CreateRenderTargetView(m_RTResource, &RTVDesc, m_RTVCPUHandle); D3D12_SHADER_RESOURCE_VIEW_DESC SRVDesc; ZeroMemory(&SRVDesc, sizeof(SRVDesc)); SRVDesc.Format = tex_format; SRVDesc.ViewDimension = D3D12_SRV_DIMENSION_TEXTURE2DARRAY; SRVDesc.Texture2DArray.ArraySize = num_slices; SRVDesc.Texture2DArray.MipLevels = 1; SRVDesc.Shader4ComponentMapping = D3D12_DEFAULT_SHADER_4_COMPONENT_MAPPING; m_SRVCPUHandle = shared_context.gfx_device->GetDescHeapCBV_SRV()->GetNewCPUHandle(); m_SRVGPUHandle = shared_context.gfx_device->GetDescHeapCBV_SRV()->GetGPUHandleAtHead(); shared_context.gfx_device->GetDevice()->CreateShaderResourceView(m_RTResource, &SRVDesc, m_SRVCPUHandle); }
void VertexManager::CreateDeviceObjects() { m_vertexDrawOffset = 0; m_indexDrawOffset = 0; CheckHR( D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(MAX_VBUFFER_SIZE), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_vertexBuffer) ) ); D3D::SetDebugObjectName12(m_vertexBuffer, "Vertex Buffer of VertexManager"); CheckHR(m_vertexBuffer->Map(0, nullptr, &m_vertexBufferData)); CheckHR( D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(MAX_IBUFFER_SIZE), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_indexBuffer) ) ); D3D::SetDebugObjectName12(m_indexBuffer, "Index Buffer of VertexManager"); CheckHR(m_indexBuffer->Map(0, nullptr, &m_indexBufferData)); SetIndexBuffer(); // Use CPU-only memory if the GPU won't be reading from the buffers, // since reading upload heaps on the CPU is slow.. vertexCpuBuffer = new u8[MAXVBUFFERSIZE]; indexCpuBuffer = new u8[MAXIBUFFERSIZE]; }
void BBox::Init() { memset(s_bbox_shadow_copy, 0, sizeof(s_bbox_shadow_copy)); s_bbox_cpu_dirty = true; s_bbox_gpu_dirty = true; CD3DX12_RESOURCE_DESC buffer_desc(CD3DX12_RESOURCE_DESC::Buffer(BBOX_BUFFER_SIZE, D3D12_RESOURCE_FLAG_ALLOW_UNORDERED_ACCESS, 0)); CD3DX12_RESOURCE_DESC staging_buffer_desc(CD3DX12_RESOURCE_DESC::Buffer(BBOX_BUFFER_SIZE, D3D12_RESOURCE_FLAG_NONE, 0)); CheckHR(D3D::device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &buffer_desc, D3D12_RESOURCE_STATE_UNORDERED_ACCESS, nullptr, IID_PPV_ARGS(&s_bbox_buffer))); s_current_bbox_state = D3D12_RESOURCE_STATE_UNORDERED_ACCESS; CheckHR(D3D::device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_READBACK), D3D12_HEAP_FLAG_NONE, &staging_buffer_desc, D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&s_bbox_staging_buffer))); s_bbox_stream_buffer = std::make_unique<D3DStreamBuffer>(BBOX_STREAM_BUFFER_SIZE, BBOX_STREAM_BUFFER_SIZE, nullptr); // D3D12 root signature UAV must be raw or structured buffers, not typed. Since we used a typed buffer, // we have to use a descriptor table. Luckily, we only have to allocate this once, and it never changes. D3D12_CPU_DESCRIPTOR_HANDLE cpu_descriptor_handle; if (!D3D::gpu_descriptor_heap_mgr->Allocate(&cpu_descriptor_handle, &s_bbox_descriptor_handle, nullptr, false)) PanicAlert("Failed to create bounding box UAV descriptor"); D3D12_UNORDERED_ACCESS_VIEW_DESC view_desc = { DXGI_FORMAT_R32_SINT, D3D12_UAV_DIMENSION_BUFFER }; view_desc.Buffer.FirstElement = 0; view_desc.Buffer.NumElements = 4; view_desc.Buffer.StructureByteStride = 0; view_desc.Buffer.CounterOffsetInBytes = 0; view_desc.Buffer.Flags = D3D12_BUFFER_UAV_FLAG_NONE; D3D::device->CreateUnorderedAccessView(s_bbox_buffer, nullptr, &view_desc, cpu_descriptor_handle); Bind(); }
D3DTexture2D* D3DTexture2D::Create(unsigned int width, unsigned int height, D3D11_BIND_FLAG bind, D3D11_USAGE usage, DXGI_FORMAT fmt, unsigned int levels, unsigned int slices, D3D12_SUBRESOURCE_DATA* data) { ID3D12Resource* texture12 = nullptr; D3D12_RESOURCE_DESC texdesc12 = CD3DX12_RESOURCE_DESC::Tex2D( fmt, width, height, slices, levels ); D3D12_CLEAR_VALUE optimized_clear_value = {}; optimized_clear_value.Format = fmt; if (bind & D3D11_BIND_RENDER_TARGET) { texdesc12.Flags |= D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET; optimized_clear_value.Color[0] = 0.0f; optimized_clear_value.Color[1] = 0.0f; optimized_clear_value.Color[2] = 0.0f; optimized_clear_value.Color[3] = 1.0f; } if (bind & D3D11_BIND_DEPTH_STENCIL) { texdesc12.Flags |= D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL; optimized_clear_value.DepthStencil.Depth = 0.0f; optimized_clear_value.DepthStencil.Stencil = 0; } CheckHR( D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC(texdesc12), D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE, &optimized_clear_value, IID_PPV_ARGS(&texture12) ) ); D3D::SetDebugObjectName12(texture12, "Texture created via D3DTexture2D::Create"); D3DTexture2D* ret = new D3DTexture2D(texture12, bind, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, DXGI_FORMAT_UNKNOWN, false, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); if (data) { DX12::D3D::ReplaceRGBATexture2D(texture12, reinterpret_cast<const u8*>(data->pData), width, height, static_cast<unsigned int>(data->RowPitch), 0, D3D12_RESOURCE_STATE_PIXEL_SHADER_RESOURCE); } SAFE_RELEASE(texture12); return ret; }
PerfQuery::PerfQuery() { D3D12_QUERY_HEAP_DESC desc = {D3D12_QUERY_HEAP_TYPE_OCCLUSION, PERF_QUERY_BUFFER_SIZE, 0}; CheckHR(D3D::device12->CreateQueryHeap(&desc, IID_PPV_ARGS(&m_query_heap))); CheckHR(D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_READBACK), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(QUERY_READBACK_BUFFER_SIZE), D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&m_query_readback_buffer))); m_tracking_fence = D3D::command_list_mgr->RegisterQueueFenceCallback(this, &PerfQuery::QueueFenceCallback); }
ID3D12Resource * RenderTargets::bindAddressAsDepthStencil(ID3D12Device * device, ID3D12GraphicsCommandList * cmdList, u32 address, size_t width, size_t height, u8 surfaceDepthFormat, float depthClear, u8 stencilClear) { ID3D12Resource* ds; auto It = m_depthStencil.find(address); // TODO: Check if sizes and surface depth format match if (It != m_depthStencil.end()) { ds = It->second; cmdList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(ds, D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_DEPTH_WRITE)); } else { D3D12_CLEAR_VALUE clearDepthValue = {}; clearDepthValue.DepthStencil.Depth = depthClear; D3D12_HEAP_PROPERTIES heapProp = {}; heapProp.Type = D3D12_HEAP_TYPE_DEFAULT; DXGI_FORMAT dxgiFormat; switch (surfaceDepthFormat) { case 0: break; case CELL_GCM_SURFACE_Z16: dxgiFormat = DXGI_FORMAT_R16_TYPELESS; clearDepthValue.Format = DXGI_FORMAT_D16_UNORM; break; case CELL_GCM_SURFACE_Z24S8: dxgiFormat = DXGI_FORMAT_R24G8_TYPELESS; clearDepthValue.Format = DXGI_FORMAT_D24_UNORM_S8_UINT; break; default: LOG_ERROR(RSX, "Bad depth format! (%d)", surfaceDepthFormat); assert(0); } device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Tex2D(dxgiFormat, (UINT)width, (UINT)height, 1, 1, 1, 0, D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL), D3D12_RESOURCE_STATE_DEPTH_WRITE, &clearDepthValue, IID_PPV_ARGS(&ds) ); m_depthStencil[address] = ds; } m_currentlyBoundDepthStencil = ds; m_currentlyBoundDepthStencilAddress = address; return ds; }
// Create the particle vertex buffer. void D3D12nBodyGravity::CreateVertexBuffer() { std::vector<ParticleVertex> vertices; vertices.resize(ParticleCount); for (UINT i = 0; i < ParticleCount; i++) { vertices[i].color = XMFLOAT4(1.0f, 1.0f, 0.2f, 1.0f); } const UINT bufferSize = ParticleCount * sizeof(ParticleVertex); ThrowIfFailed(m_device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(bufferSize), D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&m_vertexBuffer))); ThrowIfFailed(m_device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(bufferSize), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_vertexBufferUpload))); D3D12_SUBRESOURCE_DATA vertexData = {}; vertexData.pData = reinterpret_cast<UINT8*>(&vertices[0]); vertexData.RowPitch = bufferSize; vertexData.SlicePitch = vertexData.RowPitch; UpdateSubresources<1>(m_commandList.Get(), m_vertexBuffer.Get(), m_vertexBufferUpload.Get(), 0, 0, 1, &vertexData); m_commandList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(m_vertexBuffer.Get(), D3D12_RESOURCE_STATE_COPY_DEST, D3D12_RESOURCE_STATE_VERTEX_AND_CONSTANT_BUFFER)); m_vertexBufferView.BufferLocation = m_vertexBuffer->GetGPUVirtualAddress(); m_vertexBufferView.SizeInBytes = static_cast<UINT>(bufferSize); m_vertexBufferView.StrideInBytes = sizeof(ParticleVertex); }
void DynamicConstantBuffer::Init(ID3D12Device* pDevice) { const UINT bufferSize = m_perFrameConstantBufferSize * m_frameCount; ThrowIfFailed(pDevice->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(bufferSize), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_constantBuffer) )); CD3DX12_RANGE readRange(0, 0); // We do not intend to read from this resource on the CPU. ThrowIfFailed(m_constantBuffer->Map(0, &readRange, reinterpret_cast<void**>(&m_pMappedConstantBuffer))); }
// Set up appropriate views for the intermediate render target. void D3D12Fullscreen::LoadSceneResolutionDependentResources() { // Update resolutions shown in app title. UpdateTitle(); // Set up the scene viewport and scissor rect to match the current scene rendering resolution. { m_sceneViewport.Width = static_cast<float>(m_resolutionOptions[m_resolutionIndex].Width); m_sceneViewport.Height = static_cast<float>(m_resolutionOptions[m_resolutionIndex].Height); m_sceneViewport.MaxDepth = 1.0f; m_sceneScissorRect.right = static_cast<LONG>(m_resolutionOptions[m_resolutionIndex].Width); m_sceneScissorRect.bottom = static_cast<LONG>(m_resolutionOptions[m_resolutionIndex].Height); } // Update post-process viewport and scissor rectangle. UpdatePostViewAndScissor(); // Create RTV for the intermediate render target. { D3D12_RESOURCE_DESC swapChainDesc = m_renderTargets[m_frameIndex]->GetDesc(); const CD3DX12_CLEAR_VALUE clearValue(swapChainDesc.Format, ClearColor); const CD3DX12_RESOURCE_DESC renderTargetDesc = CD3DX12_RESOURCE_DESC::Tex2D( swapChainDesc.Format, m_resolutionOptions[m_resolutionIndex].Width, m_resolutionOptions[m_resolutionIndex].Height, 1u, 1u, swapChainDesc.SampleDesc.Count, swapChainDesc.SampleDesc.Quality, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET, D3D12_TEXTURE_LAYOUT_UNKNOWN, 0u); CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle(m_rtvHeap->GetCPUDescriptorHandleForHeapStart(), FrameCount, m_rtvDescriptorSize); ThrowIfFailed(m_device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &renderTargetDesc, D3D12_RESOURCE_STATE_RENDER_TARGET, &clearValue, IID_PPV_ARGS(&m_intermediateRenderTarget))); m_device->CreateRenderTargetView(m_intermediateRenderTarget.Get(), nullptr, rtvHandle); NAME_D3D12_OBJECT(m_intermediateRenderTarget); } // Create SRV for the intermediate render target. m_device->CreateShaderResourceView(m_intermediateRenderTarget.Get(), nullptr, m_cbvSrvHeap->GetCPUDescriptorHandleForHeapStart()); }
void kinc_g5_vertex_buffer_init(kinc_g5_vertex_buffer_t *buffer, int count, kinc_g5_vertex_structure_t *structure, bool gpuMemory, int instanceDataStepRate) { buffer->impl.myCount = count; buffer->impl.lastStart = -1; buffer->impl.lastCount = -1; static_assert(sizeof(D3D12VertexBufferView) == sizeof(D3D12_VERTEX_BUFFER_VIEW), "Something is wrong with D3D12IVertexBufferView"); buffer->impl.myStride = 0; for (int i = 0; i < structure->size; ++i) { switch (structure->elements[i].data) { case KINC_G4_VERTEX_DATA_FLOAT1: buffer->impl.myStride += 1 * 4; break; case KINC_G4_VERTEX_DATA_FLOAT2: buffer->impl.myStride += 2 * 4; break; case KINC_G4_VERTEX_DATA_FLOAT3: buffer->impl.myStride += 3 * 4; break; case KINC_G4_VERTEX_DATA_FLOAT4: buffer->impl.myStride += 4 * 4; break; case KINC_G4_VERTEX_DATA_COLOR: buffer->impl.myStride += 1 * 4; break; case KINC_G4_VERTEX_DATA_SHORT2_NORM: buffer->impl.myStride += 2 * 2; break; case KINC_G4_VERTEX_DATA_SHORT4_NORM: buffer->impl.myStride += 4 * 2; break; } } int uploadBufferSize = buffer->impl.myStride * buffer->impl.myCount; device->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(uploadBufferSize), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_GRAPHICS_PPV_ARGS(&buffer->impl.uploadBuffer)); // device_->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES (D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, // &CD3DX12_RESOURCE_DESC::Buffer(uploadBufferSize), // D3D12_RESOURCE_STATE_COPY_DEST, nullptr, IID_PPV_ARGS(&vertexBuffer)); buffer->impl.view.BufferLocation = buffer->impl.uploadBuffer->GetGPUVirtualAddress(); buffer->impl.view.SizeInBytes = uploadBufferSize; buffer->impl.view.StrideInBytes = buffer->impl.myStride; }
ID3D12Resource *RenderTargets::bindAddressAsRenderTargets(ID3D12Device *device, ID3D12GraphicsCommandList *cmdList, size_t slot, u32 address, size_t width, size_t height, u8 surfaceColorFormat, const std::array<float, 4> &clearColor) { ID3D12Resource* rtt; auto It = m_renderTargets.find(address); // TODO: Check if sizes match if (It != m_renderTargets.end()) { rtt = It->second; cmdList->ResourceBarrier(1, &CD3DX12_RESOURCE_BARRIER::Transition(rtt, D3D12_RESOURCE_STATE_GENERIC_READ, D3D12_RESOURCE_STATE_RENDER_TARGET)); } else { LOG_WARNING(RSX, "Creating RTT"); DXGI_FORMAT dxgiFormat; switch (surfaceColorFormat) { case CELL_GCM_SURFACE_A8R8G8B8: dxgiFormat = DXGI_FORMAT_R8G8B8A8_UNORM; break; case CELL_GCM_SURFACE_F_W16Z16Y16X16: dxgiFormat = DXGI_FORMAT_R16G16B16A16_FLOAT; break; } D3D12_CLEAR_VALUE clearColorValue = {}; clearColorValue.Format = dxgiFormat; clearColorValue.Color[0] = clearColor[0]; clearColorValue.Color[1] = clearColor[1]; clearColorValue.Color[2] = clearColor[2]; clearColorValue.Color[3] = clearColor[3]; device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Tex2D(dxgiFormat, (UINT)width, (UINT)height, 1, 1, 1, 0, D3D12_RESOURCE_FLAG_ALLOW_RENDER_TARGET), D3D12_RESOURCE_STATE_RENDER_TARGET, &clearColorValue, IID_PPV_ARGS(&rtt) ); m_renderTargets[address] = rtt; } m_currentlyBoundRenderTargetsAddress[slot] = address; m_currentlyBoundRenderTargets[slot] = rtt; return rtt; }
// Load size dependent resource HRESULT VolumetricAnimation::LoadSizeDependentResource() { HRESULT hr; // Create render target views (RTVs). CD3DX12_CPU_DESCRIPTOR_HANDLE rtvHandle( m_rtvHeap->GetCPUDescriptorHandleForHeapStart() ); for ( UINT i = 0; i < FrameCount; i++ ) { VRET( m_swapChain->GetBuffer( i, IID_PPV_ARGS( &m_renderTargets[i] ) ) ); DXDebugName( m_renderTargets[i] ); m_device->CreateRenderTargetView( m_renderTargets[i].Get(), nullptr, rtvHandle ); rtvHandle.Offset( 1, m_rtvDescriptorSize ); } // Create the depth stencil. { CD3DX12_RESOURCE_DESC shadowTextureDesc( D3D12_RESOURCE_DIMENSION_TEXTURE2D, 0, static_cast< UINT >( m_width ), static_cast< UINT >( m_height ), 1, 1, DXGI_FORMAT_D32_FLOAT, 1, 0, D3D12_TEXTURE_LAYOUT_UNKNOWN, D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL | D3D12_RESOURCE_FLAG_DENY_SHADER_RESOURCE ); D3D12_CLEAR_VALUE clearValue; // Performance tip: Tell the runtime at resource creation the desired clear value. clearValue.Format = DXGI_FORMAT_D32_FLOAT; clearValue.DepthStencil.Depth = 1.0f; clearValue.DepthStencil.Stencil = 0; VRET( m_device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES( D3D12_HEAP_TYPE_DEFAULT ), D3D12_HEAP_FLAG_NONE, &shadowTextureDesc, D3D12_RESOURCE_STATE_DEPTH_WRITE, &clearValue, IID_PPV_ARGS( &m_depthBuffer ) ) ); DXDebugName( m_depthBuffer ); // Create the depth stencil view. m_device->CreateDepthStencilView( m_depthBuffer.Get(), nullptr, m_dsvHeap->GetCPUDescriptorHandleForHeapStart() ); } m_viewport.Width = static_cast< float >( m_width ); m_viewport.Height = static_cast< float >( m_height ); m_viewport.MaxDepth = 1.0f; m_scissorRect.right = static_cast< LONG >( m_width ); m_scissorRect.bottom = static_cast< LONG >( m_height ); float fAspectRatio = m_width / ( FLOAT ) m_height; m_camera.SetProjParams( XM_PI / 4, fAspectRatio, 0.01f, 1250.0f ); m_camera.SetWindow( m_width, m_height ); return S_OK; }
void GeometryShaderCache::Init() { unsigned int gscbuf12sizeInBytes = gscbuf12paddedSize * gscbuf12Slots; CheckHR( D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(gscbuf12sizeInBytes), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&gscbuf12) ) ); D3D::SetDebugObjectName12(gscbuf12, "vertex shader constant buffer used to emulate the GX pipeline"); // Obtain persistent CPU pointer to GS Constant Buffer CheckHR(gscbuf12->Map(0, nullptr, &gscbuf12data)); // used when drawing clear quads D3D::CompileGeometryShader(clear_shader_code, &ClearGeometryShaderBlob); // used for buffer copy D3D::CompileGeometryShader(copy_shader_code, &CopyGeometryShaderBlob); Clear(); if (!File::Exists(File::GetUserPath(D_SHADERCACHE_IDX))) File::CreateDir(File::GetUserPath(D_SHADERCACHE_IDX)); // Intentionally share the same cache as DX11, as the shaders are identical. Reduces recompilation when switching APIs. std::string cache_filename = StringFromFormat("%sdx11-%s-gs.cache", File::GetUserPath(D_SHADERCACHE_IDX).c_str(), SConfig::GetInstance().m_strUniqueID.c_str()); GeometryShaderCacheInserter inserter; g_gs_disk_cache.OpenAndRead(cache_filename, inserter); if (g_Config.bEnableShaderDebugging) Clear(); last_entry = nullptr; last_uid = {}; }
void Renderer::CreateDepthStencilView() { D3D12_DEPTH_STENCIL_VIEW_DESC DepthStencilViewDesc = {}; DepthStencilViewDesc.Format = DXGI_FORMAT_D32_FLOAT; DepthStencilViewDesc.ViewDimension = D3D12_DSV_DIMENSION_TEXTURE2D; DepthStencilViewDesc.Flags = D3D12_DSV_FLAG_NONE; D3D12_CLEAR_VALUE DSVClearValue = {}; DSVClearValue.Format = DXGI_FORMAT_D32_FLOAT; DSVClearValue.DepthStencil.Depth = 1.0f; DSVClearValue.DepthStencil.Stencil = 0; Window::WindowSize Size = TargetWindow.GetWindowSize(); CD3DX12_RESOURCE_DESC ResourceDesc = CD3DX12_RESOURCE_DESC::Tex2D(DXGI_FORMAT_D32_FLOAT, Size.first, Size.second, 1, 0, 1, 0, D3D12_RESOURCE_FLAG_ALLOW_DEPTH_STENCIL); Utility::ThrowOnFail(DeviceContext.GetDevice()->CreateCommittedResource(&CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_DEFAULT), D3D12_HEAP_FLAG_NONE, &ResourceDesc, D3D12_RESOURCE_STATE_DEPTH_WRITE, &DSVClearValue, IID_PPV_ARGS(&DepthStencelView))); DeviceContext.GetDevice()->CreateDepthStencilView(DepthStencelView.Get(), &DepthStencilViewDesc, DSVHeap->GetCPUDescriptorHandleForHeapStart()); }
void FD3D12BuddyAllocator::Initialize() { FD3D12Device* Device = GetParentDevice(); FD3D12Adapter* Adapter = Device->GetParentAdapter(); if (AllocationStrategy == eBuddyAllocationStrategy::kPlacedResourceStrategy) { D3D12_HEAP_PROPERTIES HeapProps = CD3DX12_HEAP_PROPERTIES(HeapType); HeapProps.CreationNodeMask = GetNodeMask(); HeapProps.VisibleNodeMask = GetVisibilityMask(); D3D12_HEAP_DESC Desc = {}; Desc.SizeInBytes = MaxBlockSize; Desc.Properties = HeapProps; Desc.Alignment = 0; Desc.Flags = HeapFlags; ID3D12Heap* Heap = nullptr; VERIFYD3D12RESULT(Adapter->GetD3DDevice()->CreateHeap(&Desc, IID_PPV_ARGS(&Heap))); SetName(Heap, L"Placed Resource Allocator Backing Heap"); BackingHeap = new FD3D12Heap(GetParentDevice(), GetVisibilityMask()); BackingHeap->SetHeap(Heap); if (IsCPUWritable(HeapType) == false) { BackingHeap->BeginTrackingResidency(Desc.SizeInBytes); } } else { VERIFYD3D12RESULT(Adapter->CreateBuffer(HeapType, GetNodeMask(), GetVisibilityMask(), MaxBlockSize, BackingResource.GetInitReference(), ResourceFlags)); SetName(BackingResource, L"Resource Allocator Underlying Buffer"); if (IsCPUWritable(HeapType)) { BackingResource->Map(); } } }
KBuffer KGraphicsDevice::CreateBuffer(uint32 num_elements, uint32 element_size, KBufferType type, D3D12_HEAP_TYPE heap_type /*= D3D12_HEAP_TYPE_DEFAULT*/) { KBuffer buffer; m_Device->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(heap_type, 0, 0), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(element_size * num_elements), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&buffer.resource)); if(heap_type == D3D12_HEAP_TYPE_UPLOAD) buffer.resource->Map(0, nullptr, reinterpret_cast<void**>(&buffer.mem)); if(type == KBufferType::STRUCTURED) CreateShaderResourceView(&buffer, num_elements, element_size, type); if(type == KBufferType::CONSTANT) CreateConstantBufferView(&buffer, num_elements, element_size); return buffer; }
void D3DStreamBuffer::AllocateBuffer(size_t size) { // First, put existing buffer (if it exists) in deferred destruction list. if (m_buffer) { m_buffer->Unmap(0, nullptr); D3D::command_list_mgr->DestroyResourceAfterCurrentCommandListExecuted(m_buffer); m_buffer = nullptr; } CheckHR( D3D::device12->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(size), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_buffer) ) ); CheckHR(m_buffer->Map(0, nullptr, &m_buffer_cpu_address)); m_buffer_gpu_address = m_buffer->GetGPUVirtualAddress(); m_buffer_size = size; // Start at the beginning of the new buffer. m_buffer_gpu_completion_offset = 0; m_buffer_current_allocation_offset = 0; m_buffer_offset = 0; // Notify observers. if (m_buffer_reallocation_notification != nullptr) *m_buffer_reallocation_notification = true; // If we had any fences queued, they are no longer relevant. ClearFences(); }
//コンスタンスバッファ作成 void CBufferDraw::Impl::CreateConstantBuffer() { auto Dev = App::GetApp()->GetDeviceResources(); ThrowIfFailed(Dev->GetDevice()->CreateCommittedResource( &CD3DX12_HEAP_PROPERTIES(D3D12_HEAP_TYPE_UPLOAD), D3D12_HEAP_FLAG_NONE, &CD3DX12_RESOURCE_DESC::Buffer(sizeof(SpriteConstantBuffer)), D3D12_RESOURCE_STATE_GENERIC_READ, nullptr, IID_PPV_ARGS(&m_ConstantBufferUploadHeap)), L"コンスタントバッファ用のアップロードヒープ作成に失敗しました", L"Dev->GetDevice()->CreateCommittedResource()", L"TriangleSprite::CreateConstantBuffer()" ); //コンスタントバッファのビューを作成 //TODO : デスクリプタとビューの違いについて D3D12_CONSTANT_BUFFER_VIEW_DESC cbvDesc = {}; cbvDesc.BufferLocation = m_ConstantBufferUploadHeap->GetGPUVirtualAddress(); //コンスタントバッファは256バイトにアラインメント cbvDesc.SizeInBytes = (sizeof(SpriteConstantBuffer) + 255) & ~255; //コンスタントバッファビューを作成すべきデスクプリタヒープ上のハンドルを取得 //シェーダリソースがある場合コンスタントバッファはシェーダリソースビューのあとに設置する CD3DX12_CPU_DESCRIPTOR_HANDLE cbvSrvHandle( m_CbvSrvUavDescriptorHeap->GetCPUDescriptorHandleForHeapStart(), 0, 0 ); Dev->GetDevice()->CreateConstantBufferView(&cbvDesc, cbvSrvHandle); //コンスタントバッファのアップロードヒープのマップ CD3DX12_RANGE readRange(0, 0); ThrowIfFailed(m_ConstantBufferUploadHeap->Map(0, &readRange, reinterpret_cast<void**>(&m_pConstantBuffer)), L"コンスタントバッファのマップに失敗しました", L"pImpl->m_ConstantBufferUploadHeap->Map()", L"TriangleSprite::CreateConstantBuffer()" ); }