.Add("ROUNDED_CORNER,", true)
.Add("BLUR_EDGE", true);
+ Property::Map npatchShader;
+ npatchShader["shaderType"] = "npatch";
+
+ Property::Map npatchShader2;
+ npatchShader2["shaderType"] = "npatch";
+ npatchShader2["shaderOption"] = Property::Map() .Add("MASKING", true);
+ npatchShader2["xStretchCount"] = 4;
+ npatchShader2["yStretchCount"] = 3;
Property::Map customSHader;
customSHader["shaderType"] = "custom";
factory.AddPrecompileShader(textShader2);
factory.AddPrecompileShader(colorShader);
factory.AddPrecompileShader(colorShader2);
+ factory.AddPrecompileShader(npatchShader);
+ factory.AddPrecompileShader(npatchShader2);
factory.AddPrecompileShader(customSHader);
factory.UsePreCompiledShader();
const char* TOKEN_TYPE_TEXT("text");
const char* TOKEN_TYPE_COLOR("color");
const char* TOKEN_TYPE_MODEL_3D("3d");
+ const char* TOKEN_TYPE_NPATCH("npatch");
const char* TOKEN_TYPE_CUSTOM("custom");
// OPTION
const char* TOKEN_OPTION_STYLES("STYLES");
const char* TOKEN_OPTION_OVERLAY("OVERLAY");
const char* TOKEN_OPTION_EMOJI("EMOJI");
+ const char* TOKEN_OPTION_STRETCH_X("xStretchCount");
+ const char* TOKEN_OPTION_STRETCH_Y("yStretchCount");
+
// CUSTOM
const char* TOKEN_CUSTOM_VERTEX("vertexShader");
mShaderOptions(),
mShaderName(""),
mVertexShader(""),
- mFragmentShader("")
+ mFragmentShader(""),
+ mNpatchXStretchCount(0),
+ mNpatchYStretchCount(0)
{
ConvertShaderMap(shaderOption);
}
{
mShaderType = ShaderType::MODEL_3D;
}
+ else if(shaderType == TOKEN_TYPE_NPATCH)
+ {
+ mShaderType = ShaderType::NPATCH;
+ }
else if(shaderType == TOKEN_TYPE_CUSTOM)
{
mShaderType = ShaderType::CUSTOM;
mShaderName = value.Get<std::string>();
}
}
+ else if(key == TOKEN_OPTION_STRETCH_X)
+ {
+ if(value.GetType() == Property::INTEGER)
+ {
+ mNpatchXStretchCount = value.Get<int>();
+ }
+ }
+ else if(key == TOKEN_OPTION_STRETCH_Y)
+ {
+ if(value.GetType() == Property::INTEGER)
+ {
+ mNpatchYStretchCount = value.Get<int>();
+ }
+ }
}
}
return mFragmentShader;
}
+uint32_t PrecompileShaderOption::GetNpatchXStretchCount() const
+{
+ return mNpatchXStretchCount;
+}
+
+uint32_t PrecompileShaderOption::GetNpatchYStretchCount() const
+{
+ return mNpatchYStretchCount;
+}
+
} // namespace Toolkit
} // namespace Dali
* IMAGE_SHADER_ROUNDED_CORNER_YUV_AND_RGB,
* IMAGE_SHADER_BORDERLINE_YUV_AND_RGB,
* IMAGE_SHADER_ROUNDED_BORDERLINE_YUV_AND_RGB,
+ * NATIVE_IMAGE_SHADER,
+ * NATIVE_IMAGE_SHADER_ROUNDED_CORNER,
+ * NATIVE_IMAGE_SHADER_BORDERLINE,
+ * NATIVE_IMAGE_SHADER_ROUNDED_BORDERLINE,
+ * NATIVE_IMAGE_SHADER_MASKING,
+ * NATIVE_IMAGE_SHADER_ROUNDED_CORNER_MASKING,
+ * NATIVE_IMAGE_SHADER_BORDERLINE_MASKING,
+ * NATIVE_IMAGE_SHADER_ROUNDED_BORDERLINE_MASKING,
+ * NATIVE_IMAGE_SHADER_ATLAS_DEFAULT_WRAP,
+ * NATIVE_IMAGE_SHADER_ATLAS_CUSTOM_WRAP,
+ * NINE_PATCH_SHADER,
+ * NINE_PATCH_MASK_SHADER,
* TEXT_SHADER_SINGLE_COLOR_TEXT,
* TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_STYLE,
* TEXT_SHADER_SINGLE_COLOR_TEXT_WITH_OVERLAY,
COLOR,
IMAGE,
TEXT,
+ NPATCH,
MODEL_3D, // ToDO: Need to add more options
CUSTOM,
};
STYLES,
OVERLAY,
EMOJI,
+ NATIVE,
+ STRETCH_X,
+ STRETCH_Y,
};
PrecompileShaderOption(const Property::Map& shaderOption);
*/
std::string GetFragmentShader() const;
+ /**
+ * @brief Get the XStretchCount for npatch
+ *
+ * @return The NpatchXStretchCount
+ */
+ uint32_t GetNpatchXStretchCount() const;
+
+ /**
+ * @brief Get the YStretchCount for npatch
+ *
+ * @return The NpatchYStretchCount
+ */
+ uint32_t GetNpatchYStretchCount() const;
+
private:
ShaderType mShaderType;
std::vector<Flag> mShaderOptions;
std::string mShaderName;
std::string mVertexShader;
std::string mFragmentShader;
+ uint32_t mNpatchXStretchCount;
+ uint32_t mNpatchYStretchCount;
};
} // namespace Toolkit
${toolkit_src_dir}/visuals/color/color-visual-shader-factory.cpp
${toolkit_src_dir}/visuals/color/color-visual.cpp
${toolkit_src_dir}/visuals/custom-shader-factory.cpp
+ ${toolkit_src_dir}/visuals/npatch-shader-factory.cpp
${toolkit_src_dir}/visuals/gradient/gradient-visual.cpp
${toolkit_src_dir}/visuals/gradient/gradient.cpp
${toolkit_src_dir}/visuals/gradient/linear-gradient.cpp
{
auto shaderName = option.GetShaderName();
auto vertexShader = option.GetVertexShader();
- auto framentShader = option.GetFragmentShader();
-
- RequestShaderInfo info;
- info.name = shaderName;
- info.vertexPrefix = vertexShader;
- info.fragmentPrefix = framentShader;
- mRequestedPrecompileShader.push_back(info);
- DALI_LOG_RELEASE_INFO("Add custom precompile shader success!!(%s)", shaderName.c_str());
- return true;
+ auto fragmentShader = option.GetFragmentShader();
+ return SavePrecompileShader(shaderName, vertexShader, fragmentShader);
}
void CustomShaderFactory::GetPreCompiledShader(RawShaderData& shaders)
shaders.custom = true;
}
+bool CustomShaderFactory::SavePrecompileShader(std::string& shaderName, std::string& vertexShader, std::string& fragmentShader)
+{
+ RequestShaderInfo info;
+ info.name = shaderName;
+ info.vertexPrefix = vertexShader;
+ info.fragmentPrefix = fragmentShader;
+ mRequestedPrecompileShader.push_back(info);
+ DALI_LOG_RELEASE_INFO("Add precompile shader success!!(%s)",shaderName.c_str());
+ return true;
+}
+
} // namespace Internal
} // namespace Toolkit
*/
void GetPreCompiledShader(RawShaderData& shaders) override;
+private:
+ /**
+ * @brief Save the custom shader
+ */
+ bool SavePrecompileShader(std::string& shaderName, std::string& vertexPrefix, std::string& fragmentPrefix);
+
protected:
/**
* Undefined copy constructor.
--- /dev/null
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// CLASS HEADER
+#include <dali-toolkit/internal/visuals/npatch-shader-factory.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/graphics/builtin-shader-extern-gen.h>
+#include <dali-toolkit/internal/visuals/visual-string-constants.h>
+#include <dali/integration-api/debug.h>
+
+namespace Dali
+{
+namespace Toolkit
+{
+namespace Internal
+{
+
+NpatchShaderFactory::NpatchShaderFactory()
+: mNpatchXStretchCount(0),
+ mNpatchYStretchCount(0),
+ mNpatchMaskingEnable(false)
+{
+}
+
+NpatchShaderFactory::~NpatchShaderFactory()
+{
+}
+
+bool NpatchShaderFactory::AddPrecompiledShader(PrecompileShaderOption& option)
+{
+ ShaderFlagList shaderOption = option.GetShaderOptions();
+
+ // Find Masking flag
+ for(uint32_t i = 0; i < shaderOption.size(); ++i)
+ {
+ if(shaderOption[i] == PrecompileShaderOption::Flag::MASKING)
+ {
+ mNpatchMaskingEnable = true;
+ }
+ }
+
+ mNpatchXStretchCount = option.GetNpatchXStretchCount();
+ mNpatchYStretchCount = option.GetNpatchYStretchCount();
+
+ std::string vertexShader;
+ std::string fragmentShader;
+ GetVertexShader(vertexShader);
+ GetFragmentShader(fragmentShader);
+
+ VisualFactoryCache::ShaderType shaderType = mNpatchMaskingEnable? VisualFactoryCache::ShaderType::NINE_PATCH_MASK_SHADER : VisualFactoryCache::ShaderType::NINE_PATCH_SHADER;
+ return SavePrecompileShader(shaderType, vertexShader, fragmentShader);
+}
+
+void NpatchShaderFactory::GetPreCompiledShader(RawShaderData& shaders)
+{
+ std::vector<std::string_view> vertexPrefix;
+ std::vector<std::string_view> fragmentPrefix;
+ std::vector<std::string_view> shaderName;
+ int shaderCount = 0;
+ shaders.shaderCount = 0;
+
+ // precompile requested shader first
+ for(uint32_t i = 0; i < mRequestedPrecompileShader.size(); i++ )
+ {
+ vertexPrefix.push_back(mRequestedPrecompileShader[i].vertexPrefix);
+ fragmentPrefix.push_back(mRequestedPrecompileShader[i].fragmentPrefix);
+ shaderName.push_back(mRequestedPrecompileShader[i].name);
+ shaderCount++;
+ }
+
+ shaders.vertexPrefix = std::move(vertexPrefix);
+ shaders.fragmentPrefix = std::move(fragmentPrefix);
+ shaders.shaderName = std::move(shaderName);
+ shaders.vertexShader = ""; // Custom shader use prefix shader only. No need to set vertexShader and fragmentShader.
+ shaders.fragmentShader = ""; // Custom shader use prefix shader only. No need to set vertexShader and fragmentShader.
+ shaders.shaderCount = std::move(shaderCount);
+ shaders.custom = true;
+}
+
+void NpatchShaderFactory::GetVertexShader(std::string& vertexShader) const
+{
+ if(DALI_LIKELY((mNpatchXStretchCount == 1 && mNpatchYStretchCount == 1) ||
+ (mNpatchXStretchCount == 0 && mNpatchYStretchCount == 0)))
+ {
+ vertexShader += SHADER_NPATCH_VISUAL_3X3_SHADER_VERT;
+ }
+ else if(mNpatchXStretchCount > 0 || mNpatchYStretchCount > 0)
+ {
+ std::stringstream vertextShaderStream;
+ vertextShaderStream << "#define FACTOR_SIZE_X " << mNpatchXStretchCount + 2 << "\n"
+ << "#define FACTOR_SIZE_Y " << mNpatchYStretchCount + 2 << "\n"
+ << SHADER_NPATCH_VISUAL_SHADER_VERT;
+ vertexShader += vertextShaderStream.str();
+ }
+}
+
+void NpatchShaderFactory::GetFragmentShader(std::string& fragmentShader) const
+{
+ fragmentShader += (mNpatchMaskingEnable ? SHADER_NPATCH_VISUAL_MASK_SHADER_FRAG : SHADER_NPATCH_VISUAL_SHADER_FRAG);
+}
+
+bool NpatchShaderFactory::SavePrecompileShader(VisualFactoryCache::ShaderType shader, std::string& vertexShader, std::string& fragmentShader)
+{
+ for(uint32_t i = 0u; i< mRequestedPrecompileShader.size(); i++)
+ {
+ if(mRequestedPrecompileShader[i].type == shader)
+ {
+ DALI_LOG_WARNING("This shader already requsted(%s).", Scripting::GetLinearEnumerationName<VisualFactoryCache::ShaderType>(mRequestedPrecompileShader[i].type, VISUAL_SHADER_TYPE_TABLE, VISUAL_SHADER_TYPE_TABLE_COUNT));
+ return false;
+ }
+ }
+
+ std::string shaderName = Scripting::GetLinearEnumerationName<VisualFactoryCache::ShaderType>(shader, VISUAL_SHADER_TYPE_TABLE, VISUAL_SHADER_TYPE_TABLE_COUNT);
+ if(!((mNpatchXStretchCount == 1 && mNpatchYStretchCount == 1) || (mNpatchXStretchCount == 0 && mNpatchYStretchCount == 0)))
+ {
+ if(mNpatchXStretchCount > 0 || mNpatchYStretchCount > 0)
+ {
+ std::stringstream shaderNameStream;
+ shaderNameStream << "NINE_PATCH_SHADER_" << mNpatchXStretchCount << "x" << mNpatchYStretchCount;
+ shaderName = shaderNameStream.str();
+ }
+ }
+
+ RequestShaderInfo info;
+ info.type = shader;
+ info.name = shaderName;
+ info.vertexPrefix = vertexShader;
+ info.fragmentPrefix = fragmentShader;
+ mRequestedPrecompileShader.push_back(info);
+ DALI_LOG_RELEASE_INFO("Add precompile shader success!!(%s)",Scripting::GetLinearEnumerationName<VisualFactoryCache::ShaderType>(shader, VISUAL_SHADER_TYPE_TABLE, VISUAL_SHADER_TYPE_TABLE_COUNT));
+ return true;
+}
+
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali
--- /dev/null
+#ifndef DALI_TOOLKIT_NPATCH_SHADER_FACTORY_H
+#define DALI_TOOLKIT_NPATCH_SHADER_FACTORY_H
+
+/*
+ * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// EXTERNAL INCLUDES
+#include <dali/integration-api/adaptor-framework/shader-precompiler.h>
+
+// INTERNAL INCLUDES
+#include <dali-toolkit/internal/visuals/visual-factory-cache.h>
+#include <dali-toolkit/internal/visuals/visual-shader-factory-interface.h>
+#include <string_view>
+
+namespace Dali
+{
+namespace Toolkit
+{
+namespace Internal
+{
+
+/**
+ * NpatchShaderFactory is an object that provides custom shader
+ */
+class NpatchShaderFactory : public VisualShaderFactoryInterface
+{
+public:
+ /**
+ * @brief Constructor
+ */
+ NpatchShaderFactory();
+
+ /**
+ * @brief Destructor
+ */
+ ~NpatchShaderFactory() override;
+
+public: // Implementation of VisualShaderFactoryInterface
+ /**
+ * @copydoc Dali::Toolkit::VisualShaderFactoryInterface::AddPrecompiledShader
+ */
+ bool AddPrecompiledShader(PrecompileShaderOption& option) override;
+
+ /**
+ * @copydoc Dali::Toolkit::VisualShaderFactoryInterface::GetPreCompiledShader
+ */
+ void GetPreCompiledShader(RawShaderData& shaders) override;
+
+private:
+ /**
+ * @brief Get the NPatch vertex shader. this is used for generating pre-compiled shader.
+ */
+ void GetVertexShader(std::string& vertexShader) const;
+
+ /**
+ * @brief Get the NPatch fragment shader. this is used for generating pre-compiled shader
+ */
+ void GetFragmentShader(std::string& fragmentShader) const;
+
+ /**
+ * @brief Save the npatch shader
+ */
+ bool SavePrecompileShader(VisualFactoryCache::ShaderType shader, std::string& vertexPrefix, std::string& fragmentPrefix);
+
+protected:
+ /**
+ * Undefined copy constructor.
+ */
+ NpatchShaderFactory(const NpatchShaderFactory&) = delete;
+
+ /**
+ * Undefined assignment operator.
+ */
+ NpatchShaderFactory& operator=(const NpatchShaderFactory& rhs) = delete;
+
+private:
+ // For Npatch
+ uint32_t mNpatchXStretchCount;
+ uint32_t mNpatchYStretchCount;
+ bool mNpatchMaskingEnable;
+};
+
+} // namespace Internal
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif // DALI_TOOLKIT_NPATCH_SHADER_FACTORY_H
#include <dali-toolkit/internal/visuals/color/color-visual-shader-factory.h>
#include <dali-toolkit/internal/visuals/color/color-visual.h>
#include <dali-toolkit/internal/visuals/custom-shader-factory.h>
+#include <dali-toolkit/internal/visuals/npatch-shader-factory.h>
#include <dali-toolkit/internal/visuals/gradient/gradient-visual.h>
#include <dali-toolkit/internal/visuals/image/image-visual-shader-factory.h>
#include <dali-toolkit/internal/visuals/image/image-visual.h>
GetColorVisualShaderFactory().GetPreCompiledShader(colorShaderData);
rawShaderList.push_back(colorShaderData);
+ RawShaderData npatchShaderData;
+ GetNpatchShaderFactory().GetPreCompiledShader(npatchShaderData);
+ rawShaderList.push_back(npatchShaderData);
+
// Get 3D shader
// Get Custom shader
RawShaderData customShaderData;
return *mColorVisualShaderFactory;
}
+NpatchShaderFactory& VisualFactory::GetNpatchShaderFactory()
+{
+ if(!mNpatchShaderFactory)
+ {
+ mNpatchShaderFactory = std::unique_ptr<NpatchShaderFactory>(new NpatchShaderFactory());
+ }
+ return *mNpatchShaderFactory;
+}
+
CustomShaderFactory& VisualFactory::GetCustomShaderFactory()
{
if(!mCustomShaderFactory)
ret = GetTextVisualShaderFactory().AddPrecompiledShader(option);
break;
}
+ case PrecompileShaderOption::ShaderType::NPATCH:
+ {
+ ret = GetNpatchShaderFactory().AddPrecompiledShader(option);
+ }
case PrecompileShaderOption::ShaderType::MODEL_3D:
{
// TODO
class ImageVisualShaderFactory;
class TextVisualShaderFactory;
class ColorVisualShaderFactory;
+class NpatchShaderFactory;
class CustomShaderFactory;
/**
ColorVisualShaderFactory& GetColorVisualShaderFactory();
/**
+ * Get the npatch shader factory, creating it if necessary.
+ */
+ NpatchShaderFactory& GetNpatchShaderFactory();
+
+ /**
* Get the custom shader factory, creating it if necessary.
*/
- CustomShaderFactory& GetCustomShaderFactory();
+ CustomShaderFactory& GetCustomShaderFactory();
/**
* @brief Add precompiled shader
std::unique_ptr<ImageVisualShaderFactory> mImageVisualShaderFactory;
std::unique_ptr<TextVisualShaderFactory> mTextVisualShaderFactory;
std::unique_ptr<ColorVisualShaderFactory> mColorVisualShaderFactory;
+ std::unique_ptr<NpatchShaderFactory> mNpatchShaderFactory;
std::unique_ptr<CustomShaderFactory> mCustomShaderFactory;
SlotDelegate<VisualFactory> mSlotDelegate;
CallbackBase* mIdleCallback;
projects / platform / core / uifw / dali-toolkit.git / commitdiff