fixes

Author: Cheaterdev

sources/DirectXFramework/DX12/CommandList.cpp

@@ -187,14 +187,28 @@ namespace DX12
 		m_commandList->EndQuery(pQueryHeap.get_native(), D3D12_QUERY_TYPE_TIMESTAMP, QueryIdx);
 	}
 
-	void Eventer::resolve_times(Resource* resource, QueryHeap& pQueryHeap, uint32_t NumQueries, std::function<void()> f)
-	{
-
+	void Eventer::resolve_times(QueryHeap& pQueryHeap, uint32_t NumQueries, std::function<void(std::span<UINT64>)> f)
+	{	
 		CommandList* list = static_cast<CommandList*>(this); // :(
-		list->transition(resource, ResourceState::COPY_DEST);
+		auto info = list->read_data(NumQueries* sizeof(UINT64));
+
 		list->flush_transitions();
-		m_commandList->ResolveQueryData(pQueryHeap.get_native(), D3D12_QUERY_TYPE_TIMESTAMP, 0, NumQueries, resource->get_native().Get(), 0);
-		on_execute_funcs.emplace_back(f);
+		m_commandList->ResolveQueryData(pQueryHeap.get_native(), D3D12_QUERY_TYPE_TIMESTAMP, 0, NumQueries, info.resource->get_native().Get(), info.offset);
+
+
+		on_execute_funcs.emplace_back([info, f, NumQueries]() {
+
+			UINT64* data;
+			D3D12_RANGE range;
+			range.Begin = info.offset;
+			range.End = info.offset + info.size;
+			info.resource->get_native()->Map(0, &range, reinterpret_cast<void**>(&data));
+
+
+			f(std::span(data, NumQueries));
+			info.resource->get_native()->Unmap(0, nullptr);
+
+			});
 	}
 
 	void GraphicsContext::set_signature(const RootSignature::ptr& s)
@@ -385,7 +399,7 @@ namespace DX12
 		desc.SizeInBytes = (UINT)Math::AlignUp(size, D3D12_CONSTANT_BUFFER_DATA_PLACEMENT_ALIGNMENT);
 
 		assert(desc.SizeInBytes < 65536);
-		Handle h = list.frame_resources->srv_uav_cbv_cpu.place();
+		Handle h = list.frame_resources->get_cpu_heap(Render::DescriptorHeapType::CBV_SRV_UAV).place();
 
 		Device::get().create_cbv(h, resource.get(), desc);
 
@@ -405,39 +419,20 @@ namespace DX12
 		UploadInfo info;
 		info.resource = upload_resources.back();
 		info.offset = resource_offset;
-		resource_offset += AlignedSize;
-		//	UINT64 uploadBufferSize = GetRequiredIntermediateSize(resource->get_native().Get(), first_subresource, sub_count);
-		/*   while (resource_index < upload_resources.size() && resource_offset + uploadBufferSize > upload_resources[resource_index]->get_size())
-		   {
-			   resource_index++; resource_offset = 0;
-		   }
-
-		   if (upload_resources.empty() || upload_resources.size() == resource_index)
-		   {
-			   upload_resources.push_back(BufferCache::get().get_upload(std::max(heap_size, uploadBufferSize)));
-			   resource_offset = 0;
-			   resource_index = upload_resources.size() - 1;
-		   }
-
-		   assert(!upload_resources.empty());
-		   UploadInfo info;
-		   info.resource = upload_resources[resource_index];
-		   info.offset = resource_offset;
-		   resource_offset += uploadBufferSize;
-
-		   if (resource_offset >= upload_resources.back()->get_size())
-			   resource_index++;
-			*/
 		info.size = AlignedSize;
+
+		resource_offset += AlignedSize;
 		return info;
 	}
+
 	Readbacker::ReadBackInfo Readbacker::read_data(UINT64 uploadBufferSize)
 	{
 		auto buff = BufferCache::get().get_readback(uploadBufferSize);//std::make_shared<BufferBase>(uploadBufferSize, HeapType::READBACK, ResourceState::COPY_DEST);
 		read_back_resources.push_back(buff);
 		ReadBackInfo info;
 		info.resource = buff;//read_back_resources.back();
 		info.offset = 0;
+		info.size = uploadBufferSize;
 		return info;
 	}
 	void  CopyContext::update_resource(Resource::ptr resource, UINT first_subresource, UINT sub_count, D3D12_SUBRESOURCE_DATA* data)
@@ -555,7 +550,11 @@ namespace DX12
 	}
 	std::future<bool> CopyContext::read_texture(const Resource* resource, ivec3 offset, ivec3 box, UINT sub_resource, std::function<void(const char*, UINT64, UINT64, UINT64)> f)
 	{
-		base.transition(resource, Render::ResourceState::COPY_SOURCE);
+		if (base.type != CommandListType::COPY)
+			base.transition(resource, Render::ResourceState::COPY_SOURCE);
+		else
+			base.transition(resource, Render::ResourceState::COMMON);
+
 		base.flush_transitions();
 		UINT64 RequiredSize = 0;
 		D3D12_PLACED_SUBRESOURCE_FOOTPRINT Layouts;

sources/DirectXFramework/DX12/CommandList.h

@@ -33,6 +33,8 @@ namespace DX12
 		std::mutex upload;
 		std::mutex read_back;
 
+
+		ResourceHeapAllocator allocator;
 	public:
 
 		std::shared_ptr<UploadBuffer> get_upload(UINT64 size);
@@ -168,31 +170,46 @@ namespace DX12
 	template<class LockPolicy = Free>
 	class GPUCompiledManager : public Uploader
 	{
-		//	using cb_buffer = virtual_gpu_buffer<std::byte>;
+		enum_array<DescriptorHeapType, typename DynamicDescriptor<LockPolicy>::ptr> cpu_heaps;
+		enum_array<DescriptorHeapType, typename DynamicDescriptor<LockPolicy>::ptr> gpu_heaps;
 
-		//	static Cache<std::shared_ptr<cb_buffer>> cbv_cache;
 	public:
-		DynamicDescriptor<DescriptorHeapType::CBV_SRV_UAV, LockPolicy, DescriptorHeapFlags::SHADER_VISIBLE> srv;
-		DynamicDescriptor<DescriptorHeapType::SAMPLER, LockPolicy, DescriptorHeapFlags::SHADER_VISIBLE> smp;
 
-		DynamicDescriptor<DescriptorHeapType::CBV_SRV_UAV, LockPolicy> srv_uav_cbv_cpu;
-		DynamicDescriptor<DescriptorHeapType::RTV, LockPolicy> rtv_cpu;
-		DynamicDescriptor<DescriptorHeapType::DSV, LockPolicy> dsv_cpu;
-		DynamicDescriptor<DescriptorHeapType::SAMPLER, LockPolicy> smp_cpu;
+		DynamicDescriptor<LockPolicy>& get_cpu_heap(DescriptorHeapType type)
+		{
+			assert(cpu_heaps[type]);
+			return *cpu_heaps[type];
+		}
 
-		//	std::shared_ptr<cb_buffer> cb;
+		DynamicDescriptor<LockPolicy>& get_gpu_heap(DescriptorHeapType type)
+		{
+			assert(cpu_heaps[type]);
+			return *gpu_heaps[type];
+		}
+
+		GPUCompiledManager()
+		{
+			gpu_heaps[DescriptorHeapType::CBV_SRV_UAV] = std::make_shared<DynamicDescriptor<LockPolicy>>(DescriptorHeapType::CBV_SRV_UAV, DescriptorHeapFlags::SHADER_VISIBLE);
+			gpu_heaps[DescriptorHeapType::SAMPLER] = std::make_shared<DynamicDescriptor<LockPolicy>>(DescriptorHeapType::SAMPLER, DescriptorHeapFlags::SHADER_VISIBLE);
+
+			cpu_heaps[DescriptorHeapType::CBV_SRV_UAV] = std::make_shared<DynamicDescriptor<LockPolicy>>(DescriptorHeapType::CBV_SRV_UAV, DescriptorHeapFlags::NONE);
+			cpu_heaps[DescriptorHeapType::RTV] = std::make_shared<DynamicDescriptor<LockPolicy>>(DescriptorHeapType::RTV, DescriptorHeapFlags::NONE);
+			cpu_heaps[DescriptorHeapType::DSV] = std::make_shared<DynamicDescriptor<LockPolicy>>(DescriptorHeapType::DSV, DescriptorHeapFlags::NONE);
+			cpu_heaps[DescriptorHeapType::SAMPLER] = std::make_shared<DynamicDescriptor<LockPolicy>>(DescriptorHeapType::SAMPLER, DescriptorHeapFlags::NONE);
+		}
 
 		void reset()
 		{
-			srv.reset();
-			smp.reset();
 
-			srv_uav_cbv_cpu.reset();
-			rtv_cpu.reset();
-			dsv_cpu.reset();
-			smp_cpu.reset();
-			Uploader::reset();
+			for (auto& h : gpu_heaps)
+				if (h)
+					h->reset();
 
+			for (auto& h : cpu_heaps)
+				if (h)
+					h->reset();
+
+			Uploader::reset();
 		}
 
 	};
@@ -556,6 +573,7 @@ namespace DX12
 		{
 			std::shared_ptr<CPUBuffer> resource;
 			UINT64 offset;
+			UINT64 size;
 		};
 
 		ReadBackInfo read_data(UINT64 uploadBufferSize);
@@ -641,7 +659,7 @@ namespace DX12
 
 		// timers
 		void insert_time(QueryHeap& pQueryHeap, uint32_t QueryIdx);
-		void resolve_times(Resource* resource, QueryHeap& pQueryHeap, uint32_t NumQueries, std::function<void()>);
+		void resolve_times(QueryHeap& pQueryHeap, uint32_t NumQueries, std::function<void(std::span<UINT64>)>);
 
 	};
 
@@ -856,7 +874,7 @@ namespace DX12
 			transition_uav(h.resource_info);
 
 			flush_transitions();
-			auto handle = srv.place(h);
+			auto handle = get_cpu_heap(DescriptorHeapType::CBV_SRV_UAV).place(h);
 			get_native_list()->ClearUnorderedAccessViewUint(handle.gpu, h.cpu, resource->get_native().Get(), reinterpret_cast<UINT*>(ClearColor.data()), 0, nullptr);
 		}
 
@@ -866,7 +884,7 @@ namespace DX12
 			transition_uav(h.resource_info);
 
 			flush_transitions();
-			auto handle = srv.place(h);
+			auto handle = get_cpu_heap(DescriptorHeapType::CBV_SRV_UAV).place(h);
 			get_native_list()->ClearUnorderedAccessViewFloat(handle.gpu, h.cpu, resource->get_native().Get(), reinterpret_cast<FLOAT*>(ClearColor.data()), 0, nullptr);
 		}
 
@@ -1124,22 +1142,22 @@ namespace DX12
 
 		HandleTableLight place_rtv(UINT count)
 		{
-			return get_base().rtv_cpu.place(count);
+			return get_base().get_cpu_heap(DescriptorHeapType::RTV).place(count);
 		}
 
 		HandleTableLight place_dsv(UINT count)
 		{
-			return get_base().dsv_cpu.place(count);
+			return get_base().get_cpu_heap(DescriptorHeapType::DSV).place(count);
 		}
 
 		HandleTableLight place_rtv(std::initializer_list<Handle> list)
 		{
-			return get_base().rtv_cpu.place(list);
+			return get_base().get_cpu_heap(DescriptorHeapType::RTV).place(list);
 		}
 
 		HandleTableLight place_dsv(std::initializer_list<Handle> list)
 		{
-			return get_base().dsv_cpu.place(list);
+			return get_base().get_cpu_heap(DescriptorHeapType::DSV).place(list);
 		}
 
 		void set_rtvs_internal(D3D12_CPU_DESCRIPTOR_HANDLE* t, Handle h)

sources/DirectXFramework/DX12/Descriptors.h

@@ -766,9 +766,12 @@ namespace DX12
 		using mutex = std::atomic<std::thread::id>;
 	};
 
-	template<DescriptorHeapType type, class LockPolicy = Free, DescriptorHeapFlags flags = DescriptorHeapFlags::NONE>
+	template<class LockPolicy = Free>
 	class DynamicDescriptor
 	{
+		DescriptorHeapType type;
+		DescriptorHeapFlags flags = DescriptorHeapFlags::NONE;
+
 		friend class CommandList;
 		friend class GraphicsContext;
 		friend class ComputeContext;
@@ -779,7 +782,7 @@ namespace DX12
 		typename LockPolicy::mutex m;
 		void create_heap(UINT count)
 		{
-			if constexpr (flags == DescriptorHeapFlags::SHADER_VISIBLE)
+			if (flags == DescriptorHeapFlags::SHADER_VISIBLE)
 			{
 				pages.push_back(DescriptorHeapManager::get().get_gpu_heap(type)->create_page(count));
 			}
@@ -815,6 +818,13 @@ namespace DX12
 		}
 
 	public:
+
+		using ptr = std::shared_ptr<DynamicDescriptor<LockPolicy>>;
+		DynamicDescriptor(DescriptorHeapType type, DescriptorHeapFlags flags):type(type),flags(flags)
+		{
+
+		}
+
 		~DynamicDescriptor()
 		{
 			reset();

sources/DirectXFramework/DX12/GPUTimer.h

@@ -9,9 +9,6 @@ namespace DX12
 
 		QueryHeap heap;
 		std::mutex buffer_lock;
-		std::queue<std::shared_ptr<CPUBuffer>> buffers;
-	
-
 		static const int MAX_TIMERS = 1024;
 		IdGenerator ids;
 		std::array<UINT64, MAX_TIMERS*2> read_back_data;
@@ -47,70 +44,14 @@ namespace DX12
 			return static_cast<double>(gpu_start) / frequency;
 		}
 
-
-		/*	void start_read()
-			{
-				if (fence != -1)
-					DX12::Device::get().get_queue(CommandListType::DIRECT)->wait(fence);
-
-				read_back_data = buffer.map<UINT64>(0, MAX_TIMERS * 2);
-			}
-
-			void end_read()
-			{
-				buffer.unmap();
-				auto list = DX12::Device::get().get_queue(CommandListType::DIRECT)->get_free_list();
-				list->begin();
-				list->resolve_times(&buffer, heap, MAX_TIMERS * 2);
-				list->end();
-				fence = list->execute();
-			}
-			*/
 		void read_buffer(CommandList::ptr &list, std::function<void()> f)
 		{
-			std::shared_ptr<CPUBuffer> current_buffer;
-			{
-				std::lock_guard<std::mutex> g(buffer_lock);
-
-				if(buffers.empty())
-				{
-					current_buffer.reset(new CPUBuffer(MAX_TIMERS * 2, sizeof(UINT64)));
-				}
-				else {
-					current_buffer = buffers.front();
-					buffers.pop();
-				}
-			}
-
-			list->resolve_times(current_buffer.get(), heap, MAX_TIMERS * 2, [this, f, current_buffer]() {
-				memcpy(read_back_data.data(), current_buffer->map<UINT64>(0, MAX_TIMERS * 2), sizeof(UINT64)*MAX_TIMERS*2);
-				current_buffer->unmap();
-				{
-					std::lock_guard<std::mutex> g(buffer_lock);
-					buffers.push(current_buffer);
-				}
+			list->resolve_times( heap, MAX_TIMERS * 2, [this, f](std::span<UINT64> data) {
+				std::copy(data.begin(), data.end(), read_back_data.begin());
 				f();
-			
 			});
 		}
 
-		/*
-		void read_buffer(std::function<void()> f)
-		{
-			auto list = DX12::Device::get().get_queue(CommandListType::DIRECT)->get_free_list();
-			list->begin();
-			list->resolve_times(&buffer, heap, MAX_TIMERS * 2, [this, f]() {
-				read_back_data = buffer.map<UINT64>(0, MAX_TIMERS * 2);
-				f();
-				buffer.unmap();
-			});
-
-			list->end();
-			list->execute();
-
-
-
-		}*/
 	};
 
 

sources/DirectXFramework/DX12/Memory.h

@@ -14,6 +14,8 @@ namespace DX12
 
 	class ResourceHeap
 	{
+		std::shared_ptr<Resource> cpu_buffer;
+
 	public:
 		ComPtr<ID3D12Heap > heap;
 		HeapType type;
@@ -176,12 +178,6 @@ namespace DX12
 		UINT offset;
 		UINT count = 1;
 	};
-	enum class TileState : int
-	{
-		LOADED,
-		FREED,
-		NONE
-	};
 
 	struct ResourceTile
 	{

sources/DirectXFramework/DX12/PipelineState.h

@@ -470,7 +470,7 @@ namespace DX12
 				//Log::get() << desc << Log::endl;
 				auto state=  PipelineState::ptr(new PipelineState(desc, binary));
 
-				if (!desc.name.empty() && binary.empty())
+				if (!desc.name.empty())
 				{
 					binary_cache[desc.name] = state->get_cache();
 				}
@@ -485,7 +485,7 @@ namespace DX12
 					//Log::get() << desc << Log::endl;
 					auto state = ComputePipelineState::ptr(new ComputePipelineState(desc,binary));
 
-					if (!desc.name.empty() &&binary.empty())
+					if (!desc.name.empty())
 					{
 						binary_cache[desc.name] = state->get_cache();
 					}