/**************************************************************************** Copyright (c) 2021 Xiamen Yaji Software Co., Ltd. http://www.cocos.com Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated engine source code (the "Software"), a limited, worldwide, royalty-free, non-assignable, revocable and non-exclusive license to use Cocos Creator solely to develop games on your target platforms. You shall not use Cocos Creator software for developing other software or tools that's used for developing games. You are not granted to publish, distribute, sublicense, and/or sell copies of Cocos Creator. The software or tools in this License Agreement are licensed, not sold. Xiamen Yaji Software Co., Ltd. reserves all rights not expressly granted to you. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ****************************************************************************/ #include "core/data/deserializer/EffectAssetDeserializer.h" #include "base/Log.h" #include "core/assets/EffectAsset.h" namespace cc { template using DeserializeArrayElementCallback = std::function; template static void deserializeArray(const rapidjson::Value &valArray, ccstd::vector &cValArray, const DeserializeArrayElementCallback &deserializeArrayElement) { CC_ASSERT(valArray.IsArray()); index_t i = 0; cValArray.resize(valArray.Size()); for (const auto &val : valArray.GetArray()) { deserializeArrayElement(val, cValArray[i]); ++i; } } static void deserializeArray(const rapidjson::Value &valArray, ccstd::vector &cValArray) { deserializeArray(valArray, cValArray, [](const rapidjson::Value &val, ccstd::string &cVal) { cVal = val.GetString(); }); } static void deserializeArray(const rapidjson::Value &valArray, ccstd::vector &cValArray) { CC_ASSERT(valArray.IsArray()); index_t i = 0; cValArray.resize(valArray.Size()); // note: candidate function not viable: no known conversion from 'std::__1::vector::reference' (aka '__bit_reference>') to 'bool &' for 2nd argument for (const auto &val : valArray.GetArray()) { cValArray[i] = val.GetBool(); ++i; } } template ::value && !std::is_same::value, T>> static void deserializeArray(const rapidjson::Value &valArray, ccstd::vector &cValArray) { DeserializeArrayElementCallback cb{[](const rapidjson::Value &val, T &cVal) { cVal = val.Get(); }}; deserializeArray(valArray, cValArray, cb); } static MacroRecord jsonToMacroRecord(const rapidjson::Value &embeddedMacrosVal) { MacroRecord cEmbeddedMacros; for (const auto ¯o : embeddedMacrosVal.GetObject()) { const auto *name = macro.name.GetString(); const auto &value = macro.value; // using MacroValue = ccstd::variant; // MacroValue only support one of int32_t, float, bool, ccstd::string if (value.IsInt()) { cEmbeddedMacros.emplace(name, value.GetInt()); // CC_LOG_DEBUG(">> embeddedMacros[%s]=%d", name, value.GetInt()); } else if (value.IsInt64()) { cEmbeddedMacros.emplace(name, static_cast(value.GetInt64())); //cjh TODO: need int64? // CC_LOG_DEBUG(">> embeddedMacros[%s]=%ld", name, value.GetInt64()); } else if (value.IsBool()) { cEmbeddedMacros.emplace(name, value.GetBool()); // CC_LOG_DEBUG(">> embeddedMacros[%s]=%d", name, static_cast(value.GetBool())); } else if (value.IsString()) { cEmbeddedMacros.emplace(name, value.GetString()); // CC_LOG_DEBUG(">> embeddedMacros[%s]=%s", name, value.GetString()); } else { CC_LOG_WARNING("Unknown macro value type: %s", name); } } return cEmbeddedMacros; } static IPropertyHandleInfo jsonToPropertyHandleInfo(const rapidjson::Value &handleInfoVal) { if (handleInfoVal.IsArray()) { // using IPropertyHandleInfo = std::tuple; ccstd::string t0; uint32_t t1 = 0; gfx::Type t2 = gfx::Type::UNKNOWN; int32_t i = 0; for (const auto &e : handleInfoVal.GetArray()) { switch (i) { case 0: t0 = e.GetString(); break; case 1: t1 = e.GetUint(); break; case 2: t2 = static_cast(e.GetUint()); break; default: break; } ++i; } return IPropertyHandleInfo{t0, t1, t2}; } return {}; } static IPropertyInfo jsonToPropertyInfo(const rapidjson::Value &propertyInfoVal) { IPropertyInfo ret; ret.type = propertyInfoVal["type"].GetInt(); if (propertyInfoVal.HasMember("value")) { const auto &val = propertyInfoVal["value"]; if (val.IsArray()) { ccstd::vector arr; arr.reserve(val.GetArray().Size()); for (const auto &e : val.GetArray()) { if (e.IsNumber()) { arr.emplace_back(e.GetFloat()); } } ret.value = std::move(arr); } else if (val.IsString()) { ret.value = val.GetString(); } else { CC_ASSERT(false); } } if (propertyInfoVal.HasMember("handleInfo")) { ret.handleInfo = jsonToPropertyHandleInfo(propertyInfoVal["handleInfo"]); // using IPropertyHandleInfo = std::tuple; // CC_LOG_DEBUG("handleInfo: %s, %u, %u", std::get<0>(ret.handleInfo.value()).c_str(), std::get<1>(ret.handleInfo.value()), static_cast(std::get<2>(ret.handleInfo.value()))); } if (propertyInfoVal.HasMember("samplerHash")) { ret.samplerHash = propertyInfoVal.GetUint(); // CC_LOG_DEBUG("samplerHash: %u", ret.samplerHash.value()); } return ret; } static PassPropertyInfoMap jsonToPassPropertyInfoMap(const rapidjson::Value &propertyInfoMapVal) { PassPropertyInfoMap propertyInfoMap; for (const auto &propertyVal : propertyInfoMapVal.GetObject()) { const auto *name = propertyVal.name.GetString(); const auto &value = propertyVal.value; propertyInfoMap.emplace(name, jsonToPropertyInfo(value)); } return propertyInfoMap; } static RasterizerStateInfo jsonToRasterizerState(const rapidjson::Value &rasterizerStateVal) { RasterizerStateInfo rasterizerState; CC_ASSERT(rasterizerStateVal.IsObject()); if (rasterizerStateVal.HasMember("cullMode")) { rasterizerState.cullMode = static_cast(rasterizerStateVal["cullMode"].GetInt()); // CC_LOG_DEBUG("cullMode: %d", static_cast(rasterizerState->cullMode)); } if (rasterizerStateVal.HasMember("isDiscard")) { rasterizerState.isDiscard = rasterizerStateVal["isDiscard"].GetUint(); } if (rasterizerStateVal.HasMember("polygonMode")) { rasterizerState.polygonMode = static_cast(rasterizerStateVal["polygonMode"].GetInt()); } if (rasterizerStateVal.HasMember("shadeModel")) { rasterizerState.shadeModel = static_cast(rasterizerStateVal["shadeModel"].GetInt()); } if (rasterizerStateVal.HasMember("isFrontFaceCCW")) { rasterizerState.isFrontFaceCCW = rasterizerStateVal["isFrontFaceCCW"].GetUint(); } if (rasterizerStateVal.HasMember("depthBiasEnabled")) { rasterizerState.depthBiasEnabled = rasterizerStateVal["depthBiasEnabled"].GetUint(); } if (rasterizerStateVal.HasMember("depthBias")) { rasterizerState.depthBias = rasterizerStateVal["depthBias"].GetFloat(); } if (rasterizerStateVal.HasMember("depthBiasClamp")) { rasterizerState.depthBiasClamp = rasterizerStateVal["depthBiasClamp"].GetFloat(); } if (rasterizerStateVal.HasMember("depthBiasSlop")) { rasterizerState.depthBiasSlop = rasterizerStateVal["depthBiasSlop"].GetFloat(); } if (rasterizerStateVal.HasMember("isDepthClip")) { rasterizerState.isDepthClip = rasterizerStateVal["isDepthClip"].GetUint(); } if (rasterizerStateVal.HasMember("isMultisample")) { rasterizerState.isMultisample = rasterizerStateVal["isMultisample"].GetUint(); } if (rasterizerStateVal.HasMember("lineWidth")) { rasterizerState.lineWidth = rasterizerStateVal["lineWidth"].GetFloat(); } return rasterizerState; } static DepthStencilStateInfo jsonToDepthStencilState(const rapidjson::Value &val) { DepthStencilStateInfo dss; CC_ASSERT(val.IsObject()); if (val.HasMember("depthTest")) { dss.depthTest = val["depthTest"].GetBool() ? 1 : 0; } if (val.HasMember("depthWrite")) { dss.depthWrite = val["depthWrite"].GetBool() ? 1 : 0; } if (val.HasMember("depthFunc")) { dss.depthFunc = static_cast(val["depthFunc"].GetInt()); } if (val.HasMember("stencilTestFront")) { dss.stencilTestFront = val["stencilTestFront"].GetBool() ? 1 : 0; } if (val.HasMember("stencilFuncFront")) { dss.stencilFuncFront = static_cast(val["stencilFuncFront"].GetInt()); } if (val.HasMember("stencilReadMaskFront")) { dss.stencilReadMaskFront = val["stencilReadMaskFront"].GetUint(); } if (val.HasMember("stencilWriteMaskFront")) { dss.stencilWriteMaskFront = val["stencilWriteMaskFront"].GetUint(); } if (val.HasMember("stencilFailOpFront")) { dss.stencilFailOpFront = static_cast(val["stencilFailOpFront"].GetUint()); } if (val.HasMember("stencilZFailOpFront")) { dss.stencilZFailOpFront = static_cast(val["stencilZFailOpFront"].GetUint()); } if (val.HasMember("stencilPassOpFront")) { dss.stencilPassOpFront = static_cast(val["stencilPassOpFront"].GetUint()); } if (val.HasMember("stencilRefFront")) { dss.stencilRefFront = val["stencilRefFront"].GetUint(); } if (val.HasMember("stencilTestBack")) { dss.stencilTestBack = val["stencilTestBack"].GetBool() ? 1 : 0; } if (val.HasMember("stencilFuncBack")) { dss.stencilFuncBack = static_cast(val["stencilFuncBack"].GetInt()); } if (val.HasMember("stencilReadMaskBack")) { dss.stencilReadMaskBack = val["stencilReadMaskBack"].GetUint(); } if (val.HasMember("stencilWriteMaskBack")) { dss.stencilWriteMaskBack = val["stencilWriteMaskBack"].GetUint(); } if (val.HasMember("stencilFailOpBack")) { dss.stencilFailOpBack = static_cast(val["stencilFailOpBack"].GetInt()); } if (val.HasMember("stencilZFailOpBack")) { dss.stencilZFailOpBack = static_cast(val["stencilZFailOpBack"].GetInt()); } if (val.HasMember("stencilPassOpBack")) { dss.stencilPassOpBack = static_cast(val["stencilPassOpBack"].GetInt()); } if (val.HasMember("stencilRefBack")) { dss.stencilWriteMaskBack = val["stencilRefBack"].GetUint(); } return dss; } static void jsonToBlendTarget(const rapidjson::Value &val, BlendTargetInfo *outBlendTarget) { if (outBlendTarget == nullptr) { return; } CC_ASSERT(val.IsObject()); if (val.HasMember("blend")) { outBlendTarget->blend = val["blend"].GetBool() ? 1 : 0; } if (val.HasMember("blendSrc")) { outBlendTarget->blendSrc = static_cast(val["blendSrc"].GetInt()); } if (val.HasMember("blendDst")) { outBlendTarget->blendDst = static_cast(val["blendDst"].GetInt()); } if (val.HasMember("blendEq")) { outBlendTarget->blendEq = static_cast(val["blendEq"].GetInt()); } if (val.HasMember("blendSrcAlpha")) { outBlendTarget->blendSrcAlpha = static_cast(val["blendSrcAlpha"].GetInt()); } if (val.HasMember("blendDstAlpha")) { outBlendTarget->blendDstAlpha = static_cast(val["blendDstAlpha"].GetInt()); } if (val.HasMember("blendAlphaEq")) { outBlendTarget->blendAlphaEq = static_cast(val["blendAlphaEq"].GetInt()); } if (val.HasMember("blendColorMask")) { outBlendTarget->blendColorMask = static_cast(val["blendColorMask"].GetInt()); } } static void deserializeGfxColor(const rapidjson::Value &color, ccstd::optional &gfxColor) { if (gfxColor.has_value()) { if (color.HasMember("x")) { gfxColor->x = color["x"].GetFloat(); } if (color.HasMember("y")) { gfxColor->y = color["y"].GetFloat(); } if (color.HasMember("z")) { gfxColor->z = color["z"].GetFloat(); } if (color.HasMember("w")) { gfxColor->w = color["w"].GetFloat(); } } } static BlendStateInfo jsonToBlendState(const rapidjson::Value &val) { CC_ASSERT(val.IsObject()); BlendStateInfo bs; if (val.HasMember("isA2C")) { bs.isA2C = val["isA2C"].GetBool() ? 1 : 0; } if (val.HasMember("isIndepend")) { bs.isIndepend = val["isIndepend"].GetBool() ? 1 : 0; } if (val.HasMember("blendColor")) { deserializeGfxColor(val["blendColor"], bs.blendColor); } if (val.HasMember("targets")) { if (val["targets"].IsArray()) { const auto &targetsVal = val["targets"].GetArray(); BlendTargetInfoList targets; targets.resize(targetsVal.Size()); int32_t i = 0; for (const auto &targetVal : targetsVal) { jsonToBlendTarget(targetVal, &targets[i]); ++i; } bs.targets = targets; } } return bs; } static void deserializePass(const rapidjson::Value &passVal, IPassInfoFull &cPass) { // Filling IPassInfo is enough, the properties in IPassInfoFull will be assigned in Material::createPasses CC_ASSERT(passVal.IsObject()); // IPassInfo cPass.program = passVal["program"].GetString(); // CC_LOG_DEBUG("program: %s", cPass.program.c_str()); if (passVal.HasMember("embeddedMacros")) { cPass.embeddedMacros = jsonToMacroRecord(passVal["embeddedMacros"]); } if (passVal.HasMember("propertyIndex")) { cPass.propertyIndex = passVal["propertyIndex"].GetInt(); // CC_LOG_DEBUG("propertyIndex: %d", cPass.propertyIndex); } if (passVal.HasMember("switch")) { cPass.switch_ = passVal["switch"].GetString(); // CC_LOG_DEBUG("switch: %s", cPass.switch_.value().c_str()); } if (passVal.HasMember("properties")) { cPass.properties = jsonToPassPropertyInfoMap(passVal["properties"]); } // IPassStates if (passVal.HasMember("priority")) { cPass.priority = passVal["priority"].GetInt(); // CC_LOG_DEBUG("priority: %d", cPass.priority.value()); } if (passVal.HasMember("primitive")) { cPass.primitive = static_cast(passVal["primitive"].GetInt()); } if (passVal.HasMember("stage")) { cPass.stage = static_cast(passVal["stage"].GetInt()); } if (passVal.HasMember("rasterizerState")) { cPass.rasterizerState = jsonToRasterizerState(passVal["rasterizerState"]); } if (passVal.HasMember("depthStencilState")) { cPass.depthStencilState = jsonToDepthStencilState(passVal["depthStencilState"]); } if (passVal.HasMember("blendState")) { cPass.blendState = jsonToBlendState(passVal["blendState"]); } if (passVal.HasMember("dynamicStates")) { cPass.dynamicStates = static_cast(passVal["dynamicStates"].GetInt()); } if (passVal.HasMember("phase")) { cPass.phase = passVal["phase"].GetString(); // CC_LOG_DEBUG("phase: %s", cPass.phase.value().c_str()); } } static void deserializeTechnique(const rapidjson::Value &technique, ITechniqueInfo &cTechnique) { if (technique.IsObject()) { if (technique.HasMember("name")) { cTechnique.name = technique["name"].GetString(); // CC_LOG_DEBUG("tech name: %s", _techniques[techIndex].name.value().c_str()); } if (technique.HasMember("passes")) { const auto &passesVal = technique["passes"]; deserializeArray(passesVal, cTechnique.passes, deserializePass); } } } static void deserializeShaderBuiltin(const rapidjson::Value &builtinVal, IBuiltin &cBuiltin) { CC_ASSERT(builtinVal.IsObject()); if (builtinVal.HasMember("name")) { cBuiltin.name = builtinVal["name"].GetString(); } if (builtinVal.HasMember("defines")) { deserializeArray(builtinVal["defines"], cBuiltin.defines); } } static void deserializeShaderBuiltinInfo(const rapidjson::Value &builtinInfoVal, IBuiltinInfo &cBuiltinInfo) { CC_ASSERT(builtinInfoVal.IsObject()); if (builtinInfoVal.HasMember("blocks")) { deserializeArray(builtinInfoVal["blocks"], cBuiltinInfo.blocks, deserializeShaderBuiltin); } if (builtinInfoVal.HasMember("samplerTextures")) { deserializeArray(builtinInfoVal["samplerTextures"], cBuiltinInfo.samplerTextures, deserializeShaderBuiltin); } } static void deserializeShaderBuiltinsStatistics(const rapidjson::Value &statisticsVal, BuiltinsStatisticsType &cStatistics) { CC_ASSERT(statisticsVal.IsObject()); for (const auto &e : statisticsVal.GetObject()) { cStatistics[e.name.GetString()] = e.value.GetInt(); } } static void deserializeShaderBuiltins(const rapidjson::Value &builtinsVal, IBuiltins &cBuiltins) { CC_ASSERT(builtinsVal.IsObject()); if (builtinsVal.HasMember("globals")) { deserializeShaderBuiltinInfo(builtinsVal["globals"], cBuiltins.globals); } if (builtinsVal.HasMember("locals")) { deserializeShaderBuiltinInfo(builtinsVal["locals"], cBuiltins.locals); } if (builtinsVal.HasMember("statistics")) { deserializeShaderBuiltinsStatistics(builtinsVal["statistics"], cBuiltins.statistics); } } // static void deserializeShaderDefine(const rapidjson::Value &defineVal, IDefineInfo &cDefine) { CC_ASSERT(defineVal.IsObject()); if (defineVal.HasMember("name")) { cDefine.name = defineVal["name"].GetString(); } if (defineVal.HasMember("type")) { cDefine.type = defineVal["type"].GetString(); } if (defineVal.HasMember("range")) { auto &cRange = cDefine.range; const auto &rangeVal = defineVal["range"]; cRange = ccstd::vector{}; deserializeArray(rangeVal, cRange.value()); } if (defineVal.HasMember("options")) { auto &cOptions = cDefine.options; const auto &optionsVal = defineVal["options"]; cOptions = ccstd::vector{}; deserializeArray(optionsVal, cOptions.value()); } if (defineVal.HasMember("default")) { cDefine.defaultVal = defineVal["default"].GetString(); } } // static void deserializeMember(const rapidjson::Value &memberVal, gfx::Uniform &cMember) { CC_ASSERT(memberVal.IsObject()); if (memberVal.HasMember("name")) { cMember.name = memberVal["name"].GetString(); } if (memberVal.HasMember("type")) { cMember.type = static_cast(memberVal["type"].GetInt()); } if (memberVal.HasMember("count")) { cMember.count = memberVal["count"].GetUint(); } } static void deserializeShaderBlock(const rapidjson::Value &blockVal, IBlockInfo &cBlock) { CC_ASSERT(blockVal.IsObject()); if (blockVal.HasMember("binding")) { cBlock.binding = blockVal["binding"].GetInt(); } if (blockVal.HasMember("name")) { cBlock.name = blockVal["name"].GetString(); } if (blockVal.HasMember("members")) { deserializeArray(blockVal["members"], cBlock.members, deserializeMember); } if (blockVal.HasMember("stageFlags")) { cBlock.stageFlags = static_cast(blockVal["stageFlags"].GetInt()); } } static void deserializeShaderSamplerTexture(const rapidjson::Value &samplerTextureVal, ISamplerTextureInfo &cSamplerTexture) { CC_ASSERT(samplerTextureVal.IsObject()); if (samplerTextureVal.HasMember("binding")) { cSamplerTexture.binding = samplerTextureVal["binding"].GetInt(); } if (samplerTextureVal.HasMember("name")) { cSamplerTexture.name = samplerTextureVal["name"].GetString(); } if (samplerTextureVal.HasMember("type")) { cSamplerTexture.type = static_cast(samplerTextureVal["type"].GetInt()); } if (samplerTextureVal.HasMember("count")) { cSamplerTexture.count = samplerTextureVal["count"].GetUint(); } if (samplerTextureVal.HasMember("stageFlags")) { cSamplerTexture.stageFlags = static_cast(samplerTextureVal["stageFlags"].GetInt()); } } static void deserializeShaderSampler(const rapidjson::Value &samplerVal, ISamplerInfo &cSampler) { CC_ASSERT(samplerVal.IsObject()); if (samplerVal.HasMember("set")) { cSampler.set = samplerVal["set"].GetUint(); } if (samplerVal.HasMember("binding")) { cSampler.binding = samplerVal["binding"].GetInt(); } if (samplerVal.HasMember("name")) { cSampler.name = samplerVal["name"].GetString(); } if (samplerVal.HasMember("count")) { cSampler.count = samplerVal["count"].GetUint(); } if (samplerVal.HasMember("stageFlags")) { cSampler.stageFlags = static_cast(samplerVal["stageFlags"].GetInt()); } } static void deserializeShaderTexture(const rapidjson::Value &textureVal, ITextureInfo &cTexture) { CC_ASSERT(textureVal.IsObject()); if (textureVal.HasMember("set")) { cTexture.set = textureVal["set"].GetUint(); } if (textureVal.HasMember("binding")) { cTexture.binding = textureVal["binding"].GetInt(); } if (textureVal.HasMember("name")) { cTexture.name = textureVal["name"].GetString(); } if (textureVal.HasMember("type")) { cTexture.type = static_cast(textureVal["type"].GetInt()); } if (textureVal.HasMember("count")) { cTexture.count = textureVal["count"].GetUint(); } if (textureVal.HasMember("stageFlags")) { cTexture.stageFlags = static_cast(textureVal["stageFlags"].GetInt()); } } static void deserializeShaderBuffer(const rapidjson::Value &bufferVal, IBufferInfo &cBuffer) { CC_ASSERT(bufferVal.IsObject()); if (bufferVal.HasMember("binding")) { cBuffer.binding = bufferVal["binding"].GetInt(); } if (bufferVal.HasMember("name")) { cBuffer.name = bufferVal["name"].GetString(); } if (bufferVal.HasMember("memoryAccess")) { cBuffer.memoryAccess = static_cast(bufferVal["memoryAccess"].GetInt()); } if (bufferVal.HasMember("stageFlags")) { cBuffer.stageFlags = static_cast(bufferVal["stageFlags"].GetInt()); } } static void deserializeShaderImage(const rapidjson::Value &imageVal, IImageInfo &cImage) { CC_ASSERT(imageVal.IsObject()); if (imageVal.HasMember("binding")) { cImage.binding = imageVal["binding"].GetInt(); } if (imageVal.HasMember("name")) { cImage.name = imageVal["name"].GetString(); } if (imageVal.HasMember("type")) { cImage.type = static_cast(imageVal["type"].GetInt()); } if (imageVal.HasMember("count")) { cImage.count = imageVal["count"].GetUint(); } if (imageVal.HasMember("memoryAccess")) { cImage.memoryAccess = static_cast(imageVal["memoryAccess"].GetInt()); } if (imageVal.HasMember("stageFlags")) { cImage.stageFlags = static_cast(imageVal["stageFlags"].GetInt()); } } static void deserializeShaderInputAttachment(const rapidjson::Value &inputAttachmentVal, IInputAttachmentInfo &cInputAttachment) { CC_ASSERT(inputAttachmentVal.IsObject()); if (inputAttachmentVal.HasMember("set")) { cInputAttachment.set = inputAttachmentVal["set"].GetUint(); } if (inputAttachmentVal.HasMember("binding")) { cInputAttachment.binding = inputAttachmentVal["binding"].GetInt(); } if (inputAttachmentVal.HasMember("name")) { cInputAttachment.name = inputAttachmentVal["name"].GetString(); } if (inputAttachmentVal.HasMember("count")) { cInputAttachment.count = inputAttachmentVal["count"].GetUint(); } if (inputAttachmentVal.HasMember("stageFlags")) { cInputAttachment.stageFlags = static_cast(inputAttachmentVal["stageFlags"].GetInt()); } } static void deserializeShaderAttribute(const rapidjson::Value &gfxAttributeVal, IAttributeInfo &cAttribute) { CC_ASSERT(gfxAttributeVal.IsObject()); if (gfxAttributeVal.HasMember("name")) { cAttribute.name = gfxAttributeVal["name"].GetString(); } if (gfxAttributeVal.HasMember("format")) { cAttribute.format = static_cast(gfxAttributeVal["format"].GetInt()); } if (gfxAttributeVal.HasMember("isNormalized")) { cAttribute.isNormalized = gfxAttributeVal["isNormalized"].GetBool(); } if (gfxAttributeVal.HasMember("stream")) { cAttribute.stream = gfxAttributeVal["stream"].GetUint(); } if (gfxAttributeVal.HasMember("isInstanced")) { cAttribute.isInstanced = gfxAttributeVal["isInstanced"].GetBool(); } if (gfxAttributeVal.HasMember("location")) { cAttribute.location = gfxAttributeVal["location"].GetUint(); } } static void deserializeShaderAttributeInfo(const rapidjson::Value &attributeVal, IAttributeInfo &cAttributeInfo) { CC_ASSERT(attributeVal.IsObject()); deserializeShaderAttribute(attributeVal, cAttributeInfo); if (attributeVal.HasMember("defines")) { deserializeArray(attributeVal["defines"], cAttributeInfo.defines); } } static void deserializeShader(const rapidjson::Value &shaderVal, IShaderInfo &cShader) { CC_ASSERT(shaderVal.IsObject()); cShader.name = shaderVal["name"].GetString(); cShader.hash = shaderVal["hash"].GetUint(); //NOTE: glsl1, glsl3, glsl4 are not initialized here deserializeShaderBuiltins(shaderVal["builtins"], cShader.builtins); deserializeArray(shaderVal["defines"], cShader.defines, deserializeShaderDefine); deserializeArray(shaderVal["attributes"], cShader.attributes, deserializeShaderAttributeInfo); deserializeArray(shaderVal["blocks"], cShader.blocks, deserializeShaderBlock); deserializeArray(shaderVal["samplerTextures"], cShader.samplerTextures, deserializeShaderSamplerTexture); deserializeArray(shaderVal["samplers"], cShader.samplers, deserializeShaderSampler); deserializeArray(shaderVal["textures"], cShader.textures, deserializeShaderTexture); deserializeArray(shaderVal["buffers"], cShader.buffers, deserializeShaderBuffer); deserializeArray(shaderVal["images"], cShader.images, deserializeShaderImage); deserializeArray(shaderVal["subpassInputs"], cShader.subpassInputs, deserializeShaderInputAttachment); } static void deserializePreCompileInfoValue(const rapidjson::Value &infoVal, IPreCompileInfoValueType &cInfo) { if (infoVal.IsBool()) { ccstd::vector boolInfo; deserializeArray(infoVal, boolInfo); cInfo = std::move(boolInfo); } else if (infoVal.IsInt()) { ccstd::vector intInfo; deserializeArray(infoVal, intInfo); cInfo = std::move(intInfo); } else if (infoVal.IsString()) { ccstd::vector strInfo; deserializeArray(infoVal, strInfo); cInfo = std::move(strInfo); } else { CC_ASSERT(false); } } static void deserializeCombination(const rapidjson::Value &combinationVal, IPreCompileInfo &cCombination) { CC_ASSERT(combinationVal.IsObject()); for (const auto &e : combinationVal.GetObject()) { IPreCompileInfoValueType info; deserializePreCompileInfoValue(e.value, info); cCombination.emplace(e.name.GetString(), info); } } void EffectAssetDeserializer::deserialize(const rapidjson::Value &serializedData, Asset *asset) { CC_ASSERT(serializedData.IsObject()); auto *effectAsset = dynamic_cast(asset); CC_ASSERT(effectAsset != nullptr); effectAsset->_name = serializedData["name"].GetString(); //cjh TODO: name needs to be deserialize in CCObject class. // CC_LOG_DEBUG("EffectAsset::deserialize: %s", _name.c_str()); if (serializedData.HasMember("techniques")) { deserializeArray(serializedData["techniques"], effectAsset->_techniques, deserializeTechnique); } if (serializedData.HasMember("shaders")) { deserializeArray(serializedData["shaders"], effectAsset->_shaders, deserializeShader); } if (serializedData.HasMember("combinations")) { deserializeArray(serializedData["combinations"], effectAsset->_combinations, deserializeCombination); } } } // namespace cc