mirror of
https://github.com/cocos/cocos4.git
synced 2026-11-20 23:52:40 +08:00
fg: use hashmap in resource allocators (#3962)
...to handle hash collisions gracefully.
This commit is contained in:
@@ -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;
|
||||
}
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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},
|
||||
|
||||
@@ -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) {
|
||||
|
||||
@@ -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();
|
||||
|
||||
@@ -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],
|
||||
|
||||
Reference in New Issue
Block a user