fg: use hashmap in resource allocators (#3962)

...to handle hash collisions gracefully.
This commit is contained in:
Yun Hsiao Wu
2021-10-11 15:28:03 +08:00
committed by GitHub
parent 3965709e15
commit 5e282a9ce5
16 changed files with 471 additions and 422 deletions
+121 -121
View File
@@ -15541,9 +15541,9 @@ bool js_register_gfx_GFXObject(se::Object* obj) // NOLINT(readability-identifier
{
auto* cls = se::Class::create("GFXObject", obj, nullptr, _SE(js_gfx_GFXObject_constructor));
cls->defineProperty("typedID", _SE(js_gfx_GFXObject_getTypedID), nullptr);
cls->defineProperty("objectID", _SE(js_gfx_GFXObject_getObjectID), nullptr);
cls->defineProperty("objectType", _SE(js_gfx_GFXObject_getObjectType), nullptr);
cls->defineProperty("objectID", _SE(js_gfx_GFXObject_getObjectID), nullptr);
cls->defineProperty("typedID", _SE(js_gfx_GFXObject_getTypedID), nullptr);
cls->defineFinalizeFunction(_SE(js_cc_gfx_GFXObject_finalize));
cls->install();
JSBClassType::registerClass<cc::gfx::GFXObject>(cls);
@@ -15773,12 +15773,12 @@ bool js_register_gfx_Buffer(se::Object* obj) // NOLINT(readability-identifier-na
{
auto* cls = se::Class::create("Buffer", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_gfx_Buffer_constructor));
cls->defineProperty("count", _SE(js_gfx_Buffer_getCount), nullptr);
cls->defineProperty("usage", _SE(js_gfx_Buffer_getUsage), nullptr);
cls->defineProperty("memUsage", _SE(js_gfx_Buffer_getMemUsage), nullptr);
cls->defineProperty("stride", _SE(js_gfx_Buffer_getStride), nullptr);
cls->defineProperty("flags", _SE(js_gfx_Buffer_getFlags), nullptr);
cls->defineProperty("usage", _SE(js_gfx_Buffer_getUsage), nullptr);
cls->defineProperty("count", _SE(js_gfx_Buffer_getCount), nullptr);
cls->defineProperty("size", _SE(js_gfx_Buffer_getSize), nullptr);
cls->defineProperty("flags", _SE(js_gfx_Buffer_getFlags), nullptr);
cls->defineFunction("destroy", _SE(js_gfx_Buffer_destroy));
cls->defineFunction("isBufferView", _SE(js_gfx_Buffer_isBufferView));
cls->defineFunction("resize", _SE(js_gfx_Buffer_resize));
@@ -16239,19 +16239,19 @@ bool js_register_gfx_InputAssembler(se::Object* obj) // NOLINT(readability-ident
{
auto* cls = se::Class::create("InputAssembler", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_gfx_InputAssembler_constructor));
cls->defineProperty("instanceCount", _SE(js_gfx_InputAssembler_getInstanceCount), _SE(js_gfx_InputAssembler_setInstanceCount));
cls->defineProperty("vertexBuffers", _SE(js_gfx_InputAssembler_getVertexBuffers), nullptr);
cls->defineProperty("attributesHash", _SE(js_gfx_InputAssembler_getAttributesHash), nullptr);
cls->defineProperty("firstInstance", _SE(js_gfx_InputAssembler_getFirstInstance), _SE(js_gfx_InputAssembler_setFirstInstance));
cls->defineProperty("vertexCount", _SE(js_gfx_InputAssembler_getVertexCount), _SE(js_gfx_InputAssembler_setVertexCount));
cls->defineProperty("drawInfo", _SE(js_gfx_InputAssembler_getDrawInfo), nullptr);
cls->defineProperty("indexBuffer", _SE(js_gfx_InputAssembler_getIndexBuffer), nullptr);
cls->defineProperty("vertexOffset", _SE(js_gfx_InputAssembler_getVertexOffset), _SE(js_gfx_InputAssembler_setVertexOffset));
cls->defineProperty("attributes", _SE(js_gfx_InputAssembler_getAttributes), nullptr);
cls->defineProperty("indexBuffer", _SE(js_gfx_InputAssembler_getIndexBuffer), nullptr);
cls->defineProperty("indirectBuffer", _SE(js_gfx_InputAssembler_getIndirectBuffer), nullptr);
cls->defineProperty("attributesHash", _SE(js_gfx_InputAssembler_getAttributesHash), nullptr);
cls->defineProperty("drawInfo", _SE(js_gfx_InputAssembler_getDrawInfo), nullptr);
cls->defineProperty("vertexCount", _SE(js_gfx_InputAssembler_getVertexCount), _SE(js_gfx_InputAssembler_setVertexCount));
cls->defineProperty("firstVertex", _SE(js_gfx_InputAssembler_getFirstVertex), _SE(js_gfx_InputAssembler_setFirstVertex));
cls->defineProperty("indexCount", _SE(js_gfx_InputAssembler_getIndexCount), _SE(js_gfx_InputAssembler_setIndexCount));
cls->defineProperty("firstIndex", _SE(js_gfx_InputAssembler_getFirstIndex), _SE(js_gfx_InputAssembler_setFirstIndex));
cls->defineProperty("indirectBuffer", _SE(js_gfx_InputAssembler_getIndirectBuffer), nullptr);
cls->defineProperty("firstVertex", _SE(js_gfx_InputAssembler_getFirstVertex), _SE(js_gfx_InputAssembler_setFirstVertex));
cls->defineProperty("vertexOffset", _SE(js_gfx_InputAssembler_getVertexOffset), _SE(js_gfx_InputAssembler_setVertexOffset));
cls->defineProperty("instanceCount", _SE(js_gfx_InputAssembler_getInstanceCount), _SE(js_gfx_InputAssembler_setInstanceCount));
cls->defineProperty("firstInstance", _SE(js_gfx_InputAssembler_getFirstInstance), _SE(js_gfx_InputAssembler_setFirstInstance));
cls->defineFunction("destroy", _SE(js_gfx_InputAssembler_destroy));
cls->defineFunction("initialize", _SE(js_gfx_InputAssembler_initialize));
cls->defineFinalizeFunction(_SE(js_cc_gfx_InputAssembler_finalize));
@@ -17412,7 +17412,7 @@ static bool js_gfx_DescriptorSet_getLayout(se::State& s) // NOLINT(readability-i
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_gfx_DescriptorSet_getLayout)
SE_BIND_PROP_GET(js_gfx_DescriptorSet_getLayout)
static bool js_gfx_DescriptorSet_getSampler(se::State& s) // NOLINT(readability-identifier-naming)
{
@@ -17563,6 +17563,7 @@ bool js_register_gfx_DescriptorSet(se::Object* obj) // NOLINT(readability-identi
{
auto* cls = se::Class::create("DescriptorSet", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_gfx_DescriptorSet_constructor));
cls->defineProperty("layout", _SE(js_gfx_DescriptorSet_getLayout), nullptr);
cls->defineFunction("bindBuffer", _SE(js_gfx_DescriptorSet_bindBuffer));
cls->defineFunction("bindBufferJSB", _SE(js_gfx_DescriptorSet_bindBufferJSB));
cls->defineFunction("bindSampler", _SE(js_gfx_DescriptorSet_bindSampler));
@@ -17571,7 +17572,6 @@ bool js_register_gfx_DescriptorSet(se::Object* obj) // NOLINT(readability-identi
cls->defineFunction("bindTextureJSB", _SE(js_gfx_DescriptorSet_bindTextureJSB));
cls->defineFunction("destroy", _SE(js_gfx_DescriptorSet_destroy));
cls->defineFunction("getBuffer", _SE(js_gfx_DescriptorSet_getBuffer));
cls->defineFunction("getLayout", _SE(js_gfx_DescriptorSet_getLayout));
cls->defineFunction("getSampler", _SE(js_gfx_DescriptorSet_getSampler));
cls->defineFunction("getTexture", _SE(js_gfx_DescriptorSet_getTexture));
cls->defineFunction("initialize", _SE(js_gfx_DescriptorSet_initialize));
@@ -17867,8 +17867,8 @@ bool js_register_gfx_Framebuffer(se::Object* obj) // NOLINT(readability-identifi
{
auto* cls = se::Class::create("Framebuffer", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_gfx_Framebuffer_constructor));
cls->defineProperty("colorTextures", _SE(js_gfx_Framebuffer_getColorTextures), nullptr);
cls->defineProperty("renderPass", _SE(js_gfx_Framebuffer_getRenderPass), nullptr);
cls->defineProperty("colorTextures", _SE(js_gfx_Framebuffer_getColorTextures), nullptr);
cls->defineProperty("depthStencilTexture", _SE(js_gfx_Framebuffer_getDepthStencilTexture), nullptr);
cls->defineFunction("destroy", _SE(js_gfx_Framebuffer_destroy));
cls->defineFunction("initialize", _SE(js_gfx_Framebuffer_initialize));
@@ -18237,14 +18237,14 @@ bool js_register_gfx_PipelineState(se::Object* obj) // NOLINT(readability-identi
{
auto* cls = se::Class::create("PipelineState", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_gfx_PipelineState_constructor));
cls->defineProperty("primitive", _SE(js_gfx_PipelineState_getPrimitive), nullptr);
cls->defineProperty("rasterizerState", _SE(js_gfx_PipelineState_getRasterizerState), nullptr);
cls->defineProperty("shader", _SE(js_gfx_PipelineState_getShader), nullptr);
cls->defineProperty("primitive", _SE(js_gfx_PipelineState_getPrimitive), nullptr);
cls->defineProperty("bindPoint", _SE(js_gfx_PipelineState_getBindPoint), nullptr);
cls->defineProperty("inputState", _SE(js_gfx_PipelineState_getInputState), nullptr);
cls->defineProperty("rasterizerState", _SE(js_gfx_PipelineState_getRasterizerState), nullptr);
cls->defineProperty("depthStencilState", _SE(js_gfx_PipelineState_getDepthStencilState), nullptr);
cls->defineProperty("blendState", _SE(js_gfx_PipelineState_getBlendState), nullptr);
cls->defineProperty("renderPass", _SE(js_gfx_PipelineState_getRenderPass), nullptr);
cls->defineProperty("inputState", _SE(js_gfx_PipelineState_getInputState), nullptr);
cls->defineProperty("bindPoint", _SE(js_gfx_PipelineState_getBindPoint), nullptr);
cls->defineProperty("depthStencilState", _SE(js_gfx_PipelineState_getDepthStencilState), nullptr);
cls->defineFunction("destroy", _SE(js_gfx_PipelineState_destroy));
cls->defineFunction("getDynamicStates", _SE(js_gfx_PipelineState_getDynamicStates));
cls->defineFunction("getPipelineLayout", _SE(js_gfx_PipelineState_getPipelineLayout));
@@ -18830,10 +18830,10 @@ bool js_register_gfx_Shader(se::Object* obj) // NOLINT(readability-identifier-na
{
auto* cls = se::Class::create("Shader", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_gfx_Shader_constructor));
cls->defineProperty("attributes", _SE(js_gfx_Shader_getAttributes), nullptr);
cls->defineProperty("stages", _SE(js_gfx_Shader_getStages), nullptr);
cls->defineProperty("blocks", _SE(js_gfx_Shader_getBlocks), nullptr);
cls->defineProperty("name", _SE(js_gfx_Shader_getName), nullptr);
cls->defineProperty("stages", _SE(js_gfx_Shader_getStages), nullptr);
cls->defineProperty("attributes", _SE(js_gfx_Shader_getAttributes), nullptr);
cls->defineProperty("blocks", _SE(js_gfx_Shader_getBlocks), nullptr);
cls->defineProperty("samplers", _SE(js_gfx_Shader_getSamplers), nullptr);
cls->defineFunction("destroy", _SE(js_gfx_Shader_destroy));
cls->defineFunction("getBuffers", _SE(js_gfx_Shader_getBuffers));
@@ -19107,12 +19107,12 @@ bool js_register_gfx_Texture(se::Object* obj) // NOLINT(readability-identifier-n
auto* cls = se::Class::create("Texture", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_gfx_Texture_constructor));
cls->defineProperty("info", _SE(js_gfx_Texture_getInfo), nullptr);
cls->defineProperty("hash", _SE(js_gfx_Texture_getHash), nullptr);
cls->defineProperty("format", _SE(js_gfx_Texture_getFormat), nullptr);
cls->defineProperty("height", _SE(js_gfx_Texture_getHeight), nullptr);
cls->defineProperty("width", _SE(js_gfx_Texture_getWidth), nullptr);
cls->defineProperty("viewInfo", _SE(js_gfx_Texture_getViewInfo), nullptr);
cls->defineProperty("width", _SE(js_gfx_Texture_getWidth), nullptr);
cls->defineProperty("height", _SE(js_gfx_Texture_getHeight), nullptr);
cls->defineProperty("format", _SE(js_gfx_Texture_getFormat), nullptr);
cls->defineProperty("size", _SE(js_gfx_Texture_getSize), nullptr);
cls->defineProperty("hash", _SE(js_gfx_Texture_getHash), nullptr);
cls->defineFunction("destroy", _SE(js_gfx_Texture_destroy));
cls->defineFunction("isTextureView", _SE(js_gfx_Texture_isTextureView));
cls->defineFunction("resize", _SE(js_gfx_Texture_resize));
@@ -19384,10 +19384,10 @@ bool js_register_gfx_Swapchain(se::Object* obj) // NOLINT(readability-identifier
auto* cls = se::Class::create("Swapchain", obj, __jsb_cc_gfx_GFXObject_proto, _SE(js_gfx_Swapchain_constructor));
cls->defineProperty("width", _SE(js_gfx_Swapchain_getWidth), nullptr);
cls->defineProperty("surfaceTransform", _SE(js_gfx_Swapchain_getSurfaceTransform), nullptr);
cls->defineProperty("depthStencilTexture", _SE(js_gfx_Swapchain_getDepthStencilTexture), nullptr);
cls->defineProperty("colorTexture", _SE(js_gfx_Swapchain_getColorTexture), nullptr);
cls->defineProperty("height", _SE(js_gfx_Swapchain_getHeight), nullptr);
cls->defineProperty("surfaceTransform", _SE(js_gfx_Swapchain_getSurfaceTransform), nullptr);
cls->defineProperty("colorTexture", _SE(js_gfx_Swapchain_getColorTexture), nullptr);
cls->defineProperty("depthStencilTexture", _SE(js_gfx_Swapchain_getDepthStencilTexture), nullptr);
cls->defineFunction("createSurface", _SE(js_gfx_Swapchain_createSurface));
cls->defineFunction("destroy", _SE(js_gfx_Swapchain_destroy));
cls->defineFunction("destroySurface", _SE(js_gfx_Swapchain_destroySurface));
@@ -20418,17 +20418,17 @@ bool js_register_gfx_Device(se::Object* obj) // NOLINT(readability-identifier-na
{
auto* cls = se::Class::create("Device", obj, nullptr, nullptr);
cls->defineProperty("gfxAPI", _SE(js_gfx_Device_getGfxAPI), nullptr);
cls->defineProperty("deviceName", _SE(js_gfx_Device_getDeviceName), nullptr);
cls->defineProperty("memoryStatus", _SE(js_gfx_Device_getMemoryStatus), nullptr);
cls->defineProperty("queue", _SE(js_gfx_Device_getQueue), nullptr);
cls->defineProperty("commandBuffer", _SE(js_gfx_Device_getCommandBuffer), nullptr);
cls->defineProperty("renderer", _SE(js_gfx_Device_getRenderer), nullptr);
cls->defineProperty("vendor", _SE(js_gfx_Device_getVendor), nullptr);
cls->defineProperty("numDrawCalls", _SE(js_gfx_Device_getNumDrawCalls), nullptr);
cls->defineProperty("memoryStatus", _SE(js_gfx_Device_getMemoryStatus), nullptr);
cls->defineProperty("gfxAPI", _SE(js_gfx_Device_getGfxAPI), nullptr);
cls->defineProperty("capabilities", _SE(js_gfx_Device_getCapabilities), nullptr);
cls->defineProperty("numTris", _SE(js_gfx_Device_getNumTris), nullptr);
cls->defineProperty("queue", _SE(js_gfx_Device_getQueue), nullptr);
cls->defineProperty("renderer", _SE(js_gfx_Device_getRenderer), nullptr);
cls->defineProperty("commandBuffer", _SE(js_gfx_Device_getCommandBuffer), nullptr);
cls->defineProperty("numInstances", _SE(js_gfx_Device_getNumInstances), nullptr);
cls->defineProperty("numTris", _SE(js_gfx_Device_getNumTris), nullptr);
cls->defineProperty("capabilities", _SE(js_gfx_Device_getCapabilities), nullptr);
cls->defineFunction("acquire", _SE(js_gfx_Device_acquire));
cls->defineFunction("bindingMappingInfo", _SE(js_gfx_Device_bindingMappingInfo));
cls->defineFunction("createCommandBuffer", _SE(js_gfx_Device_createCommandBuffer));
@@ -20462,19 +20462,6 @@ bool js_register_gfx_Device(se::Object* obj) // NOLINT(readability-identifier-na
se::Object* __jsb_cc_gfx_DeviceManager_proto = nullptr;
se::Class* __jsb_cc_gfx_DeviceManager_class = nullptr;
static bool js_gfx_DeviceManager_destroy(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cc::gfx::DeviceManager::destroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_gfx_DeviceManager_destroy)
static bool js_gfx_DeviceManager_create(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
@@ -20495,6 +20482,19 @@ static bool js_gfx_DeviceManager_create(se::State& s) // NOLINT(readability-iden
}
SE_BIND_FUNC(js_gfx_DeviceManager_create)
static bool js_gfx_DeviceManager_destroy(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
size_t argc = args.size();
if (argc == 0) {
cc::gfx::DeviceManager::destroy();
return true;
}
SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0);
return false;
}
SE_BIND_FUNC(js_gfx_DeviceManager_destroy)
static bool js_gfx_DeviceManager_addSurfaceEventListener(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
@@ -20526,8 +20526,8 @@ bool js_register_gfx_DeviceManager(se::Object* obj) // NOLINT(readability-identi
{
auto* cls = se::Class::create("DeviceManager", obj, nullptr, nullptr);
cls->defineStaticFunction("destroy", _SE(js_gfx_DeviceManager_destroy));
cls->defineStaticFunction("create", _SE(js_gfx_DeviceManager_create));
cls->defineStaticFunction("destroy", _SE(js_gfx_DeviceManager_destroy));
cls->defineStaticFunction("addSurfaceEventListener", _SE(js_gfx_DeviceManager_addSurfaceEventListener));
cls->defineFinalizeFunction(_SE(js_cc_gfx_DeviceManager_finalize));
cls->install();
@@ -20551,81 +20551,81 @@ bool register_all_gfx(se::Object* obj)
}
se::Object* ns = nsVal.toObject();
js_register_gfx_Size(ns);
js_register_gfx_DeviceCaps(ns);
js_register_gfx_Offset(ns);
js_register_gfx_Rect(ns);
js_register_gfx_Extent(ns);
js_register_gfx_TextureSubresLayers(ns);
js_register_gfx_TextureSubresRange(ns);
js_register_gfx_TextureCopy(ns);
js_register_gfx_TextureBlit(ns);
js_register_gfx_BufferTextureCopy(ns);
js_register_gfx_Viewport(ns);
js_register_gfx_Color(ns);
js_register_gfx_BindingMappingInfo(ns);
js_register_gfx_SwapchainInfo(ns);
js_register_gfx_DeviceInfo(ns);
js_register_gfx_BufferInfo(ns);
js_register_gfx_BufferViewInfo(ns);
js_register_gfx_DrawInfo(ns);
js_register_gfx_DispatchInfo(ns);
js_register_gfx_IndirectBuffer(ns);
js_register_gfx_TextureInfo(ns);
js_register_gfx_TextureViewInfo(ns);
js_register_gfx_SamplerInfo(ns);
js_register_gfx_Uniform(ns);
js_register_gfx_UniformBlock(ns);
js_register_gfx_UniformSamplerTexture(ns);
js_register_gfx_UniformSampler(ns);
js_register_gfx_UniformTexture(ns);
js_register_gfx_UniformStorageImage(ns);
js_register_gfx_UniformStorageBuffer(ns);
js_register_gfx_UniformInputAttachment(ns);
js_register_gfx_ShaderStage(ns);
js_register_gfx_Attribute(ns);
js_register_gfx_ShaderInfo(ns);
js_register_gfx_InputAssemblerInfo(ns);
js_register_gfx_ColorAttachment(ns);
js_register_gfx_DepthStencilAttachment(ns);
js_register_gfx_SubpassInfo(ns);
js_register_gfx_SubpassDependency(ns);
js_register_gfx_RenderPassInfo(ns);
js_register_gfx_GlobalBarrierInfo(ns);
js_register_gfx_TextureBarrierInfo(ns);
js_register_gfx_FramebufferInfo(ns);
js_register_gfx_DescriptorSetLayoutBinding(ns);
js_register_gfx_DescriptorSetLayoutInfo(ns);
js_register_gfx_DescriptorSetInfo(ns);
js_register_gfx_PipelineLayoutInfo(ns);
js_register_gfx_InputState(ns);
js_register_gfx_RasterizerState(ns);
js_register_gfx_DepthStencilState(ns);
js_register_gfx_BlendTarget(ns);
js_register_gfx_BlendState(ns);
js_register_gfx_PipelineStateInfo(ns);
js_register_gfx_CommandBufferInfo(ns);
js_register_gfx_QueueInfo(ns);
js_register_gfx_MemoryStatus(ns);
js_register_gfx_GFXObject(ns);
js_register_gfx_Buffer(ns);
js_register_gfx_InputAssembler(ns);
js_register_gfx_CommandBuffer(ns);
js_register_gfx_DescriptorSet(ns);
js_register_gfx_DescriptorSetLayout(ns);
js_register_gfx_Framebuffer(ns);
js_register_gfx_PipelineLayout(ns);
js_register_gfx_PipelineState(ns);
js_register_gfx_Queue(ns);
js_register_gfx_RenderPass(ns);
js_register_gfx_Shader(ns);
js_register_gfx_Texture(ns);
js_register_gfx_Swapchain(ns);
js_register_gfx_GlobalBarrier(ns);
js_register_gfx_Sampler(ns);
js_register_gfx_TextureBarrier(ns);
js_register_gfx_Device(ns);
js_register_gfx_Texture(ns);
js_register_gfx_Uniform(ns);
js_register_gfx_DescriptorSet(ns);
js_register_gfx_BlendTarget(ns);
js_register_gfx_DispatchInfo(ns);
js_register_gfx_PipelineState(ns);
js_register_gfx_TextureBarrierInfo(ns);
js_register_gfx_PipelineLayout(ns);
js_register_gfx_Sampler(ns);
js_register_gfx_InputAssembler(ns);
js_register_gfx_RenderPass(ns);
js_register_gfx_BufferInfo(ns);
js_register_gfx_SamplerInfo(ns);
js_register_gfx_QueueInfo(ns);
js_register_gfx_UniformStorageBuffer(ns);
js_register_gfx_SubpassDependency(ns);
js_register_gfx_UniformSamplerTexture(ns);
js_register_gfx_BufferTextureCopy(ns);
js_register_gfx_PipelineLayoutInfo(ns);
js_register_gfx_InputAssemblerInfo(ns);
js_register_gfx_TextureBlit(ns);
js_register_gfx_TextureInfo(ns);
js_register_gfx_GlobalBarrierInfo(ns);
js_register_gfx_RenderPassInfo(ns);
js_register_gfx_Extent(ns);
js_register_gfx_Offset(ns);
js_register_gfx_CommandBuffer(ns);
js_register_gfx_Framebuffer(ns);
js_register_gfx_Viewport(ns);
js_register_gfx_TextureSubresLayers(ns);
js_register_gfx_BufferViewInfo(ns);
js_register_gfx_UniformInputAttachment(ns);
js_register_gfx_UniformSampler(ns);
js_register_gfx_ShaderInfo(ns);
js_register_gfx_PipelineStateInfo(ns);
js_register_gfx_Shader(ns);
js_register_gfx_BlendState(ns);
js_register_gfx_GlobalBarrier(ns);
js_register_gfx_DescriptorSetInfo(ns);
js_register_gfx_DescriptorSetLayoutInfo(ns);
js_register_gfx_DrawInfo(ns);
js_register_gfx_InputState(ns);
js_register_gfx_CommandBufferInfo(ns);
js_register_gfx_UniformStorageImage(ns);
js_register_gfx_UniformBlock(ns);
js_register_gfx_DepthStencilAttachment(ns);
js_register_gfx_TextureSubresRange(ns);
js_register_gfx_TextureViewInfo(ns);
js_register_gfx_Queue(ns);
js_register_gfx_ColorAttachment(ns);
js_register_gfx_RasterizerState(ns);
js_register_gfx_DeviceManager(ns);
js_register_gfx_Color(ns);
js_register_gfx_Attribute(ns);
js_register_gfx_MemoryStatus(ns);
js_register_gfx_DeviceInfo(ns);
js_register_gfx_Swapchain(ns);
js_register_gfx_DepthStencilState(ns);
js_register_gfx_BindingMappingInfo(ns);
js_register_gfx_FramebufferInfo(ns);
js_register_gfx_DeviceCaps(ns);
js_register_gfx_Rect(ns);
js_register_gfx_ShaderStage(ns);
js_register_gfx_DescriptorSetLayoutBinding(ns);
js_register_gfx_UniformTexture(ns);
js_register_gfx_DescriptorSetLayout(ns);
js_register_gfx_TextureCopy(ns);
js_register_gfx_IndirectBuffer(ns);
js_register_gfx_Size(ns);
return true;
}
+1 -2
View File
@@ -650,7 +650,6 @@ SE_DECLARE_FUNC(js_gfx_DescriptorSet_bindTexture);
SE_DECLARE_FUNC(js_gfx_DescriptorSet_bindTextureJSB);
SE_DECLARE_FUNC(js_gfx_DescriptorSet_destroy);
SE_DECLARE_FUNC(js_gfx_DescriptorSet_getBuffer);
SE_DECLARE_FUNC(js_gfx_DescriptorSet_getLayout);
SE_DECLARE_FUNC(js_gfx_DescriptorSet_getSampler);
SE_DECLARE_FUNC(js_gfx_DescriptorSet_getTexture);
SE_DECLARE_FUNC(js_gfx_DescriptorSet_initialize);
@@ -851,7 +850,7 @@ bool js_register_cc_gfx_DeviceManager(se::Object* obj);
bool register_all_gfx(se::Object* obj);
JSB_REGISTER_OBJECT_TYPE(cc::gfx::DeviceManager);
SE_DECLARE_FUNC(js_gfx_DeviceManager_destroy);
SE_DECLARE_FUNC(js_gfx_DeviceManager_create);
SE_DECLARE_FUNC(js_gfx_DeviceManager_destroy);
SE_DECLARE_FUNC(js_gfx_DeviceManager_addSurfaceEventListener);
@@ -36,8 +36,6 @@
namespace cc {
namespace framegraph {
#define PRESENT_USING_MOVE_SEMANTIC 1
namespace {
// use function scoped static member
// to ensure correct initialization order
@@ -47,10 +45,6 @@ StringPool &getStringPool() {
}
} // namespace
FrameGraph::~FrameGraph() {
gc(0);
}
StringHandle FrameGraph::stringToHandle(const char *const name) {
return getStringPool().stringToHandle(name);
}
@@ -59,20 +53,8 @@ const char *FrameGraph::handleToString(const StringHandle &handle) noexcept {
return getStringPool().handleToString(handle);
}
void FrameGraph::present(const TextureHandle &input, gfx::Texture *target) {
void FrameGraph::present(const TextureHandle &input, gfx::Texture *target, bool useMoveSemantic) {
static const StringHandle PRESENT_PASS{FrameGraph::stringToHandle("Present")};
// using a global map here so that the user don't need to worry about importing the targets every frame
static std::unordered_map<uint32_t, std::pair<StringHandle, Texture>> presentTargets;
if (!presentTargets.count(target->getTypedID())) {
auto name = FrameGraph::stringToHandle(StringUtil::format("Present Target %d", target->getTypedID()).c_str());
presentTargets.emplace(std::piecewise_construct, std::forward_as_tuple(target->getTypedID()), std::forward_as_tuple(name, Texture{target}));
}
auto & resourceInfo{presentTargets[target->getTypedID()]};
TextureHandle output{getBlackboard().get(resourceInfo.first)};
if (!output.isValid()) {
output = importExternal(resourceInfo.first, resourceInfo.second);
getBlackboard().put(resourceInfo.first, output);
}
const ResourceNode &resourceNode{getResourceNode(input)};
CC_ASSERT(resourceNode.writer);
@@ -85,11 +67,24 @@ void FrameGraph::present(const TextureHandle &input, gfx::Texture *target) {
resourceNode.writer->_insertPoint, PRESENT_PASS,
[&](PassNodeBuilder &builder, PassDataPresent &data) {
data.input = builder.read(input);
#if PRESENT_USING_MOVE_SEMANTIC
move(data.input, output, 0, 0, 0);
data.input = output;
#endif
builder.sideEffect();
if (useMoveSemantic) {
// using a global map here so that the user don't need to worry about importing the targets every frame
static std::unordered_map<uint32_t, std::pair<StringHandle, Texture>> presentTargets;
if (!presentTargets.count(target->getTypedID())) {
auto name = FrameGraph::stringToHandle(StringUtil::format("Present Target %d", target->getTypedID()).c_str());
presentTargets.emplace(std::piecewise_construct, std::forward_as_tuple(target->getTypedID()), std::forward_as_tuple(name, Texture{target}));
}
auto & resourceInfo{presentTargets[target->getTypedID()]};
TextureHandle output{getBlackboard().get(resourceInfo.first)};
if (!output.isValid()) {
output = importExternal(resourceInfo.first, resourceInfo.second);
getBlackboard().put(resourceInfo.first, output);
}
move(data.input, output, 0, 0, 0);
data.input = output;
}
},
[target](const PassDataPresent &data, const DevicePassResourceTable &table) {
auto *cmdBuff = gfx::Device::getInstance()->getCommandBuffer();
@@ -106,17 +101,17 @@ void FrameGraph::present(const TextureHandle &input, gfx::Texture *target) {
});
}
void FrameGraph::presentLastVersion(const VirtualResource *const virtualResource, gfx::Texture *target) {
void FrameGraph::presentLastVersion(const VirtualResource *const virtualResource, gfx::Texture *target, bool useMoveSemantic) {
const auto it = std::find_if(_resourceNodes.rbegin(), _resourceNodes.rend(), [&virtualResource](const ResourceNode &node) {
return node.virtualResource == virtualResource;
});
CC_ASSERT(it != _resourceNodes.rend());
present(TextureHandle(static_cast<Handle::IndexType>(it.base() - _resourceNodes.begin() - 1)), target);
present(TextureHandle(static_cast<Handle::IndexType>(it.base() - _resourceNodes.begin() - 1)), target, useMoveSemantic);
}
void FrameGraph::presentFromBlackboard(const StringHandle &inputName, gfx::Texture *target) {
present(TextureHandle(_blackboard.get(inputName)), target);
void FrameGraph::presentFromBlackboard(const StringHandle &inputName, gfx::Texture *target, bool useMoveSemantic) {
present(TextureHandle(_blackboard.get(inputName)), target, useMoveSemantic);
}
void FrameGraph::compile() {
@@ -44,7 +44,7 @@ public:
using ResourceHandleBlackboard = Blackboard<StringHandle, Handle::IndexType, Handle::UNINITIALIZED>;
FrameGraph() = default;
~FrameGraph();
~FrameGraph() = default;
FrameGraph(const FrameGraph &) = delete;
FrameGraph(FrameGraph &&) noexcept = delete;
FrameGraph &operator=(const FrameGraph &) = delete;
@@ -53,9 +53,9 @@ public:
static StringHandle stringToHandle(const char *name);
static const char * handleToString(const StringHandle &handle) noexcept;
void present(const TextureHandle &input, gfx::Texture *target);
void presentLastVersion(const VirtualResource *virtualResource, gfx::Texture *target);
void presentFromBlackboard(const StringHandle &inputName, gfx::Texture *target);
void present(const TextureHandle &input, gfx::Texture *target, bool useMoveSemantic = true);
void presentLastVersion(const VirtualResource *virtualResource, gfx::Texture *target, bool useMoveSemantic = true);
void presentFromBlackboard(const StringHandle &inputName, gfx::Texture *target, bool useMoveSemantic = true);
void compile();
void execute() noexcept;
void reset() noexcept;
+20 -50
View File
@@ -37,13 +37,6 @@
namespace cc {
namespace framegraph {
template <typename DescriptorType>
struct ResourceDescriptorHasher final {
inline uint32_t operator()(const DescriptorType & /*desc*/) const {
return 1;
}
};
template <typename DeviceResourceType, typename DescriptorType>
struct DeviceResourceCreator final {
inline DeviceResourceType *operator()(const DescriptorType & /*desc*/) const {
@@ -52,15 +45,12 @@ struct DeviceResourceCreator final {
};
template <typename DeviceResourceType, typename DescriptorType,
typename DeviceResourceCreatorType = DeviceResourceCreator<DeviceResourceType, DescriptorType>,
typename DescriptorHasherType = ResourceDescriptorHasher<DescriptorType>>
typename DeviceResourceCreatorType = DeviceResourceCreator<DeviceResourceType, DescriptorType>>
class Resource final {
public:
using Allocator = ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>;
using DescriptorHash = typename Allocator::DescriptorHash;
using DeviceResource = DeviceResourceType;
using Descriptor = DescriptorType;
using DescriptorHasher = DescriptorHasherType;
Resource() = default;
explicit Resource(const Descriptor &desc);
@@ -80,10 +70,8 @@ public:
private:
explicit Resource(DeviceResourceType *external);
void computeHash() noexcept;
Descriptor _desc;
DescriptorHash _hash{0};
DeviceResourceType *_deviceObject{nullptr};
friend class FrameGraph;
@@ -91,76 +79,57 @@ private:
//////////////////////////////////////////////////////////////////////////
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType, typename DescriptorHasherType>
Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType, DescriptorHasherType>::Resource(const Descriptor &desc)
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::Resource(const Descriptor &desc)
: _desc(desc) {
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType, typename DescriptorHasherType>
Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType, DescriptorHasherType>::Resource(DeviceResourceType *external)
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::Resource(DeviceResourceType *external)
: _desc(external->getInfo()), _deviceObject(external) {
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType, typename DescriptorHasherType>
void Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType, DescriptorHasherType>::createTransient() noexcept {
computeHash();
_deviceObject = Allocator::getInstance().alloc(_desc, _hash);
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
void Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::createTransient() noexcept {
_deviceObject = Allocator::getInstance().alloc(_desc);
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType, typename DescriptorHasherType>
void Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType, DescriptorHasherType>::createPersistent() noexcept {
computeHash();
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
void Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::createPersistent() noexcept {
if (!_deviceObject) {
DeviceResourceCreatorType creator;
_deviceObject = creator(_desc);
}
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType, typename DescriptorHasherType>
void Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType, DescriptorHasherType>::destroyTransient() noexcept {
CC_ASSERT(_hash);
Allocator::getInstance().free(_desc, _hash, _deviceObject);
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
void Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::destroyTransient() noexcept {
Allocator::getInstance().free(_desc, _deviceObject);
_deviceObject = nullptr;
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType, typename DescriptorHasherType>
void Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType, DescriptorHasherType>::destroyPersistent() noexcept {
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
void Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::destroyPersistent() noexcept {
if (_deviceObject) {
delete _deviceObject;
_deviceObject = nullptr;
}
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType, typename DescriptorHasherType>
DeviceResourceType *Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType, DescriptorHasherType>::get() const noexcept {
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
DeviceResourceType *Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::get() const noexcept {
return _deviceObject;
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType, typename DescriptorHasherType>
const DescriptorType &Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType, DescriptorHasherType>::getDesc() const noexcept {
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
const DescriptorType &Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::getDesc() const noexcept {
return _desc;
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType, typename DescriptorHasherType>
void Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType, DescriptorHasherType>::computeHash() noexcept {
if (!_hash) {
DescriptorHasher hasher;
_hash = hasher(_desc);
}
}
//////////////////////////////////////////////////////////////////////////
#define DEFINE_GFX_RESOURCE(Type) \
template <> \
struct ResourceDescriptorHasher<gfx::Type##Info> final { \
inline uint32_t operator()(const gfx::Type##Info &desc) const { \
return gfx::Type::computeHash(desc); \
} \
}; \
\
template <> \
struct DeviceResourceCreator<gfx::Type, gfx::Type##Info> final { \
inline gfx::Type *operator()(const gfx::Type##Info &desc) const { \
return gfx::Device::getInstance()->create##Type(desc); \
@@ -169,6 +138,7 @@ void Resource<DeviceResourceType, DescriptorType, DeviceResourceCreatorType, Des
using Type = Resource<gfx::Type, gfx::Type##Info>; \
using Type##Handle = TypedHandle<Type>;
// Descriptors must have std::hash specialization and == operators
DEFINE_GFX_RESOURCE(Buffer)
DEFINE_GFX_RESOURCE(Framebuffer)
DEFINE_GFX_RESOURCE(RenderPass)
@@ -26,6 +26,7 @@
#pragma once
#include <algorithm>
#include <unordered_map>
#include "base/memory/Memory.h"
namespace cc {
@@ -34,96 +35,79 @@ namespace framegraph {
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
class ResourceAllocator final {
public:
using DescriptorHash = uint32_t;
using DeviceResourceCreator = DeviceResourceCreatorType;
ResourceAllocator(const ResourceAllocator &) = delete;
ResourceAllocator(ResourceAllocator &&) = delete;
ResourceAllocator(const ResourceAllocator &) = delete;
ResourceAllocator(ResourceAllocator &&) noexcept = delete;
ResourceAllocator &operator=(const ResourceAllocator &) = delete;
ResourceAllocator &operator=(ResourceAllocator &&) = delete;
ResourceAllocator &operator=(ResourceAllocator &&) noexcept = delete;
static ResourceAllocator &getInstance() noexcept;
DeviceResourceType * alloc(const DescriptorType &desc, DescriptorHash key) noexcept;
void free(const DescriptorType &desc, DescriptorHash key, DeviceResourceType *resource) noexcept;
DeviceResourceType * alloc(const DescriptorType &desc) noexcept;
void free(const DescriptorType &desc, DeviceResourceType *resource) noexcept;
inline void tick() noexcept;
void gc(uint32_t unusedFrameCount) noexcept;
private:
using DeviceResourcePtr = DeviceResourceType *;
struct DeviceResourcePtrGC {
DeviceResourcePtr resource{nullptr};
uint64_t age{0ULL};
struct Bucket {
explicit Bucket(DescriptorHash const key) noexcept : key(key) {}
using Pool = std::vector<DeviceResourcePtr>;
DescriptorHash key{0};
Pool pool{};
};
struct BucketGC final : public Bucket {
using Bucket::Bucket;
std::vector<uint64_t> ages{};
DeviceResourcePtrGC(DeviceResourcePtr resource, uint64_t age) : resource(resource), age(age) {}
};
using DeviceResourcePool = std::vector<DeviceResourcePtr>;
using DeviceResourcePoolGC = std::vector<DeviceResourcePtrGC>;
ResourceAllocator() noexcept = default;
~ResourceAllocator() = default;
template <typename Cache>
typename Bucket::Pool *getPool(DescriptorHash key, Cache &from) noexcept;
BucketGC & getBucketGC(DescriptorHash key) noexcept;
std::vector<BucketGC> _free{};
std::vector<Bucket> _inUse{};
uint64_t _age{0};
std::unordered_map<DescriptorType, DeviceResourcePool> _livepool{};
std::unordered_map<DescriptorType, DeviceResourcePoolGC> _deadpool{};
uint64_t _age{0};
};
//////////////////////////////////////////////////////////////////////////
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType> &ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::getInstance() noexcept {
ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType> &
ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::getInstance() noexcept {
static ResourceAllocator instance;
return instance;
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
DeviceResourceType *ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::alloc(const DescriptorType &desc, DescriptorHash const key) noexcept {
auto it = std::find_if(_free.begin(), _free.end(), [&key](const BucketGC &x) {
return key == x.key;
});
DeviceResourceType *ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::alloc(const DescriptorType &desc) noexcept {
auto &deadpool{_deadpool[desc]};
if (it == _free.end()) {
_free.emplace_back(key);
_inUse.emplace_back(key);
it = _free.end() - 1;
}
DeviceResourcePtr resource{nullptr};
DeviceResourcePtr resource = nullptr;
if (it->pool.empty()) {
if (deadpool.empty()) {
DeviceResourceCreator creator;
resource = creator(desc);
} else {
resource = it->pool.back();
it->pool.pop_back();
it->ages.pop_back();
resource = deadpool.back().resource;
deadpool.pop_back();
}
getPool(key, _inUse)->emplace_back(resource);
auto &livepool{_livepool[desc]};
livepool.emplace_back(resource);
return resource;
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
void ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::free(const DescriptorType & /*desc*/, DescriptorHash const key, DeviceResourceType *const resource) noexcept {
auto *pool = getPool(key, _inUse);
CC_ASSERT(!pool->empty());
void ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::free(const DescriptorType &desc, DeviceResourceType *const resource) noexcept {
auto &livepool{_livepool[desc]};
CC_ASSERT(!livepool.empty());
auto it = std::find_if(pool->begin(), pool->end(), [&resource](DeviceResourcePtr x) {
auto it = std::find_if(livepool.begin(), livepool.end(), [&resource](DeviceResourcePtr x) {
return resource == x;
});
CC_ASSERT(it != pool->end());
pool->erase(it);
CC_ASSERT(it != livepool.end());
livepool.erase(it);
auto &freeBucket = getBucketGC(key);
freeBucket.pool.emplace_back(resource);
freeBucket.ages.emplace_back(_age);
DeviceResourcePoolGC &deadpool{_deadpool[desc]};
deadpool.emplace_back(resource, _age);
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
@@ -133,8 +117,10 @@ void ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreator
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
void ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::gc(uint32_t const unusedFrameCount) noexcept {
std::for_each(_free.begin(), _free.end(), [&](BucketGC &bucket) {
const size_t count = bucket.ages.size();
for (auto &pair : _deadpool) {
DeviceResourcePoolGC &deadpool = pair.second;
const size_t count = deadpool.size();
if (!count) {
return;
@@ -143,16 +129,15 @@ void ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreator
size_t destroyBegin = count - 1;
for (size_t i = 0; i < count; ++i) {
if (_age - bucket.ages[i] < unusedFrameCount) {
if (_age - deadpool[i].age < unusedFrameCount) {
continue;
}
size_t j = destroyBegin;
for (; j > i; --j) {
if (_age - bucket.ages[j] < unusedFrameCount) {
std::swap(bucket.ages[i], bucket.ages[j]);
std::swap(bucket.pool[i], bucket.pool[j]);
if (_age - deadpool[j].age < unusedFrameCount) {
std::swap(deadpool[i], deadpool[j]);
destroyBegin = j;
break;
}
@@ -168,34 +153,10 @@ void ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreator
}
while (++destroyBegin <= count) {
CC_SAFE_DESTROY(bucket.pool.back());
bucket.pool.pop_back();
bucket.ages.pop_back();
CC_SAFE_DESTROY(deadpool.back().resource);
deadpool.pop_back();
}
});
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
template <typename Cache>
typename ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::Bucket::Pool *
ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::getPool(
DescriptorHash const key, Cache &from) noexcept {
auto it = std::find_if(from.begin(), from.end(), [&key](const Bucket &x) {
return key == x.key;
});
return it == from.end() ? nullptr : &it->pool;
}
template <typename DeviceResourceType, typename DescriptorType, typename DeviceResourceCreatorType>
typename ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::BucketGC &
ResourceAllocator<DeviceResourceType, DescriptorType, DeviceResourceCreatorType>::getBucketGC(DescriptorHash const key) noexcept {
auto it = std::find_if(_free.begin(), _free.end(), [&key](const BucketGC &x) {
return key == x.key;
});
CC_ASSERT(it != _free.end());
return *it;
}
}
} // namespace framegraph
+2 -6
View File
@@ -39,12 +39,8 @@ Buffer::Buffer()
Buffer::~Buffer() = default;
uint32_t Buffer::computeHash(const BufferInfo &info) {
uint32_t seed = 4;
seed ^= static_cast<uint32_t>(info.usage) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= static_cast<uint32_t>(info.memUsage) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= static_cast<uint32_t>(info.size) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= static_cast<uint32_t>(info.flags) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
return seed;
std::hash<BufferInfo> hasher;
return utils::toUint(hasher(info));
}
void Buffer::initialize(const BufferInfo &info) {
+219
View File
@@ -24,12 +24,231 @@
****************************************************************************/
#include "base/CoreStd.h"
#include "base/Utils.h"
#include "GFXDef.h"
#include "GFXTexture.h"
#include "gfx-base/GFXDef-common.h"
namespace std {
std::size_t hash<cc::gfx::RenderPassInfo>::operator()(const cc::gfx::RenderPassInfo& info) const {
static auto computeAttachmentHash = [](const cc::gfx::ColorAttachment& attachment, uint32_t& seed) {
seed ^= toNumber(attachment.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(attachment.sampleCount) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(attachment.loadOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(attachment.storeOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
for (cc::gfx::AccessType type : attachment.beginAccesses) {
seed ^= toNumber(type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
for (cc::gfx::AccessType type : attachment.endAccesses) {
seed ^= toNumber(type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
};
static auto computeDSAttachmentHash = [](const cc::gfx::DepthStencilAttachment& attachment, uint32_t& seed) {
seed ^= toNumber(attachment.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(attachment.sampleCount) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(attachment.depthLoadOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(attachment.depthStoreOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(attachment.stencilLoadOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(attachment.stencilStoreOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
for (auto type : attachment.beginAccesses) {
seed ^= toNumber(type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
for (auto type : attachment.endAccesses) {
seed ^= toNumber(type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
};
uint32_t seed = 0;
if (!info.subpasses.empty()) {
for (const auto& subpass : info.subpasses) {
for (const uint32_t iaIndex : subpass.inputs) {
if (iaIndex >= info.colorAttachments.size()) break;
const auto& ia = info.colorAttachments[iaIndex];
seed += cc::utils::toUint(4 + ia.beginAccesses.size() + ia.endAccesses.size());
}
for (const uint32_t caIndex : subpass.colors) {
if (caIndex >= info.colorAttachments.size()) break;
const auto& ca = info.colorAttachments[caIndex];
seed += cc::utils::toUint(4 + ca.beginAccesses.size() + ca.endAccesses.size());
}
for (const uint32_t raIndex : subpass.resolves) {
if (raIndex >= info.colorAttachments.size()) break;
const auto& ra = info.colorAttachments[raIndex];
seed += cc::utils::toUint(4 + ra.beginAccesses.size() + ra.endAccesses.size());
}
for (const uint32_t paIndex : subpass.preserves) {
if (paIndex >= info.colorAttachments.size()) break;
const auto& pa = info.colorAttachments[paIndex];
seed += cc::utils::toUint(4 + pa.beginAccesses.size() + pa.endAccesses.size());
}
if (subpass.depthStencil != cc::gfx::INVALID_BINDING) {
if (subpass.depthStencil < info.colorAttachments.size()) {
const auto& ds = info.colorAttachments[subpass.depthStencil];
seed += cc::utils::toUint(4 + ds.beginAccesses.size() + ds.endAccesses.size());
} else {
const auto& ds = info.depthStencilAttachment;
seed += cc::utils::toUint(6 + ds.beginAccesses.size() + ds.endAccesses.size());
}
}
}
for (const auto& subpass : info.subpasses) {
for (const uint32_t iaIndex : subpass.inputs) {
if (iaIndex >= info.colorAttachments.size()) break;
computeAttachmentHash(info.colorAttachments[iaIndex], seed);
}
for (const uint32_t caIndex : subpass.colors) {
if (caIndex >= info.colorAttachments.size()) break;
computeAttachmentHash(info.colorAttachments[caIndex], seed);
}
for (const uint32_t raIndex : subpass.resolves) {
if (raIndex >= info.colorAttachments.size()) break;
computeAttachmentHash(info.colorAttachments[raIndex], seed);
}
for (const uint32_t paIndex : subpass.preserves) {
if (paIndex >= info.colorAttachments.size()) break;
computeAttachmentHash(info.colorAttachments[paIndex], seed);
}
if (subpass.depthStencil != cc::gfx::INVALID_BINDING) {
if (subpass.depthStencil < info.colorAttachments.size()) {
computeAttachmentHash(info.colorAttachments[subpass.depthStencil], seed);
} else {
computeDSAttachmentHash(info.depthStencilAttachment, seed);
}
}
}
} else {
for (const auto& ca : info.colorAttachments) {
seed += cc::utils::toUint(4 + ca.beginAccesses.size() + ca.endAccesses.size());
}
seed += cc::utils::toUint(6 + info.depthStencilAttachment.beginAccesses.size() + info.depthStencilAttachment.endAccesses.size());
for (const auto& ca : info.colorAttachments) {
computeAttachmentHash(ca, seed);
}
computeDSAttachmentHash(info.depthStencilAttachment, seed);
}
return seed;
}
std::size_t hash<cc::gfx::FramebufferInfo>::operator()(const cc::gfx::FramebufferInfo& info) const {
auto seed = cc::utils::toUint(info.colorTextures.size() * 2 + (info.depthStencilTexture ? 2 : 0));
for (const auto* attachment : info.colorTextures) {
seed ^= attachment->getHash() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= attachment->getTypedID() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
if (info.depthStencilTexture) {
seed ^= info.depthStencilTexture->getHash() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.depthStencilTexture->getTypedID() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
return seed;
}
std::size_t hash<cc::gfx::TextureInfo>::operator()(const cc::gfx::TextureInfo& info) const {
uint32_t seed = 10;
seed ^= toNumber(info.type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.usage) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.flags) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.samples) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.width + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.height + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.depth + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.layerCount + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.levelCount + 0x9e3779b9 + (seed << 6) + (seed >> 2);
return seed;
}
std::size_t hash<cc::gfx::TextureViewInfo>::operator()(const cc::gfx::TextureViewInfo& info) const {
uint32_t seed = 7;
seed ^= info.texture->getHash() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.baseLevel + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.levelCount + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.baseLayer + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.layerCount + 0x9e3779b9 + (seed << 6) + (seed >> 2);
return seed;
}
std::size_t hash<cc::gfx::BufferInfo>::operator()(const cc::gfx::BufferInfo& info) const {
uint32_t seed = 4;
seed ^= toNumber(info.usage) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.memUsage) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.flags) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.size + 0x9e3779b9 + (seed << 6) + (seed >> 2);
return seed;
}
} // namespace std
namespace cc {
namespace gfx {
bool operator==(const ColorAttachment& lhs, const ColorAttachment& rhs) {
return lhs.format == rhs.format &&
lhs.sampleCount == rhs.sampleCount &&
lhs.loadOp == rhs.loadOp &&
lhs.storeOp == rhs.storeOp &&
lhs.isGeneralLayout == rhs.isGeneralLayout &&
lhs.beginAccesses == rhs.beginAccesses &&
lhs.endAccesses == rhs.endAccesses;
}
bool operator==(const DepthStencilAttachment& lhs, const DepthStencilAttachment& rhs) {
return lhs.format == rhs.format &&
lhs.sampleCount == rhs.sampleCount &&
lhs.depthLoadOp == rhs.depthLoadOp &&
lhs.depthStoreOp == rhs.depthStoreOp &&
lhs.stencilLoadOp == rhs.stencilLoadOp &&
lhs.stencilStoreOp == rhs.stencilStoreOp &&
lhs.isGeneralLayout == rhs.isGeneralLayout &&
lhs.beginAccesses == rhs.beginAccesses &&
lhs.endAccesses == rhs.endAccesses;
}
bool operator==(const SubpassInfo& lhs, const SubpassInfo& rhs) {
return lhs.colors == rhs.colors &&
lhs.resolves == rhs.resolves &&
lhs.inputs == rhs.inputs &&
lhs.preserves == rhs.preserves &&
lhs.depthStencil == rhs.depthStencil &&
lhs.depthStencilResolve == rhs.depthStencilResolve &&
lhs.depthResolveMode == rhs.depthResolveMode &&
lhs.stencilResolveMode == rhs.stencilResolveMode;
}
bool operator==(const SubpassDependency& lhs, const SubpassDependency& rhs) {
return lhs.srcAccesses == rhs.srcAccesses &&
lhs.dstAccesses == rhs.dstAccesses &&
lhs.srcSubpass == rhs.srcSubpass &&
lhs.dstSubpass == rhs.dstSubpass;
}
bool operator==(const RenderPassInfo& lhs, const RenderPassInfo& rhs) {
return lhs.colorAttachments == rhs.colorAttachments &&
lhs.depthStencilAttachment == rhs.depthStencilAttachment &&
lhs.subpasses == rhs.subpasses &&
lhs.dependencies == rhs.dependencies;
}
bool operator==(const FramebufferInfo& lhs, const FramebufferInfo& rhs) {
return lhs.renderPass == rhs.renderPass &&
lhs.colorTextures == rhs.colorTextures &&
lhs.depthStencilTexture == rhs.depthStencilTexture;
}
bool operator==(const TextureInfo& lhs, const TextureInfo& rhs) {
return !memcmp(&lhs, &rhs, sizeof(TextureInfo));
}
bool operator==(const TextureViewInfo& lhs, const TextureViewInfo& rhs) {
return !memcmp(&lhs, &rhs, sizeof(TextureViewInfo));
}
bool operator==(const BufferInfo& lhs, const BufferInfo& rhs) {
return !memcmp(&lhs, &rhs, sizeof(BufferInfo));
}
const FormatInfo GFX_FORMAT_INFOS[] = {
{"UNKNOWN", 0, 0, FormatType::NONE, false, false, false, false},
{"A8", 1, 1, FormatType::UNORM, true, false, false, false},
+24
View File
@@ -25,11 +25,35 @@
#pragma once
#include <functional>
#include "GFXDef-common.h"
namespace std {
template <>
struct hash<cc::gfx::RenderPassInfo> { std::size_t operator()(const cc::gfx::RenderPassInfo& info) const; };
template <>
struct hash<cc::gfx::FramebufferInfo> { std::size_t operator()(const cc::gfx::FramebufferInfo& info) const; };
template <>
struct hash<cc::gfx::TextureInfo> { std::size_t operator()(const cc::gfx::TextureInfo& info) const; };
template <>
struct hash<cc::gfx::TextureViewInfo> { std::size_t operator()(const cc::gfx::TextureViewInfo& info) const; };
template <>
struct hash<cc::gfx::BufferInfo> { std::size_t operator()(const cc::gfx::BufferInfo& info) const; };
} // namespace std
namespace cc {
namespace gfx {
extern bool operator==(const ColorAttachment& lhs, const ColorAttachment& rhs);
extern bool operator==(const DepthStencilAttachment& lhs, const DepthStencilAttachment& rhs);
extern bool operator==(const SubpassInfo& lhs, const SubpassInfo& rhs);
extern bool operator==(const SubpassDependency& lhs, const SubpassDependency& rhs);
extern bool operator==(const RenderPassInfo& lhs, const RenderPassInfo& rhs);
extern bool operator==(const FramebufferInfo& lhs, const FramebufferInfo& rhs);
extern bool operator==(const TextureInfo& lhs, const TextureInfo& rhs);
extern bool operator==(const TextureViewInfo& lhs, const TextureViewInfo& rhs);
extern bool operator==(const BufferInfo& lhs, const BufferInfo& rhs);
struct SwapchainTextureInfo {
Swapchain* swapchain{nullptr};
Format format{Format::UNKNOWN};
@@ -39,16 +39,8 @@ Framebuffer::Framebuffer()
Framebuffer::~Framebuffer() = default;
uint32_t Framebuffer::computeHash(const FramebufferInfo &info) {
auto seed = utils::toUint(info.colorTextures.size() * 2 + (info.depthStencilTexture ? 2 : 0));
for (const Texture *attachment : info.colorTextures) {
seed ^= attachment->getHash() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= attachment->getTypedID() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
if (info.depthStencilTexture) {
seed ^= info.depthStencilTexture->getHash() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= info.depthStencilTexture->getTypedID() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
return seed;
std::hash<FramebufferInfo> hasher;
return utils::toUint(hasher(info));
}
void Framebuffer::initialize(const FramebufferInfo &info) {
@@ -27,6 +27,8 @@
#include "GFXObject.h"
#include "GFXRenderPass.h"
#include "base/Utils.h"
#include "gfx-base/GFXDef-common.h"
namespace cc {
namespace gfx {
@@ -114,103 +116,8 @@ uint32_t RenderPass::computeHash() {
}
uint32_t RenderPass::computeHash(const RenderPassInfo &info) {
static auto computeAttachmentHash = [](const ColorAttachment &attachment, uint32_t &seed) {
seed ^= static_cast<uint32_t>(attachment.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= static_cast<uint32_t>(attachment.sampleCount) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= static_cast<uint32_t>(attachment.loadOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= static_cast<uint32_t>(attachment.storeOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
for (AccessType type : attachment.beginAccesses) {
seed ^= static_cast<uint32_t>(type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
for (AccessType type : attachment.endAccesses) {
seed ^= static_cast<uint32_t>(type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
};
static auto computeDSAttachmentHash = [](const DepthStencilAttachment &attachment, uint32_t &seed) {
seed ^= static_cast<uint32_t>(attachment.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= static_cast<uint32_t>(attachment.sampleCount) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= static_cast<uint32_t>(attachment.depthLoadOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= static_cast<uint32_t>(attachment.depthStoreOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= static_cast<uint32_t>(attachment.stencilLoadOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= static_cast<uint32_t>(attachment.stencilStoreOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
for (AccessType type : attachment.beginAccesses) {
seed ^= static_cast<uint32_t>(type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
for (AccessType type : attachment.endAccesses) {
seed ^= static_cast<uint32_t>(type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
};
uint32_t seed = 0;
if (!info.subpasses.empty()) {
for (const SubpassInfo &subpass : info.subpasses) {
for (const uint32_t iaIndex : subpass.inputs) {
if (iaIndex >= info.colorAttachments.size()) break;
const ColorAttachment &ia = info.colorAttachments[iaIndex];
seed += static_cast<uint32_t>(4 + ia.beginAccesses.size() + ia.endAccesses.size());
}
for (const uint32_t caIndex : subpass.colors) {
if (caIndex >= info.colorAttachments.size()) break;
const ColorAttachment &ca = info.colorAttachments[caIndex];
seed += static_cast<uint32_t>(4 + ca.beginAccesses.size() + ca.endAccesses.size());
}
for (const uint32_t raIndex : subpass.resolves) {
if (raIndex >= info.colorAttachments.size()) break;
const ColorAttachment &ra = info.colorAttachments[raIndex];
seed += static_cast<uint32_t>(4 + ra.beginAccesses.size() + ra.endAccesses.size());
}
for (const uint32_t paIndex : subpass.preserves) {
if (paIndex >= info.colorAttachments.size()) break;
const ColorAttachment &pa = info.colorAttachments[paIndex];
seed += static_cast<uint32_t>(4 + pa.beginAccesses.size() + pa.endAccesses.size());
}
if (subpass.depthStencil != INVALID_BINDING) {
if (subpass.depthStencil < info.colorAttachments.size()) {
const auto &ds = info.colorAttachments[subpass.depthStencil];
seed += static_cast<uint32_t>(4 + ds.beginAccesses.size() + ds.endAccesses.size());
} else {
const auto &ds = info.depthStencilAttachment;
seed += static_cast<uint32_t>(6 + ds.beginAccesses.size() + ds.endAccesses.size());
}
}
}
for (const SubpassInfo &subpass : info.subpasses) {
for (const uint32_t iaIndex : subpass.inputs) {
if (iaIndex >= info.colorAttachments.size()) break;
computeAttachmentHash(info.colorAttachments[iaIndex], seed);
}
for (const uint32_t caIndex : subpass.colors) {
if (caIndex >= info.colorAttachments.size()) break;
computeAttachmentHash(info.colorAttachments[caIndex], seed);
}
for (const uint32_t raIndex : subpass.resolves) {
if (raIndex >= info.colorAttachments.size()) break;
computeAttachmentHash(info.colorAttachments[raIndex], seed);
}
for (const uint32_t paIndex : subpass.preserves) {
if (paIndex >= info.colorAttachments.size()) break;
computeAttachmentHash(info.colorAttachments[paIndex], seed);
}
if (subpass.depthStencil != INVALID_BINDING) {
if (subpass.depthStencil < info.colorAttachments.size()) {
computeAttachmentHash(info.colorAttachments[subpass.depthStencil], seed);
} else {
computeDSAttachmentHash(info.depthStencilAttachment, seed);
}
}
}
} else {
for (const ColorAttachment &ca : info.colorAttachments) {
seed += static_cast<uint32_t>(4 + ca.beginAccesses.size() + ca.endAccesses.size());
}
seed += static_cast<uint32_t>(6 + info.depthStencilAttachment.beginAccesses.size() + info.depthStencilAttachment.endAccesses.size());
for (const ColorAttachment &ca : info.colorAttachments) {
computeAttachmentHash(ca, seed);
}
computeDSAttachmentHash(info.depthStencilAttachment, seed);
}
return seed;
std::hash<RenderPassInfo> hasher;
return utils::toUint(hasher(info));
}
void RenderPass::initialize(const RenderPassInfo &info) {
+5 -21
View File
@@ -24,6 +24,7 @@
****************************************************************************/
#include "base/CoreStd.h"
#include "base/Utils.h"
#include "GFXSwapchain.h"
#include "GFXTexture.h"
@@ -38,30 +39,13 @@ Texture::Texture()
Texture::~Texture() = default;
uint32_t Texture::computeHash(const TextureInfo &info) {
uint32_t seed = 10;
seed ^= toNumber(info.type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.usage) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.flags) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.samples) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= (info.width) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= (info.height) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= (info.depth) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= (info.layerCount) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= (info.levelCount) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
return seed;
std::hash<TextureInfo> hasher;
return utils::toUint(hasher(info));
}
uint32_t Texture::computeHash(const TextureViewInfo &info) {
uint32_t seed = 7;
seed ^= info.texture->getHash() + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.type) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= toNumber(info.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= (info.baseLevel) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= (info.levelCount) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= (info.baseLayer) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
seed ^= (info.layerCount) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
return seed;
std::hash<TextureViewInfo> hasher;
return utils::toUint(hasher(info));
}
uint32_t Texture::computeHash(const Texture *texture) {
@@ -58,6 +58,7 @@ RenderPipeline::RenderPipeline()
}
RenderPipeline::~RenderPipeline() {
framegraph::FrameGraph::gc(0);
RenderPipeline::instance = nullptr;
}
@@ -133,7 +133,7 @@ protected:
std::unordered_map<uint, gfx::InputAssembler *> _quadIA;
framegraph::FrameGraph _fg;
map<gfx::ClearFlags, gfx::RenderPass *> _renderPasses;
unordered_map<gfx::ClearFlags, gfx::RenderPass *> _renderPasses;
// use cluster culling or not
bool _clusterEnabled{false};
@@ -73,7 +73,7 @@ void ShadowStage::render(scene::Camera *camera) {
_renderArea.x = static_cast<int>(viewport.x * shadowMapSize.x);
_renderArea.y = static_cast<int>(viewport.y * shadowMapSize.y);
_renderArea.width = static_cast<uint>(viewport.z * shadowMapSize.x * sharedData->shadingScale);
_renderArea.height = static_cast<int>(viewport.w * shadowMapSize.y * sharedData->shadingScale);
_renderArea.height = static_cast<uint>(viewport.w * shadowMapSize.y * sharedData->shadingScale);
_clearColors[0] = {1.0F, 1.0F, 1.0F, 1.0F};
auto *renderPass = _framebuffer->getRenderPass();
+1
View File
@@ -79,6 +79,7 @@ getter_setter = Device::[gfxAPI deviceName memoryStatus queue commandBuffer rend
Texture::[info viewInfo width height format size hash],
Queue::[type],
RenderPass::[hash],
DescriptorSet::[layout],
PipelineState::[shader primitive bindPoint inputState rasterizerState depthStencilState blendState renderPass],
InputAssembler::[vertexBuffers attributes indexBuffer indirectBuffer attributesHash drawInfo vertexCount firstVertex indexCount firstIndex vertexOffset instanceCount firstInstance],
Commanduffer::[type queue numDrawCalls numInstances numTris],