gfx: refactor binding mappings (#4195)

* gfx: refactor binding mappings

* fg: fix scissor merge

* fix genbindings on PyYAML 6.0+
This commit is contained in:
Yun Hsiao Wu
2022-01-21 09:43:55 +08:00
committed by GitHub
parent 7285dfc584
commit a360e4390a
35 changed files with 399 additions and 162 deletions
-1
View File
@@ -13,7 +13,6 @@
"external/sources",
"external/sources/khronos",
"external/win32/include",
"external/win32/include/glslang",
"external/win32/include/v8"
],
"compileCommands": "${workspaceFolder}/compile_commands.json"
+217 -42
View File
@@ -3545,86 +3545,221 @@ bool js_register_gfx_Color(se::Object* obj) // NOLINT(readability-identifier-nam
se::Object* __jsb_cc_gfx_BindingMappingInfo_proto = nullptr;
se::Class* __jsb_cc_gfx_BindingMappingInfo_class = nullptr;
static bool js_gfx_BindingMappingInfo_get_bufferOffsets(se::State& s) // NOLINT(readability-identifier-naming)
static bool js_gfx_BindingMappingInfo_get_maxBlockCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_get_bufferOffsets : Invalid Native Object");
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_get_maxBlockCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= nativevalue_to_se(cobj->bufferOffsets, jsret, s.thisObject() /*ctx*/);
ok &= nativevalue_to_se(cobj->maxBlockCounts, jsret, s.thisObject() /*ctx*/);
s.rval() = jsret;
SE_HOLD_RETURN_VALUE(cobj->bufferOffsets, s.thisObject(), s.rval());
SE_HOLD_RETURN_VALUE(cobj->maxBlockCounts, s.thisObject(), s.rval());
return true;
}
SE_BIND_PROP_GET(js_gfx_BindingMappingInfo_get_bufferOffsets)
SE_BIND_PROP_GET(js_gfx_BindingMappingInfo_get_maxBlockCounts)
static bool js_gfx_BindingMappingInfo_set_bufferOffsets(se::State& s) // NOLINT(readability-identifier-naming)
static bool js_gfx_BindingMappingInfo_set_maxBlockCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_set_bufferOffsets : Invalid Native Object");
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_set_maxBlockCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
ok &= sevalue_to_native(args[0], &cobj->bufferOffsets, s.thisObject());
SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_set_bufferOffsets : Error processing new value");
ok &= sevalue_to_native(args[0], &cobj->maxBlockCounts, s.thisObject());
SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_set_maxBlockCounts : Error processing new value");
return true;
}
SE_BIND_PROP_SET(js_gfx_BindingMappingInfo_set_bufferOffsets)
SE_BIND_PROP_SET(js_gfx_BindingMappingInfo_set_maxBlockCounts)
static bool js_gfx_BindingMappingInfo_get_samplerOffsets(se::State& s) // NOLINT(readability-identifier-naming)
static bool js_gfx_BindingMappingInfo_get_maxSamplerTextureCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_get_samplerOffsets : Invalid Native Object");
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_get_maxSamplerTextureCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= nativevalue_to_se(cobj->samplerOffsets, jsret, s.thisObject() /*ctx*/);
ok &= nativevalue_to_se(cobj->maxSamplerTextureCounts, jsret, s.thisObject() /*ctx*/);
s.rval() = jsret;
SE_HOLD_RETURN_VALUE(cobj->samplerOffsets, s.thisObject(), s.rval());
SE_HOLD_RETURN_VALUE(cobj->maxSamplerTextureCounts, s.thisObject(), s.rval());
return true;
}
SE_BIND_PROP_GET(js_gfx_BindingMappingInfo_get_samplerOffsets)
SE_BIND_PROP_GET(js_gfx_BindingMappingInfo_get_maxSamplerTextureCounts)
static bool js_gfx_BindingMappingInfo_set_samplerOffsets(se::State& s) // NOLINT(readability-identifier-naming)
static bool js_gfx_BindingMappingInfo_set_maxSamplerTextureCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_set_samplerOffsets : Invalid Native Object");
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_set_maxSamplerTextureCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
ok &= sevalue_to_native(args[0], &cobj->samplerOffsets, s.thisObject());
SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_set_samplerOffsets : Error processing new value");
ok &= sevalue_to_native(args[0], &cobj->maxSamplerTextureCounts, s.thisObject());
SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_set_maxSamplerTextureCounts : Error processing new value");
return true;
}
SE_BIND_PROP_SET(js_gfx_BindingMappingInfo_set_samplerOffsets)
SE_BIND_PROP_SET(js_gfx_BindingMappingInfo_set_maxSamplerTextureCounts)
static bool js_gfx_BindingMappingInfo_get_flexibleSet(se::State& s) // NOLINT(readability-identifier-naming)
static bool js_gfx_BindingMappingInfo_get_maxSamplerCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_get_flexibleSet : Invalid Native Object");
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_get_maxSamplerCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= nativevalue_to_se(cobj->flexibleSet, jsret, s.thisObject() /*ctx*/);
ok &= nativevalue_to_se(cobj->maxSamplerCounts, jsret, s.thisObject() /*ctx*/);
s.rval() = jsret;
SE_HOLD_RETURN_VALUE(cobj->flexibleSet, s.thisObject(), s.rval());
SE_HOLD_RETURN_VALUE(cobj->maxSamplerCounts, s.thisObject(), s.rval());
return true;
}
SE_BIND_PROP_GET(js_gfx_BindingMappingInfo_get_flexibleSet)
SE_BIND_PROP_GET(js_gfx_BindingMappingInfo_get_maxSamplerCounts)
static bool js_gfx_BindingMappingInfo_set_flexibleSet(se::State& s) // NOLINT(readability-identifier-naming)
static bool js_gfx_BindingMappingInfo_set_maxSamplerCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_set_flexibleSet : Invalid Native Object");
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_set_maxSamplerCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
ok &= sevalue_to_native(args[0], &cobj->flexibleSet, s.thisObject());
SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_set_flexibleSet : Error processing new value");
ok &= sevalue_to_native(args[0], &cobj->maxSamplerCounts, s.thisObject());
SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_set_maxSamplerCounts : Error processing new value");
return true;
}
SE_BIND_PROP_SET(js_gfx_BindingMappingInfo_set_flexibleSet)
SE_BIND_PROP_SET(js_gfx_BindingMappingInfo_set_maxSamplerCounts)
static bool js_gfx_BindingMappingInfo_get_maxTextureCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_get_maxTextureCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= nativevalue_to_se(cobj->maxTextureCounts, jsret, s.thisObject() /*ctx*/);
s.rval() = jsret;
SE_HOLD_RETURN_VALUE(cobj->maxTextureCounts, s.thisObject(), s.rval());
return true;
}
SE_BIND_PROP_GET(js_gfx_BindingMappingInfo_get_maxTextureCounts)
static bool js_gfx_BindingMappingInfo_set_maxTextureCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_set_maxTextureCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
ok &= sevalue_to_native(args[0], &cobj->maxTextureCounts, s.thisObject());
SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_set_maxTextureCounts : Error processing new value");
return true;
}
SE_BIND_PROP_SET(js_gfx_BindingMappingInfo_set_maxTextureCounts)
static bool js_gfx_BindingMappingInfo_get_maxBufferCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_get_maxBufferCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= nativevalue_to_se(cobj->maxBufferCounts, jsret, s.thisObject() /*ctx*/);
s.rval() = jsret;
SE_HOLD_RETURN_VALUE(cobj->maxBufferCounts, s.thisObject(), s.rval());
return true;
}
SE_BIND_PROP_GET(js_gfx_BindingMappingInfo_get_maxBufferCounts)
static bool js_gfx_BindingMappingInfo_set_maxBufferCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_set_maxBufferCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
ok &= sevalue_to_native(args[0], &cobj->maxBufferCounts, s.thisObject());
SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_set_maxBufferCounts : Error processing new value");
return true;
}
SE_BIND_PROP_SET(js_gfx_BindingMappingInfo_set_maxBufferCounts)
static bool js_gfx_BindingMappingInfo_get_maxImageCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_get_maxImageCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= nativevalue_to_se(cobj->maxImageCounts, jsret, s.thisObject() /*ctx*/);
s.rval() = jsret;
SE_HOLD_RETURN_VALUE(cobj->maxImageCounts, s.thisObject(), s.rval());
return true;
}
SE_BIND_PROP_GET(js_gfx_BindingMappingInfo_get_maxImageCounts)
static bool js_gfx_BindingMappingInfo_set_maxImageCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_set_maxImageCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
ok &= sevalue_to_native(args[0], &cobj->maxImageCounts, s.thisObject());
SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_set_maxImageCounts : Error processing new value");
return true;
}
SE_BIND_PROP_SET(js_gfx_BindingMappingInfo_set_maxImageCounts)
static bool js_gfx_BindingMappingInfo_get_maxSubpassInputCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_get_maxSubpassInputCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= nativevalue_to_se(cobj->maxSubpassInputCounts, jsret, s.thisObject() /*ctx*/);
s.rval() = jsret;
SE_HOLD_RETURN_VALUE(cobj->maxSubpassInputCounts, s.thisObject(), s.rval());
return true;
}
SE_BIND_PROP_GET(js_gfx_BindingMappingInfo_get_maxSubpassInputCounts)
static bool js_gfx_BindingMappingInfo_set_maxSubpassInputCounts(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_set_maxSubpassInputCounts : Invalid Native Object");
CC_UNUSED bool ok = true;
ok &= sevalue_to_native(args[0], &cobj->maxSubpassInputCounts, s.thisObject());
SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_set_maxSubpassInputCounts : Error processing new value");
return true;
}
SE_BIND_PROP_SET(js_gfx_BindingMappingInfo_set_maxSubpassInputCounts)
static bool js_gfx_BindingMappingInfo_get_setIndices(se::State& s) // NOLINT(readability-identifier-naming)
{
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_get_setIndices : Invalid Native Object");
CC_UNUSED bool ok = true;
se::Value jsret;
ok &= nativevalue_to_se(cobj->setIndices, jsret, s.thisObject() /*ctx*/);
s.rval() = jsret;
SE_HOLD_RETURN_VALUE(cobj->setIndices, s.thisObject(), s.rval());
return true;
}
SE_BIND_PROP_GET(js_gfx_BindingMappingInfo_get_setIndices)
static bool js_gfx_BindingMappingInfo_set_setIndices(se::State& s) // NOLINT(readability-identifier-naming)
{
const auto& args = s.args();
auto* cobj = SE_THIS_OBJECT<cc::gfx::BindingMappingInfo>(s);
SE_PRECONDITION2(cobj, false, "js_gfx_BindingMappingInfo_set_setIndices : Invalid Native Object");
CC_UNUSED bool ok = true;
ok &= sevalue_to_native(args[0], &cobj->setIndices, s.thisObject());
SE_PRECONDITION2(ok, false, "js_gfx_BindingMappingInfo_set_setIndices : Error processing new value");
return true;
}
SE_BIND_PROP_SET(js_gfx_BindingMappingInfo_set_setIndices)
template<>
@@ -3639,17 +3774,37 @@ bool sevalue_to_native(const se::Value &from, cc::gfx::BindingMappingInfo * to,
}
se::Value field;
bool ok = true;
json->getProperty("bufferOffsets", &field);
json->getProperty("maxBlockCounts", &field);
if(!field.isNullOrUndefined()) {
ok &= sevalue_to_native(field, &(to->bufferOffsets), ctx);
ok &= sevalue_to_native(field, &(to->maxBlockCounts), ctx);
}
json->getProperty("samplerOffsets", &field);
json->getProperty("maxSamplerTextureCounts", &field);
if(!field.isNullOrUndefined()) {
ok &= sevalue_to_native(field, &(to->samplerOffsets), ctx);
ok &= sevalue_to_native(field, &(to->maxSamplerTextureCounts), ctx);
}
json->getProperty("flexibleSet", &field);
json->getProperty("maxSamplerCounts", &field);
if(!field.isNullOrUndefined()) {
ok &= sevalue_to_native(field, &(to->flexibleSet), ctx);
ok &= sevalue_to_native(field, &(to->maxSamplerCounts), ctx);
}
json->getProperty("maxTextureCounts", &field);
if(!field.isNullOrUndefined()) {
ok &= sevalue_to_native(field, &(to->maxTextureCounts), ctx);
}
json->getProperty("maxBufferCounts", &field);
if(!field.isNullOrUndefined()) {
ok &= sevalue_to_native(field, &(to->maxBufferCounts), ctx);
}
json->getProperty("maxImageCounts", &field);
if(!field.isNullOrUndefined()) {
ok &= sevalue_to_native(field, &(to->maxImageCounts), ctx);
}
json->getProperty("maxSubpassInputCounts", &field);
if(!field.isNullOrUndefined()) {
ok &= sevalue_to_native(field, &(to->maxSubpassInputCounts), ctx);
}
json->getProperty("setIndices", &field);
if(!field.isNullOrUndefined()) {
ok &= sevalue_to_native(field, &(to->setIndices), ctx);
}
return ok;
}
@@ -3690,13 +3845,28 @@ static bool js_gfx_BindingMappingInfo_constructor(se::State& s) // NOLINT(readab
cc::gfx::BindingMappingInfo* cobj = JSB_ALLOC(cc::gfx::BindingMappingInfo);
if (argc > 0 && !args[0].isUndefined()) {
ok &= sevalue_to_native(args[0], &(cobj->bufferOffsets), nullptr);
ok &= sevalue_to_native(args[0], &(cobj->maxBlockCounts), nullptr);
}
if (argc > 1 && !args[1].isUndefined()) {
ok &= sevalue_to_native(args[1], &(cobj->samplerOffsets), nullptr);
ok &= sevalue_to_native(args[1], &(cobj->maxSamplerTextureCounts), nullptr);
}
if (argc > 2 && !args[2].isUndefined()) {
ok &= sevalue_to_native(args[2], &(cobj->flexibleSet), nullptr);
ok &= sevalue_to_native(args[2], &(cobj->maxSamplerCounts), nullptr);
}
if (argc > 3 && !args[3].isUndefined()) {
ok &= sevalue_to_native(args[3], &(cobj->maxTextureCounts), nullptr);
}
if (argc > 4 && !args[4].isUndefined()) {
ok &= sevalue_to_native(args[4], &(cobj->maxBufferCounts), nullptr);
}
if (argc > 5 && !args[5].isUndefined()) {
ok &= sevalue_to_native(args[5], &(cobj->maxImageCounts), nullptr);
}
if (argc > 6 && !args[6].isUndefined()) {
ok &= sevalue_to_native(args[6], &(cobj->maxSubpassInputCounts), nullptr);
}
if (argc > 7 && !args[7].isUndefined()) {
ok &= sevalue_to_native(args[7], &(cobj->setIndices), nullptr);
}
if(!ok) {
@@ -3730,9 +3900,14 @@ bool js_register_gfx_BindingMappingInfo(se::Object* obj) // NOLINT(readability-i
{
auto* cls = se::Class::create("BindingMappingInfo", obj, nullptr, _SE(js_gfx_BindingMappingInfo_constructor));
cls->defineProperty("bufferOffsets", _SE(js_gfx_BindingMappingInfo_get_bufferOffsets), _SE(js_gfx_BindingMappingInfo_set_bufferOffsets));
cls->defineProperty("samplerOffsets", _SE(js_gfx_BindingMappingInfo_get_samplerOffsets), _SE(js_gfx_BindingMappingInfo_set_samplerOffsets));
cls->defineProperty("flexibleSet", _SE(js_gfx_BindingMappingInfo_get_flexibleSet), _SE(js_gfx_BindingMappingInfo_set_flexibleSet));
cls->defineProperty("maxBlockCounts", _SE(js_gfx_BindingMappingInfo_get_maxBlockCounts), _SE(js_gfx_BindingMappingInfo_set_maxBlockCounts));
cls->defineProperty("maxSamplerTextureCounts", _SE(js_gfx_BindingMappingInfo_get_maxSamplerTextureCounts), _SE(js_gfx_BindingMappingInfo_set_maxSamplerTextureCounts));
cls->defineProperty("maxSamplerCounts", _SE(js_gfx_BindingMappingInfo_get_maxSamplerCounts), _SE(js_gfx_BindingMappingInfo_set_maxSamplerCounts));
cls->defineProperty("maxTextureCounts", _SE(js_gfx_BindingMappingInfo_get_maxTextureCounts), _SE(js_gfx_BindingMappingInfo_set_maxTextureCounts));
cls->defineProperty("maxBufferCounts", _SE(js_gfx_BindingMappingInfo_get_maxBufferCounts), _SE(js_gfx_BindingMappingInfo_set_maxBufferCounts));
cls->defineProperty("maxImageCounts", _SE(js_gfx_BindingMappingInfo_get_maxImageCounts), _SE(js_gfx_BindingMappingInfo_set_maxImageCounts));
cls->defineProperty("maxSubpassInputCounts", _SE(js_gfx_BindingMappingInfo_get_maxSubpassInputCounts), _SE(js_gfx_BindingMappingInfo_set_maxSubpassInputCounts));
cls->defineProperty("setIndices", _SE(js_gfx_BindingMappingInfo_get_setIndices), _SE(js_gfx_BindingMappingInfo_set_setIndices));
cls->defineFinalizeFunction(_SE(js_cc_gfx_BindingMappingInfo_finalize));
cls->install();
JSBClassType::registerClass<cc::gfx::BindingMappingInfo>(cls);
@@ -24,16 +24,18 @@
****************************************************************************/
#include "DevicePass.h"
#include <algorithm>
#include "CallbackPass.h"
#include "DevicePassResourceTable.h"
#include "FrameGraph.h"
#include "PassNode.h"
#include "ResourceNode.h"
#include "base/Utils.h"
#include "gfx-base/GFXCommandBuffer.h"
#include "gfx-base/GFXDef-common.h"
#include <algorithm>
namespace cc {
namespace framegraph {
@@ -225,8 +227,8 @@ void DevicePass::begin(gfx::CommandBuffer *cmdBuff) {
// calculate the union of all viewports as render area
_viewport.left = _scissor.x = std::min(_scissor.x, pass.viewport.left);
_viewport.top = _scissor.y = std::min(_scissor.y, pass.viewport.top);
_viewport.width = _scissor.width = std::max(_scissor.width, pass.viewport.width);
_viewport.height = _scissor.height = std::max(_scissor.height, pass.viewport.height);
_viewport.width = _scissor.width = std::max(_scissor.width, pass.viewport.width + pass.viewport.left - _scissor.x);
_viewport.height = _scissor.height = std::max(_scissor.height, pass.viewport.height + pass.viewport.top - _scissor.y);
}
}
}
@@ -191,12 +191,7 @@ void FrameGraph::move(const TextureHandle from, const TextureHandle to, uint8_t
}
bool FrameGraph::hasPass(StringHandle handle) {
for (const auto &passNode : _passNodes) {
if (passNode->_name == handle) {
return true;
}
}
return false;
return std::any_of(_passNodes.begin(), _passNodes.end(), [&](const auto &passNode) { return passNode->_name == handle; });
}
Handle FrameGraph::create(VirtualResource *const virtualResource) {
+15 -4
View File
@@ -123,6 +123,7 @@ enum class API : uint32_t {
GLES3,
METAL,
VULKAN,
NVN,
WEBGL,
WEBGL2,
WEBGPU,
@@ -884,12 +885,22 @@ using ColorList = vector<Color>;
* The GFX layer assumes the binding numbers for each descriptor type inside each set
* are guaranteed to be consecutive, so the mapping procedure is reduced
* to a simple shifting operation. This data structure specifies the
* offsets for each descriptor type in each set.
* capacity for each descriptor type in each set.
*
* The `setIndices` field defines the binding ordering between different sets.
* The last set index is treated as the 'flexible set', whose capacity is dynamically
* assigned based on the total available descriptor slots on the runtime device.
*/
struct BindingMappingInfo {
std::vector<int32_t> bufferOffsets;
std::vector<int32_t> samplerOffsets;
uint32_t flexibleSet{0U};
std::vector<uint32_t> maxBlockCounts{0};
std::vector<uint32_t> maxSamplerTextureCounts{0};
std::vector<uint32_t> maxSamplerCounts{0};
std::vector<uint32_t> maxTextureCounts{0};
std::vector<uint32_t> maxBufferCounts{0};
std::vector<uint32_t> maxImageCounts{0};
std::vector<uint32_t> maxSubpassInputCounts{0};
std::vector<uint32_t> setIndices{0};
};
struct SwapchainInfo {
@@ -49,12 +49,6 @@ Device::~Device() {
bool Device::initialize(const DeviceInfo &info) {
_bindingMappingInfo = info.bindingMappingInfo;
if (_bindingMappingInfo.bufferOffsets.empty()) {
_bindingMappingInfo.bufferOffsets.push_back(0);
}
if (_bindingMappingInfo.samplerOffsets.empty()) {
_bindingMappingInfo.samplerOffsets.push_back(0);
}
#if CC_CPU_ARCH == CC_CPU_ARCH_32
static_assert(sizeof(void*) == 4, "pointer size assumption broken");
@@ -78,9 +72,6 @@ void Device::destroy() {
CC_SAFE_DELETE(pair.second);
}
_bindingMappingInfo.bufferOffsets.clear();
_bindingMappingInfo.samplerOffsets.clear();
doDestroy();
CC_SAFE_DELETE(_onAcquire);
@@ -61,6 +61,13 @@ enum class GLESCmdType : uint8_t {
COUNT,
};
class GLESBindingMapping {
public:
vector<int32_t> blockOffsets;
vector<int32_t> samplerTextureOffsets;
uint32_t flexibleSet{0};
};
class GLESCmd : public Object {
public:
GLESCmdType type;
@@ -54,7 +54,7 @@ void GLES2CommandBuffer::doInit(const CommandBufferInfo &info) {
_cmdAllocator = CC_NEW(GLES2GPUCommandAllocator);
_curCmdPackage = CC_NEW(GLES2CmdPackage);
size_t setCount = GLES2Device::getInstance()->bindingMappingInfo().bufferOffsets.size();
size_t setCount = GLES2Device::getInstance()->bindingMappingInfo().setIndices.size();
_curGPUDescriptorSets.resize(setCount);
_curDynamicOffsets.resize(setCount);
}
@@ -27,6 +27,7 @@
#include "GLES2Commands.h"
#include "GLES2Device.h"
#include "gfx-gles-common/GLESCommandPool.h"
#define BUFFER_OFFSET(idx) (static_cast<char *>(0) + (idx))
@@ -1100,14 +1101,14 @@ void cmdFuncGLES2CreateShader(GLES2Device *device, GLES2GPUShader *gpuShader) {
// texture unit index mapping optimization
vector<GLES2GPUUniformSamplerTexture> glActiveSamplerTextures;
vector<GLint> glActiveSamplerLocations;
const BindingMappingInfo & bindingMappingInfo = device->bindingMappingInfo();
unordered_map<String, uint32_t> & texUnitCacheMap = device->stateCache()->texUnitCacheMap;
const GLESBindingMapping & bindingMappings = device->bindingMappings();
unordered_map<String, uint32_t> & texUnitCacheMap = device->stateCache()->texUnitCacheMap;
// sampler bindings in the flexible set comes strictly after buffer bindings
// so we need to subtract the buffer count for these samplers
uint32_t flexibleSetBaseOffset = 0U;
for (auto &block : gpuShader->blocks) {
if (block.set == bindingMappingInfo.flexibleSet) {
for (const auto &block : gpuShader->blocks) {
if (block.set == bindingMappings.flexibleSet) {
flexibleSetBaseOffset++;
}
}
@@ -1122,8 +1123,8 @@ void cmdFuncGLES2CreateShader(GLES2Device *device, GLES2GPUShader *gpuShader) {
glActiveSamplerLocations.push_back(glLoc);
}
if (!texUnitCacheMap.count(samplerTexture.name)) {
uint32_t binding = samplerTexture.binding + bindingMappingInfo.samplerOffsets[samplerTexture.set] + arrayOffset;
if (samplerTexture.set == bindingMappingInfo.flexibleSet) binding -= flexibleSetBaseOffset;
uint32_t binding = samplerTexture.binding + bindingMappings.samplerTextureOffsets[samplerTexture.set] + arrayOffset;
if (samplerTexture.set == bindingMappings.flexibleSet) binding -= flexibleSetBaseOffset;
texUnitCacheMap[samplerTexture.name] = binding % device->getCapabilities().maxTextureUnits;
arrayOffset += samplerTexture.count - 1;
}
@@ -73,23 +73,23 @@ void GLES2DescriptorSet::doDestroy() {
void GLES2DescriptorSet::update() {
if (_isDirty && _gpuDescriptorSet) {
const GLES2GPUDescriptorList &descriptors = _gpuDescriptorSet->gpuDescriptors;
auto &descriptors = _gpuDescriptorSet->gpuDescriptors;
for (size_t i = 0; i < descriptors.size(); i++) {
if (hasAnyFlags(descriptors[i].type, DESCRIPTOR_BUFFER_TYPE)) {
auto *buffer = static_cast<GLES2Buffer *>(_buffers[i]);
if (buffer) {
if (buffer->gpuBuffer()) {
_gpuDescriptorSet->gpuDescriptors[i].gpuBuffer = buffer->gpuBuffer();
descriptors[i].gpuBuffer = buffer->gpuBuffer();
} else if (buffer->gpuBufferView()) {
_gpuDescriptorSet->gpuDescriptors[i].gpuBufferView = buffer->gpuBufferView();
descriptors[i].gpuBufferView = buffer->gpuBufferView();
}
}
} else if (hasAnyFlags(descriptors[i].type, DESCRIPTOR_TEXTURE_TYPE)) {
if (_textures[i]) {
_gpuDescriptorSet->gpuDescriptors[i].gpuTexture = static_cast<GLES2Texture *>(_textures[i])->gpuTexture();
descriptors[i].gpuTexture = static_cast<GLES2Texture *>(_textures[i])->gpuTexture();
}
if (_samplers[i]) {
_gpuDescriptorSet->gpuDescriptors[i].gpuSampler = static_cast<GLES2Sampler *>(_samplers[i])->gpuSampler();
descriptors[i].gpuSampler = static_cast<GLES2Sampler *>(_samplers[i])->gpuSampler();
}
}
}
@@ -83,6 +83,21 @@ bool GLES2Device::doInit(const DeviceInfo & /*info*/) {
return false;
};
_bindingMappings.blockOffsets.resize(_bindingMappingInfo.setIndices.size());
_bindingMappings.samplerTextureOffsets.resize(_bindingMappingInfo.setIndices.size());
for (size_t i = 0; i < _bindingMappingInfo.setIndices.size(); ++i) {
uint32_t curSet{_bindingMappingInfo.setIndices[i]};
uint32_t prevSet{i ? _bindingMappingInfo.setIndices[i - 1] : curSet};
// accumulate the per set offset according to the specified capacity
_bindingMappings.blockOffsets[curSet] = i ? static_cast<int32_t>(_bindingMappingInfo.maxBlockCounts[prevSet]) + _bindingMappings.blockOffsets[prevSet] : 0;
_bindingMappings.samplerTextureOffsets[curSet] = i ? static_cast<int32_t>(_bindingMappingInfo.maxSamplerTextureCounts[prevSet]) + _bindingMappings.samplerTextureOffsets[prevSet] : 0;
}
for (uint32_t curSet : _bindingMappingInfo.setIndices) {
// textures always come after UBOs
_bindingMappings.samplerTextureOffsets[curSet] -= static_cast<int32_t>(_bindingMappingInfo.maxBlockCounts[curSet]);
}
_bindingMappings.flexibleSet = _bindingMappingInfo.setIndices.back();
String extStr = reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS));
_extensions = StringUtil::split(extStr, " ");
@@ -28,6 +28,7 @@
#include "GLES2Std.h"
#include "gfx-base/GFXDevice.h"
#include "gfx-base/GFXSwapchain.h"
#include "gfx-gles-common/GLESCommandPool.h"
namespace cc {
namespace gfx {
@@ -67,6 +68,8 @@ public:
void acquire(Swapchain *const *swapchains, uint32_t count) override;
void present() override;
inline const GLESBindingMapping &bindingMappings() const { return _bindingMappings; }
inline GLES2GPUContext * context() const { return _gpuContext; }
inline GLES2GPUStateCache * stateCache() const { return _gpuStateCache; }
inline GLES2GPUBlitManager * blitManager() const { return _gpuBlitManager; }
@@ -123,6 +126,8 @@ protected:
vector<GLES2GPUSwapchain *> _swapchains;
GLESBindingMapping _bindingMappings;
StringArray _extensions;
};
@@ -53,7 +53,7 @@ void GLES3CommandBuffer::doInit(const CommandBufferInfo & /*info*/) {
_cmdAllocator = CC_NEW(GLES3GPUCommandAllocator);
_curCmdPackage = CC_NEW(GLES3CmdPackage);
size_t setCount = GLES3Device::getInstance()->bindingMappingInfo().bufferOffsets.size();
size_t setCount = GLES3Device::getInstance()->bindingMappingInfo().setIndices.size();
_curGPUDescriptorSets.resize(setCount);
_curDynamicOffsets.resize(setCount);
}
@@ -29,6 +29,7 @@
#include "GLES3Device.h"
#include "GLES3QueryPool.h"
#include "gfx-base/GFXDef-common.h"
#include "gfx-gles-common/GLESCommandPool.h"
#define BUFFER_OFFSET(idx) (static_cast<char *>(0) + (idx))
@@ -1147,7 +1148,7 @@ void cmdFuncGLES3CreateShader(GLES3Device *device, GLES3GPUShader *gpuShader) {
if (block.name == glBlock.name) {
glBlock.set = block.set;
glBlock.binding = block.binding;
glBlock.glBinding = block.binding + device->bindingMappingInfo().bufferOffsets[block.set];
glBlock.glBinding = block.binding + device->bindingMappings().blockOffsets[block.set];
GL_CHECK(glUniformBlockBinding(gpuShader->glProgram, i, glBlock.glBinding));
break;
}
@@ -1216,14 +1217,14 @@ void cmdFuncGLES3CreateShader(GLES3Device *device, GLES3GPUShader *gpuShader) {
// texture unit index mapping optimization
vector<GLES3GPUUniformSamplerTexture> glActiveSamplerTextures;
vector<GLint> glActiveSamplerLocations;
const BindingMappingInfo & bindingMappingInfo = device->bindingMappingInfo();
unordered_map<String, uint32_t> & texUnitCacheMap = device->stateCache()->texUnitCacheMap;
const GLESBindingMapping & bindingMappings = device->bindingMappings();
unordered_map<String, uint32_t> & texUnitCacheMap = device->stateCache()->texUnitCacheMap;
// sampler bindings in the flexible set comes strictly after buffer bindings
// so we need to subtract the buffer count for these samplers
uint32_t flexibleSetBaseOffset = 0U;
for (GLES3GPUUniformBuffer &buffer : gpuShader->glBuffers) {
if (buffer.set == bindingMappingInfo.flexibleSet) {
for (const auto &buffer : gpuShader->blocks) {
if (buffer.set == bindingMappings.flexibleSet) {
flexibleSetBaseOffset++;
}
}
@@ -1239,8 +1240,8 @@ void cmdFuncGLES3CreateShader(GLES3Device *device, GLES3GPUShader *gpuShader) {
glActiveSamplerLocations.push_back(glLoc);
if (texUnitCacheMap.count(samplerTexture.name) == 0U) {
uint32_t binding = samplerTexture.binding + bindingMappingInfo.samplerOffsets[samplerTexture.set] + arrayOffset;
if (samplerTexture.set == bindingMappingInfo.flexibleSet) binding -= flexibleSetBaseOffset;
uint32_t binding = samplerTexture.binding + bindingMappings.samplerTextureOffsets[samplerTexture.set] + arrayOffset;
if (samplerTexture.set == bindingMappings.flexibleSet) binding -= flexibleSetBaseOffset;
texUnitCacheMap[samplerTexture.name] = binding % device->getCapabilities().maxTextureUnits;
arrayOffset += samplerTexture.count - 1;
}
@@ -69,18 +69,18 @@ void GLES3DescriptorSet::doDestroy() {
void GLES3DescriptorSet::update() {
if (_isDirty && _gpuDescriptorSet) {
const GLES3GPUDescriptorList &descriptors = _gpuDescriptorSet->gpuDescriptors;
auto &descriptors = _gpuDescriptorSet->gpuDescriptors;
for (size_t i = 0; i < descriptors.size(); i++) {
if (hasAnyFlags(descriptors[i].type, DESCRIPTOR_BUFFER_TYPE)) {
if (_buffers[i]) {
_gpuDescriptorSet->gpuDescriptors[i].gpuBuffer = static_cast<GLES3Buffer *>(_buffers[i])->gpuBuffer();
descriptors[i].gpuBuffer = static_cast<GLES3Buffer *>(_buffers[i])->gpuBuffer();
}
} else if (hasAnyFlags(descriptors[i].type, DESCRIPTOR_TEXTURE_TYPE)) {
if (_textures[i]) {
_gpuDescriptorSet->gpuDescriptors[i].gpuTexture = static_cast<GLES3Texture *>(_textures[i])->gpuTexture();
descriptors[i].gpuTexture = static_cast<GLES3Texture *>(_textures[i])->gpuTexture();
}
if (_samplers[i]) {
_gpuDescriptorSet->gpuDescriptors[i].gpuSampler = static_cast<GLES3Sampler *>(_samplers[i])->gpuSampler();
descriptors[i].gpuSampler = static_cast<GLES3Sampler *>(_samplers[i])->gpuSampler();
}
}
}
@@ -83,6 +83,21 @@ bool GLES3Device::doInit(const DeviceInfo & /*info*/) {
return false;
};
_bindingMappings.blockOffsets.resize(_bindingMappingInfo.setIndices.size());
_bindingMappings.samplerTextureOffsets.resize(_bindingMappingInfo.setIndices.size());
for (size_t i = 0; i < _bindingMappingInfo.setIndices.size(); ++i) {
uint32_t curSet{_bindingMappingInfo.setIndices[i]};
uint32_t prevSet{i ? _bindingMappingInfo.setIndices[i - 1] : curSet};
// accumulate the per set offset according to the specified capacity
_bindingMappings.blockOffsets[curSet] = i ? static_cast<int32_t>(_bindingMappingInfo.maxBlockCounts[prevSet]) + _bindingMappings.blockOffsets[prevSet] : 0;
_bindingMappings.samplerTextureOffsets[curSet] = i ? static_cast<int32_t>(_bindingMappingInfo.maxSamplerTextureCounts[prevSet]) + _bindingMappings.samplerTextureOffsets[prevSet] : 0;
}
for (uint32_t curSet : _bindingMappingInfo.setIndices) {
// textures always come after UBOs
_bindingMappings.samplerTextureOffsets[curSet] -= static_cast<int32_t>(_bindingMappingInfo.maxBlockCounts[curSet]);
}
_bindingMappings.flexibleSet = _bindingMappingInfo.setIndices.back();
String extStr = reinterpret_cast<const char *>(glGetString(GL_EXTENSIONS));
_extensions = StringUtil::split(extStr, " ");
@@ -27,6 +27,7 @@
#include "GLES3Std.h"
#include "gfx-base/GFXDevice.h"
#include "gfx-gles-common/GLESCommandPool.h"
namespace cc {
namespace gfx {
@@ -67,6 +68,8 @@ public:
void acquire(Swapchain *const *swapchains, uint32_t count) override;
void present() override;
inline const GLESBindingMapping &bindingMappings() const { return _bindingMappings; }
inline GLES3GPUContext * context() const { return _gpuContext; }
inline GLES3GPUStateCache * stateCache() const { return _gpuStateCache; }
inline GLES3GPUFramebufferHub * framebufferHub() const { return _gpuFramebufferHub; }
@@ -122,6 +125,8 @@ protected:
vector<GLES3GPUSwapchain *> _swapchains;
GLESBindingMapping _bindingMappings;
StringArray _extensions;
};
@@ -52,7 +52,7 @@ CCMTLCommandBuffer::CCMTLCommandBuffer()
_mtlCommandQueue = id<MTLCommandQueue>(_mtlDevice->getMTLCommandQueue());
_indirectDrawSuppotred = _mtlDevice->isIndirectDrawSupported();
const auto setCount = _mtlDevice->bindingMappingInfo().bufferOffsets.size();
const auto setCount = _mtlDevice->bindingMappingInfo().setIndices.size();
_GPUDescriptorSets.resize(setCount);
_dynamicOffsets.resize(setCount);
_indirectDrawSuppotred = _mtlDevice->isIndirectDrawSupported();
@@ -71,14 +71,14 @@ void CCMTLCommandBuffer::doDestroy() {
CC_DELETE(_texCopySemaphore);
_texCopySemaphore = nullptr;
}
if(_commandBufferBegan) {
if(_gpuCommandBufferObj && _gpuCommandBufferObj->mtlCommandBuffer) {
[_gpuCommandBufferObj->mtlCommandBuffer commit];
}
_commandBufferBegan = false;
}
_GPUDescriptorSets.clear();
_dynamicOffsets.clear();
_firstDirtyDescriptorSet = UINT_MAX;
@@ -146,7 +146,7 @@ void CCMTLCommandBuffer::beginRenderPass(RenderPass *renderPass, Framebuffer *fb
if (_gpuCommandBufferObj->isSecondary) {
return;
}
_gpuCommandBufferObj->renderPass = static_cast<CCMTLRenderPass *>(renderPass);
_gpuCommandBufferObj->fbo = static_cast<CCMTLFramebuffer *>(fbo);
@@ -229,7 +229,7 @@ void CCMTLCommandBuffer::beginRenderPass(RenderPass *renderPass, Framebuffer *fb
mtlRenderPassDescriptor.colorAttachments[color].storeAction = MTLStoreActionMultisampleResolve;
}
}
for (size_t j = 0; j < subpasses[i].preserves.size(); ++j) {
uint32_t preserves = subpasses[i].preserves[j];
mtlRenderPassDescriptor.colorAttachments[preserves].storeAction = MTLStoreActionStoreAndMultisampleResolve;
@@ -237,7 +237,7 @@ void CCMTLCommandBuffer::beginRenderPass(RenderPass *renderPass, Framebuffer *fb
}
updateDepthStencilState(ccMtlRenderPass->getCurrentSubpassIndex(), mtlRenderPassDescriptor);
}
mtlRenderPassDescriptor.depthAttachment.clearDepth = clampf(depth, 0.0F, 1.0F);
mtlRenderPassDescriptor.stencilAttachment.clearStencil = stencil;
@@ -258,7 +258,7 @@ void CCMTLCommandBuffer::beginRenderPass(RenderPass *renderPass, Framebuffer *fb
_renderEncoder.initialize(mtlCommandBuffer, mtlRenderPassDescriptor);
//[_renderEncoder.getMTLEncoder() memoryBarrierWithScope:MTLBarrierScopeTextures afterStages:MTLRenderStageFragment beforeStages:MTLRenderStageFragment];
}
if (!renderingFullFramebuffer) {
//Metal doesn't apply the viewports and scissors to renderpass load-action clearing.
mu::clearRenderArea(_mtlDevice, _renderEncoder.getMTLEncoder(), renderPass, renderArea, colors, depth, stencil);
@@ -272,7 +272,7 @@ void CCMTLCommandBuffer::beginRenderPass(RenderPass *renderPass, Framebuffer *fb
#endif
_renderEncoder.setViewport(scissorArea);
_renderEncoder.setScissor(scissorArea);
if(_firstRenderPass) {
_firstRenderPass = false;
}
@@ -301,7 +301,7 @@ void CCMTLCommandBuffer::updateDepthStencilState(uint32_t index, MTLRenderPassDe
CCMTLRenderPass * curRenderPass = _gpuCommandBufferObj->renderPass;
CCMTLFramebuffer * curFBO = _gpuCommandBufferObj->fbo;
const SubpassInfoList &subpasses = curRenderPass->getSubpasses();
const DepthStencilAttachment& dsAttachment = curRenderPass->getDepthStencilAttachment();
const SubpassInfo& subpass = subpasses[index];
if (subpass.depthStencil != INVALID_BINDING) {
@@ -359,7 +359,7 @@ void CCMTLCommandBuffer::updateDepthStencilState(uint32_t index, MTLRenderPassDe
if (@available(iOS 12.0, *)) {
descriptor.stencilAttachment.stencilResolveFilter = mu::toMTLStencilResolveMode(subpass.stencilResolveMode);
}
if(index == subpasses.size() - 1) {
descriptor.depthAttachment.storeAction = dsAttachment.depthStoreOp == StoreOp::STORE ? MTLStoreActionStoreAndMultisampleResolve : MTLStoreActionMultisampleResolve;
descriptor.stencilAttachment.storeAction = dsAttachment.stencilStoreOp == StoreOp::STORE ? MTLStoreActionStoreAndMultisampleResolve : MTLStoreActionMultisampleResolve;
@@ -877,7 +877,7 @@ void CCMTLCommandBuffer::copyTextureToBuffers(Texture *src, uint8_t *const *buff
auto * ccMTLTexture = static_cast<CCMTLTexture *>(src);
Format convertedFormat = ccMTLTexture->getConvertedFormat();
id<MTLTexture> mtlTexture = ccMTLTexture->getMTLTexture();
if([mtlTexture storageMode] == MTLStorageModeShared) {
for (size_t i = 0; i < count; ++i) {
uint32_t width = regions[i].texExtent.width;
@@ -897,7 +897,7 @@ void CCMTLCommandBuffer::copyTextureToBuffers(Texture *src, uint8_t *const *buff
}
} else {
id<MTLCommandBuffer> mtlCommandBuffer = getMTLCommandBuffer();
std::vector<std::pair<uint8_t*, uint32_t>> stagingAddrs(count);
for (size_t i = 0; i < count; ++i) {
uint32_t width = regions[i].texExtent.width;
@@ -927,7 +927,7 @@ void CCMTLCommandBuffer::copyTextureToBuffers(Texture *src, uint8_t *const *buff
if(!_texCopySemaphore) {
_texCopySemaphore = CC_NEW(CCMTLSemaphore(0));
}
[mtlCommandBuffer addCompletedHandler:^(id<MTLCommandBuffer> commandBuffer) {
for(size_t i = 0; i < count; ++i) {
memcpy(buffers[i], stagingAddrs[i].first, stagingAddrs[i].second);
+3 -7
View File
@@ -370,7 +370,7 @@ CCMTLGPUPipelineState *getClearRenderPassPipelineState(CCMTLDevice *device, Rend
pipelineInfo.shader = createShader(device);
pipelineInfo.inputState = {{position}};
pipelineInfo.renderPass = curPass;
DepthStencilState dsState;
dsState.depthWrite = 0;
dsState.depthTest = 1;
@@ -927,7 +927,6 @@ String mu::spirv2MSL(const uint32_t *ir, size_t word_count,
// TODO: bindings from shader just kind of validation, cannot be directly input
// Get all uniform buffers in the shader.
uint maxBufferBindingIndex = device->getMaximumBufferBindingIndex();
const auto &bufferBindingOffset = device->bindingMappingInfo().bufferOffsets;
for (const auto &ubo : resources.uniform_buffers) {
auto set = msl.get_decoration(ubo.id, spv::DecorationDescriptorSet);
auto binding = msl.get_decoration(ubo.id, spv::DecorationBinding);
@@ -965,7 +964,7 @@ String mu::spirv2MSL(const uint32_t *ir, size_t word_count,
if (binding >= maxBufferBindingIndex) {
CC_LOG_ERROR("Implementation limits: %s binding at %d, should not use more than %d entries in the buffer argument table", ubo.name.c_str(), binding, maxBufferBindingIndex);
}
uint nameHash = static_cast<uint>(std::hash<String>{}(ubo.name));
if (gpuShader->blocks.find(nameHash) == gpuShader->blocks.end()) {
auto mappedBinding = gpuShader->bufferIndex;
@@ -992,9 +991,6 @@ String mu::spirv2MSL(const uint32_t *ir, size_t word_count,
return "";
}
// Get all sampled images in the shader.
const auto &samplerBindingOffset = device->bindingMappingInfo().samplerOffsets;
// avoid conflict index with input attachments.
const uint8_t rtOffsets = executionModel == spv::ExecutionModelFragment ? resources.subpass_inputs.size() : 0;
for (const auto &sampler : resources.sampled_images) {
@@ -1634,7 +1630,7 @@ void mu::clearRenderArea(CCMTLDevice *device, id<MTLRenderCommandEncoder> render
const auto gpuPSO = getClearRenderPassPipelineState(device, renderPass);
const auto mtlRenderPass = static_cast<CCMTLRenderPass *>(renderPass);
uint slot = 0u;
const auto &renderTargetSizes = mtlRenderPass->getRenderTargetSizes();
float renderTargetWidth = renderTargetSizes[slot].x;
float renderTargetHeight = renderTargetSizes[slot].y;
@@ -40,6 +40,8 @@
namespace cc {
namespace gfx {
bool BufferValidator::recordInitStack{true};
BufferValidator::BufferValidator(Buffer *actor)
: Agent<Buffer>(actor) {
_typedID = actor->getTypedID();
@@ -66,7 +68,7 @@ void BufferValidator::doInit(const BufferInfo &info) {
CCASSERT(info.size, "zero-sized buffer?");
CCASSERT(info.size / info.stride * info.stride == info.size, "size is not multiple of stride?");
_initStack = se::ScriptEngine::getInstance()->getCurrentStackTrace();
if (recordInitStack) _initStack = se::ScriptEngine::getInstance()->getCurrentStackTrace();
_creationFrame = DeviceValidator::getInstance()->currentFrame();
_totalUpdateTimes = 0U;
@@ -33,6 +33,8 @@ namespace gfx {
class CC_DLL BufferValidator final : public Agent<Buffer> {
public:
static bool recordInitStack;
explicit BufferValidator(Buffer *actor);
~BufferValidator() override;
@@ -58,7 +58,7 @@ void CommandBufferValidator::initValidator() {
CCASSERT(!isInited(), "initializing twice?");
_inited = true;
size_t descriptorSetCount = DeviceValidator::getInstance()->bindingMappingInfo().bufferOffsets.size();
size_t descriptorSetCount = DeviceValidator::getInstance()->bindingMappingInfo().setIndices.size();
_curStates.descriptorSets.resize(descriptorSetCount);
_curStates.dynamicOffsets.resize(descriptorSetCount);
}
@@ -238,7 +238,7 @@ void CommandBufferValidator::bindDescriptorSet(uint32_t set, DescriptorSet *desc
CCASSERT(isInited(), "alread destroyed?");
CCASSERT(descriptorSet && static_cast<DescriptorSetValidator *>(descriptorSet)->isInited(), "already destroyed?");
CCASSERT(set < DeviceValidator::getInstance()->bindingMappingInfo().bufferOffsets.size(), "invalid set index");
CCASSERT(set < DeviceValidator::getInstance()->bindingMappingInfo().setIndices.size(), "invalid set index");
//CCASSERT(descriptorSet->getLayout()->getDynamicBindings().size() == dynamicOffsetCount, "wrong number of dynamic offsets"); // be more lenient on this
_curStates.descriptorSets[set] = descriptorSet;
@@ -35,10 +35,8 @@
#include "VKQueue.h"
#include "VKRenderPass.h"
#include "VKTexture.h"
#include "gfx-base/GFXDef-common.h"
#include "states/VKGlobalBarrier.h"
#include "states/VKTextureBarrier.h"
#include "vulkan/vulkan_core.h"
namespace cc {
namespace gfx {
@@ -56,7 +54,7 @@ void CCVKCommandBuffer::doInit(const CommandBufferInfo & /*info*/) {
_gpuCommandBuffer->level = mapVkCommandBufferLevel(_type);
_gpuCommandBuffer->queueFamilyIndex = static_cast<CCVKQueue *>(_queue)->gpuQueue()->queueFamilyIndex;
size_t setCount = CCVKDevice::getInstance()->bindingMappingInfo().bufferOffsets.size();
size_t setCount = CCVKDevice::getInstance()->bindingMappingInfo().setIndices.size();
_curGPUDescriptorSets.resize(setCount);
_curVkDescriptorSets.resize(setCount);
_curDynamicOffsetsArray.resize(setCount);
@@ -477,18 +477,14 @@ void cmdFuncCCVKCreateRenderPass(CCVKDevice *device, CCVKGPURenderPass *gpuRende
if (subpassInfo.depthStencilResolve != INVALID_BINDING) {
Format dsFormat{Format::UNKNOWN};
bool isGeneralLayout{false};
if (subpassInfo.depthStencil >= colorAttachmentCount) {
const DepthStencilAttachment & desc = gpuRenderPass->depthStencilAttachment;
const VkAttachmentDescription2 &attachment = attachmentDescriptions.back();
isGeneralLayout = desc.isGeneralLayout;
dsFormat = desc.format;
sampleCount = std::max(sampleCount, attachment.samples);
if (subpassInfo.depthStencilResolve >= colorAttachmentCount) {
const DepthStencilAttachment &desc = gpuRenderPass->depthStencilAttachment;
isGeneralLayout = desc.isGeneralLayout;
dsFormat = desc.format;
} else {
const ColorAttachment & desc = gpuRenderPass->colorAttachments[subpassInfo.depthStencil];
const VkAttachmentDescription2 &attachment = attachmentDescriptions[subpassInfo.depthStencil];
isGeneralLayout = desc.isGeneralLayout;
dsFormat = desc.format;
sampleCount = std::max(sampleCount, attachment.samples);
const ColorAttachment &desc = gpuRenderPass->colorAttachments[subpassInfo.depthStencilResolve];
isGeneralLayout = desc.isGeneralLayout;
dsFormat = desc.format;
}
VkImageAspectFlags aspect = GFX_FORMAT_INFOS[toNumber(dsFormat)].hasStencil
@@ -1170,7 +1166,7 @@ void cmdFuncCCVKUpdateBuffer(CCVKDevice *device, CCVKGPUBuffer *gpuBuffer, const
} else {
for (size_t i = 0; i < drawInfoCount; ++i) {
gpuBuffer->indirectCmds[i].vertexCount = drawInfo->vertexCount;
gpuBuffer->indirectCmds[i].instanceCount = drawInfo->instanceCount;
gpuBuffer->indirectCmds[i].instanceCount = std::max(drawInfo->instanceCount, 1U);
gpuBuffer->indirectCmds[i].firstVertex = drawInfo->firstVertex;
gpuBuffer->indirectCmds[i].firstInstance = drawInfo->firstInstance;
drawInfo++;
@@ -1355,7 +1351,7 @@ void cmdFuncCCVKCopyBuffersToTexture(CCVKDevice *device, const uint8_t *const *b
}
void cmdFuncCCVKCopyTextureToBuffers(CCVKDevice *device, CCVKGPUTexture *srcTexture, CCVKGPUBuffer *destBuffer,
const BufferTextureCopy *regions, uint32_t count, const CCVKGPUCommandBuffer *gpuCommandBuffer) {
const BufferTextureCopy *regions, uint32_t count, const CCVKGPUCommandBuffer *gpuCommandBuffer) {
vector<ThsvsAccessType> &curTypes = srcTexture->currentAccessTypes;
ThsvsImageBarrier barrier{};
@@ -40,6 +40,7 @@
#include "VKSwapchain.h"
#include "VKTexture.h"
#include "VKUtils.h"
#include "base/Utils.h"
#include "states/VKGlobalBarrier.h"
#include "states/VKSampler.h"
#include "states/VKTextureBarrier.h"
@@ -283,7 +284,7 @@ bool CCVKDevice::doInit(const DeviceInfo & /*info*/) {
_caps.maxVertexTextureUnits = limits.maxPerStageDescriptorSampledImages;
_caps.maxTextureSize = limits.maxImageDimension2D;
_caps.maxCubeMapTextureSize = limits.maxImageDimensionCube;
_caps.uboOffsetAlignment = static_cast<uint32_t>(limits.minUniformBufferOffsetAlignment);
_caps.uboOffsetAlignment = utils::toUint(limits.minUniformBufferOffsetAlignment);
// compute shaders
_caps.maxComputeSharedMemorySize = limits.maxComputeSharedMemorySize;
_caps.maxComputeWorkGroupInvocations = limits.maxComputeWorkGroupInvocations;
@@ -597,8 +598,9 @@ void CCVKDevice::acquire(Swapchain *const *swapchains, uint32_t count) {
for (uint32_t i = 0; i < vkSwapchains.size(); ++i) {
VkSemaphore acquireSemaphore = _gpuSemaphorePool->alloc();
VK_CHECK(vkAcquireNextImageKHR(_gpuDevice->vkDevice, vkSwapchains[i], ~0ULL,
acquireSemaphore, VK_NULL_HANDLE, &vkSwapchainIndices[i]));
VkResult res = vkAcquireNextImageKHR(_gpuDevice->vkDevice, vkSwapchains[i], ~0ULL,
acquireSemaphore, VK_NULL_HANDLE, &vkSwapchainIndices[i]);
CCASSERT(res == VK_SUCCESS || res == VK_SUBOPTIMAL_KHR, "acquire surface failed");
gpuSwapchains[i]->curImageIndex = vkSwapchainIndices[i];
queue->gpuQueue()->lastSignaledSemaphores.push_back(acquireSemaphore);
@@ -274,8 +274,6 @@ class CCVKGPUShader final : public Object {
public:
String name;
AttributeList attributes;
UniformBlockList blocks;
UniformSamplerList samplers;
vector<CCVKGPUShaderStage> gpuStages;
};
@@ -979,6 +977,18 @@ public:
}
}
}
void update(const CCVKGPUTexture *texture) {
for (auto &it : _textures) {
if (it.first->gpuTexture != texture) continue;
const auto &info = it.second;
for (uint32_t i = 0U; i < info.descriptors.size(); i++) {
doUpdate(it.first, info.descriptors[i]);
}
for (const auto *set : info.sets) {
_descriptorSetHub->record(set);
}
}
}
void disengage(const CCVKGPUBufferView *buffer) {
auto it = _buffers.find(buffer);
@@ -27,7 +27,6 @@
#include "VKCommandBuffer.h"
#include "VKCommands.h"
#include "VKDevice.h"
#include "vulkan/vulkan_core.h"
namespace cc {
namespace gfx {
@@ -29,7 +29,6 @@
#include "VKCommands.h"
#include "VKDevice.h"
#include "VKQueue.h"
#include "vulkan/vulkan_core.h"
namespace cc {
namespace gfx {
@@ -44,8 +44,6 @@ void CCVKShader::doInit(const ShaderInfo & /*info*/) {
_gpuShader = CC_NEW(CCVKGPUShader);
_gpuShader->name = _name;
_gpuShader->attributes = _attributes;
_gpuShader->blocks = _blocks;
_gpuShader->samplers = _samplers;
for (ShaderStage &stage : _stages) {
_gpuShader->gpuStages.push_back({stage.stage, stage.source});
}
@@ -126,6 +126,7 @@ void CCVKTexture::doResize(uint32_t width, uint32_t height, uint32_t size) {
cmdFuncCCVKCreateTextureView(CCVKDevice::getInstance(), _gpuTextureView);
CCVKDevice::getInstance()->gpuFramebufferHub()->update(_gpuTexture);
CCVKDevice::getInstance()->gpuDescriptorHub()->update(_gpuTexture);
}
///////////////////////////// Swapchain Specific /////////////////////////////
@@ -24,7 +24,7 @@
****************************************************************************/
#include "VKGlobalBarrier.h"
#include "../VKCommands.h"
#include "../VKGPUObjects.h"
namespace cc {
namespace gfx {
+12 -7
View File
@@ -30,20 +30,25 @@
namespace cc {
namespace pipeline {
int globalUBOCount = static_cast<int>(PipelineGlobalBindings::SAMPLER_SHADOWMAP);
int globalSamplerCount = static_cast<int>(PipelineGlobalBindings::COUNT) - globalUBOCount;
static uint32_t globalUBOCount = static_cast<uint32_t>(PipelineGlobalBindings::SAMPLER_SHADOWMAP);
static uint32_t globalSamplerCount = static_cast<uint32_t>(PipelineGlobalBindings::COUNT) - globalUBOCount;
int localUBOCount = static_cast<int>(ModelLocalBindings::SAMPLER_JOINTS);
int localSamplerCount = static_cast<int>(ModelLocalBindings::COUNT) - localUBOCount;
static uint32_t localUBOCount = static_cast<uint32_t>(ModelLocalBindings::SAMPLER_JOINTS);
static uint32_t localSamplerCount = static_cast<uint32_t>(ModelLocalBindings::COUNT) - localUBOCount;
uint globalSet = static_cast<uint>(SetIndex::GLOBAL);
uint materialSet = static_cast<uint>(SetIndex::MATERIAL);
uint localSet = static_cast<uint>(SetIndex::LOCAL);
gfx::BindingMappingInfo bindingMappingInfo = {
{0, globalUBOCount + localUBOCount, globalUBOCount},
{-globalUBOCount, globalSamplerCount + localSamplerCount, globalSamplerCount - localUBOCount},
1,
{globalUBOCount, 0, localUBOCount}, // Uniform Buffer Counts
{globalSamplerCount, 0, localSamplerCount}, // Combined Sampler Texture Counts
{0, 0, 0}, // Sampler Counts
{0, 0, 0}, // Texture Counts
{0, 0, 0}, // Storage Buffer Counts
{0, 0, 0}, // Storage Image Counts
{0, 0, 0}, // Subpass Input Counts
{0, 2, 1}, // Set Order Indices
};
DescriptorSetLayoutInfos globalDescriptorSetLayout;
-6
View File
@@ -222,9 +222,6 @@ enum class CC_DLL PipelineGlobalBindings {
};
CC_ENUM_CONVERSION_OPERATOR(PipelineGlobalBindings)
extern CC_DLL int globalUBOCount;
extern CC_DLL int globalSamplerCount;
enum class CC_DLL ModelLocalBindings {
UBO_LOCAL,
UBO_FORWARD_LIGHTS,
@@ -246,9 +243,6 @@ enum class CC_DLL ModelLocalBindings {
};
CC_ENUM_CONVERSION_OPERATOR(ModelLocalBindings)
extern CC_DLL int localUBOCount;
extern CC_DLL int localSamplerCount;
enum class CC_DLL SetIndex {
GLOBAL,
MATERIAL,
+3 -3
View File
@@ -1153,7 +1153,7 @@ class NativeClass(object):
def generate_struct_constructor(self):
stream = open(os.path.join(self.generator.target, "conversions.yaml"), "r")
config = yaml.load(stream)
config = yaml.safe_load(stream)
tpl = Template(config['definitions']['constructor'],
searchList=[self])
self.struct_constructor_name = str(tpl)
@@ -1585,7 +1585,7 @@ class Generator(object):
return False
def should_skip_public_field(self, class_name, field_name, verbose=False):
if class_name == "*" and "*" in self.skip_public_fields_classes:
for func in self.skip_public_fields_classes["*"]:
if re.match(func, field_name):
@@ -1697,7 +1697,7 @@ class Generator(object):
def generate_code(self):
# must read the yaml file first
stream = open(os.path.join(self.target, "conversions.yaml"), "r")
data = yaml.load(stream)
data = yaml.safe_load(stream)
self.config = data
implfilepath = os.path.join(self.outdir, self.out_file + ".cpp")
headfilepath = os.path.join(self.outdir, self.out_file + ".h")
+21 -8
View File
@@ -72,12 +72,19 @@ while (enumCap) {
enumCap = enumRE.exec(header);
}
// now discard all block comments
header = header.replace(/\/\*.*?\*\//gs, '');
header = header.replace(/\s*[*&](.)/g, (_, c) => (c === '>' ? '' : ' ') + c);
header = header.replace(/(?:\w*::)?vector<(.+?)>/g, '$1[]');
// and preprocessors
// save & strip block comments
const blockComments = [];
const blockCommentsRE = /(\/\*\*.*?\*\/)\s*(.+?\n)/gs;
header = header.replace(blockCommentsRE, (_, comments, succeeding) => {
blockComments.push({ succeeding, source: comments });
return succeeding;
});
// discard preprocessors
header = header.replace(/\s*#(if|else|elif|end).*/gm, '');
// replace vector<x>
header = header.replace(/(?:\w*::)?vector<(.+?)>/g, (_, type) => {
return `${type.replace(/[*\s]+/g, '')}[]`;
});
const typedefRE = /^\s*using\s+(.+?)\s*=\s*(.+?);/gsm;
const typedefMap = { lists: {}, others: [] };
@@ -124,7 +131,7 @@ const getMemberList = (() => {
};
})();
const structRE = /(struct\s+(?:\w+\(\w+\)\s+)?)(\w+).*?{\s*(.+?)\s*};/gs;
const structRE = /(struct\s+(?:\w+\(\w+\)\s+)?(\w+).*?){\s*.+?\s*};/gs;
const structMemberRE = /^\s*(const\w*\s*)?([\w[\]]+)\s+?(\w+)(?:\s*[={]?\s*(.*?)\s*}*\s*)?;(?:\s*\/\/\s*@ts-(.*?)$)?/gm;
const structMap = {};
const replaceConstants = (() => {
@@ -153,9 +160,13 @@ const getArrayValue = (decayedType, value) => {
let structCap = structRE.exec(header);
while (structCap) {
const struct = structMap[structCap[2]] = {};
struct.comments = blockComments.find((c) => structCap[0].startsWith(c.succeeding))?.source;
struct.member = {};
// structRE can not reliably extract the correct member declaration range
const memberList = getMemberList(header, structCap.index + structCap[1].length);
let memberList = getMemberList(header, structCap.index + structCap[1].length);
// discard pointer signs
memberList = memberList.replace(/\*/g, '');
let memberCap = structMemberRE.exec(memberList);
while (memberCap) {
@@ -178,6 +189,7 @@ while (structCap) {
let n = Number.parseInt(value);
if (!Number.isNaN(n)) {
if (!value.startsWith('0x')) { value = n; } // keep hexadecimal numbers
if (isArray) { value = `[${value}]`; }
} else if (value) {
value = replaceConstants(value);
if (isArray) { value = getArrayValue(decayedType, value); }
@@ -242,12 +254,13 @@ output += `\n`;
for (const name of Object.keys(structMap)) {
if (name in ignoreList) { continue; }
const struct = structMap[name];
if (struct.comments) { output += struct.comments + '\n'; }
output += `export class ${name} {\n declare private _token: never; `;
output += `// to make sure all usages must be an instance of this exact class, not assembled from plain object`;
output += `\n\n constructor (\n`;
const struct = structMap[name];
for (const key in struct.member) {
const { readonly, type, value } = struct.member[key];
const decl = readonly ? `readonly ${key}` : key;