Merge "Move shader program creation from update side to render side" into devel/master

diff --git a/dali/internal/event/rendering/shader-impl.cpp b/dali/internal/event/rendering/shader-impl.cpp
index c8b399a..ecf2894 100644 (file)
--- a/dali/internal/event/rendering/shader-impl.cpp
+++ b/dali/internal/event/rendering/shader-impl.cpp
@@ -203,10 +203,8 @@ void Shader::SetShader(std::string_view          vertexSource,
   size_t              shaderHash;
   mShaderData = shaderFactory.Load(vertexSource, fragmentSource, hints, shaderHash);
 
-  // Add shader program to scene-object using a message to the UpdateManager
-  EventThreadServices&       eventThreadServices = GetEventThreadServices();
-  SceneGraph::UpdateManager& updateManager       = eventThreadServices.GetUpdateManager();
-  SetShaderProgramMessage(updateManager, GetShaderSceneObject(), mShaderData, (hints & Dali::Shader::Hint::MODIFIES_GEOMETRY) != 0x0);
+  // Add shader data to scene-object
+  SceneGraph::SetShaderDataMessage(GetEventThreadServices(), GetShaderSceneObject(), mShaderData);
 }
 
 Shader::~Shader()

diff --git a/dali/internal/render/common/render-manager.cpp b/dali/internal/render/common/render-manager.cpp
index 32b6c81..ab3548d 100644 (file)
--- a/dali/internal/render/common/render-manager.cpp
+++ b/dali/internal/render/common/render-manager.cpp
@@ -247,7 +247,7 @@ void RenderManager::SetShaderSaver(ShaderSaver& upstream)
 void RenderManager::AddRenderer(OwnerPointer<Render::Renderer>& renderer)
 {
   // Initialize the renderer as we are now in render thread
-  renderer->Initialize(mImpl->context);
+  renderer->Initialize(mImpl->context, mImpl->programController);
 
   mImpl->rendererContainer.PushBack(renderer.Release());
 }
@@ -335,6 +335,7 @@ void RenderManager::RemoveFrameBuffer(Render::FrameBuffer* frameBuffer)
     }
   }
 }
+
 void RenderManager::InitializeScene(SceneGraph::Scene* scene)
 {
   scene->Initialize(*mImpl->CreateSceneContext());

diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp
index cea62ab..1ffc12f 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.cpp
+++ b/dali/internal/render/renderers/render-renderer.cpp
@@ -130,6 +130,7 @@ Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider,
 : mRenderDataProvider(dataProvider),
   mContext(nullptr),
   mGeometry(geometry),
+  mProgramCache(nullptr),
   mUniformIndexMap(),
   mAttributesLocation(),
   mUniformsHash(),
@@ -154,9 +155,10 @@ Renderer::Renderer(SceneGraph::RenderDataProvider* dataProvider,
   mBlendingOptions.SetBlendColor(blendColor);
 }
 
-void Renderer::Initialize(Context& context)
+void Renderer::Initialize(Context& context, ProgramCache& programCache)
 {
-  mContext = &context;
+  mContext      = &context;
+  mProgramCache = &programCache;
 }
 
 Renderer::~Renderer() = default;
@@ -585,8 +587,11 @@ void Renderer::Render(Context&                                             conte
     return;
   }
 
-  // Get the program to use:
-  Program* program = mRenderDataProvider->GetShader().GetProgram();
+  // Get the program to use
+  // The program cache owns the Program object so we don't need to worry about this raw allocation here.
+  ShaderDataPtr shaderData = mRenderDataProvider->GetShader().GetShaderData();
+  Program*      program    = Program::New(*mProgramCache, shaderData, (shaderData->GetHints() & Dali::Shader::Hint::MODIFIES_GEOMETRY) != 0x0);
+
   if(!program)
   {
     DALI_LOG_ERROR("Failed to get program for shader at address %p.\n", reinterpret_cast<void*>(&mRenderDataProvider->GetShader()));

diff --git a/dali/internal/render/renderers/render-renderer.h b/dali/internal/render/renderers/render-renderer.h
index d6668a1..b62bd78 100644 (file)
--- a/dali/internal/render/renderers/render-renderer.h
+++ b/dali/internal/render/renderers/render-renderer.h
@@ -39,6 +39,7 @@ namespace Internal
 class Context;
 class Texture;
 class Program;
+class ProgramCache;
 
 namespace SceneGraph
 {
@@ -165,8 +166,9 @@ public:
    * Second-phase construction.
    * This is called when the renderer is inside render thread
    * @param[in] context Context used by the renderer
+   * @param[in] programCache Cache of program objects
    */
-  void Initialize(Context& context);
+  void Initialize(Context& context, ProgramCache& programCache);
 
   /**
    * Destructor
@@ -446,6 +448,8 @@ private:
   Context*          mContext;
   Render::Geometry* mGeometry;
 
+  ProgramCache* mProgramCache;
+
   struct UniformIndexMap
   {
     uint32_t                 uniformIndex; ///< The index of the cached location in the Program

diff --git a/dali/internal/render/shaders/scene-graph-shader.cpp b/dali/internal/render/shaders/scene-graph-shader.cpp
index e6eb761..c3a35da 100644 (file)
--- a/dali/internal/render/shaders/scene-graph-shader.cpp
+++ b/dali/internal/render/shaders/scene-graph-shader.cpp
@@ -33,7 +33,6 @@ namespace SceneGraph
 {
 Shader::Shader(Dali::Shader::Hint::Value& hints)
 : mHints(hints),
-  mProgram(nullptr),
   mConnectionObservers()
 {
   AddUniformMapObserver(*this);
@@ -44,24 +43,18 @@ Shader::~Shader()
   mConnectionObservers.Destroy(*this);
 }
 
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-// The following methods are called during RenderManager::Render()
-////////////////////////////////////////////////////////////////////////////////////////////////////////////////
-void Shader::SetProgram(Internal::ShaderDataPtr shaderData,
-                        ProgramCache*           programCache,
-                        bool                    modifiesGeometry)
+void Shader::SetShaderData(ShaderDataPtr shaderData)
 {
   DALI_LOG_TRACE_METHOD_FMT(Debug::Filter::gShader, "%d\n", shaderData->GetHashValue());
 
-  mProgram = Program::New(*programCache, shaderData, modifiesGeometry);
-  // The program cache owns the Program object so we don't need to worry about this raw allocation here.
+  mShaderData = shaderData;
 
   mConnectionObservers.ConnectionsChanged(*this);
 }
 
-Program* Shader::GetProgram()
+ShaderDataPtr Shader::GetShaderData() const
 {
-  return mProgram;
+  return mShaderData;
 }
 
 void Shader::AddConnectionObserver(ConnectionChangePropagator::Observer& observer)

diff --git a/dali/internal/render/shaders/scene-graph-shader.h b/dali/internal/render/shaders/scene-graph-shader.h
index 4b6bda6..6e25894 100644 (file)
--- a/dali/internal/render/shaders/scene-graph-shader.h
+++ b/dali/internal/render/shaders/scene-graph-shader.h
@@ -20,6 +20,7 @@
 
 // INTERNAL INCLUDES
 #include <dali/internal/common/shader-data.h>
+#include <dali/internal/event/common/event-thread-services.h>
 #include <dali/internal/update/common/property-owner.h>
 #include <dali/internal/update/common/scene-graph-connection-change-propagator.h>
 
@@ -95,21 +96,16 @@ public:
   ////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
   /**
-   * @brief Set the program for this shader.
-   * @param[in] shaderData        The program's vertex/fragment source and optionally precompiled shader binary.
-   * @param[in] programCache      Owner of the Programs.
-   * @param[in] modifiesGeometry  True if the vertex shader changes the positions of vertexes such that
-   * they might exceed the bounding box of vertexes passing through the default transformation.
+   * @brief Set the shader data for this shader.
+   * @param[in] shaderData The program's vertex/fragment source and optionally pre-compiled shader binary.
    */
-  void SetProgram(Internal::ShaderDataPtr shaderData,
-                  ProgramCache*           programCache,
-                  bool                    modifiesGeometry);
+  void SetShaderData(ShaderDataPtr shaderData);
 
   /**
-   * Get the program built for this shader
-   * @return The program built from the shader sources.
+   * Get the shader data for this shader.
+   * @return The shader data.
    */
-  Program* GetProgram();
+  ShaderDataPtr GetShaderData() const;
 
 public: // Implementation of ConnectionChangePropagator
   /**
@@ -131,11 +127,22 @@ public: // UniformMap::Observer
 private: // Data
   Dali::Shader::Hint::Value mHints;
 
-  Program* mProgram;
+  ShaderDataPtr mShaderData;
 
   ConnectionChangePropagator mConnectionObservers;
 };
 
+inline void SetShaderDataMessage(EventThreadServices& eventThreadServices, const Shader& shader, ShaderDataPtr shaderData)
+{
+  using LocalType = MessageValue1<Shader, ShaderDataPtr>;
+
+  // Reserve some memory inside the message queue
+  uint32_t* slot = eventThreadServices.ReserveMessageSlot(sizeof(LocalType));
+
+  // Construct message in the message queue memory; note that delete should not be called on the return value
+  new(slot) LocalType(&shader, &Shader::SetShaderData, shaderData);
+}
+
 } // namespace SceneGraph
 
 } // namespace Internal

diff --git a/dali/internal/update/manager/update-manager.cpp b/dali/internal/update/manager/update-manager.cpp
index fa8d9cd..b082a9c 100644 (file)
--- a/dali/internal/update/manager/update-manager.cpp
+++ b/dali/internal/update/manager/update-manager.cpp
@@ -582,22 +582,6 @@ void UpdateManager::RemoveShader(Shader* shader)
   EraseUsingDiscardQueue(mImpl->shaders, shader, mImpl->discardQueue, mSceneGraphBuffers.GetUpdateBufferIndex());
 }
 
-void UpdateManager::SetShaderProgram(Shader*                 shader,
-                                     Internal::ShaderDataPtr shaderData,
-                                     bool                    modifiesGeometry)
-{
-  if(shaderData)
-  {
-    using DerivedType = MessageValue3<Shader, Internal::ShaderDataPtr, ProgramCache*, bool>;
-
-    // Reserve some memory inside the render queue
-    uint32_t* slot = mImpl->renderQueue.ReserveMessageSlot(mSceneGraphBuffers.GetUpdateBufferIndex(), sizeof(DerivedType));
-
-    // Construct message in the render queue memory; note that delete should not be called on the return value
-    new(slot) DerivedType(shader, &Shader::SetProgram, shaderData, mImpl->renderManager.GetProgramCache(), modifiesGeometry);
-  }
-}
-
 void UpdateManager::SaveBinary(Internal::ShaderDataPtr shaderData)
 {
   DALI_ASSERT_DEBUG(shaderData && "No NULL shader data pointers please.");

diff --git a/dali/internal/update/manager/update-manager.h b/dali/internal/update/manager/update-manager.h
index a63cf22..29d0e0f 100644 (file)
--- a/dali/internal/update/manager/update-manager.h
+++ b/dali/internal/update/manager/update-manager.h
@@ -300,12 +300,11 @@ public:
   void RemoveShader(Shader* shader);
 
   /**
-   * Set the shader program for a Shader object
+   * Set the shader data for a Shader object
    * @param[in] shader        The shader to modify
    * @param[in] shaderData    Source code, hash over source, and optional compiled binary for the shader program
-   * @param[in] modifiesGeometry True if the vertex shader modifies geometry
    */
-  void SetShaderProgram(Shader* shader, Internal::ShaderDataPtr shaderData, bool modifiesGeometry);
+  void SetShaderData(Shader* shader, Internal::ShaderDataPtr shaderData);
 
   /**
    * @brief Accept compiled shaders passed back on render thread for saving.
@@ -1016,20 +1015,6 @@ inline void RemoveShaderMessage(UpdateManager& manager, const Shader* shader)
   new(slot) LocalType(&manager, &UpdateManager::RemoveShader, const_cast<Shader*>(shader));
 }
 
-inline void SetShaderProgramMessage(UpdateManager&          manager,
-                                    const Shader&           shader,
-                                    Internal::ShaderDataPtr shaderData,
-                                    bool                    modifiesGeometry)
-{
-  using LocalType = MessageValue3<UpdateManager, Shader*, Internal::ShaderDataPtr, bool>;
-
-  // Reserve some memory inside the message queue
-  uint32_t* slot = manager.ReserveMessageSlot(sizeof(LocalType));
-
-  // Construct message in the message queue memory; note that delete should not be called on the return value
-  new(slot) LocalType(&manager, &UpdateManager::SetShaderProgram, const_cast<Shader*>(&shader), shaderData, modifiesGeometry);
-}
-
 inline void SurfaceReplacedMessage(UpdateManager& manager, const SceneGraph::Scene& constScene)
 {
   // The scene-graph thread owns this object so it can safely edit it.