diff --git a/native/cocos/bindings/auto/jsb_gfx_auto.cpp b/native/cocos/bindings/auto/jsb_gfx_auto.cpp index f06cfa81d0..1eaa58e046 100644 --- a/native/cocos/bindings/auto/jsb_gfx_auto.cpp +++ b/native/cocos/bindings/auto/jsb_gfx_auto.cpp @@ -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(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; } diff --git a/native/cocos/bindings/auto/jsb_gfx_auto.h b/native/cocos/bindings/auto/jsb_gfx_auto.h index 1dfbea2cea..d445c48bc7 100644 --- a/native/cocos/bindings/auto/jsb_gfx_auto.h +++ b/native/cocos/bindings/auto/jsb_gfx_auto.h @@ -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); diff --git a/native/cocos/renderer/frame-graph/FrameGraph.cpp b/native/cocos/renderer/frame-graph/FrameGraph.cpp index 060a848e8a..9265ecd96c 100644 --- a/native/cocos/renderer/frame-graph/FrameGraph.cpp +++ b/native/cocos/renderer/frame-graph/FrameGraph.cpp @@ -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> 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> 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(it.base() - _resourceNodes.begin() - 1)), target); + present(TextureHandle(static_cast(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() { diff --git a/native/cocos/renderer/frame-graph/FrameGraph.h b/native/cocos/renderer/frame-graph/FrameGraph.h index 44c8f7a12f..92cc9d964b 100644 --- a/native/cocos/renderer/frame-graph/FrameGraph.h +++ b/native/cocos/renderer/frame-graph/FrameGraph.h @@ -44,7 +44,7 @@ public: using ResourceHandleBlackboard = Blackboard; 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; diff --git a/native/cocos/renderer/frame-graph/Resource.h b/native/cocos/renderer/frame-graph/Resource.h index 1a4bd29ecc..df2913cf70 100644 --- a/native/cocos/renderer/frame-graph/Resource.h +++ b/native/cocos/renderer/frame-graph/Resource.h @@ -37,13 +37,6 @@ namespace cc { namespace framegraph { -template -struct ResourceDescriptorHasher final { - inline uint32_t operator()(const DescriptorType & /*desc*/) const { - return 1; - } -}; - template struct DeviceResourceCreator final { inline DeviceResourceType *operator()(const DescriptorType & /*desc*/) const { @@ -52,15 +45,12 @@ struct DeviceResourceCreator final { }; template , - typename DescriptorHasherType = ResourceDescriptorHasher> + typename DeviceResourceCreatorType = DeviceResourceCreator> class Resource final { public: using Allocator = ResourceAllocator; - 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 -Resource::Resource(const Descriptor &desc) +template +Resource::Resource(const Descriptor &desc) : _desc(desc) { } -template -Resource::Resource(DeviceResourceType *external) +template +Resource::Resource(DeviceResourceType *external) : _desc(external->getInfo()), _deviceObject(external) { } -template -void Resource::createTransient() noexcept { - computeHash(); - _deviceObject = Allocator::getInstance().alloc(_desc, _hash); +template +void Resource::createTransient() noexcept { + _deviceObject = Allocator::getInstance().alloc(_desc); } -template -void Resource::createPersistent() noexcept { - computeHash(); - +template +void Resource::createPersistent() noexcept { if (!_deviceObject) { DeviceResourceCreatorType creator; _deviceObject = creator(_desc); } } -template -void Resource::destroyTransient() noexcept { - CC_ASSERT(_hash); - Allocator::getInstance().free(_desc, _hash, _deviceObject); +template +void Resource::destroyTransient() noexcept { + Allocator::getInstance().free(_desc, _deviceObject); _deviceObject = nullptr; } -template -void Resource::destroyPersistent() noexcept { +template +void Resource::destroyPersistent() noexcept { if (_deviceObject) { delete _deviceObject; _deviceObject = nullptr; } } -template -DeviceResourceType *Resource::get() const noexcept { +template +DeviceResourceType *Resource::get() const noexcept { return _deviceObject; } -template -const DescriptorType &Resource::getDesc() const noexcept { +template +const DescriptorType &Resource::getDesc() const noexcept { return _desc; } -template -void Resource::computeHash() noexcept { - if (!_hash) { - DescriptorHasher hasher; - _hash = hasher(_desc); - } -} - ////////////////////////////////////////////////////////////////////////// #define DEFINE_GFX_RESOURCE(Type) \ template <> \ - struct ResourceDescriptorHasher final { \ - inline uint32_t operator()(const gfx::Type##Info &desc) const { \ - return gfx::Type::computeHash(desc); \ - } \ - }; \ - \ - template <> \ struct DeviceResourceCreator final { \ inline gfx::Type *operator()(const gfx::Type##Info &desc) const { \ return gfx::Device::getInstance()->create##Type(desc); \ @@ -169,6 +138,7 @@ void Resource; \ using Type##Handle = TypedHandle; +// Descriptors must have std::hash specialization and == operators DEFINE_GFX_RESOURCE(Buffer) DEFINE_GFX_RESOURCE(Framebuffer) DEFINE_GFX_RESOURCE(RenderPass) diff --git a/native/cocos/renderer/frame-graph/ResourceAllocator.h b/native/cocos/renderer/frame-graph/ResourceAllocator.h index 5f957a16eb..de6a4a22e7 100644 --- a/native/cocos/renderer/frame-graph/ResourceAllocator.h +++ b/native/cocos/renderer/frame-graph/ResourceAllocator.h @@ -26,6 +26,7 @@ #pragma once #include +#include #include "base/memory/Memory.h" namespace cc { @@ -34,96 +35,79 @@ namespace framegraph { template 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; - DescriptorHash key{0}; - Pool pool{}; - }; - - struct BucketGC final : public Bucket { - using Bucket::Bucket; - std::vector ages{}; + DeviceResourcePtrGC(DeviceResourcePtr resource, uint64_t age) : resource(resource), age(age) {} }; + using DeviceResourcePool = std::vector; + using DeviceResourcePoolGC = std::vector; ResourceAllocator() noexcept = default; ~ResourceAllocator() = default; - template - typename Bucket::Pool *getPool(DescriptorHash key, Cache &from) noexcept; - BucketGC & getBucketGC(DescriptorHash key) noexcept; - std::vector _free{}; - std::vector _inUse{}; - uint64_t _age{0}; + std::unordered_map _livepool{}; + std::unordered_map _deadpool{}; + uint64_t _age{0}; }; ////////////////////////////////////////////////////////////////////////// template -ResourceAllocator &ResourceAllocator::getInstance() noexcept { +ResourceAllocator & +ResourceAllocator::getInstance() noexcept { static ResourceAllocator instance; return instance; } template -DeviceResourceType *ResourceAllocator::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::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 -void ResourceAllocator::free(const DescriptorType & /*desc*/, DescriptorHash const key, DeviceResourceType *const resource) noexcept { - auto *pool = getPool(key, _inUse); - CC_ASSERT(!pool->empty()); +void ResourceAllocator::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 @@ -133,8 +117,10 @@ void ResourceAllocator void ResourceAllocator::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 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 -template -typename ResourceAllocator::Bucket::Pool * -ResourceAllocator::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 ResourceAllocator::BucketGC & -ResourceAllocator::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 diff --git a/native/cocos/renderer/gfx-base/GFXBuffer.cpp b/native/cocos/renderer/gfx-base/GFXBuffer.cpp index a9f3d0861a..1450c7dbf5 100644 --- a/native/cocos/renderer/gfx-base/GFXBuffer.cpp +++ b/native/cocos/renderer/gfx-base/GFXBuffer.cpp @@ -39,12 +39,8 @@ Buffer::Buffer() Buffer::~Buffer() = default; uint32_t Buffer::computeHash(const BufferInfo &info) { - uint32_t seed = 4; - seed ^= static_cast(info.usage) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= static_cast(info.memUsage) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= static_cast(info.size) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= static_cast(info.flags) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - return seed; + std::hash hasher; + return utils::toUint(hasher(info)); } void Buffer::initialize(const BufferInfo &info) { diff --git a/native/cocos/renderer/gfx-base/GFXDef.cpp b/native/cocos/renderer/gfx-base/GFXDef.cpp index 65437dff71..668c2d5e77 100644 --- a/native/cocos/renderer/gfx-base/GFXDef.cpp +++ b/native/cocos/renderer/gfx-base/GFXDef.cpp @@ -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::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::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::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::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::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}, diff --git a/native/cocos/renderer/gfx-base/GFXDef.h b/native/cocos/renderer/gfx-base/GFXDef.h index 43bd2ba026..7d08807142 100644 --- a/native/cocos/renderer/gfx-base/GFXDef.h +++ b/native/cocos/renderer/gfx-base/GFXDef.h @@ -25,11 +25,35 @@ #pragma once +#include #include "GFXDef-common.h" +namespace std { +template <> +struct hash { std::size_t operator()(const cc::gfx::RenderPassInfo& info) const; }; +template <> +struct hash { std::size_t operator()(const cc::gfx::FramebufferInfo& info) const; }; +template <> +struct hash { std::size_t operator()(const cc::gfx::TextureInfo& info) const; }; +template <> +struct hash { std::size_t operator()(const cc::gfx::TextureViewInfo& info) const; }; +template <> +struct hash { 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}; diff --git a/native/cocos/renderer/gfx-base/GFXFramebuffer.cpp b/native/cocos/renderer/gfx-base/GFXFramebuffer.cpp index f7f752f1d1..dde57cb7b3 100644 --- a/native/cocos/renderer/gfx-base/GFXFramebuffer.cpp +++ b/native/cocos/renderer/gfx-base/GFXFramebuffer.cpp @@ -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 hasher; + return utils::toUint(hasher(info)); } void Framebuffer::initialize(const FramebufferInfo &info) { diff --git a/native/cocos/renderer/gfx-base/GFXRenderPass.cpp b/native/cocos/renderer/gfx-base/GFXRenderPass.cpp index 7f32fa6eae..1bdb3d02f3 100644 --- a/native/cocos/renderer/gfx-base/GFXRenderPass.cpp +++ b/native/cocos/renderer/gfx-base/GFXRenderPass.cpp @@ -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(attachment.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= static_cast(attachment.sampleCount) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= static_cast(attachment.loadOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= static_cast(attachment.storeOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - for (AccessType type : attachment.beginAccesses) { - seed ^= static_cast(type) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - } - for (AccessType type : attachment.endAccesses) { - seed ^= static_cast(type) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - } - }; - static auto computeDSAttachmentHash = [](const DepthStencilAttachment &attachment, uint32_t &seed) { - seed ^= static_cast(attachment.format) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= static_cast(attachment.sampleCount) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= static_cast(attachment.depthLoadOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= static_cast(attachment.depthStoreOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= static_cast(attachment.stencilLoadOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - seed ^= static_cast(attachment.stencilStoreOp) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - for (AccessType type : attachment.beginAccesses) { - seed ^= static_cast(type) + 0x9e3779b9 + (seed << 6) + (seed >> 2); - } - for (AccessType type : attachment.endAccesses) { - seed ^= static_cast(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(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(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(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(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(4 + ds.beginAccesses.size() + ds.endAccesses.size()); - } else { - const auto &ds = info.depthStencilAttachment; - seed += static_cast(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(4 + ca.beginAccesses.size() + ca.endAccesses.size()); - } - seed += static_cast(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 hasher; + return utils::toUint(hasher(info)); } void RenderPass::initialize(const RenderPassInfo &info) { diff --git a/native/cocos/renderer/gfx-base/GFXTexture.cpp b/native/cocos/renderer/gfx-base/GFXTexture.cpp index 5af7d77ff7..b8d769f00f 100644 --- a/native/cocos/renderer/gfx-base/GFXTexture.cpp +++ b/native/cocos/renderer/gfx-base/GFXTexture.cpp @@ -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 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 hasher; + return utils::toUint(hasher(info)); } uint32_t Texture::computeHash(const Texture *texture) { diff --git a/native/cocos/renderer/pipeline/RenderPipeline.cpp b/native/cocos/renderer/pipeline/RenderPipeline.cpp index c7697328f3..e88b672c1b 100644 --- a/native/cocos/renderer/pipeline/RenderPipeline.cpp +++ b/native/cocos/renderer/pipeline/RenderPipeline.cpp @@ -58,6 +58,7 @@ RenderPipeline::RenderPipeline() } RenderPipeline::~RenderPipeline() { + framegraph::FrameGraph::gc(0); RenderPipeline::instance = nullptr; } diff --git a/native/cocos/renderer/pipeline/RenderPipeline.h b/native/cocos/renderer/pipeline/RenderPipeline.h index 769aef59e7..800b6b06ab 100644 --- a/native/cocos/renderer/pipeline/RenderPipeline.h +++ b/native/cocos/renderer/pipeline/RenderPipeline.h @@ -133,7 +133,7 @@ protected: std::unordered_map _quadIA; framegraph::FrameGraph _fg; - map _renderPasses; + unordered_map _renderPasses; // use cluster culling or not bool _clusterEnabled{false}; diff --git a/native/cocos/renderer/pipeline/shadow/ShadowStage.cpp b/native/cocos/renderer/pipeline/shadow/ShadowStage.cpp index e182cf3767..fb6c2edaa9 100644 --- a/native/cocos/renderer/pipeline/shadow/ShadowStage.cpp +++ b/native/cocos/renderer/pipeline/shadow/ShadowStage.cpp @@ -73,7 +73,7 @@ void ShadowStage::render(scene::Camera *camera) { _renderArea.x = static_cast(viewport.x * shadowMapSize.x); _renderArea.y = static_cast(viewport.y * shadowMapSize.y); _renderArea.width = static_cast(viewport.z * shadowMapSize.x * sharedData->shadingScale); - _renderArea.height = static_cast(viewport.w * shadowMapSize.y * sharedData->shadingScale); + _renderArea.height = static_cast(viewport.w * shadowMapSize.y * sharedData->shadingScale); _clearColors[0] = {1.0F, 1.0F, 1.0F, 1.0F}; auto *renderPass = _framebuffer->getRenderPass(); diff --git a/native/tools/tojs/gfx.ini b/native/tools/tojs/gfx.ini index f96c940598..3e8013a5be 100644 --- a/native/tools/tojs/gfx.ini +++ b/native/tools/tojs/gfx.ini @@ -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],