Added useFileCaching flag for shader

Previously, all custom Shaders supported file caching, which was not the intended behavior.
therefore, we added a flag to distinguish between internally generated code and externally generated code.
if you want to enable File Caching for externally generated shader code, you can do so using this flag.
(however, the validity of the shader must be verified by the app itself.)

Change-Id: I5e0cb0c6f4177da8159c50e2e27a0833b2c6e54f

diff --git a/automated-tests/src/dali-internal/utc-Dali-Internal-Shader.cpp b/automated-tests/src/dali-internal/utc-Dali-Internal-Shader.cpp
index 5e8df61c2a9290747cb287a2dce3e40b33f356d6..46b6d7b3e548a9fc7e458716fb619fd99d3b37be 100644 (file)
--- a/automated-tests/src/dali-internal/utc-Dali-Internal-Shader.cpp
+++ b/automated-tests/src/dali-internal/utc-Dali-Internal-Shader.cpp
@@ -51,7 +51,7 @@ int UtcDaliShaderTestVersion(void)
   Dali::Internal::ThreadLocalStorage& tls           = Dali::Internal::ThreadLocalStorage::Get();
   Dali::Internal::ShaderFactory&      shaderFactory = tls.GetShaderFactory();
   size_t                              shaderHash;
-  Internal::ShaderDataPtr             shaderData = shaderFactory.Load(vertexShader, fragmentShader, {}, {}, "", shaderHash);
+  Internal::ShaderDataPtr             shaderData = shaderFactory.Load(vertexShader, fragmentShader, {}, {}, "", shaderHash, false);
 
   bool dataValid = (shaderData != nullptr);
   DALI_TEST_EQUALS(dataValid, true, TEST_LOCATION);
@@ -87,7 +87,7 @@ int UtcDaliShaderWithPrefixTestVersion(void)
   Dali::Internal::ThreadLocalStorage& tls           = Dali::Internal::ThreadLocalStorage::Get();
   Dali::Internal::ShaderFactory&      shaderFactory = tls.GetShaderFactory();
   size_t                              shaderHash;
-  Internal::ShaderDataPtr             shaderData = shaderFactory.Load(vertexShader, fragmentShader, {}, {}, "", shaderHash);
+  Internal::ShaderDataPtr             shaderData = shaderFactory.Load(vertexShader, fragmentShader, {}, {}, "", shaderHash, false);
 
   bool dataValid = (shaderData != nullptr);
   DALI_TEST_EQUALS(dataValid, true, TEST_LOCATION);
@@ -130,7 +130,7 @@ int UtcDaliShaderWithPrefixTestVersion2(void)
   Dali::Internal::ThreadLocalStorage& tls           = Dali::Internal::ThreadLocalStorage::Get();
   Dali::Internal::ShaderFactory&      shaderFactory = tls.GetShaderFactory();
   size_t                              shaderHash;
-  Internal::ShaderDataPtr             shaderData = shaderFactory.Load(vertexShader, fragmentShader, {}, {}, "", shaderHash);
+  Internal::ShaderDataPtr             shaderData = shaderFactory.Load(vertexShader, fragmentShader, {}, {}, "", shaderHash, false);
 
   bool dataValid = (shaderData != nullptr);
   DALI_TEST_EQUALS(dataValid, true, TEST_LOCATION);
@@ -167,7 +167,7 @@ int UtcDaliInternalShaderSaveAndLoad01(void)
 
   tet_printf("Load shader1. It should be fail to load from platform abstraction\n");
   size_t                  shaderHash1 = 0u;
-  Internal::ShaderDataPtr shaderData1 = shaderFactory.Load(vertexShader1, fragmentShader1, Shader::Hint::NONE, 0u, "", shaderHash1);
+  Internal::ShaderDataPtr shaderData1 = shaderFactory.Load(vertexShader1, fragmentShader1, Shader::Hint::NONE, 0u, "", shaderHash1, false);
   DALI_TEST_CHECK(shaderHash1 != 0u);
   DALI_TEST_EQUALS(shaderData1.Get()->HasBinary(), false, TEST_LOCATION);
 
@@ -209,7 +209,7 @@ int UtcDaliInternalShaderSaveAndLoad01(void)
 
   tet_printf("Load shaderData2 with same code as shaderData1\n");
   size_t                  shaderHash2 = 0u;
-  Internal::ShaderDataPtr shaderData2 = shaderFactory.Load(vertexShader1, fragmentShader1, Shader::Hint::NONE, 0u, "", shaderHash2);
+  Internal::ShaderDataPtr shaderData2 = shaderFactory.Load(vertexShader1, fragmentShader1, Shader::Hint::NONE, 0u, "", shaderHash2, false);
 
   tet_printf("Check shaderData2 cached\n");
   DALI_TEST_EQUALS(shaderHash2, shaderHash1, TEST_LOCATION);
@@ -232,7 +232,7 @@ int UtcDaliInternalShaderSaveAndLoad01(void)
 
   tet_printf("Load shader3. It will get binary same as dummyBuffer\n");
   size_t                  shaderHash3 = 0u;
-  Internal::ShaderDataPtr shaderData3 = shaderFactory.Load(vertexShader2, fragmentShader2, Shader::Hint::NONE, 0u, "", shaderHash3);
+  Internal::ShaderDataPtr shaderData3 = shaderFactory.Load(vertexShader2, fragmentShader2, Shader::Hint::NONE, 0u, "", shaderHash3, false);
   DALI_TEST_CHECK(shaderHash3 != 0u);
   DALI_TEST_EQUALS(shaderData3.Get()->HasBinary(), true, TEST_LOCATION);
   DALI_TEST_EQUALS(shaderData3->GetBufferSize(), dummyBuffer.Count(), TEST_LOCATION);
@@ -273,7 +273,7 @@ int UtcDaliInternalShaderSaveAndLoad02(void)
 
   tet_printf("Load shader1. It should be cached at string container\n");
   size_t                  shaderHash1 = 0u;
-  Internal::ShaderDataPtr shaderData1 = shaderFactory.Load(vertexShader1, fragmentShader1, Shader::Hint::NONE, 0u, "", shaderHash1);
+  Internal::ShaderDataPtr shaderData1 = shaderFactory.Load(vertexShader1, fragmentShader1, Shader::Hint::NONE, 0u, "", shaderHash1, false);
   DALI_TEST_CHECK(shaderHash1 != 0u);
 
   DALI_TEST_EQUALS(platformAbstraction.WasCalled(TestPlatformAbstraction::SaveShaderBinaryFileFunc), false, TEST_LOCATION);
@@ -284,7 +284,7 @@ int UtcDaliInternalShaderSaveAndLoad02(void)
 
   tet_printf("Load shader2. It also should be cached at string container\n");
   size_t                  shaderHash2 = 0u;
-  Internal::ShaderDataPtr shaderData2 = shaderFactory.Load(vertexShader2, fragmentShader2, Shader::Hint::NONE, 0u, "", shaderHash2);
+  Internal::ShaderDataPtr shaderData2 = shaderFactory.Load(vertexShader2, fragmentShader2, Shader::Hint::NONE, 0u, "", shaderHash2, false);
   DALI_TEST_CHECK(shaderHash2 != 0u);
 
   DALI_TEST_EQUALS(platformAbstraction.WasCalled(TestPlatformAbstraction::SaveShaderBinaryFileFunc), false, TEST_LOCATION);
@@ -329,7 +329,7 @@ int UtcDaliInternalShaderSaveAndLoad02(void)
 
   tet_printf("Load shader with same code as shaderData1\n");
   size_t                  shaderHash3 = 0u;
-  Internal::ShaderDataPtr shaderData3 = shaderFactory.Load(vertexShader1, fragmentShader1, Shader::Hint::NONE, 0u, "", shaderHash3);
+  Internal::ShaderDataPtr shaderData3 = shaderFactory.Load(vertexShader1, fragmentShader1, Shader::Hint::NONE, 0u, "", shaderHash3, false);
 
   tet_printf("Check shaderData1 cached\n");
   DALI_TEST_EQUALS(shaderHash3, shaderHash1, TEST_LOCATION);
@@ -344,7 +344,7 @@ int UtcDaliInternalShaderSaveAndLoad02(void)
 
   tet_printf("Load shader with same code as shaderData2\n");
   size_t                  shaderHash4 = 0u;
-  Internal::ShaderDataPtr shaderData4 = shaderFactory.Load(vertexShader2, fragmentShader2, Shader::Hint::NONE, 0u, "", shaderHash4);
+  Internal::ShaderDataPtr shaderData4 = shaderFactory.Load(vertexShader2, fragmentShader2, Shader::Hint::NONE, 0u, "", shaderHash4, false);
 
   tet_printf("Check shaderData2 cached\n");
   DALI_TEST_EQUALS(shaderHash4, shaderHash2, TEST_LOCATION);
@@ -362,7 +362,7 @@ int UtcDaliInternalShaderSaveAndLoad02(void)
 
   tet_printf("Load shader same as shaderData1, but difference render pass tag\n");
   size_t                  shaderHash5 = 0u;
-  Internal::ShaderDataPtr shaderData5 = shaderFactory.Load(vertexShader1, fragmentShader1, Shader::Hint::NONE, 1u, "", shaderHash5);
+  Internal::ShaderDataPtr shaderData5 = shaderFactory.Load(vertexShader1, fragmentShader1, Shader::Hint::NONE, 1u, "", shaderHash5, false);
 
   tet_printf("Check shaderData1 and shaderData5 have same hash, but deferent buffer\n");
   DALI_TEST_EQUALS(shaderHash5, shaderHash1, TEST_LOCATION);

diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-actor-utils.cpp b/automated-tests/src/dali/dali-test-suite-utils/test-actor-utils.cpp
index d628f0d601e26d40e9e39b3dd7f2dc2f2c3b053c..45ebb8035c3cfc004bde88209a75b76133ef5fba 100644 (file)
--- a/automated-tests/src/dali/dali-test-suite-utils/test-actor-utils.cpp
+++ b/automated-tests/src/dali/dali-test-suite-utils/test-actor-utils.cpp
@@ -63,13 +63,13 @@ Actor CreateRenderableActor(Texture texture)
   return CreateRenderableActor(texture, VERTEX_SHADER, FRAGMENT_SHADER);
 }
 
-Actor CreateRenderableActor(Texture texture, const std::string& vertexShader, const std::string& fragmentShader)
+Actor CreateRenderableActor(Texture texture, const std::string& vertexShader, const std::string& fragmentShader, bool useFileCache)
 {
   // Create the geometry
   Geometry geometry = CreateQuadGeometry();
 
   // Create Shader
-  Shader shader = Shader::New(vertexShader, fragmentShader);
+  Shader shader = Shader::New(vertexShader, fragmentShader,Shader::Hint::NONE, "", useFileCache);
 
   // Create renderer from geometry and material
   Renderer renderer = Renderer::New(geometry, shader);

diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-actor-utils.h b/automated-tests/src/dali/dali-test-suite-utils/test-actor-utils.h
index 03a65c1813b4905d0c68d5395161d17ffbc88d09..9e5d38002ab453ba0b46a9a44579f6db693bbdc4 100644 (file)
--- a/automated-tests/src/dali/dali-test-suite-utils/test-actor-utils.h
+++ b/automated-tests/src/dali/dali-test-suite-utils/test-actor-utils.h
@@ -49,9 +49,10 @@ Actor CreateRenderableActor(Texture texture);
  * @param[in] texture Texture to set.
  * @param[in] vertexShader The vertex-shader.
  * @param[in] fragmentShader The fragment-shader.
+ * @param[in] useFileCache If true, the shaders are loaded from files. Otherwise, they are compiled directly. Default is false.
  * @return An actor with a renderer.
  */
-Actor CreateRenderableActor(Texture texture, const std::string& vertexShader, const std::string& fragmentShader);
+Actor CreateRenderableActor(Texture texture, const std::string& vertexShader, const std::string& fragmentShader, bool useFileCache = false);
 
 /**
  * @brief Creates a renderable-actor with a texture and custom shaders.

diff --git a/automated-tests/src/dali/dali-test-suite-utils/test-gl-abstraction.h b/automated-tests/src/dali/dali-test-suite-utils/test-gl-abstraction.h
index a70c21f40c50941975feeb75cb4aa03dbf9252fc..52b7411b17735907f946af75448daf65f293cdb8 100644 (file)
--- a/automated-tests/src/dali/dali-test-suite-utils/test-gl-abstraction.h
+++ b/automated-tests/src/dali/dali-test-suite-utils/test-gl-abstraction.h
@@ -2120,6 +2120,7 @@ public:
 
   inline void GetProgramBinary(GLuint program, GLsizei bufSize, GLsizei* length, GLenum* binaryFormat, GLvoid* binary) override
   {
+    *length = bufSize; // commonly it is same. so we provide bufSize for test
     mGetProgramBinaryCalled = true;
   }
 

diff --git a/dali/graphics-api/graphics-program-create-info.h b/dali/graphics-api/graphics-program-create-info.h
index 3f98d169311d65d13afd3e59606cdb780e42dd5f..252bfe5156c525938303edfbba69c31546c73ac7 100644 (file)
--- a/dali/graphics-api/graphics-program-create-info.h
+++ b/dali/graphics-api/graphics-program-create-info.h
@@ -106,12 +106,25 @@ struct ProgramCreateInfo
     return *this;
   }
 
+  /**
+   * @brief Sets whether the program is used the funcation of file-caching by DALi.
+   *
+   * @param[in] value true if the program is used internally by DALi. Otherwise false. Default is false.
+   * @return reference to this structure.
+   */
+  auto& SetFileCaching(bool value)
+  {
+    useFileCache = value;
+    return *this;
+  }
+
   GraphicsStructureType type{GraphicsStructureType::PROGRAM_CREATE_INFO_STRUCT};
   ExtensionCreateInfo*  nextExtension{nullptr};
 
   std::string_view                name{};
   const std::vector<ShaderState>* shaderState{nullptr};
   const AllocationCallbacks*      allocationCallbacks{nullptr};
+  bool                            useFileCache{false};
 };
 
 } // namespace Graphics

diff --git a/dali/integration-api/shader-integ.cpp b/dali/integration-api/shader-integ.cpp
index dee7594ea1dda804450e287642757497a7f7cf5f..9fe8452da5d646806c4b4a7e9b05bdd91007a6df 100644 (file)
--- a/dali/integration-api/shader-integ.cpp
+++ b/dali/integration-api/shader-integ.cpp
@@ -25,7 +25,7 @@ namespace Dali::Integration
 {
 Dali::Shader ShaderNewWithUniformBlock(std::string_view vertexShader, std::string_view fragmentShader, Shader::Hint::Value hints, std::string_view shaderName, std::vector<Dali::UniformBlock> uniformBlocks)
 {
-  Internal::ShaderPtr shader = Dali::Internal::Shader::New(vertexShader, fragmentShader, hints, shaderName, std::move(uniformBlocks));
+  Internal::ShaderPtr shader = Dali::Internal::Shader::New(vertexShader, fragmentShader, hints, shaderName, std::move(uniformBlocks), !shaderName.empty());
   return Shader(shader.Get());
 }
 

diff --git a/dali/internal/common/shader-data.h b/dali/internal/common/shader-data.h
index f52accde036122abf3b1014eb03107d37cea8bc6..ebb7bc531b68ae2faec79a4a66d20988f0abc209 100644 (file)
--- a/dali/internal/common/shader-data.h
+++ b/dali/internal/common/shader-data.h
@@ -62,15 +62,17 @@ public:
    * @param[in] hints          Hints for rendering
    * @param[in] renderPassTag  RenderPassTag to match shader data and render task.
    * @param[in] name           Shader name for debug.
+   * @param[in] useFileCache   Whether to use file cache or not.
    */
-  ShaderData(std::string vertexSource, std::string fragmentSource, const Dali::Shader::Hint::Value hints, uint32_t renderPassTag, std::string_view name)
+  ShaderData(std::string vertexSource, std::string fragmentSource, const Dali::Shader::Hint::Value hints, uint32_t renderPassTag, std::string_view name, bool useFileCache)
   : mShaderHash(-1),
     mVertexShader(StringToVector(vertexSource)),
     mFragmentShader(StringToVector(fragmentSource)),
     mHints(hints),
     mSourceMode(Graphics::ShaderSourceMode::TEXT),
     mRenderPassTag(renderPassTag),
-    mName(name)
+    mName(name),
+    mUseFileCache(useFileCache)
   {
     UpdateShaderVersion(mVertexShader, mVertexShaderVersion);
     UpdateShaderVersion(mFragmentShader, mFragmentShaderVersion);
@@ -83,15 +85,17 @@ public:
    * @param[in] hints          Hints for rendering
    * @param[in] renderPassTag  RenderPassTag to match shader data and render task.
    * @param[in] name           Shader name for debug.
+   * @param[in] useFileCache   Whether to use file cache or not.
    */
-  ShaderData(std::string_view vertexSource, std::string_view fragmentSource, const Dali::Shader::Hint::Value hints, uint32_t renderPassTag, std::string_view name)
+  ShaderData(std::string_view vertexSource, std::string_view fragmentSource, const Dali::Shader::Hint::Value hints, uint32_t renderPassTag, std::string_view name, bool useFileCache)
   : mShaderHash(-1),
     mVertexShader(StringToVector(vertexSource)),
     mFragmentShader(StringToVector(fragmentSource)),
     mHints(hints),
     mSourceMode(Graphics::ShaderSourceMode::TEXT),
     mRenderPassTag(renderPassTag),
-    mName(name)
+    mName(name),
+    mUseFileCache(useFileCache)
   {
     UpdateShaderVersion(mVertexShader, mVertexShaderVersion);
     UpdateShaderVersion(mFragmentShader, mFragmentShaderVersion);
@@ -103,16 +107,18 @@ public:
    * @param[in] fragmentSource Source code for fragment program
    * @param[in] hints          Hints for rendering
    * @param[in] renderPassTag  RenderPassTag to match shader data and render task.
-   * @param[in] name Shader name for debug.
+   * @param[in] name           Shader name for debug.
+   * @param[in] useFileCache   Whether to use file cache or not.
    */
-  ShaderData(std::vector<char>& vertexSource, std::vector<char>& fragmentSource, const Dali::Shader::Hint::Value hints, uint32_t renderPassTag, std::string_view name)
+  ShaderData(std::vector<char>& vertexSource, std::vector<char>& fragmentSource, const Dali::Shader::Hint::Value hints, uint32_t renderPassTag, std::string_view name, bool useFileCache)
   : mShaderHash(-1),
     mVertexShader(vertexSource),
     mFragmentShader(fragmentSource),
     mHints(hints),
     mSourceMode(Graphics::ShaderSourceMode::BINARY),
     mRenderPassTag(renderPassTag),
-    mName(name)
+    mName(name),
+    mUseFileCache(useFileCache)
   {
     UpdateShaderVersion(mVertexShader, mVertexShaderVersion);
     UpdateShaderVersion(mFragmentShader, mFragmentShaderVersion);
@@ -300,6 +306,14 @@ public: // API
     return mFragmentShaderVersion;
   }
 
+  /**
+   * Check whether to use file cache or not
+   */
+  bool IsUseFileCache() const
+  {
+    return mUseFileCache;
+  }
+
 private:                                        // Not implemented
   ShaderData(const ShaderData& other);          ///< no copying of this object
   ShaderData& operator=(const ShaderData& rhs); ///< no copying of this object
@@ -342,6 +356,7 @@ private:                                             // Data
   std::string                mName{""};              ///< Name for this shader
   uint32_t                   mVertexShaderVersion;   ///< Vertex shader version
   uint32_t                   mFragmentShaderVersion; ///< Fragment shader version
+  bool                       mUseFileCache;          ///< Whether to use file cache or not
 };
 
 } // namespace Internal

diff --git a/dali/internal/event/effects/shader-factory.cpp b/dali/internal/event/effects/shader-factory.cpp
index f3f54fd7ef86a26f16b4585d66d031b319abc3e8..ba2c55c77bfbd1f6d5fd4cf0af2899ea541603bb 100644 (file)
--- a/dali/internal/event/effects/shader-factory.cpp
+++ b/dali/internal/event/effects/shader-factory.cpp
@@ -80,7 +80,7 @@ ShaderFactory::~ShaderFactory()
   }
 }
 
-ShaderDataPtr ShaderFactory::Load(std::string_view vertexSource, std::string_view fragmentSource, const Dali::Shader::Hint::Value hints, uint32_t renderPassTag, std::string_view name, size_t& shaderHash)
+ShaderDataPtr ShaderFactory::Load(std::string_view vertexSource, std::string_view fragmentSource, const Dali::Shader::Hint::Value hints, uint32_t renderPassTag, std::string_view name, size_t& shaderHash, bool useFileCache)
 {
   // Work out the filename for the binary that the glsl source will be compiled and linked to:
   shaderHash = CalculateHash(vertexSource, fragmentSource);
@@ -136,7 +136,7 @@ ShaderDataPtr ShaderFactory::Load(std::string_view vertexSource, std::string_vie
     shaderBinaryFilename(shaderHash, binaryShaderFilename);
 
     // Allocate the structure that returns the loaded shader:
-    shaderData = new ShaderData(vertexSource, fragmentSource, hints, renderPassTag, name);
+    shaderData = new ShaderData(vertexSource, fragmentSource, hints, renderPassTag, name, useFileCache);
     shaderData->SetHashValue(shaderHash);
     shaderData->GetBuffer().Clear();
 

diff --git a/dali/internal/event/effects/shader-factory.h b/dali/internal/event/effects/shader-factory.h
index afadccd8fcb9cbb84a1253f9f904c91e326e9000..cb1d70acf528f943650e9ac8e5d42ad1957311b2 100644 (file)
--- a/dali/internal/event/effects/shader-factory.h
+++ b/dali/internal/event/effects/shader-factory.h
@@ -60,16 +60,17 @@ public:
    * If the cache hits or the load succeeds, the buffer member of the returned ShaderData will
    * contain a precompiled shader binary program which can be uploaded directly to GLES.
    *
-   * @param [in] vertexSource   The vertex shader source code
-   * @param [in] fragmentSource The fragment shader source code
-   * @param [in] renderPassTag  RenderPass the shaders are executed
-   * @param [in] name           The name of shaders are executed
-   * @param [out] shaderHash    Hash key created from vertex and fragment shader code
-   * @return                    ShaderData containing the source and hash value, and additionally,
-   *                            a compiled shader program binary if one could be found, else an
-   *                            empty binary buffer cleared to size zero.
+   * @param [in]  vertexSource     The vertex shader source code
+   * @param [in]  fragmentSource   The fragment shader source code
+   * @param [in]  renderPassTag    RenderPass the shaders are executed
+   * @param [in]  name             The name of shaders are executed
+   * @param [out] shaderHash       Hash key created from vertex and fragment shader code
+   * @param [in]  useFileCache     If true, it tries to load shader binary from file cache.
+   * @return                       ShaderData containing the source and hash value, and additionally,
+   *                               a compiled shader program binary if one could be found, else an
+   *                               empty binary buffer cleared to size zero.
    */
-  Internal::ShaderDataPtr Load(std::string_view vertexSource, std::string_view fragmentSource, const Dali::Shader::Hint::Value hints, uint32_t renderPassTag, std::string_view name, size_t& shaderHash);
+  Internal::ShaderDataPtr Load(std::string_view vertexSource, std::string_view fragmentSource, const Dali::Shader::Hint::Value hints, uint32_t renderPassTag, std::string_view name, size_t& shaderHash, bool useFileCache);
 
   /**
    * @brief Saves shader to memory cache and filesystem.

diff --git a/dali/internal/event/rendering/shader-impl.cpp b/dali/internal/event/rendering/shader-impl.cpp
index a6ff3c6bfa8b437594247f7b47c3fbd3134d63f8..a75333c30481b28ba80a2ad57af5d165c6258eec 100644 (file)
--- a/dali/internal/event/rendering/shader-impl.cpp
+++ b/dali/internal/event/rendering/shader-impl.cpp
@@ -141,7 +141,8 @@ ShaderPtr Shader::New(std::string_view                vertexShader,
                       std::string_view                fragmentShader,
                       Dali::Shader::Hint::Value       hints,
                       std::string_view                shaderName,
-                      std::vector<Dali::UniformBlock> uniformBlocks)
+                      std::vector<Dali::UniformBlock> uniformBlocks,
+                      bool                            isInternal)
 {
   // create scene object first so it's guaranteed to exist for the event side
   auto                             sceneObject = new SceneGraph::Shader();
@@ -154,7 +155,7 @@ ShaderPtr Shader::New(std::string_view                vertexShader,
   AddShaderMessage(updateManager, transferOwnership);
 
   services.RegisterObject(shader.Get());
-  shader->UpdateShaderData(vertexShader, fragmentShader, DEFAULT_RENDER_PASS_TAG, hints, shaderName);
+  shader->UpdateShaderData(vertexShader, fragmentShader, DEFAULT_RENDER_PASS_TAG, hints, shaderName, isInternal);
 
   // Connect UniformBlock without clean up cache
   for(auto&& uniformBlock : uniformBlocks)
@@ -260,13 +261,14 @@ void Shader::UpdateShaderData(std::string_view          vertexSource,
                               std::string_view          fragmentSource,
                               uint32_t                  renderPassTag,
                               Dali::Shader::Hint::Value hints,
-                              std::string_view          name)
+                              std::string_view          name,
+                              bool                      isInternal)
 {
   // Try to load a pre-compiled shader binary for the source pair:
   ThreadLocalStorage&     tls           = ThreadLocalStorage::Get();
   ShaderFactory&          shaderFactory = tls.GetShaderFactory();
   size_t                  shaderHash;
-  Internal::ShaderDataPtr shaderData = shaderFactory.Load(vertexSource, fragmentSource, hints, renderPassTag, name, shaderHash);
+  Internal::ShaderDataPtr shaderData = shaderFactory.Load(vertexSource, fragmentSource, hints, renderPassTag, name, shaderHash, isInternal);
 
   std::vector<Internal::ShaderDataPtr>::iterator shaderDataIterator = std::find_if(mShaderDataList.begin(), mShaderDataList.end(), [&shaderData](const Internal::ShaderDataPtr& shaderDataItem) { return shaderDataItem->GetRenderPassTag() == shaderData->GetRenderPassTag(); });
   if(shaderDataIterator != mShaderDataList.end())
@@ -296,7 +298,7 @@ void Shader::SetShaderProperty(const Dali::Property::Value& shaderMap)
       std::string               name(DEFAULT_SHADER_NAME);
       GetShaderData(*map, vertex, fragment, renderPassTag, hints, name);
 
-      UpdateShaderData(vertex, fragment, renderPassTag, hints, name);
+      UpdateShaderData(vertex, fragment, renderPassTag, hints, name, false);
     }
   }
   else if(shaderMap.GetType() == Property::ARRAY)
@@ -317,7 +319,7 @@ void Shader::SetShaderProperty(const Dali::Property::Value& shaderMap)
           std::string               name(DEFAULT_SHADER_NAME);
           GetShaderData(*map, vertex, fragment, renderPassTag, hints, name);
 
-          UpdateShaderData(vertex, fragment, renderPassTag, hints, name);
+          UpdateShaderData(vertex, fragment, renderPassTag, hints, name, false);
         }
       }
     }

diff --git a/dali/internal/event/rendering/shader-impl.h b/dali/internal/event/rendering/shader-impl.h
index 6ffc6f158428eaa090eb1830ea139fb3ccc8ecee..832178f7b349dd006206c10caa889ce8e2b73528 100644 (file)
--- a/dali/internal/event/rendering/shader-impl.h
+++ b/dali/internal/event/rendering/shader-impl.h
@@ -55,7 +55,8 @@ public:
                        std::string_view                fragmentShader,
                        Dali::Shader::Hint::Value       hints,
                        std::string_view                shaderName,
-                       std::vector<Dali::UniformBlock> uniformBlocks);
+                       std::vector<Dali::UniformBlock> uniformBlocks,
+                       bool                            isInternal = false);
 
   /**
    * @copydoc Dali::Shader::New()
@@ -101,8 +102,9 @@ private: // implementation
    * @param[in] renderPassTag render pass tag of this shader data
    * @param[in] hints Hints to define the geometry of the rendered object
    * @param[in] name The name of shader data.
+   * @param[in] isInternal Whether this shader is internal or not.
    */
-  void UpdateShaderData(std::string_view vertexShader, std::string_view fragmentShader, uint32_t renderPassTag, Dali::Shader::Hint::Value hints, std::string_view name);
+  void UpdateShaderData(std::string_view vertexShader, std::string_view fragmentShader, uint32_t renderPassTag, Dali::Shader::Hint::Value hints, std::string_view name, bool isInternal);
 
   /**
    * @brief Sets shader data from shaderMap.

diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp
index 445d10da6f5b9b56bc0f05d525fea3e98cc70bfa..ae6a91aa86387108bae06079307a1948c3b892b0 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.cpp
+++ b/dali/internal/render/renderers/render-renderer.cpp
@@ -492,6 +492,7 @@ Program* Renderer::PrepareProgram(const SceneGraph::RenderInstruction& instructi
     auto createInfo = Graphics::ProgramCreateInfo();
     createInfo.SetShaderState(shaderStates);
     createInfo.SetName(shaderData->GetName());
+    createInfo.SetFileCaching(shaderData->IsUseFileCache());
     auto graphicsProgram = mGraphicsController->CreateProgram(createInfo, nullptr);
     program->SetGraphicsProgram(std::move(graphicsProgram), *mUniformBufferManager, shader.GetConnectedUniformBlocks()); // generates reflection, defines memory reqs
 

diff --git a/dali/public-api/rendering/shader.cpp b/dali/public-api/rendering/shader.cpp
index 77890471cc195259740b83e4b2f7063a1825d11e..330b15e8bea09b1ed6b685885114c89b4a6825ed 100644 (file)
--- a/dali/public-api/rendering/shader.cpp
+++ b/dali/public-api/rendering/shader.cpp
@@ -26,9 +26,10 @@ namespace Dali
 Shader Shader::New(std::string_view vertexShader,
                    std::string_view fragmentShader,
                    Hint::Value      hints,
-                   std::string_view shaderName)
+                   std::string_view shaderName,
+                   bool             useFileCache)
 {
-  Internal::ShaderPtr shader = Internal::Shader::New(vertexShader, fragmentShader, hints, shaderName, {});
+  Internal::ShaderPtr shader = Internal::Shader::New(vertexShader, fragmentShader, hints, shaderName, {}, useFileCache);
   return Shader(shader.Get());
 }
 

diff --git a/dali/public-api/rendering/shader.h b/dali/public-api/rendering/shader.h
index ae9f34f012e45862cd76a25743f113d70d35c51b..d95f98a8eb2d7896cd1982a9e3a1a25b286a3631 100644 (file)
--- a/dali/public-api/rendering/shader.h
+++ b/dali/public-api/rendering/shader.h
@@ -125,12 +125,14 @@ public:
    * @param[in] fragmentShader Fragment Shader code for the effect.
    * @param[in] hints Hints to define the geometry of the rendered object
    * @param[in] shaderName The name of this shader. (optional)
+   * @param[in] useFileCache Whether to cache the shader or not. default is false
    * @return A handle to a shader effect
    */
   static Shader New(std::string_view vertexShader,
                     std::string_view fragmentShader,
                     Hint::Value      hints      = Hint::NONE,
-                    std::string_view shaderName = "");
+                    std::string_view shaderName = "",
+                    bool             useFileCache = false);
 
   /**
    * @brief Creates Shader.