diff --git a/native/CMakeLists.txt b/native/CMakeLists.txt index b76d0ba173..421dec4a2b 100644 --- a/native/CMakeLists.txt +++ b/native/CMakeLists.txt @@ -50,7 +50,7 @@ endif() # set c++ standard set(CMAKE_C_STANDARD 99) set(CMAKE_C_STANDARD_REQUIRED ON) -set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD 17) set(CMAKE_CXX_STANDARD_REQUIRED ON) set(CMAKE_CXX_EXTENSIONS OFF) @@ -320,6 +320,18 @@ cocos_source_files( cocos/base/memory/NedPooling.h cocos/base/memory/StdAlloc.h cocos/base/memory/StlAlloc.h + cocos/base/threading/ConditionVariable.h + cocos/base/threading/ConditionVariable.cpp + cocos/base/threading/Event.h + cocos/base/threading/MessageQueue.h + cocos/base/threading/MessageQueue.cpp + cocos/base/threading/Semaphore.h + cocos/base/threading/Semaphore.cpp + cocos/base/threading/ThreadPool.h + cocos/base/threading/ThreadPool.cpp + cocos/base/threading/ThreadSafeCounter.h + cocos/base/threading/ThreadSafeLinearAllocator.h + cocos/base/threading/ThreadSafeLinearAllocator.cpp cocos/base/Object.h cocos/base/TypeDef.h cocos/base/uthash.h @@ -332,6 +344,21 @@ cocos_source_files( cocos/base/ZipUtils.h ) +##### job system +cocos_source_files( + cocos/base/job-system/JobSystem.h + + cocos/base/job-system/job-system-taskflow/TFJobGraph.h + cocos/base/job-system/job-system-taskflow/TFJobGraph.cpp + cocos/base/job-system/job-system-taskflow/TFJobSystem.h + cocos/base/job-system/job-system-taskflow/TFJobSystem.cpp + + cocos/base/job-system/job-system-tbb/TBBJobGraph.h + cocos/base/job-system/job-system-tbb/TBBJobGraph.cpp + cocos/base/job-system/job-system-tbb/TBBJobSystem.h + cocos/base/job-system/job-system-tbb/TBBJobSystem.cpp +) + ##### math cocos_source_files( cocos/math/Geometry.cpp @@ -567,6 +594,36 @@ cocos_source_files( cocos/renderer/core/gfx/GFXTexture.h cocos/renderer/core/gfx/GFXFence.h cocos/renderer/core/gfx/GFXFence.cpp + cocos/renderer/core/gfx-agent/GFXAgent.h + cocos/renderer/core/gfx-agent/GFXBufferAgent.h + cocos/renderer/core/gfx-agent/GFXBufferAgent.cpp + cocos/renderer/core/gfx-agent/GFXCommandBufferAgent.h + cocos/renderer/core/gfx-agent/GFXCommandBufferAgent.cpp + cocos/renderer/core/gfx-agent/GFXDescriptorSetAgent.h + cocos/renderer/core/gfx-agent/GFXDescriptorSetAgent.cpp + cocos/renderer/core/gfx-agent/GFXDescriptorSetLayoutAgent.h + cocos/renderer/core/gfx-agent/GFXDescriptorSetLayoutAgent.cpp + cocos/renderer/core/gfx-agent/GFXDeviceAgent.h + cocos/renderer/core/gfx-agent/GFXDeviceAgent.cpp + cocos/renderer/core/gfx-agent/GFXFramebufferAgent.h + cocos/renderer/core/gfx-agent/GFXFramebufferAgent.cpp + cocos/renderer/core/gfx-agent/GFXInputAssemblerAgent.h + cocos/renderer/core/gfx-agent/GFXInputAssemblerAgent.cpp + cocos/renderer/core/gfx-agent/GFXLinearAllocatorPool.h + cocos/renderer/core/gfx-agent/GFXPipelineLayoutAgent.h + cocos/renderer/core/gfx-agent/GFXPipelineLayoutAgent.cpp + cocos/renderer/core/gfx-agent/GFXPipelineStateAgent.h + cocos/renderer/core/gfx-agent/GFXPipelineStateAgent.cpp + cocos/renderer/core/gfx-agent/GFXQueueAgent.h + cocos/renderer/core/gfx-agent/GFXQueueAgent.cpp + cocos/renderer/core/gfx-agent/GFXRenderPassAgent.h + cocos/renderer/core/gfx-agent/GFXRenderPassAgent.cpp + cocos/renderer/core/gfx-agent/GFXSamplerAgent.h + cocos/renderer/core/gfx-agent/GFXSamplerAgent.cpp + cocos/renderer/core/gfx-agent/GFXShaderAgent.h + cocos/renderer/core/gfx-agent/GFXShaderAgent.cpp + cocos/renderer/core/gfx-agent/GFXTextureAgent.h + cocos/renderer/core/gfx-agent/GFXTextureAgent.cpp cocos/renderer/pipeline/BatchedBuffer.cpp cocos/renderer/pipeline/BatchedBuffer.h cocos/renderer/pipeline/Define.h @@ -1099,19 +1156,19 @@ if(USE_MIDDLEWARE) cocos/editor-support/dragonbones/core/BaseObject.cpp cocos/editor-support/dragonbones/core/BaseObject.h cocos/editor-support/dragonbones/core/DragonBones.cpp - cocos/editor-support/dragonbones/core/DragonBones.h + cocos/editor-support/dragonbones/core/DragonBones.h cocos/editor-support/dragonbones/event/EventObject.cpp cocos/editor-support/dragonbones/event/EventObject.h - cocos/editor-support/dragonbones/event/IEventDispatcher.h + cocos/editor-support/dragonbones/event/IEventDispatcher.h cocos/editor-support/dragonbones/factory/BaseFactory.cpp - cocos/editor-support/dragonbones/factory/BaseFactory.h + cocos/editor-support/dragonbones/factory/BaseFactory.h cocos/editor-support/dragonbones/geom/ColorTransform.h cocos/editor-support/dragonbones/geom/Matrix.h cocos/editor-support/dragonbones/geom/Point.cpp cocos/editor-support/dragonbones/geom/Point.h cocos/editor-support/dragonbones/geom/Rectangle.h cocos/editor-support/dragonbones/geom/Transform.cpp - cocos/editor-support/dragonbones/geom/Transform.h + cocos/editor-support/dragonbones/geom/Transform.h cocos/editor-support/dragonbones/model/AnimationConfig.cpp cocos/editor-support/dragonbones/model/AnimationConfig.h cocos/editor-support/dragonbones/model/AnimationData.cpp @@ -1139,7 +1196,7 @@ if(USE_MIDDLEWARE) cocos/editor-support/dragonbones/parser/DataParser.cpp cocos/editor-support/dragonbones/parser/DataParser.h cocos/editor-support/dragonbones/parser/JSONDataParser.cpp - cocos/editor-support/dragonbones/parser/JSONDataParser.h + cocos/editor-support/dragonbones/parser/JSONDataParser.h cocos/editor-support/dragonbones-creator-support/ArmatureCache.cpp cocos/editor-support/dragonbones-creator-support/ArmatureCache.h cocos/editor-support/dragonbones-creator-support/ArmatureCacheMgr.cpp @@ -1504,6 +1561,11 @@ target_include_directories(cocos2d ${CC_EXTERNAL_PRIVATE_INCLUDES} ) +target_compile_definitions(cocos2d + PRIVATE + ${CC_EXTERNAL_PRIVATE_DEFINITIONS} +) + if(WIN32) target_link_libraries(cocos2d PUBLIC ws2_32 userenv psapi winmm Version Iphlpapi opengl32 @@ -1523,7 +1585,6 @@ if(WIN32) _USRLIBSIMSTATIC SE_ENABLE_INSPECTOR ) - endif() if(ANDROID) diff --git a/native/cocos/base/threading/MessageQueue.h b/native/cocos/base/threading/MessageQueue.h index 609d9a72bf..67804a9e4c 100644 --- a/native/cocos/base/threading/MessageQueue.h +++ b/native/cocos/base/threading/MessageQueue.h @@ -1,7 +1,7 @@ #pragma once #include "Event.h" -#include "concurrentqueue.h" +#include "concurrentqueue/concurrentqueue.h" #include namespace cc { diff --git a/native/cocos/base/threading/Semaphore.h b/native/cocos/base/threading/Semaphore.h index 6d41299d9c..de2f7a5b7a 100644 --- a/native/cocos/base/threading/Semaphore.h +++ b/native/cocos/base/threading/Semaphore.h @@ -1,8 +1,8 @@ #pragma once #include -#include "concurrentqueue.h" -#include "lightweightsemaphore.h" +#include "concurrentqueue/concurrentqueue.h" +#include "concurrentqueue/lightweightsemaphore.h" namespace cc { diff --git a/native/cocos/base/threading/ThreadPool.h b/native/cocos/base/threading/ThreadPool.h index 4bd852a867..dbe31da875 100644 --- a/native/cocos/base/threading/ThreadPool.h +++ b/native/cocos/base/threading/ThreadPool.h @@ -8,7 +8,7 @@ #include #include #include -#include "concurrentqueue.h" +#include "concurrentqueue/concurrentqueue.h" #include "Event.h" namespace cc { diff --git a/native/cocos/bindings/auto/jsb_gfx_auto.cpp b/native/cocos/bindings/auto/jsb_gfx_auto.cpp index dfa20088a0..62533ed5ad 100644 --- a/native/cocos/bindings/auto/jsb_gfx_auto.cpp +++ b/native/cocos/bindings/auto/jsb_gfx_auto.cpp @@ -11321,6 +11321,7 @@ static bool js_gfx_Buffer_getCount(se::State& s) unsigned int result = cobj->getCount(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Buffer_getCount : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -11339,6 +11340,7 @@ static bool js_gfx_Buffer_getFlags(se::State& s) int result = (int)cobj->getFlags(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Buffer_getFlags : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -11357,6 +11359,7 @@ static bool js_gfx_Buffer_getMemUsage(se::State& s) int result = (int)cobj->getMemUsage(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Buffer_getMemUsage : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -11375,6 +11378,7 @@ static bool js_gfx_Buffer_getSize(se::State& s) unsigned int result = cobj->getSize(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Buffer_getSize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -11393,6 +11397,7 @@ static bool js_gfx_Buffer_getStride(se::State& s) unsigned int result = cobj->getStride(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Buffer_getStride : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -11411,6 +11416,7 @@ static bool js_gfx_Buffer_getUsage(se::State& s) int result = (int)cobj->getUsage(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Buffer_getUsage : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -11617,14 +11623,15 @@ static bool js_gfx_CommandBuffer_beginRenderPass(se::State& s) } while(false); do { - if (argc == 7) { + if (argc == 8) { HolderType arg0 = {}; HolderType arg1 = {}; HolderType arg2 = {}; HolderType arg3 = {}; HolderType arg4 = {}; HolderType arg5 = {}; - HolderType arg6 = {}; + HolderType arg6 = {}; + HolderType arg7 = {}; ok &= sevalue_to_native(args[0], &arg0, s.thisObject()); if (!ok) { ok = true; break; } @@ -11639,7 +11646,10 @@ static bool js_gfx_CommandBuffer_beginRenderPass(se::State& s) ok &= sevalue_to_native(args[5], &arg5, s.thisObject()); if (!ok) { ok = true; break; } ok &= sevalue_to_native(args[6], &arg6, s.thisObject()); - cobj->beginRenderPass(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value(), arg6.value()); + if (!ok) { ok = true; break; } + ok &= sevalue_to_native(args[7], &arg7, s.thisObject()); + if (!ok) { ok = true; break; } + cobj->beginRenderPass(arg0.value(), arg1.value(), arg2.value(), arg3.value(), arg4.value(), arg5.value(), arg6.value(), arg7.value()); return true; } } while(false); @@ -11831,6 +11841,7 @@ static bool js_gfx_CommandBuffer_getNumDrawCalls(se::State& s) unsigned int result = cobj->getNumDrawCalls(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_CommandBuffer_getNumDrawCalls : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -11849,6 +11860,7 @@ static bool js_gfx_CommandBuffer_getNumInstances(se::State& s) unsigned int result = cobj->getNumInstances(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_CommandBuffer_getNumInstances : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -11867,6 +11879,7 @@ static bool js_gfx_CommandBuffer_getNumTris(se::State& s) unsigned int result = cobj->getNumTris(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_CommandBuffer_getNumTris : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -11885,6 +11898,7 @@ static bool js_gfx_CommandBuffer_getQueue(se::State& s) cc::gfx::Queue* result = cobj->getQueue(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_CommandBuffer_getQueue : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -11903,6 +11917,7 @@ static bool js_gfx_CommandBuffer_getType(se::State& s) int result = (int)cobj->getType(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_CommandBuffer_getType : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -11924,6 +11939,7 @@ static bool js_gfx_CommandBuffer_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_CommandBuffer_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -12189,6 +12205,7 @@ static bool js_gfx_Context_getColorFormat(se::State& s) int result = (int)cobj->getColorFormat(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Context_getColorFormat : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -12207,6 +12224,7 @@ static bool js_gfx_Context_getDepthStencilFormat(se::State& s) int result = (int)cobj->getDepthStencilFormat(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Context_getDepthStencilFormat : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -12225,6 +12243,7 @@ static bool js_gfx_Context_getDevice(se::State& s) cc::gfx::Device* result = cobj->getDevice(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Context_getDevice : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -12243,6 +12262,7 @@ static bool js_gfx_Context_getSharedContext(se::State& s) cc::gfx::Context* result = cobj->getSharedContext(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Context_getSharedContext : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -12261,6 +12281,7 @@ static bool js_gfx_Context_getVsyncMode(se::State& s) int result = (int)cobj->getVsyncMode(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Context_getVsyncMode : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -12282,6 +12303,7 @@ static bool js_gfx_Context_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Context_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -12417,6 +12439,7 @@ static bool js_gfx_DescriptorSet_bindBufferJSB(se::State& s) bool result = cobj->bindBufferJSB(arg0.value(), arg1.value(), arg2.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSet_bindBufferJSB : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); @@ -12485,6 +12508,7 @@ static bool js_gfx_DescriptorSet_bindSamplerJSB(se::State& s) bool result = cobj->bindSamplerJSB(arg0.value(), arg1.value(), arg2.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSet_bindSamplerJSB : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); @@ -12553,6 +12577,7 @@ static bool js_gfx_DescriptorSet_bindTextureJSB(se::State& s) bool result = cobj->bindTextureJSB(arg0.value(), arg1.value(), arg2.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSet_bindTextureJSB : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 3); @@ -12591,6 +12616,7 @@ static bool js_gfx_DescriptorSet_getBuffer(se::State& s) cc::gfx::Buffer* result = cobj->getBuffer(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSet_getBuffer : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } } while(false); @@ -12607,6 +12633,7 @@ static bool js_gfx_DescriptorSet_getBuffer(se::State& s) cc::gfx::Buffer* result = cobj->getBuffer(arg0.value(), arg1.value()); ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSet_getBuffer : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } } while(false); @@ -12632,6 +12659,7 @@ static bool js_gfx_DescriptorSet_getSampler(se::State& s) cc::gfx::Sampler* result = cobj->getSampler(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSet_getSampler : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } } while(false); @@ -12648,6 +12676,7 @@ static bool js_gfx_DescriptorSet_getSampler(se::State& s) cc::gfx::Sampler* result = cobj->getSampler(arg0.value(), arg1.value()); ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSet_getSampler : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } } while(false); @@ -12673,6 +12702,7 @@ static bool js_gfx_DescriptorSet_getTexture(se::State& s) cc::gfx::Texture* result = cobj->getTexture(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSet_getTexture : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } } while(false); @@ -12689,6 +12719,7 @@ static bool js_gfx_DescriptorSet_getTexture(se::State& s) cc::gfx::Texture* result = cobj->getTexture(arg0.value(), arg1.value()); ok &= nativevalue_to_se(result, s.rval(), s.thisObject() /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSet_getTexture : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } } while(false); @@ -12712,6 +12743,7 @@ static bool js_gfx_DescriptorSet_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSet_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -12817,6 +12849,7 @@ static bool js_gfx_DescriptorSetLayout_getBindings(se::State& s) const std::vector& result = cobj->getBindings(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSetLayout_getBindings : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -12835,6 +12868,7 @@ static bool js_gfx_DescriptorSetLayout_getDescriptorCount(se::State& s) const unsigned int result = cobj->getDescriptorCount(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSetLayout_getDescriptorCount : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -12856,6 +12890,7 @@ static bool js_gfx_DescriptorSetLayout_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_DescriptorSetLayout_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -12941,6 +12976,7 @@ static bool js_gfx_Fence_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Fence_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -13053,6 +13089,7 @@ static bool js_gfx_Queue_getType(se::State& s) int result = (int)cobj->getType(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Queue_getType : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13074,6 +13111,7 @@ static bool js_gfx_Queue_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Queue_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -13092,6 +13130,7 @@ static bool js_gfx_Queue_isAsync(se::State& s) bool result = cobj->isAsync(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Queue_isAsync : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13229,6 +13268,7 @@ static bool js_gfx_Sampler_getAddressU(se::State& s) int result = (int)cobj->getAddressU(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getAddressU : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13247,6 +13287,7 @@ static bool js_gfx_Sampler_getAddressV(se::State& s) int result = (int)cobj->getAddressV(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getAddressV : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13265,6 +13306,7 @@ static bool js_gfx_Sampler_getAddressW(se::State& s) int result = (int)cobj->getAddressW(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getAddressW : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13283,6 +13325,7 @@ static bool js_gfx_Sampler_getBorderColor(se::State& s) const cc::gfx::Color& result = cobj->getBorderColor(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getBorderColor : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13301,6 +13344,7 @@ static bool js_gfx_Sampler_getCmpFunc(se::State& s) int result = (int)cobj->getCmpFunc(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getCmpFunc : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13319,6 +13363,7 @@ static bool js_gfx_Sampler_getMagFilter(se::State& s) int result = (int)cobj->getMagFilter(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getMagFilter : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13337,6 +13382,7 @@ static bool js_gfx_Sampler_getMaxAnisotropy(se::State& s) unsigned int result = cobj->getMaxAnisotropy(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getMaxAnisotropy : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13355,6 +13401,7 @@ static bool js_gfx_Sampler_getMaxLOD(se::State& s) unsigned int result = cobj->getMaxLOD(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getMaxLOD : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13373,6 +13420,7 @@ static bool js_gfx_Sampler_getMinFilter(se::State& s) int result = (int)cobj->getMinFilter(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getMinFilter : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13391,6 +13439,7 @@ static bool js_gfx_Sampler_getMinLOD(se::State& s) unsigned int result = cobj->getMinLOD(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getMinLOD : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13409,6 +13458,7 @@ static bool js_gfx_Sampler_getMipFilter(se::State& s) int result = (int)cobj->getMipFilter(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getMipFilter : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13427,6 +13477,7 @@ static bool js_gfx_Sampler_getMipLODBias(se::State& s) float result = cobj->getMipLODBias(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_getMipLODBias : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13448,6 +13499,7 @@ static bool js_gfx_Sampler_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Sampler_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -13540,6 +13592,7 @@ static bool js_gfx_InputAssembler_getAttributes(se::State& s) const std::vector& result = cobj->getAttributes(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getAttributes : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13558,6 +13611,7 @@ static bool js_gfx_InputAssembler_getAttributesHash(se::State& s) unsigned int result = cobj->getAttributesHash(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getAttributesHash : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13576,6 +13630,7 @@ static bool js_gfx_InputAssembler_getFirstIndex(se::State& s) unsigned int result = cobj->getFirstIndex(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getFirstIndex : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13594,6 +13649,7 @@ static bool js_gfx_InputAssembler_getFirstInstance(se::State& s) unsigned int result = cobj->getFirstInstance(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getFirstInstance : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13612,6 +13668,7 @@ static bool js_gfx_InputAssembler_getFirstVertex(se::State& s) unsigned int result = cobj->getFirstVertex(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getFirstVertex : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13630,6 +13687,7 @@ static bool js_gfx_InputAssembler_getIndexBuffer(se::State& s) cc::gfx::Buffer* result = cobj->getIndexBuffer(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getIndexBuffer : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13648,6 +13706,7 @@ static bool js_gfx_InputAssembler_getIndexCount(se::State& s) unsigned int result = cobj->getIndexCount(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getIndexCount : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13666,6 +13725,7 @@ static bool js_gfx_InputAssembler_getIndirectBuffer(se::State& s) cc::gfx::Buffer* result = cobj->getIndirectBuffer(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getIndirectBuffer : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13684,6 +13744,7 @@ static bool js_gfx_InputAssembler_getInstanceCount(se::State& s) unsigned int result = cobj->getInstanceCount(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getInstanceCount : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13702,6 +13763,7 @@ static bool js_gfx_InputAssembler_getVertexBuffers(se::State& s) const std::vector& result = cobj->getVertexBuffers(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getVertexBuffers : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13720,6 +13782,7 @@ static bool js_gfx_InputAssembler_getVertexCount(se::State& s) unsigned int result = cobj->getVertexCount(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getVertexCount : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13738,6 +13801,7 @@ static bool js_gfx_InputAssembler_getVertexOffset(se::State& s) unsigned int result = cobj->getVertexOffset(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_getVertexOffset : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -13759,6 +13823,7 @@ static bool js_gfx_InputAssembler_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_InputAssembler_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -13984,6 +14049,7 @@ static bool js_gfx_RenderPass_getDepthStencilAttachment(se::State& s) const cc::gfx::DepthStencilAttachment& result = cobj->getDepthStencilAttachment(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_RenderPass_getDepthStencilAttachment : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14002,6 +14068,7 @@ static bool js_gfx_RenderPass_getHash(se::State& s) unsigned int result = cobj->getHash(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_RenderPass_getHash : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14020,6 +14087,7 @@ static bool js_gfx_RenderPass_getSubPasses(se::State& s) const std::vector& result = cobj->getSubPasses(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_RenderPass_getSubPasses : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14041,6 +14109,7 @@ static bool js_gfx_RenderPass_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_RenderPass_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -14124,6 +14193,7 @@ static bool js_gfx_Framebuffer_getColorTextures(se::State& s) const std::vector& result = cobj->getColorTextures(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Framebuffer_getColorTextures : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14142,6 +14212,7 @@ static bool js_gfx_Framebuffer_getDepthStencilTexture(se::State& s) cc::gfx::Texture* result = cobj->getDepthStencilTexture(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Framebuffer_getDepthStencilTexture : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14160,6 +14231,7 @@ static bool js_gfx_Framebuffer_getRenderPass(se::State& s) cc::gfx::RenderPass* result = cobj->getRenderPass(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Framebuffer_getRenderPass : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14181,6 +14253,7 @@ static bool js_gfx_Framebuffer_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Framebuffer_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -14264,6 +14337,7 @@ static bool js_gfx_PipelineLayout_getSetLayouts(se::State& s) const std::vector& result = cobj->getSetLayouts(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineLayout_getSetLayouts : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14285,6 +14359,7 @@ static bool js_gfx_PipelineLayout_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineLayout_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -14366,6 +14441,7 @@ static bool js_gfx_PipelineState_getBlendState(se::State& s) const cc::gfx::BlendState& result = cobj->getBlendState(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineState_getBlendState : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14384,6 +14460,7 @@ static bool js_gfx_PipelineState_getDepthStencilState(se::State& s) const cc::gfx::DepthStencilState& result = cobj->getDepthStencilState(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineState_getDepthStencilState : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14402,6 +14479,7 @@ static bool js_gfx_PipelineState_getDynamicStates(se::State& s) int result = (int)cobj->getDynamicStates(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineState_getDynamicStates : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14420,6 +14498,7 @@ static bool js_gfx_PipelineState_getInputState(se::State& s) const cc::gfx::InputState& result = cobj->getInputState(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineState_getInputState : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14438,6 +14517,7 @@ static bool js_gfx_PipelineState_getPipelineLayout(se::State& s) const cc::gfx::PipelineLayout* result = cobj->getPipelineLayout(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineState_getPipelineLayout : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14456,6 +14536,7 @@ static bool js_gfx_PipelineState_getPrimitive(se::State& s) int result = (int)cobj->getPrimitive(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineState_getPrimitive : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14474,6 +14555,7 @@ static bool js_gfx_PipelineState_getRasterizerState(se::State& s) const cc::gfx::RasterizerState& result = cobj->getRasterizerState(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineState_getRasterizerState : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14492,6 +14574,7 @@ static bool js_gfx_PipelineState_getRenderPass(se::State& s) const cc::gfx::RenderPass* result = cobj->getRenderPass(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineState_getRenderPass : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14510,6 +14593,7 @@ static bool js_gfx_PipelineState_getShader(se::State& s) cc::gfx::Shader* result = cobj->getShader(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineState_getShader : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14531,6 +14615,7 @@ static bool js_gfx_PipelineState_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_PipelineState_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -14620,6 +14705,7 @@ static bool js_gfx_Texture_getBuffer(se::State& s) unsigned char* result = cobj->getBuffer(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getBuffer : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14638,6 +14724,7 @@ static bool js_gfx_Texture_getDepth(se::State& s) unsigned int result = cobj->getDepth(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getDepth : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14656,6 +14743,7 @@ static bool js_gfx_Texture_getFlags(se::State& s) int result = (int)cobj->getFlags(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getFlags : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14674,6 +14762,7 @@ static bool js_gfx_Texture_getFormat(se::State& s) int result = (int)cobj->getFormat(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getFormat : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14692,6 +14781,7 @@ static bool js_gfx_Texture_getHeight(se::State& s) unsigned int result = cobj->getHeight(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getHeight : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14710,6 +14800,7 @@ static bool js_gfx_Texture_getLayerCount(se::State& s) unsigned int result = cobj->getLayerCount(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getLayerCount : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14728,6 +14819,7 @@ static bool js_gfx_Texture_getLevelCount(se::State& s) unsigned int result = cobj->getLevelCount(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getLevelCount : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14746,6 +14838,7 @@ static bool js_gfx_Texture_getSamples(se::State& s) int result = (int)cobj->getSamples(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getSamples : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14764,6 +14857,7 @@ static bool js_gfx_Texture_getSize(se::State& s) unsigned int result = cobj->getSize(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getSize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14782,6 +14876,7 @@ static bool js_gfx_Texture_getType(se::State& s) int result = (int)cobj->getType(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getType : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14800,6 +14895,7 @@ static bool js_gfx_Texture_getUsage(se::State& s) int result = (int)cobj->getUsage(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getUsage : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14818,6 +14914,7 @@ static bool js_gfx_Texture_getWidth(se::State& s) unsigned int result = cobj->getWidth(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_getWidth : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14836,6 +14933,7 @@ static bool js_gfx_Texture_isTextureView(se::State& s) bool result = cobj->isTextureView(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Texture_isTextureView : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14950,6 +15048,7 @@ static bool js_gfx_Shader_getAttributes(se::State& s) const std::vector& result = cobj->getAttributes(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Shader_getAttributes : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14968,6 +15067,7 @@ static bool js_gfx_Shader_getBlocks(se::State& s) const std::vector& result = cobj->getBlocks(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Shader_getBlocks : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -14986,6 +15086,7 @@ static bool js_gfx_Shader_getID(se::State& s) unsigned int result = cobj->getID(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Shader_getID : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15004,6 +15105,7 @@ static bool js_gfx_Shader_getName(se::State& s) const cc::String& result = cobj->getName(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Shader_getName : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15022,6 +15124,7 @@ static bool js_gfx_Shader_getSamplers(se::State& s) const std::vector& result = cobj->getSamplers(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Shader_getSamplers : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15040,6 +15143,7 @@ static bool js_gfx_Shader_getStages(se::State& s) const std::vector& result = cobj->getStages(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Shader_getStages : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15061,6 +15165,7 @@ static bool js_gfx_Shader_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Shader_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15147,6 +15252,7 @@ static bool js_gfx_Device_bindingMappingInfo(se::State& s) const cc::gfx::BindingMappingInfo& result = cobj->bindingMappingInfo(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_bindingMappingInfo : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15169,6 +15275,7 @@ static bool js_gfx_Device_createCommandBuffer(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createCommandBuffer : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15191,6 +15298,7 @@ static bool js_gfx_Device_createDescriptorSet(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createDescriptorSet : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15213,6 +15321,7 @@ static bool js_gfx_Device_createDescriptorSetLayout(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createDescriptorSetLayout : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15235,6 +15344,7 @@ static bool js_gfx_Device_createFence(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createFence : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15257,6 +15367,7 @@ static bool js_gfx_Device_createFramebuffer(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createFramebuffer : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15279,6 +15390,7 @@ static bool js_gfx_Device_createInputAssembler(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createInputAssembler : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15301,6 +15413,7 @@ static bool js_gfx_Device_createPipelineLayout(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createPipelineLayout : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15323,6 +15436,7 @@ static bool js_gfx_Device_createPipelineState(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createPipelineState : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15345,6 +15459,7 @@ static bool js_gfx_Device_createQueue(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createQueue : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15367,6 +15482,7 @@ static bool js_gfx_Device_createRenderPass(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createRenderPass : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15389,6 +15505,7 @@ static bool js_gfx_Device_createSampler(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createSampler : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15411,6 +15528,7 @@ static bool js_gfx_Device_createShader(se::State& s) ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_createShader : Error processing arguments"); se::NonRefNativePtrCreatedByCtorMap::emplace(result); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -15444,6 +15562,7 @@ static bool js_gfx_Device_genShaderId(se::State& s) unsigned int result = cobj->genShaderId(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_genShaderId : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15462,6 +15581,7 @@ static bool js_gfx_Device_getClipSpaceMinZ(se::State& s) float result = cobj->getClipSpaceMinZ(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getClipSpaceMinZ : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15480,6 +15600,7 @@ static bool js_gfx_Device_getColorFormat(se::State& s) int result = (int)cobj->getColorFormat(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getColorFormat : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15498,6 +15619,7 @@ static bool js_gfx_Device_getCommandBuffer(se::State& s) cc::gfx::CommandBuffer* result = cobj->getCommandBuffer(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getCommandBuffer : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15516,6 +15638,7 @@ static bool js_gfx_Device_getContext(se::State& s) cc::gfx::Context* result = cobj->getContext(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getContext : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15534,6 +15657,7 @@ static bool js_gfx_Device_getDepthBits(se::State& s) int result = cobj->getDepthBits(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getDepthBits : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15552,6 +15676,7 @@ static bool js_gfx_Device_getDepthStencilFormat(se::State& s) int result = (int)cobj->getDepthStencilFormat(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getDepthStencilFormat : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15570,6 +15695,7 @@ static bool js_gfx_Device_getDeviceName(se::State& s) const cc::String& result = cobj->getDeviceName(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getDeviceName : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15588,6 +15714,7 @@ static bool js_gfx_Device_getGfxAPI(se::State& s) int result = (int)cobj->getGfxAPI(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getGfxAPI : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15606,6 +15733,7 @@ static bool js_gfx_Device_getHeight(se::State& s) unsigned int result = cobj->getHeight(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getHeight : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15624,6 +15752,7 @@ static bool js_gfx_Device_getMaxCubeMapTextureSize(se::State& s) int result = cobj->getMaxCubeMapTextureSize(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getMaxCubeMapTextureSize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15642,6 +15771,7 @@ static bool js_gfx_Device_getMaxFragmentUniformVectors(se::State& s) int result = cobj->getMaxFragmentUniformVectors(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getMaxFragmentUniformVectors : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15660,6 +15790,7 @@ static bool js_gfx_Device_getMaxTextureSize(se::State& s) int result = cobj->getMaxTextureSize(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getMaxTextureSize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15678,6 +15809,7 @@ static bool js_gfx_Device_getMaxTextureUnits(se::State& s) int result = cobj->getMaxTextureUnits(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getMaxTextureUnits : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15696,6 +15828,7 @@ static bool js_gfx_Device_getMaxUniformBlockSize(se::State& s) int result = cobj->getMaxUniformBlockSize(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getMaxUniformBlockSize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15714,6 +15847,7 @@ static bool js_gfx_Device_getMaxUniformBufferBindings(se::State& s) int result = cobj->getMaxUniformBufferBindings(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getMaxUniformBufferBindings : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15732,6 +15866,7 @@ static bool js_gfx_Device_getMaxVertexAttributes(se::State& s) int result = cobj->getMaxVertexAttributes(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getMaxVertexAttributes : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15750,6 +15885,7 @@ static bool js_gfx_Device_getMaxVertexTextureUnits(se::State& s) int result = cobj->getMaxVertexTextureUnits(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getMaxVertexTextureUnits : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15768,6 +15904,7 @@ static bool js_gfx_Device_getMaxVertexUniformVectors(se::State& s) int result = cobj->getMaxVertexUniformVectors(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getMaxVertexUniformVectors : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15786,6 +15923,7 @@ static bool js_gfx_Device_getMemoryStatus(se::State& s) cc::gfx::MemoryStatus& result = cobj->getMemoryStatus(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getMemoryStatus : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15804,6 +15942,7 @@ static bool js_gfx_Device_getNativeHeight(se::State& s) unsigned int result = cobj->getNativeHeight(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getNativeHeight : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15822,6 +15961,7 @@ static bool js_gfx_Device_getNativeWidth(se::State& s) unsigned int result = cobj->getNativeWidth(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getNativeWidth : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15840,6 +15980,7 @@ static bool js_gfx_Device_getNumDrawCalls(se::State& s) unsigned int result = cobj->getNumDrawCalls(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getNumDrawCalls : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15858,6 +15999,7 @@ static bool js_gfx_Device_getNumInstances(se::State& s) unsigned int result = cobj->getNumInstances(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getNumInstances : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15876,6 +16018,7 @@ static bool js_gfx_Device_getNumTris(se::State& s) unsigned int result = cobj->getNumTris(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getNumTris : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15894,6 +16037,7 @@ static bool js_gfx_Device_getQueue(se::State& s) cc::gfx::Queue* result = cobj->getQueue(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getQueue : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15912,6 +16056,7 @@ static bool js_gfx_Device_getRenderer(se::State& s) const cc::String& result = cobj->getRenderer(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getRenderer : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15930,6 +16075,7 @@ static bool js_gfx_Device_getScreenSpaceSignY(se::State& s) float result = cobj->getScreenSpaceSignY(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getScreenSpaceSignY : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15948,6 +16094,7 @@ static bool js_gfx_Device_getStencilBits(se::State& s) int result = cobj->getStencilBits(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getStencilBits : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15966,6 +16113,7 @@ static bool js_gfx_Device_getSurfaceTransform(se::State& s) int result = (int)cobj->getSurfaceTransform(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getSurfaceTransform : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -15984,6 +16132,7 @@ static bool js_gfx_Device_getUVSpaceSignY(se::State& s) float result = cobj->getUVSpaceSignY(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getUVSpaceSignY : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -16002,6 +16151,7 @@ static bool js_gfx_Device_getUboOffsetAlignment(se::State& s) int result = cobj->getUboOffsetAlignment(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getUboOffsetAlignment : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -16020,6 +16170,7 @@ static bool js_gfx_Device_getVendor(se::State& s) const cc::String& result = cobj->getVendor(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getVendor : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -16038,6 +16189,7 @@ static bool js_gfx_Device_getWidth(se::State& s) unsigned int result = cobj->getWidth(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_getWidth : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); @@ -16059,6 +16211,7 @@ static bool js_gfx_Device_hasFeature(se::State& s) bool result = cobj->hasFeature(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_hasFeature : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); @@ -16080,6 +16233,7 @@ static bool js_gfx_Device_initialize(se::State& s) bool result = cobj->initialize(arg0.value()); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gfx_Device_initialize : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 1); diff --git a/native/cocos/bindings/auto/jsb_gles2_auto.cpp b/native/cocos/bindings/auto/jsb_gles2_auto.cpp index a0c6d5473b..54a0b0ff83 100644 --- a/native/cocos/bindings/auto/jsb_gles2_auto.cpp +++ b/native/cocos/bindings/auto/jsb_gles2_auto.cpp @@ -46,6 +46,7 @@ static bool js_gles2_GLES2Device_getThreadID(se::State& s) unsigned int result = cobj->getThreadID(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gles2_GLES2Device_getThreadID : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); diff --git a/native/cocos/bindings/auto/jsb_gles3_auto.cpp b/native/cocos/bindings/auto/jsb_gles3_auto.cpp index 27549223ed..d6965f909f 100644 --- a/native/cocos/bindings/auto/jsb_gles3_auto.cpp +++ b/native/cocos/bindings/auto/jsb_gles3_auto.cpp @@ -46,6 +46,7 @@ static bool js_gles3_GLES3Device_getThreadID(se::State& s) unsigned int result = cobj->getThreadID(); ok &= nativevalue_to_se(result, s.rval(), nullptr /*ctx*/); SE_PRECONDITION2(ok, false, "js_gles3_GLES3Device_getThreadID : Error processing arguments"); + SE_HOLD_RETURN_VALUE(result, s.thisObject(), s.rval()); return true; } SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); diff --git a/native/cocos/bindings/auto/jsb_mtl_auto.cpp b/native/cocos/bindings/auto/jsb_mtl_auto.cpp index 369fe2e0d0..b76d366b0b 100644 --- a/native/cocos/bindings/auto/jsb_mtl_auto.cpp +++ b/native/cocos/bindings/auto/jsb_mtl_auto.cpp @@ -13,6 +13,21 @@ se::Object* __jsb_cc_gfx_CCMTLDevice_proto = nullptr; se::Class* __jsb_cc_gfx_CCMTLDevice_class = nullptr; +static bool js_mtl_CCMTLDevice_ensureAutoreleasePool(se::State& s) +{ + cc::gfx::CCMTLDevice* cobj = SE_THIS_OBJECT(s); + SE_PRECONDITION2(cobj, false, "js_mtl_CCMTLDevice_ensureAutoreleasePool : Invalid Native Object"); + const auto& args = s.args(); + size_t argc = args.size(); + if (argc == 0) { + cobj->ensureAutoreleasePool(); + return true; + } + SE_REPORT_ERROR("wrong number of arguments: %d, was expecting %d", (int)argc, 0); + return false; +} +SE_BIND_FUNC(js_mtl_CCMTLDevice_ensureAutoreleasePool) + SE_DECLARE_FINALIZE_FUNC(js_cc_gfx_CCMTLDevice_finalize) static bool js_mtl_CCMTLDevice_constructor(se::State& s) // constructor.c @@ -45,6 +60,7 @@ bool js_register_mtl_CCMTLDevice(se::Object* obj) { auto cls = se::Class::create("CCMTLDevice", obj, __jsb_cc_gfx_Device_proto, _SE(js_mtl_CCMTLDevice_constructor)); + cls->defineFunction("ensureAutoreleasePool", _SE(js_mtl_CCMTLDevice_ensureAutoreleasePool)); cls->defineFinalizeFunction(_SE(js_cc_gfx_CCMTLDevice_finalize)); cls->install(); JSBClassType::registerClass(cls); diff --git a/native/cocos/bindings/auto/jsb_mtl_auto.h b/native/cocos/bindings/auto/jsb_mtl_auto.h index d7cd9b191c..7d7cba1b78 100644 --- a/native/cocos/bindings/auto/jsb_mtl_auto.h +++ b/native/cocos/bindings/auto/jsb_mtl_auto.h @@ -12,5 +12,6 @@ bool js_register_cc_gfx_CCMTLDevice(se::Object* obj); bool register_all_mtl(se::Object* obj); JSB_REGISTER_OBJECT_TYPE(cc::gfx::CCMTLDevice); +SE_DECLARE_FUNC(js_mtl_CCMTLDevice_ensureAutoreleasePool); SE_DECLARE_FUNC(js_mtl_CCMTLDevice_CCMTLDevice); diff --git a/native/cocos/cocos2d.h b/native/cocos/cocos2d.h index 3c7b5d8799..bc38dcf2c3 100644 --- a/native/cocos/cocos2d.h +++ b/native/cocos/cocos2d.h @@ -51,8 +51,6 @@ THE SOFTWARE. #include "base/Macros.h" #include "base/UTF8.h" #include "base/Utils.h" -#include "base/job-system/JobSystem.h" - // math #include "math/Geometry.h" diff --git a/native/cocos/renderer/core/Core.h b/native/cocos/renderer/core/Core.h index 928c449be7..fc6ae5d0e6 100644 --- a/native/cocos/renderer/core/Core.h +++ b/native/cocos/renderer/core/Core.h @@ -46,18 +46,3 @@ THE SOFTWARE. #include "gfx/GFXSampler.h" #include "gfx/GFXShader.h" #include "gfx/GFXTexture.h" - -#include "threading/MessageQueue.h" -#include "threading/ThreadPool.h" - -#include "gfx-agent/GFXBufferAgent.h" -#include "gfx-agent/GFXCommandBufferAgent.h" -#include "gfx-agent/GFXDescriptorSetAgent.h" -#include "gfx-agent/GFXDeviceAgent.h" -#include "gfx-agent/GFXFramebufferAgent.h" -#include "gfx-agent/GFXInputAssemblerAgent.h" -#include "gfx-agent/GFXPipelineStateAgent.h" -#include "gfx-agent/GFXQueueAgent.h" -#include "gfx-agent/GFXRenderPassAgent.h" -#include "gfx-agent/GFXShaderAgent.h" -#include "gfx-agent/GFXTextureAgent.h" diff --git a/native/cocos/renderer/core/gfx-agent/GFXAgent.h b/native/cocos/renderer/core/gfx-agent/GFXAgent.h index 398ab4c105..827fd87011 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXAgent.h @@ -10,10 +10,10 @@ class CC_DLL Agent : public Actor { public: Agent() noexcept = delete; - explicit Agent(Actor *const actor, Device *const device) noexcept + Agent(Actor *const actor, Device *const device) noexcept : Actor(device), _actor(actor) {} - virtual ~Agent() {} + ~Agent() override {} Agent(Agent const &) = delete; @@ -26,7 +26,7 @@ public: inline Actor *getActor() const noexcept { return _actor; } protected: - Actor * _actor{nullptr}; + Actor *_actor{nullptr}; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXBufferAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXBufferAgent.cpp index 2cd4076812..19cd0fa6c2 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXBufferAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXBufferAgent.cpp @@ -1,6 +1,6 @@ #include "CoreStd.h" -#include "threading/MessageQueue.h" +#include "base/threading/MessageQueue.h" #include "GFXBufferAgent.h" #include "GFXDeviceAgent.h" #include "GFXLinearAllocatorPool.h" @@ -8,6 +8,16 @@ namespace cc { namespace gfx { +BufferAgent::~BufferAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + BufferDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool BufferAgent::initialize(const BufferInfo &info) { _usage = info.usage; _memUsage = info.memUsage; @@ -52,17 +62,13 @@ bool BufferAgent::initialize(const BufferViewInfo &info) { } void BufferAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - BufferDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + BufferDestroy, + actor, getActor(), + { + actor->destroy(); + }); } void BufferAgent::update(void *buffer, uint size) { diff --git a/native/cocos/renderer/core/gfx-agent/GFXBufferAgent.h b/native/cocos/renderer/core/gfx-agent/GFXBufferAgent.h index f297022254..7a6833dbc7 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXBufferAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXBufferAgent.h @@ -10,12 +10,13 @@ class CC_DLL BufferAgent final : public Agent { public: using Agent::Agent; BufferAgent(Device *device) = delete; + ~BufferAgent() override; - virtual bool initialize(const BufferInfo &info) override; - virtual bool initialize(const BufferViewInfo &info) override; - virtual void destroy() override; - virtual void resize(uint size) override; - virtual void update(void *buffer, uint size) override; + bool initialize(const BufferInfo &info) override; + bool initialize(const BufferViewInfo &info) override; + void destroy() override; + void resize(uint size) override; + void update(void *buffer, uint size) override; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXCommandBufferAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXCommandBufferAgent.cpp index 972731cf40..6d998c2176 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXCommandBufferAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXCommandBufferAgent.cpp @@ -1,7 +1,7 @@ #include "CoreStd.h" -#include "job-system/JobSystem.h" -#include "threading/MessageQueue.h" +#include "base/job-system/JobSystem.h" +#include "base/threading/MessageQueue.h" #include "GFXBufferAgent.h" #include "GFXCommandBufferAgent.h" #include "GFXDescriptorSetAgent.h" @@ -37,6 +37,16 @@ void CommandBufferAgent::flushCommands(CommandBufferAgent *const *cmdBuffs, uint } } +CommandBufferAgent::~CommandBufferAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + CommandBufferDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + void CommandBufferAgent::initMessageQueue() { _allocatorPools.resize(MAX_CPU_FRAME_AHEAD + 1); for (uint i = 0u; i < MAX_CPU_FRAME_AHEAD + 1; ++i) { @@ -86,17 +96,14 @@ bool CommandBufferAgent::initialize(const CommandBufferInfo &info) { void CommandBufferAgent::destroy() { destroyMessageQueue(); - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - CommandBufferDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + CommandBufferDestroy, + actor, getActor(), + { + actor->destroy(); + }); } void CommandBufferAgent::begin(RenderPass *renderPass, uint subpass, Framebuffer *frameBuffer, int submitIndex) { @@ -171,18 +178,23 @@ void CommandBufferAgent::endRenderPass() { void CommandBufferAgent::execute(const CommandBuffer *const *cmdBuffs, uint32_t count) { if (!count) return; - const CommandBuffer **actorCmdBuffs = _messageQueue->allocate(count); + const CommandBuffer **actorCmdBuffs = getAllocator()->allocate(count); for (uint i = 0; i < count; ++i) { actorCmdBuffs[i] = ((CommandBufferAgent *)cmdBuffs[i])->getActor(); } + const CommandBufferAgent **agentCmdBuffs = getAllocator()->allocate(count); + for (uint i = 0; i < count; ++i) { + agentCmdBuffs[i] = (CommandBufferAgent *)cmdBuffs[i]; + } + bool multiThreaded = _device->hasFeature(Feature::MULTITHREADED_SUBMISSION); ENQUEUE_MESSAGE_5( _messageQueue, CommandBufferExecute, actor, getActor(), - cmdBuffs, (CommandBufferAgent *const *)cmdBuffs, + cmdBuffs, (CommandBufferAgent *const *)agentCmdBuffs, actorCmdBuffs, actorCmdBuffs, count, count, multiThreaded, multiThreaded, diff --git a/native/cocos/renderer/core/gfx-agent/GFXCommandBufferAgent.h b/native/cocos/renderer/core/gfx-agent/GFXCommandBufferAgent.h index 346d5ed05b..e4b6195c72 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXCommandBufferAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXCommandBufferAgent.h @@ -15,34 +15,35 @@ class CC_DLL CommandBufferAgent final : public Agent { public: using Agent::Agent; CommandBufferAgent(Device *device) = delete; + ~CommandBufferAgent() override; static void flushCommands(CommandBufferAgent *const *cmdBuffs, uint count, bool multiThreaded); - virtual bool initialize(const CommandBufferInfo &info) override; - virtual void destroy() override; - virtual void begin(RenderPass *renderPass, uint subpass, Framebuffer *frameBuffer, int submitIndex) override; - virtual void end() override; - virtual void beginRenderPass(RenderPass *renderPass, Framebuffer *fbo, const Rect &renderArea, const Color *colors, float depth, int stencil, uint32_t secondaryCBCount, const CommandBuffer *const *secondaryCBs) override; - virtual void endRenderPass() override; - virtual void bindPipelineState(PipelineState *pso) override; - virtual void bindDescriptorSet(uint set, DescriptorSet *descriptorSet, uint dynamicOffsetCount, const uint *dynamicOffsets) override; - virtual void bindInputAssembler(InputAssembler *ia) override; - virtual void setViewport(const Viewport &vp) override; - virtual void setScissor(const Rect &rect) override; - virtual void setLineWidth(const float width) override; - virtual void setDepthBias(float constant, float clamp, float slope) override; - virtual void setBlendConstants(const Color &constants) override; - virtual void setDepthBound(float minBounds, float maxBounds) override; - virtual void setStencilWriteMask(StencilFace face, uint mask) override; - virtual void setStencilCompareMask(StencilFace face, int ref, uint mask) override; - virtual void draw(InputAssembler *ia) override; - virtual void updateBuffer(Buffer *buff, const void *data, uint size) override; - virtual void copyBuffersToTexture(const uint8_t *const *buffers, Texture *texture, const BufferTextureCopy *regions, uint count) override; - virtual void execute(const CommandBuffer *const *cmdBuffs, uint32_t count) override; + bool initialize(const CommandBufferInfo &info) override; + void destroy() override; + void begin(RenderPass *renderPass, uint subpass, Framebuffer *frameBuffer, int submitIndex) override; + void end() override; + void beginRenderPass(RenderPass *renderPass, Framebuffer *fbo, const Rect &renderArea, const Color *colors, float depth, int stencil, uint32_t secondaryCBCount, const CommandBuffer *const *secondaryCBs) override; + void endRenderPass() override; + void bindPipelineState(PipelineState *pso) override; + void bindDescriptorSet(uint set, DescriptorSet *descriptorSet, uint dynamicOffsetCount, const uint *dynamicOffsets) override; + void bindInputAssembler(InputAssembler *ia) override; + void setViewport(const Viewport &vp) override; + void setScissor(const Rect &rect) override; + void setLineWidth(const float width) override; + void setDepthBias(float constant, float clamp, float slope) override; + void setBlendConstants(const Color &constants) override; + void setDepthBound(float minBounds, float maxBounds) override; + void setStencilWriteMask(StencilFace face, uint mask) override; + void setStencilCompareMask(StencilFace face, int ref, uint mask) override; + void draw(InputAssembler *ia) override; + void updateBuffer(Buffer *buff, const void *data, uint size) override; + void copyBuffersToTexture(const uint8_t *const *buffers, Texture *texture, const BufferTextureCopy *regions, uint count) override; + void execute(const CommandBuffer *const *cmdBuffs, uint32_t count) override; - virtual uint getNumDrawCalls() const override { return _actor->getNumDrawCalls(); } - virtual uint getNumInstances() const override { return _actor->getNumInstances(); } - virtual uint getNumTris() const override { return _actor->getNumTris(); } + uint getNumDrawCalls() const override { return _actor->getNumDrawCalls(); } + uint getNumInstances() const override { return _actor->getNumInstances(); } + uint getNumTris() const override { return _actor->getNumTris(); } CC_INLINE MessageQueue *getMessageQueue() { return _messageQueue; } LinearAllocatorPool *getAllocator(); diff --git a/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetAgent.cpp index 0ead9ace52..4971db7b62 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetAgent.cpp @@ -6,11 +6,21 @@ #include "GFXDeviceAgent.h" #include "GFXSamplerAgent.h" #include "GFXTextureAgent.h" -#include "threading/MessageQueue.h" +#include "base/threading/MessageQueue.h" namespace cc { namespace gfx { +DescriptorSetAgent::~DescriptorSetAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + DescriptorSetDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool DescriptorSetAgent::initialize(const DescriptorSetInfo &info) { _layout = info.layout; uint descriptorCount = _layout->getDescriptorCount(); @@ -39,17 +49,13 @@ void DescriptorSetAgent::destroy() { _textures.clear(); _samplers.clear(); - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - DescriptorSetDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + DescriptorSetDestroy, + actor, getActor(), + { + actor->destroy(); + }); } void DescriptorSetAgent::update() { diff --git a/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetAgent.h b/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetAgent.h index b67662fbd8..a9692dd1e4 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetAgent.h @@ -10,14 +10,15 @@ class CC_DLL DescriptorSetAgent final : public Agent { public: using Agent::Agent; DescriptorSetAgent(Device *device) = delete; + ~DescriptorSetAgent() override; - virtual bool initialize(const DescriptorSetInfo &info) override; - virtual void destroy() override; - virtual void update() override; + bool initialize(const DescriptorSetInfo &info) override; + void destroy() override; + void update() override; - virtual void bindBuffer(uint binding, Buffer *buffer, uint index) override; - virtual void bindTexture(uint binding, Texture *texture, uint index) override; - virtual void bindSampler(uint binding, Sampler *sampler, uint index) override; + void bindBuffer(uint binding, Buffer *buffer, uint index) override; + void bindTexture(uint binding, Texture *texture, uint index) override; + void bindSampler(uint binding, Sampler *sampler, uint index) override; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetLayoutAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetLayoutAgent.cpp index 00b89d431f..c3d72a8141 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetLayoutAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetLayoutAgent.cpp @@ -1,12 +1,22 @@ #include "CoreStd.h" -#include "threading/MessageQueue.h" +#include "base/threading/MessageQueue.h" #include "GFXDeviceAgent.h" #include "GFXDescriptorSetLayoutAgent.h" namespace cc { namespace gfx { +DescriptorSetLayoutAgent::~DescriptorSetLayoutAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + DescriptorSetLayoutDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool DescriptorSetLayoutAgent::initialize(const DescriptorSetLayoutInfo &info) { _bindings = info.bindings; @@ -45,17 +55,13 @@ bool DescriptorSetLayoutAgent::initialize(const DescriptorSetLayoutInfo &info) { } void DescriptorSetLayoutAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - DescriptorSetLayoutDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + DescriptorSetLayoutDestroy, + actor, getActor(), + { + actor->destroy(); + }); } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetLayoutAgent.h b/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetLayoutAgent.h index 7fc2b3feee..26455f7ab5 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetLayoutAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXDescriptorSetLayoutAgent.h @@ -10,9 +10,10 @@ class CC_DLL DescriptorSetLayoutAgent final : public Agent public: using Agent::Agent; DescriptorSetLayoutAgent(Device *device) = delete; + ~DescriptorSetLayoutAgent() override; - virtual bool initialize(const DescriptorSetLayoutInfo &info) override; - virtual void destroy() override; + bool initialize(const DescriptorSetLayoutInfo &info) override; + void destroy() override; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXDeviceAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXDeviceAgent.cpp index 332a94afc5..09c9493ad3 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXDeviceAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXDeviceAgent.cpp @@ -1,10 +1,9 @@ #include "CoreStd.h" -#include "threading/MessageQueue.h" #include "GFXBufferAgent.h" #include "GFXCommandBufferAgent.h" -#include "GFXDescriptorSetLayoutAgent.h" #include "GFXDescriptorSetAgent.h" +#include "GFXDescriptorSetLayoutAgent.h" #include "GFXDeviceAgent.h" #include "GFXFramebufferAgent.h" #include "GFXInputAssemblerAgent.h" @@ -16,10 +15,15 @@ #include "GFXSamplerAgent.h" #include "GFXShaderAgent.h" #include "GFXTextureAgent.h" +#include "base/threading/MessageQueue.h" namespace cc { namespace gfx { +DeviceAgent::~DeviceAgent() { + CC_SAFE_DELETE(_actor); +} + bool DeviceAgent::initialize(const DeviceInfo &info) { _clipSpaceMinZ = _actor->getClipSpaceMinZ(); _screenSpaceSignY = _actor->getScreenSpaceSignY(); @@ -79,17 +83,13 @@ bool DeviceAgent::initialize(const DeviceInfo &info) { } void DeviceAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - getMessageQueue(), - DeviceDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + getMessageQueue(), + DeviceDestroy, + actor, getActor(), + { + actor->destroy(); + }); ((CommandBufferAgent *)_cmdBuff)->destroyMessageQueue(); CC_SAFE_DELETE(_cmdBuff); @@ -146,7 +146,7 @@ void DeviceAgent::present() { _frameBoundarySemaphore.Wait(); getMainAllocator()->reset(); - for (LinearAllocatorPool **allocatorPools: _allocatorPoolRefs) { + for (LinearAllocatorPool **allocatorPools : _allocatorPoolRefs) { allocatorPools[_currentIndex]->reset(); } } diff --git a/native/cocos/renderer/core/gfx-agent/GFXDeviceAgent.h b/native/cocos/renderer/core/gfx-agent/GFXDeviceAgent.h index dc11e8fafc..120b5ac56d 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXDeviceAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXDeviceAgent.h @@ -1,7 +1,7 @@ #pragma once #include "../gfx/GFXDevice.h" -#include "threading/Semaphore.h" +#include "base/threading/Semaphore.h" #include "GFXAgent.h" namespace cc { @@ -23,40 +23,40 @@ struct SubmitContext final { class CC_DLL DeviceAgent final : public Agent { public: using Agent::Agent; + ~DeviceAgent() override; - virtual bool initialize(const DeviceInfo &info) override; - virtual void destroy() override; - virtual void resize(uint width, uint height) override; - virtual void acquire() override; - virtual void present() override; + bool initialize(const DeviceInfo &info) override; + void destroy() override; + void resize(uint width, uint height) override; + void acquire() override; + void present() override; - virtual CommandBuffer *doCreateCommandBuffer(const CommandBufferInfo &info, bool hasAgent) override; - virtual Fence *createFence() override; - virtual Queue *createQueue() override; - virtual Buffer *createBuffer() override; - virtual Texture *createTexture() override; - virtual Sampler *createSampler() override; - virtual Shader *createShader() override; - virtual InputAssembler *createInputAssembler() override; - virtual RenderPass *createRenderPass() override; - virtual Framebuffer *createFramebuffer() override; - virtual DescriptorSet *createDescriptorSet() override; - virtual DescriptorSetLayout *createDescriptorSetLayout() override; - virtual PipelineLayout *createPipelineLayout() override; - virtual PipelineState *createPipelineState() override; - virtual void copyBuffersToTexture(const uint8_t *const *buffers, Texture *dst, const BufferTextureCopy *regions, uint count) override; + CommandBuffer *doCreateCommandBuffer(const CommandBufferInfo &info, bool hasAgent) override; + Fence *createFence() override; + Queue *createQueue() override; + Buffer *createBuffer() override; + Texture *createTexture() override; + Sampler *createSampler() override; + Shader *createShader() override; + InputAssembler *createInputAssembler() override; + RenderPass *createRenderPass() override; + Framebuffer *createFramebuffer() override; + DescriptorSet *createDescriptorSet() override; + DescriptorSetLayout *createDescriptorSetLayout() override; + PipelineLayout *createPipelineLayout() override; + PipelineState *createPipelineState() override; + void copyBuffersToTexture(const uint8_t *const *buffers, Texture *dst, const BufferTextureCopy *regions, uint count) override; - - virtual void setMultithreaded(bool multithreaded) override; - virtual SurfaceTransform getSurfaceTransform() const override { return _actor->getSurfaceTransform(); } - virtual uint getWidth() const override { return _actor->getWidth(); } - virtual uint getHeight() const override { return _actor->getHeight(); } - virtual uint getNativeWidth() const override { return _actor->getNativeWidth(); } - virtual uint getNativeHeight() const override { return _actor->getNativeHeight(); } - virtual MemoryStatus &getMemoryStatus() override { return _actor->getMemoryStatus(); } - virtual uint getNumDrawCalls() const override { return _actor->getNumDrawCalls(); } - virtual uint getNumInstances() const override { return _actor->getNumInstances(); } - virtual uint getNumTris() const override { return _actor->getNumTris(); } + void setMultithreaded(bool multithreaded) override; + SurfaceTransform getSurfaceTransform() const override { return _actor->getSurfaceTransform(); } + uint getWidth() const override { return _actor->getWidth(); } + uint getHeight() const override { return _actor->getHeight(); } + uint getNativeWidth() const override { return _actor->getNativeWidth(); } + uint getNativeHeight() const override { return _actor->getNativeHeight(); } + MemoryStatus &getMemoryStatus() override { return _actor->getMemoryStatus(); } + uint getNumDrawCalls() const override { return _actor->getNumDrawCalls(); } + uint getNumInstances() const override { return _actor->getNumInstances(); } + uint getNumTris() const override { return _actor->getNumTris(); } MessageQueue *getMessageQueue() const { return _mainEncoder; } LinearAllocatorPool *getMainAllocator() const { return _allocatorPools[_currentIndex]; } diff --git a/native/cocos/renderer/core/gfx-agent/GFXFramebufferAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXFramebufferAgent.cpp index 6243d9cf33..dbc0309e03 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXFramebufferAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXFramebufferAgent.cpp @@ -1,6 +1,6 @@ #include "CoreStd.h" -#include "threading/MessageQueue.h" +#include "base/threading/MessageQueue.h" #include "GFXDeviceAgent.h" #include "GFXFramebufferAgent.h" #include "GFXRenderPassAgent.h" @@ -9,6 +9,16 @@ namespace cc { namespace gfx { +FramebufferAgent::~FramebufferAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + FramebufferDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool FramebufferAgent::initialize(const FramebufferInfo &info) { _renderPass = info.renderPass; _colorTextures = info.colorTextures; @@ -38,17 +48,13 @@ bool FramebufferAgent::initialize(const FramebufferInfo &info) { } void FramebufferAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - FramebufferDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + FramebufferDestroy, + actor, getActor(), + { + actor->destroy(); + }); } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXFramebufferAgent.h b/native/cocos/renderer/core/gfx-agent/GFXFramebufferAgent.h index 65429d5fb6..81417ec643 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXFramebufferAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXFramebufferAgent.h @@ -10,9 +10,10 @@ class CC_DLL FramebufferAgent final : public Agent { public: using Agent::Agent; FramebufferAgent(Device *device) = delete; + ~FramebufferAgent() override; - virtual bool initialize(const FramebufferInfo &info) override; - virtual void destroy() override; + bool initialize(const FramebufferInfo &info) override; + void destroy() override; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXInputAssemblerAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXInputAssemblerAgent.cpp index 699cf9b5b2..a02b8894a5 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXInputAssemblerAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXInputAssemblerAgent.cpp @@ -1,6 +1,6 @@ #include "CoreStd.h" -#include "threading/MessageQueue.h" +#include "base/threading/MessageQueue.h" #include "GFXBufferAgent.h" #include "GFXDeviceAgent.h" #include "GFXInputAssemblerAgent.h" @@ -8,6 +8,16 @@ namespace cc { namespace gfx { +InputAssemblerAgent::~InputAssemblerAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + InputAssemblerDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool InputAssemblerAgent::initialize(const InputAssemblerInfo &info) { _attributes = info.attributes; _vertexBuffers = info.vertexBuffers; @@ -48,17 +58,13 @@ bool InputAssemblerAgent::initialize(const InputAssemblerInfo &info) { } void InputAssemblerAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - InputAssemblerDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + InputAssemblerDestroy, + actor, getActor(), + { + actor->destroy(); + }); } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXInputAssemblerAgent.h b/native/cocos/renderer/core/gfx-agent/GFXInputAssemblerAgent.h index b0ecdab728..75436a1e15 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXInputAssemblerAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXInputAssemblerAgent.h @@ -10,17 +10,18 @@ class CC_DLL InputAssemblerAgent final : public Agent { public: using Agent::Agent; InputAssemblerAgent(Device *device) = delete; + ~InputAssemblerAgent() override; - virtual bool initialize(const InputAssemblerInfo &info) override; - virtual void destroy() override; + bool initialize(const InputAssemblerInfo &info) override; + void destroy() override; - virtual void setVertexCount(uint count) override { _vertexCount = count; _actor->setVertexCount(count); } - virtual void setFirstVertex(uint first) override { _firstVertex = first; _actor->setFirstVertex(first); } - virtual void setIndexCount(uint count) override { _indexCount = count; _actor->setIndexCount(count); } - virtual void setFirstIndex(uint first) override { _firstIndex = first; _actor->setFirstIndex(first); } - virtual void setVertexOffset(uint offset) override { _vertexOffset = offset; _actor->setVertexOffset(offset); } - virtual void setInstanceCount(uint count) override { _instanceCount = count; _actor->setInstanceCount(count); } - virtual void setFirstInstance(uint first) override { _firstInstance = first; _actor->setFirstInstance(first); } + void setVertexCount(uint count) override { _vertexCount = count; _actor->setVertexCount(count); } + void setFirstVertex(uint first) override { _firstVertex = first; _actor->setFirstVertex(first); } + void setIndexCount(uint count) override { _indexCount = count; _actor->setIndexCount(count); } + void setFirstIndex(uint first) override { _firstIndex = first; _actor->setFirstIndex(first); } + void setVertexOffset(uint offset) override { _vertexOffset = offset; _actor->setVertexOffset(offset); } + void setInstanceCount(uint count) override { _instanceCount = count; _actor->setInstanceCount(count); } + void setFirstInstance(uint first) override { _firstInstance = first; _actor->setFirstInstance(first); } }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXLinearAllocatorPool.h b/native/cocos/renderer/core/gfx-agent/GFXLinearAllocatorPool.h index c24a814864..33231a05af 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXLinearAllocatorPool.h +++ b/native/cocos/renderer/core/gfx-agent/GFXLinearAllocatorPool.h @@ -2,7 +2,7 @@ #include #include -#include "threading/ThreadSafeLinearAllocator.h" +#include "base/threading/ThreadSafeLinearAllocator.h" namespace cc { namespace gfx { @@ -26,7 +26,7 @@ public: LinearAllocatorPool(size_t defaultBlockSize = DEFAULT_BLOCK_SIZE): _defaultBlockSize(defaultBlockSize) { _allocators.emplace_back(CC_NEW(ThreadSafeLinearAllocator(_defaultBlockSize))); } - + ~LinearAllocatorPool() { for (ThreadSafeLinearAllocator *allocator : _allocators) { CC_SAFE_DELETE(allocator); @@ -36,13 +36,15 @@ public: template T* allocate(const uint count, uint alignment = 64u) noexcept { + if (!count) return nullptr; + T* res = nullptr; size_t size = count * sizeof(T); for (ThreadSafeLinearAllocator *allocator : _allocators) { res = reinterpret_cast(allocator->Allocate(size, alignment)); if (res) return res; } - size_t capacity = nextPowerOf2(std::max(DEFAULT_BLOCK_SIZE, size)); + size_t capacity = nextPowerOf2(std::max(DEFAULT_BLOCK_SIZE, size + alignment)); // reserve enough padding space for alignment _allocators.emplace_back(CC_NEW(ThreadSafeLinearAllocator(capacity))); return reinterpret_cast(_allocators.back()->Allocate(size, alignment)); } diff --git a/native/cocos/renderer/core/gfx-agent/GFXPipelineLayoutAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXPipelineLayoutAgent.cpp index e62b52e40a..25435b9710 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXPipelineLayoutAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXPipelineLayoutAgent.cpp @@ -1,6 +1,6 @@ #include "CoreStd.h" -#include "threading/MessageQueue.h" +#include "base/threading/MessageQueue.h" #include "GFXDescriptorSetLayoutAgent.h" #include "GFXDeviceAgent.h" #include "GFXPipelineLayoutAgent.h" @@ -8,6 +8,16 @@ namespace cc { namespace gfx { +PipelineLayoutAgent::~PipelineLayoutAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + PipelineLayoutDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool PipelineLayoutAgent::initialize(const PipelineLayoutInfo &info) { _setLayouts = info.setLayouts; @@ -31,17 +41,13 @@ bool PipelineLayoutAgent::initialize(const PipelineLayoutInfo &info) { } void PipelineLayoutAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - PipelineLayoutDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + PipelineLayoutDestroy, + actor, getActor(), + { + actor->destroy(); + }); } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXPipelineLayoutAgent.h b/native/cocos/renderer/core/gfx-agent/GFXPipelineLayoutAgent.h index bb0de7e33b..829ab810a7 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXPipelineLayoutAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXPipelineLayoutAgent.h @@ -10,9 +10,10 @@ class CC_DLL PipelineLayoutAgent final : public Agent { public: using Agent::Agent; PipelineLayoutAgent(Device *device) = delete; + ~PipelineLayoutAgent() override; - virtual bool initialize(const PipelineLayoutInfo &info) override; - virtual void destroy() override; + bool initialize(const PipelineLayoutInfo &info) override; + void destroy() override; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXPipelineStateAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXPipelineStateAgent.cpp index a263d5d6b0..d5c12c7970 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXPipelineStateAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXPipelineStateAgent.cpp @@ -1,6 +1,6 @@ #include "CoreStd.h" -#include "threading/MessageQueue.h" +#include "base/threading/MessageQueue.h" #include "GFXDeviceAgent.h" #include "GFXPipelineLayoutAgent.h" #include "GFXPipelineStateAgent.h" @@ -10,6 +10,16 @@ namespace cc { namespace gfx { +PipelineStateAgent::~PipelineStateAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + PipelineStateDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool PipelineStateAgent::initialize(const PipelineStateInfo &info) { _primitive = info.primitive; _shader = info.shader; @@ -39,17 +49,13 @@ bool PipelineStateAgent::initialize(const PipelineStateInfo &info) { } void PipelineStateAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - PipelineStateDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + PipelineStateDestroy, + actor, getActor(), + { + actor->destroy(); + }); } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXPipelineStateAgent.h b/native/cocos/renderer/core/gfx-agent/GFXPipelineStateAgent.h index 28a806e928..dcebd49db9 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXPipelineStateAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXPipelineStateAgent.h @@ -10,9 +10,10 @@ class CC_DLL PipelineStateAgent final : public Agent { public: using Agent::Agent; PipelineStateAgent(Device *device) = delete; + ~PipelineStateAgent() override; - virtual bool initialize(const PipelineStateInfo &info) override; - virtual void destroy() override; + bool initialize(const PipelineStateInfo &info) override; + void destroy() override; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXQueueAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXQueueAgent.cpp index b52cc78bea..c7e97a8cdb 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXQueueAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXQueueAgent.cpp @@ -4,12 +4,22 @@ #include "GFXDeviceAgent.h" #include "GFXLinearAllocatorPool.h" #include "GFXQueueAgent.h" -#include "job-system/JobSystem.h" -#include "threading/MessageQueue.h" +#include "base/job-system/JobSystem.h" +#include "base/threading/MessageQueue.h" namespace cc { namespace gfx { +QueueAgent::~QueueAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + QueueDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool QueueAgent::initialize(const QueueInfo &info) { _type = info.type; @@ -26,17 +36,13 @@ bool QueueAgent::initialize(const QueueInfo &info) { } void QueueAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - QueueDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + QueueDestroy, + actor, getActor(), + { + actor->destroy(); + }); } void QueueAgent::submit(const CommandBuffer *const *cmdBuffs, uint count, Fence *fence) { @@ -48,6 +54,11 @@ void QueueAgent::submit(const CommandBuffer *const *cmdBuffs, uint count, Fence actorCmdBuffs[i] = ((CommandBufferAgent *)cmdBuffs[i])->getActor(); } + const CommandBufferAgent **agentCmdBuffs = allocator->allocate(count); + for (uint i = 0; i < count; ++i) { + agentCmdBuffs[i] = (CommandBufferAgent *)cmdBuffs[i]; + } + bool multiThreaded = _device->hasFeature(Feature::MULTITHREADED_SUBMISSION); ENQUEUE_MESSAGE_6( @@ -55,7 +66,7 @@ void QueueAgent::submit(const CommandBuffer *const *cmdBuffs, uint count, Fence QueueSubmit, actor, getActor(), multiThreaded, multiThreaded, - cmdBuffs, (CommandBufferAgent *const *)cmdBuffs, + cmdBuffs, (CommandBufferAgent *const *)agentCmdBuffs, actorCmdBuffs, actorCmdBuffs, count, count, fence, fence, diff --git a/native/cocos/renderer/core/gfx-agent/GFXQueueAgent.h b/native/cocos/renderer/core/gfx-agent/GFXQueueAgent.h index a61d9f4e6f..25cf5458e2 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXQueueAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXQueueAgent.h @@ -12,11 +12,12 @@ public: using Queue::submit; QueueAgent(Device *device) = delete; + ~QueueAgent() override; - virtual bool initialize(const QueueInfo &info) override; - virtual void destroy() override; + bool initialize(const QueueInfo &info) override; + void destroy() override; - virtual void submit(const CommandBuffer *const *cmdBuffs, uint count, Fence *fence) override; + void submit(const CommandBuffer *const *cmdBuffs, uint count, Fence *fence) override; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXRenderPassAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXRenderPassAgent.cpp index b823db0fff..d03a01a2ec 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXRenderPassAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXRenderPassAgent.cpp @@ -1,12 +1,22 @@ #include "CoreStd.h" -#include "threading/MessageQueue.h" +#include "base/threading/MessageQueue.h" #include "GFXDeviceAgent.h" #include "GFXRenderPassAgent.h" namespace cc { namespace gfx { +RenderPassAgent::~RenderPassAgent(){ + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + RenderPassDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool RenderPassAgent::initialize(const RenderPassInfo &info) { _colorAttachments = info.colorAttachments; @@ -27,17 +37,13 @@ bool RenderPassAgent::initialize(const RenderPassInfo &info) { } void RenderPassAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - RenderPassDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + RenderPassDestroy, + actor, getActor(), + { + actor->destroy(); + }); } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXRenderPassAgent.h b/native/cocos/renderer/core/gfx-agent/GFXRenderPassAgent.h index a10e94da26..0ae37b1bcd 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXRenderPassAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXRenderPassAgent.h @@ -10,9 +10,10 @@ class CC_DLL RenderPassAgent final : public Agent { public: using Agent::Agent; RenderPassAgent(Device *device) = delete; + ~RenderPassAgent() override; - virtual bool initialize(const RenderPassInfo &info) override; - virtual void destroy() override; + bool initialize(const RenderPassInfo &info) override; + void destroy() override; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXSamplerAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXSamplerAgent.cpp index bf8a5f1d8f..459a0ab333 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXSamplerAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXSamplerAgent.cpp @@ -1,6 +1,6 @@ #include "CoreStd.h" -#include "threading/MessageQueue.h" +#include "base/threading/MessageQueue.h" #include "GFXDescriptorSetLayoutAgent.h" #include "GFXDeviceAgent.h" #include "GFXSamplerAgent.h" @@ -8,6 +8,16 @@ namespace cc { namespace gfx { +SamplerAgent::~SamplerAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + SamplerDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool SamplerAgent::initialize(const SamplerInfo &info) { _minFilter = info.minFilter; @@ -36,17 +46,13 @@ bool SamplerAgent::initialize(const SamplerInfo &info) { } void SamplerAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - SamplerDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + SamplerDestroy, + actor, getActor(), + { + actor->destroy(); + }); } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXSamplerAgent.h b/native/cocos/renderer/core/gfx-agent/GFXSamplerAgent.h index eeeab014db..6b80c784a8 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXSamplerAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXSamplerAgent.h @@ -10,9 +10,10 @@ class CC_DLL SamplerAgent final : public Agent { public: using Agent::Agent; SamplerAgent(Device *device) = delete; + ~SamplerAgent() override; - virtual bool initialize(const SamplerInfo &info) override; - virtual void destroy() override; + bool initialize(const SamplerInfo &info) override; + void destroy() override; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXShaderAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXShaderAgent.cpp index 88fd5d0584..7ee44cd0e8 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXShaderAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXShaderAgent.cpp @@ -1,12 +1,22 @@ #include "CoreStd.h" -#include "threading/MessageQueue.h" +#include "base/threading/MessageQueue.h" #include "GFXDeviceAgent.h" #include "GFXShaderAgent.h" namespace cc { namespace gfx { +ShaderAgent::~ShaderAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + ShaderDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool ShaderAgent::initialize(const ShaderInfo &info) { _name = info.name; _stages = info.stages; @@ -27,17 +37,13 @@ bool ShaderAgent::initialize(const ShaderInfo &info) { } void ShaderAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - ShaderDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + ShaderDestroy, + actor, getActor(), + { + actor->destroy(); + }); } } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXShaderAgent.h b/native/cocos/renderer/core/gfx-agent/GFXShaderAgent.h index b2dcd35121..e8834437f4 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXShaderAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXShaderAgent.h @@ -10,9 +10,10 @@ class CC_DLL ShaderAgent final : public Agent { public: using Agent::Agent; ShaderAgent(Device *device) = delete; + ~ShaderAgent() override; - virtual bool initialize(const ShaderInfo &info) override; - virtual void destroy() override; + bool initialize(const ShaderInfo &info) override; + void destroy() override; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx-agent/GFXTextureAgent.cpp b/native/cocos/renderer/core/gfx-agent/GFXTextureAgent.cpp index afd803fdd9..e52bc718a0 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXTextureAgent.cpp +++ b/native/cocos/renderer/core/gfx-agent/GFXTextureAgent.cpp @@ -1,12 +1,22 @@ #include "CoreStd.h" -#include "threading/MessageQueue.h" +#include "base/threading/MessageQueue.h" #include "GFXTextureAgent.h" #include "GFXDeviceAgent.h" namespace cc { namespace gfx { +TextureAgent::~TextureAgent() { + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + TextureDestruct, + actor, _actor, + { + CC_DELETE(actor); + }); +} + bool TextureAgent::initialize(const TextureInfo &info) { _type = info.type; _usage = info.usage; @@ -66,17 +76,13 @@ bool TextureAgent::initialize(const TextureViewInfo &info) { } void TextureAgent::destroy() { - if (_actor) { - ENQUEUE_MESSAGE_1( - ((DeviceAgent *)_device)->getMessageQueue(), - TextureDestroy, - actor, getActor(), - { - CC_DESTROY(actor); - }); - - _actor = nullptr; - } + ENQUEUE_MESSAGE_1( + ((DeviceAgent *)_device)->getMessageQueue(), + TextureDestroy, + actor, getActor(), + { + actor->destroy(); + }); } void TextureAgent::resize(uint width, uint height) { diff --git a/native/cocos/renderer/core/gfx-agent/GFXTextureAgent.h b/native/cocos/renderer/core/gfx-agent/GFXTextureAgent.h index ddac4dc3bc..fd9ef0f52e 100644 --- a/native/cocos/renderer/core/gfx-agent/GFXTextureAgent.h +++ b/native/cocos/renderer/core/gfx-agent/GFXTextureAgent.h @@ -10,11 +10,12 @@ class CC_DLL TextureAgent final : public Agent { public: using Agent::Agent; TextureAgent(Device *device) = delete; + ~TextureAgent() override; - virtual bool initialize(const TextureInfo &info) override; - virtual bool initialize(const TextureViewInfo &info) override; - virtual void destroy() override; - virtual void resize(uint width, uint height) override; + bool initialize(const TextureInfo &info) override; + bool initialize(const TextureViewInfo &info) override; + void destroy() override; + void resize(uint width, uint height) override; }; } // namespace gfx diff --git a/native/cocos/renderer/core/gfx/GFXDevice.h b/native/cocos/renderer/core/gfx/GFXDevice.h index 3a261cc29e..0336010939 100755 --- a/native/cocos/renderer/core/gfx/GFXDevice.h +++ b/native/cocos/renderer/core/gfx/GFXDevice.h @@ -51,7 +51,7 @@ public: CC_INLINE PipelineLayout *createPipelineLayout(const PipelineLayoutInfo &info) { PipelineLayout *res = createPipelineLayout(); res->initialize(info); return res; } CC_INLINE PipelineState *createPipelineState(const PipelineStateInfo &info) { PipelineState *res = createPipelineState(); res->initialize(info); return res; } CC_INLINE void copyBuffersToTexture(const BufferDataList &buffers, Texture *dst, const BufferTextureCopyList ®ions) { - copyBuffersToTexture(buffers.data(), dst, regions.data(), static_cast(regions.size()) ); + copyBuffersToTexture(buffers.data(), dst, regions.data(), static_cast(regions.size())); } virtual void setMultithreaded(bool multithreaded) {} diff --git a/native/cocos/renderer/gfx-metal/MTLDevice.h b/native/cocos/renderer/gfx-metal/MTLDevice.h index bbca4bbdd3..f7d0970e4e 100644 --- a/native/cocos/renderer/gfx-metal/MTLDevice.h +++ b/native/cocos/renderer/gfx-metal/MTLDevice.h @@ -69,7 +69,6 @@ public: CC_INLINE bool isIndirectDrawSupported() const { return _indirectDrawSupported; } CC_INLINE CCMTLGPUStagingBufferPool *gpuStagingBufferPool() const { return _gpuStagingBufferPools[_currentFrameIndex]; } CC_INLINE bool isSamplerDescriptorCompareFunctionSupported() const { return _isSamplerDescriptorCompareFunctionSupported; } - CC_INLINE void *getDSSTexture() const { return _dssTex; } virtual void ensureAutoreleasePool(); diff --git a/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h b/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h index 63af396875..a2df00b633 100644 --- a/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h +++ b/native/cocos/renderer/gfx-vulkan/VKGPUObjects.h @@ -313,10 +313,10 @@ public: CCVKGPUSwapchain *swapchain = nullptr; // reference - /* * + /* */ using CommandBufferPools = tbb::concurrent_unordered_map< std::thread::id, CCVKGPUCommandBufferPool *, std::hash>; - /* */ + /* * using CommandBufferPools = unordered_map; std::mutex mutex; /* */ diff --git a/native/tools/tojs/gfx.ini b/native/tools/tojs/gfx.ini index 767ce55367..04713dbc81 100644 --- a/native/tools/tojs/gfx.ini +++ b/native/tools/tojs/gfx.ini @@ -16,7 +16,7 @@ android_flags = -target armv7-none-linux-androideabi -D_LIBCPP_DISABLE_VISIBILIT clang_headers = clang_flags = -nostdinc -x c++ -std=c++11 -fsigned-char -U__SSE__ -cocos_headers = -I%(cocosdir)s/cocos -I%(cocosdir)s/cocos/renderer -I%(cocosdir)s/cocos/renderer/core-I%(cocosdir)s/cocos/math -I%(cocosdir)s/cocos/platform/android -I%(cocosdir)s/external/source +cocos_headers = -I%(cocosdir)s/cocos -I%(cocosdir)s/cocos/renderer -I%(cocosdir)s/cocos/renderer/core-I%(cocosdir)s/cocos/math -I%(cocosdir)s/cocos/platform/android -I%(cocosdir)s/external/sources cocos_flags = -DANDROID -DCC_PLATFORM=3 -DCC_PLATFORM_MAC_IOS=1 -DCC_PLATFORM_MAC_OSX=4 -DCC_PLATFORM_WINDOWS=2 -DCC_PLATFORM_ANDROID=3