code clean

Author: hongqingwan

libobs-d3d12/d3d12-command-context.cpp

@@ -1,20 +1,3 @@
-/******************************************************************************
-    Copyright (C) 2023 by Lain Bailey <[email protected]>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-******************************************************************************/
-
 #include "d3d12-command-context.hpp"
 
 #include <util/base.h>
@@ -264,12 +247,30 @@ D3D12_CPU_DESCRIPTOR_HANDLE DescriptorAllocator::Allocate(uint32_t Count)
 			m_DescriptorSize = m_DeviceInstance->GetDevice()->GetDescriptorHandleIncrementSize(m_Type);
 	}
 
+	if (m_RemainingFreeHandles <= 0) {
+		throw HRError("DescriptorAllocator: No remaining free handles");
+	}
+
 	D3D12_CPU_DESCRIPTOR_HANDLE ret = m_CurrentHandle;
 	m_CurrentHandle.ptr += Count * m_DescriptorSize;
 	m_RemainingFreeHandles -= Count;
 	return ret;
 }
 
+size_t DescriptorAllocator::RemainingFreeCount() {
+	return m_RemainingFreeHandles;
+}
+
+void DescriptorAllocator::DiscardAll()
+{
+	if (m_CurrentHeap == nullptr) {
+		return;
+	}
+
+	m_CurrentHandle = m_CurrentHeap->GetCPUDescriptorHandleForHeapStart();
+	m_RemainingFreeHandles = sm_NumDescriptorsPerHeap;
+}
+
 DescriptorHandle::DescriptorHandle()
 {
 	m_CpuHandle.ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
@@ -743,6 +744,19 @@ GpuBuffer::~GpuBuffer()
 	Destroy();
 }
 
+void GpuBuffer::Destroy()
+{
+	if (m_UAV.ptr != D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN) {
+		m_UAV.ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
+	}
+
+	if (m_SRV.ptr != D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN) {
+		m_SRV.ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
+	}
+
+	GpuResource::Destroy();
+}
+
 void GpuBuffer::Create(const std::wstring &name, uint32_t NumElements, uint32_t ElementSize, const void *initialData)
 {
 	Destroy();
@@ -1544,6 +1558,11 @@ DepthBuffer::DepthBuffer(D3D12DeviceInstance *DeviceInstance, float ClearDepth,
 	m_hStencilSRV.ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
 }
 
+DepthBuffer::~DepthBuffer()
+{
+	Destroy();
+}
+
 void DepthBuffer::Create(const std::wstring &Name, uint32_t Width, uint32_t Height, DXGI_FORMAT Format,
 			 D3D12_GPU_VIRTUAL_ADDRESS VidMemPtr)
 {
@@ -1563,6 +1582,35 @@ void DepthBuffer::Create(const std::wstring &Name, uint32_t Width, uint32_t Heig
 	CreateDerivedViews(m_DeviceInstance->GetDevice());
 }
 
+void DepthBuffer::Destroy()
+{
+	if (m_hDSV[0].ptr != D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN) {
+		m_hDSV[0].ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
+	}
+
+	if (m_hDSV[1].ptr != D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN) {
+		m_hDSV[1].ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
+	}
+
+	if (m_hDSV[2].ptr != D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN) {
+		m_hDSV[2].ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
+	}
+
+	if (m_hDSV[3].ptr != D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN) {
+		m_hDSV[3].ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
+	}
+
+	if (m_hDepthSRV.ptr != D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN) {
+		m_hDepthSRV.ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
+	}
+
+	if (m_hStencilSRV.ptr != D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN) {
+		m_hStencilSRV.ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
+	}
+
+	GpuResource::Destroy();
+}
+
 const D3D12_CPU_DESCRIPTOR_HANDLE &DepthBuffer::GetDSV() const
 {
 	return m_hDSV[0];
@@ -3625,6 +3673,7 @@ void EngineProfiling::DisplayFrameRate()
 
 SamplerDesc::SamplerDesc(D3D12DeviceInstance *DeviceInstance) : m_DeviceInstance(DeviceInstance)
 {
+	Sampler.ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
 	Filter = D3D12_FILTER_ANISOTROPIC;
 	AddressU = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
 	AddressV = D3D12_TEXTURE_ADDRESS_MODE_WRAP;
@@ -3640,6 +3689,13 @@ SamplerDesc::SamplerDesc(D3D12DeviceInstance *DeviceInstance) : m_DeviceInstance
 	MaxLOD = D3D12_FLOAT32_MAX;
 }
 
+SamplerDesc::~SamplerDesc()
+{
+	if (Sampler.ptr != D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN) {
+		Sampler.ptr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN;
+	}
+}
+
 void SamplerDesc::SetTextureAddressMode(D3D12_TEXTURE_ADDRESS_MODE AddressMode)
 {
 	AddressU = AddressMode;
@@ -3655,17 +3711,10 @@ void SamplerDesc::SetBorderColor(Color Border)
 	BorderColor[3] = Border.w;
 }
 
-D3D12_CPU_DESCRIPTOR_HANDLE SamplerDesc::CreateDescriptor(void)
+void SamplerDesc::CreateDescriptor(void)
 {
-	size_t hashValue = Utility::HashState(this);
-	auto iter = m_DeviceInstance->GetSamplerCache().find(hashValue);
-	if (iter != m_DeviceInstance->GetSamplerCache().end()) {
-		return iter->second;
-	}
-
-	D3D12_CPU_DESCRIPTOR_HANDLE Handle = m_DeviceInstance->AllocateDescriptor(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
-	m_DeviceInstance->GetDevice()->CreateSampler(this, Handle);
-	return Handle;
+	Sampler = m_DeviceInstance->AllocateDescriptor(D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER);
+	m_DeviceInstance->GetDevice()->CreateSampler(this, Sampler);
 }
 
 void SamplerDesc::CreateDescriptor(D3D12_CPU_DESCRIPTOR_HANDLE Handle)
@@ -3862,11 +3911,6 @@ DescriptorAllocator *D3D12DeviceInstance::GetDescriptorAllocator()
 	return m_DescriptorAllocator;
 }
 
-std::map<size_t, D3D12_CPU_DESCRIPTOR_HANDLE> &D3D12DeviceInstance::GetSamplerCache()
-{
-	return m_SamplerCache;
-}
-
 ID3D12DescriptorHeap *D3D12DeviceInstance::RequestCommonHeap(D3D12_DESCRIPTOR_HEAP_TYPE Type)
 {
 	D3D12_DESCRIPTOR_HEAP_DESC Desc;
@@ -3930,6 +3974,11 @@ D3D12_CPU_DESCRIPTOR_HANDLE D3D12DeviceInstance::AllocateDescriptor(D3D12_DESCRI
 	return m_DescriptorAllocator[Type].Allocate(Count);
 }
 
+void D3D12DeviceInstance::DiscardDescriptorAll(D3D12_DESCRIPTOR_HEAP_TYPE Type, UINT Count)
+{
+	m_DescriptorAllocator[Type].DiscardAll();
+}
+
 GraphicsContext *D3D12DeviceInstance::GetNewGraphicsContext(const std::wstring &ID)
 {
 	CommandContext *NewContext = m_ContextManager->AllocateContext(D3D12_COMMAND_LIST_TYPE_DIRECT);

libobs-d3d12/d3d12-command-context.hpp

@@ -591,6 +591,8 @@ class DescriptorAllocator {
 public:
 	DescriptorAllocator(D3D12DeviceInstance *DeviceInstance, D3D12_DESCRIPTOR_HEAP_TYPE Type);
 	D3D12_CPU_DESCRIPTOR_HANDLE Allocate(uint32_t Count);
+	void DiscardAll();
+	size_t RemainingFreeCount();
 
 protected:
 	D3D12DeviceInstance *m_DeviceInstance = nullptr;
@@ -810,6 +812,8 @@ class GpuBuffer : public GpuResource {
 	GpuBuffer(D3D12DeviceInstance *DeviceInstance);
 	virtual ~GpuBuffer();
 
+	virtual void Destroy() override;
+
 	// Create a buffer.  If initial data is provided, it will be copied into the buffer using the default command context.
 	void Create(const std::wstring &name, uint32_t NumElements, uint32_t ElementSize,
 		    const void *initialData = nullptr);
@@ -944,6 +948,7 @@ struct Color {
 class DepthBuffer : public PixelBuffer {
 public:
 	DepthBuffer(D3D12DeviceInstance *DeviceInstance, float ClearDepth = 0.0f, uint8_t ClearStencil = 0);
+	virtual ~DepthBuffer();
 	// Create a depth buffer.  If an address is supplied, memory will not be allocated.
 	// The vmem address allows you to alias buffers (which can be especially useful for
 	// reusing ESRAM across a frame.)
@@ -952,6 +957,7 @@ class DepthBuffer : public PixelBuffer {
 
 	void Create(const std::wstring &Name, uint32_t Width, uint32_t Height, uint32_t NumSamples, DXGI_FORMAT Format,
 		    D3D12_GPU_VIRTUAL_ADDRESS VidMemPtr = D3D12_GPU_VIRTUAL_ADDRESS_UNKNOWN);
+	virtual void Destroy() override;
 
 	// Get pre-created CPU-visible descriptor handles
 	const D3D12_CPU_DESCRIPTOR_HANDLE &GetDSV() const;
@@ -1332,6 +1338,10 @@ class CommandContext : NonCopyable {
 	D3D12_COMMAND_LIST_TYPE m_Type;
 };
 
+class GraphicsCopyContext {
+
+};
+
 class GraphicsContext : public CommandContext {
 public:
 	void ClearUAV(GpuBuffer &Target);
@@ -1410,8 +1420,6 @@ class GraphicsContext : public CommandContext {
 
 class ComputeContext : public CommandContext {
 public:
-	static ComputeContext &Begin(const std::wstring &ID = L"", bool Async = false);
-
 	void ClearUAV(GpuBuffer &Target);
 
 	void SetRootSignature(const RootSignature &RootSig);
@@ -1538,13 +1546,15 @@ class EngineProfiling {
 class SamplerDesc : public D3D12_SAMPLER_DESC {
 public:
 	SamplerDesc(D3D12DeviceInstance *DeviceInstance);
+	~SamplerDesc();
 	void SetTextureAddressMode(D3D12_TEXTURE_ADDRESS_MODE AddressMode);
 	void SetBorderColor(Color Border);
 
-	D3D12_CPU_DESCRIPTOR_HANDLE CreateDescriptor(void);
+	void CreateDescriptor(void);
 	void CreateDescriptor(D3D12_CPU_DESCRIPTOR_HANDLE Handle);
 
 	D3D12DeviceInstance *m_DeviceInstance = nullptr;
+	D3D12_CPU_DESCRIPTOR_HANDLE Sampler;
 };
 
 struct MonitorColorInfo {
@@ -1589,14 +1599,15 @@ class D3D12DeviceInstance {
 	CommandSignature &GetDispatchIndirectCommandSignature();
 	CommandSignature &GetDrawIndirectCommandSignature();
 	DescriptorAllocator *GetDescriptorAllocator();
-	std::map<size_t, D3D12_CPU_DESCRIPTOR_HANDLE> &GetSamplerCache();
 
 	DescriptorAllocator m_DescriptorAllocator[D3D12_DESCRIPTOR_HEAP_TYPE_NUM_TYPES] = {
 		{this, D3D12_DESCRIPTOR_HEAP_TYPE_CBV_SRV_UAV},
 		{this, D3D12_DESCRIPTOR_HEAP_TYPE_SAMPLER},
 		{this, D3D12_DESCRIPTOR_HEAP_TYPE_RTV},
 		{this, D3D12_DESCRIPTOR_HEAP_TYPE_DSV}};
 	D3D12_CPU_DESCRIPTOR_HANDLE AllocateDescriptor(D3D12_DESCRIPTOR_HEAP_TYPE Type, UINT Count = 1);
+	void DiscardDescriptorAll(D3D12_DESCRIPTOR_HEAP_TYPE Type, UINT Count = 1);
+
 	ID3D12DescriptorHeap *RequestCommonHeap(D3D12_DESCRIPTOR_HEAP_TYPE Type);
 
 	ID3D12DescriptorHeap *RequestDynamicDescriptorHeap(D3D12_DESCRIPTOR_HEAP_TYPE HeapType);
@@ -1668,8 +1679,6 @@ class D3D12DeviceInstance {
 	std::map<size_t, ComPtr<ID3D12PipelineState>> m_GraphicsPSOHashMap;
 	std::map<size_t, ComPtr<ID3D12PipelineState>> m_ComputePSOHashMap;
 
-	std::map<size_t, D3D12_CPU_DESCRIPTOR_HANDLE> m_SamplerCache;
-
 	bool m_TypedUAVLoadSupport_R11G11B10_FLOAT = false;
 	bool m_TypedUAVLoadSupport_R16G16B16A16_FLOAT = false;
 	bool m_NV12Supported = false;

libobs-d3d12/d3d12-duplicator.cpp

@@ -1,20 +1,3 @@
-/******************************************************************************
-    Copyright (C) 2023 by Lain Bailey <[email protected]>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-******************************************************************************/
-
 #include "d3d12-subsystem.hpp"
 #include <unordered_map>
 

libobs-d3d12/d3d12-indexbuffer.cpp

@@ -1,20 +1,3 @@
-/******************************************************************************
-    Copyright (C) 2023 by Lain Bailey <[email protected]>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-******************************************************************************/
-
 #include "d3d12-subsystem.hpp"
 
 void gs_index_buffer::InitBuffer()

libobs-d3d12/d3d12-samplerstate.cpp

@@ -1,20 +1,3 @@
-/******************************************************************************
-    Copyright (C) 2023 by Lain Bailey <[email protected]>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-******************************************************************************/
-
 #include <graphics/vec4.h>
 #include <float.h>
 
@@ -83,5 +66,5 @@ gs_sampler_state::gs_sampler_state(gs_device_t *device, const gs_sampler_info *i
 	sampleDesc.AddressW = ConvertGSAddressMode(info->address_w);
 	sampleDesc.ComparisonFunc = D3D12_COMPARISON_FUNC_NEVER;
 	sampleDesc.MaxAnisotropy = 0;
-	sampler = sampleDesc.CreateDescriptor();
+	sampleDesc.CreateDescriptor();
 }

libobs-d3d12/d3d12-shader.cpp

@@ -1,20 +1,3 @@
-/******************************************************************************
-    Copyright (C) 2023 by Lain Bailey <[email protected]>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 2 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <http://www.gnu.org/licenses/>.
-******************************************************************************/
-
 #include "d3d12-subsystem.hpp"
 #include "d3d12-shaderprocessor.hpp"
 #include <graphics/vec2.h>
@@ -253,7 +236,8 @@ inline void gs_shader::UpdateParam(std::vector<uint8_t> &constData, gs_shader_pa
 			device_load_texture(device, shader_tex.tex, param.textureID);
 
 		if (param.nextSampler) {
-			device->context->SetDynamicSampler(samplerRootParameterIndex, 0, param.nextSampler->sampler);
+			device->context->SetDynamicSampler(samplerRootParameterIndex, 0,
+							   param.nextSampler->sampleDesc.Sampler);
 			param.nextSampler = nullptr;
 		}
 	}