Wrapped ShaderHints enum inside a struct

Change-Id: Ib1e23fcc942a7df8a83b86599c17c517b0c1df91

diff --git a/automated-tests/src/dali-internal/utc-Dali-Internal-FrustumCulling.cpp b/automated-tests/src/dali-internal/utc-Dali-Internal-FrustumCulling.cpp
index 31ef6c2..aa4f298 100644 (file)
--- a/automated-tests/src/dali-internal/utc-Dali-Internal-FrustumCulling.cpp
+++ b/automated-tests/src/dali-internal/utc-Dali-Internal-FrustumCulling.cpp
@@ -56,7 +56,7 @@ void main()
 }
 );
 
-Actor CreateMeshActorToStage( TestApplication& application, Vector3 parentOrigin = ParentOrigin::CENTER, Vector3 anchorPoint = AnchorPoint::CENTER, Shader::ShaderHints shaderHints = Shader::HINT_NONE )
+Actor CreateMeshActorToStage( TestApplication& application, Vector3 parentOrigin = ParentOrigin::CENTER, Vector3 anchorPoint = AnchorPoint::CENTER, Shader::Hint::Value shaderHints = Shader::Hint::NONE )
 {
   PixelBuffer* pixelBuffer = new PixelBuffer[ 4 ];
   BufferImage image = BufferImage::New( pixelBuffer, 1, 1 );
@@ -420,7 +420,7 @@ int UtcFrustumCullDisabledP(void)
   TraceCallStack& drawTrace = glAbstraction.GetDrawTrace();
   drawTrace.Enable( true );
 
-  CreateMeshActorToStage( application, Vector3( 7.0f, 0.5f, 0.5f ), AnchorPoint::CENTER, Shader::HINT_MODIFIES_GEOMETRY );
+  CreateMeshActorToStage( application, Vector3( 7.0f, 0.5f, 0.5f ), AnchorPoint::CENTER, Shader::Hint::MODIFIES_GEOMETRY );
 
   drawTrace.Reset();
   application.SendNotification();

diff --git a/automated-tests/src/dali/utc-Dali-Renderer.cpp b/automated-tests/src/dali/utc-Dali-Renderer.cpp
index 8bf5035..d07b473 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-Renderer.cpp
+++ b/automated-tests/src/dali/utc-Dali-Renderer.cpp
@@ -737,7 +737,7 @@ int UtcDaliRendererSetBlendMode06(void)
   tet_infoline("Test setting the blend mode to auto with an opaque color and an image without an alpha channel and a shader with the hint OUTPUT_IS_TRANSPARENT renders with blending enabled");
 
   Geometry geometry = CreateQuadGeometry();
-  Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::HINT_OUTPUT_IS_TRANSPARENT );
+  Shader shader = Shader::New( "vertexSrc", "fragmentSrc", Shader::Hint::OUTPUT_IS_TRANSPARENT );
 
   Renderer renderer = Renderer::New( geometry, shader );
 

diff --git a/automated-tests/src/dali/utc-Dali-Shader.cpp b/automated-tests/src/dali/utc-Dali-Shader.cpp
index 11403d2..77ada14 100644 (file)
--- a/automated-tests/src/dali/utc-Dali-Shader.cpp
+++ b/automated-tests/src/dali/utc-Dali-Shader.cpp
@@ -309,7 +309,7 @@ int UtcDaliShaderProgramProperty(void)
   tet_infoline("Test get/set progam property");
 
   Shader shader = Shader::New("", "");
-  std::string hintSet = "HINT_MODIFIES_GEOMETRY";
+  std::string hintSet = "MODIFIES_GEOMETRY";
 
   Property::Map map;
   map["vertex"] = VertexSource;
@@ -332,21 +332,21 @@ int UtcDaliShaderProgramProperty(void)
 
   std::string hintGot;
 
-  hintSet = "HINT_OUTPUT_IS_TRANSPARENT,HINT_MODIFIES_GEOMETRY";
+  hintSet = "OUTPUT_IS_TRANSPARENT,MODIFIES_GEOMETRY";
   map["hints"] = hintSet;
   shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
   value = shader.GetProperty(Shader::Property::PROGRAM);
   hintGot = (*value.GetMap())["hints"].Get<std::string>();
   DALI_TEST_CHECK( hintGot == hintSet );
 
-  hintSet = "HINT_OUTPUT_IS_TRANSPARENT";
+  hintSet = "OUTPUT_IS_TRANSPARENT";
   map["hints"] = hintSet;
   shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
   value = shader.GetProperty(Shader::Property::PROGRAM);
   hintGot = (*value.GetMap())["hints"].Get<std::string>();
   DALI_TEST_CHECK( hintGot == hintSet );
 
-  hintSet = "HINT_NONE";
+  hintSet = "NONE";
   map["hints"] = hintSet;
   shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
   value = shader.GetProperty(Shader::Property::PROGRAM);
@@ -358,7 +358,7 @@ int UtcDaliShaderProgramProperty(void)
   shader.SetProperty( Shader::Property::PROGRAM, Property::Value(map) );
   value = shader.GetProperty(Shader::Property::PROGRAM);
   hintGot = (*value.GetMap())["hints"].Get<std::string>();
-  DALI_TEST_CHECK( hintGot == "HINT_NONE" );
+  DALI_TEST_CHECK( hintGot == "NONE" );
 
   END_TEST;
 }

diff --git a/dali/internal/common/shader-data.h b/dali/internal/common/shader-data.h
index 7aafbf4..4b06816 100644 (file)
--- a/dali/internal/common/shader-data.h
+++ b/dali/internal/common/shader-data.h
@@ -48,7 +48,7 @@ public:
    * @param[in] vertexSource   Source code for vertex program
    * @param[in] fragmentSource Source code for fragment program
    */
-  ShaderData(const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::ShaderHints hints)
+  ShaderData(const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::Hint::Value hints)
   : mShaderHash( -1 ),
     mVertexShader(vertexSource),
     mFragmentShader(fragmentSource),
@@ -106,7 +106,7 @@ public: // API
   /**
    * @return the hints
    */
-  Dali::Shader::ShaderHints GetHints() const
+  Dali::Shader::Hint::Value GetHints() const
   {
     return mHints;
   }
@@ -166,7 +166,7 @@ private: // Data
   size_t                      mShaderHash;     ///< hash key created with vertex and fragment shader code
   std::string                 mVertexShader;   ///< source code for vertex program
   std::string                 mFragmentShader; ///< source code for fragment program
-  Dali::Shader::ShaderHints   mHints;    ///< take a hint
+  Dali::Shader::Hint::Value  mHints;          ///< take a hint
   Dali::Vector<unsigned char> mBuffer;         ///< buffer containing compiled binary bytecode
 };
 

diff --git a/dali/internal/event/actors/image-actor-impl.cpp b/dali/internal/event/actors/image-actor-impl.cpp
index e70f182..4bdff0e 100644 (file)
--- a/dali/internal/event/actors/image-actor-impl.cpp
+++ b/dali/internal/event/actors/image-actor-impl.cpp
@@ -178,7 +178,7 @@ ImageActorPtr ImageActor::New()
   GeometryPtr quad  = CreateGeometry( 1u, 1u, Vector2::ONE );
   actor->mRenderer->SetGeometry( *quad );
 
-  ShaderPtr shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER, Dali::Shader::HINT_NONE );
+  ShaderPtr shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER, Dali::Shader::Hint::NONE );
   actor->mRenderer->SetShader( *shader );
   TextureSetPtr textureSet = TextureSet::New();
   actor->mRenderer->SetTextures( *textureSet );
@@ -703,7 +703,7 @@ void ImageActor::RemoveShaderEffect()
   {
     mShaderEffect->Disconnect( this );
     // change to the standard shader and quad geometry
-    ShaderPtr shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER, Dali::Shader::HINT_NONE );
+    ShaderPtr shader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER, Dali::Shader::Hint::NONE );
     mRenderer->SetShader( *shader );
     mShaderEffect.Reset();
 

diff --git a/dali/internal/event/effects/shader-effect-impl.cpp b/dali/internal/event/effects/shader-effect-impl.cpp
index 0a6ae7d..e88ce9c 100644 (file)
--- a/dali/internal/event/effects/shader-effect-impl.cpp
+++ b/dali/internal/event/effects/shader-effect-impl.cpp
@@ -137,20 +137,20 @@ std::string GetStringProperty(const std::string& field, const Property::Value& p
   return retval;
 }
 
-Dali::Shader::ShaderHints ConvertHints( Dali::ShaderEffect::GeometryHints hints)
+Dali::Shader::Hint::Value ConvertHints( Dali::ShaderEffect::GeometryHints hints)
 {
-  int convertedHints = Dali::Shader::HINT_NONE;
+  int convertedHints = Dali::Shader::Hint::NONE;
 
   if( hints & Dali::ShaderEffect::HINT_BLENDING )
   {
-    convertedHints |= Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT;
+    convertedHints |= Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT;
   }
   if( !(hints & Dali::ShaderEffect::HINT_DOESNT_MODIFY_GEOMETRY) )
   {
-    convertedHints |= Dali::Shader::HINT_MODIFIES_GEOMETRY;
+    convertedHints |= Dali::Shader::Hint::MODIFIES_GEOMETRY;
   }
 
-  return Dali::Shader::ShaderHints( convertedHints );
+  return Dali::Shader::Hint::Value( convertedHints );
 }
 
 } // unnamed namespace

diff --git a/dali/internal/event/effects/shader-factory.cpp b/dali/internal/event/effects/shader-factory.cpp
index 37e9f00..3fbb14d 100644 (file)
--- a/dali/internal/event/effects/shader-factory.cpp
+++ b/dali/internal/event/effects/shader-factory.cpp
@@ -81,7 +81,7 @@ ShaderFactory::~ShaderFactory()
   }
 }
 
-ShaderDataPtr ShaderFactory::Load( const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::ShaderHints hints, size_t& shaderHash )
+ShaderDataPtr ShaderFactory::Load( const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::Hint::Value hints, size_t& shaderHash )
 {
   // Work out the filename for the binary that the glsl source will be compiled and linked to:
   shaderHash = CalculateHash( vertexSource.c_str(), fragmentSource.c_str() );

diff --git a/dali/internal/event/effects/shader-factory.h b/dali/internal/event/effects/shader-factory.h
index 12fd77e..9fdf663 100644 (file)
--- a/dali/internal/event/effects/shader-factory.h
+++ b/dali/internal/event/effects/shader-factory.h
@@ -68,7 +68,7 @@ public:
    *                            a compiled shader program binary if one could be found, else an
    *                            empty binary buffer cleared to size zero.
    */
-  Internal::ShaderDataPtr Load( const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::ShaderHints hints, size_t& shaderHash );
+  Internal::ShaderDataPtr Load( const std::string& vertexSource, const std::string& fragmentSource, const Dali::Shader::Hint::Value hints, size_t& shaderHash );
 
   /**
    * @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 e44a983..2eb7cf6 100644 (file)
--- a/dali/internal/event/rendering/shader-impl.cpp
+++ b/dali/internal/event/rendering/shader-impl.cpp
@@ -47,9 +47,9 @@ DALI_PROPERTY_TABLE_END( DEFAULT_ACTOR_PROPERTY_START_INDEX )
 const ObjectImplHelper<DEFAULT_PROPERTY_COUNT> SHADER_IMPL = { DEFAULT_PROPERTY_DETAILS };
 
 Dali::Scripting::StringEnum ShaderHintsTable[] =
-  { { "HINT_NONE",                     Dali::Shader::HINT_NONE},
-    { "HINT_OUTPUT_IS_TRANSPARENT",    Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT},
-    { "HINT_MODIFIES_GEOMETRY",        Dali::Shader::HINT_MODIFIES_GEOMETRY}
+  { { "NONE",                     Dali::Shader::Hint::NONE},
+    { "OUTPUT_IS_TRANSPARENT",    Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT},
+    { "MODIFIES_GEOMETRY",        Dali::Shader::Hint::MODIFIES_GEOMETRY}
   };
 
 const unsigned int ShaderHintsTableSize = sizeof( ShaderHintsTable ) / sizeof( ShaderHintsTable[0] );
@@ -72,23 +72,23 @@ void AppendString(std::string& to, const std::string& append)
   to += append;
 }
 
-Property::Value HintString(const Dali::Shader::ShaderHints& hints)
+Property::Value HintString(const Dali::Shader::Hint::Value& hints)
 {
   std::string s;
 
-  if(hints == Dali::Shader::HINT_NONE)
+  if(hints == Dali::Shader::Hint::NONE)
   {
-    s = "HINT_NONE";
+    s = "NONE";
   }
 
-  if(hints & Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT)
+  if(hints & Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT)
   {
-    AppendString(s, "HINT_OUTPUT_IS_TRANSPARENT");
+    AppendString(s, "OUTPUT_IS_TRANSPARENT");
   }
 
-  if(hints & Dali::Shader::HINT_MODIFIES_GEOMETRY)
+  if(hints & Dali::Shader::Hint::MODIFIES_GEOMETRY)
   {
-    AppendString(s, "HINT_MODIFIES_GEOMETRY");
+    AppendString(s, "MODIFIES_GEOMETRY");
   }
 
   return Property::Value(s);
@@ -99,7 +99,7 @@ Property::Value HintString(const Dali::Shader::ShaderHints& hints)
 
 ShaderPtr Shader::New( const std::string& vertexShader,
                        const std::string& fragmentShader,
-                       Dali::Shader::ShaderHints hints )
+                       Dali::Shader::Hint::Value hints )
 {
   ShaderPtr shader( new Shader() );
   shader->Initialize( vertexShader, fragmentShader, hints );
@@ -170,7 +170,7 @@ void Shader::SetDefaultProperty( Property::Index index,
         {
           std::string vertex;
           std::string fragment;
-          Dali::Shader::ShaderHints hints(Dali::Shader::HINT_NONE);
+          Dali::Shader::Hint::Value hints(Dali::Shader::Hint::NONE);
 
           if( Property::Value* value = map->Find("vertex") )
           {
@@ -185,7 +185,7 @@ void Shader::SetDefaultProperty( Property::Index index,
           if( Property::Value* value = map->Find("hints") )
           {
             static_cast<void>( // ignore return
-              Scripting::GetEnumeration< Dali::Shader::ShaderHints >(value->Get<std::string>().c_str(),
+              Scripting::GetEnumeration< Dali::Shader::Hint::Value >(value->Get<std::string>().c_str(),
                                                                      ShaderHintsTable, ShaderHintsTableSize, hints)
               );
           }
@@ -292,7 +292,7 @@ Shader::Shader()
 void Shader::Initialize(
   const std::string& vertexSource,
   const std::string& fragmentSource,
-  Dali::Shader::ShaderHints hints )
+  Dali::Shader::Hint::Value hints )
 {
   EventThreadServices& eventThreadServices = GetEventThreadServices();
   SceneGraph::UpdateManager& updateManager = eventThreadServices.GetUpdateManager();
@@ -308,7 +308,7 @@ void Shader::Initialize(
   mShaderData = shaderFactory.Load( vertexSource, fragmentSource, hints, shaderHash );
 
   // Add shader program to scene-object using a message to the UpdateManager
-  SetShaderProgramMessage( updateManager, *mSceneObject, mShaderData, (hints & Dali::Shader::HINT_MODIFIES_GEOMETRY) != 0x0 );
+  SetShaderProgramMessage( updateManager, *mSceneObject, mShaderData, (hints & Dali::Shader::Hint::MODIFIES_GEOMETRY) != 0x0 );
   eventThreadServices.RegisterObject( this );
 }
 

diff --git a/dali/internal/event/rendering/shader-impl.h b/dali/internal/event/rendering/shader-impl.h
index 48cef47..083633f 100644 (file)
--- a/dali/internal/event/rendering/shader-impl.h
+++ b/dali/internal/event/rendering/shader-impl.h
@@ -52,7 +52,7 @@ public:
    */
   static ShaderPtr New( const std::string& vertexShader,
                         const std::string& fragmentShader,
-                        Dali::Shader::ShaderHints hints );
+                        Dali::Shader::Hint::Value hints );
 
   /**
    * @brief Get the shader scene object
@@ -155,7 +155,7 @@ private: // implementation
   /**
    * Second stage initialization
    */
-  void Initialize( const std::string& vertexShader, const std::string& fragmentShader, Dali::Shader::ShaderHints hints );
+  void Initialize( const std::string& vertexShader, const std::string& fragmentShader, Dali::Shader::Hint::Value hints );
 
 protected:
   /**

diff --git a/dali/internal/render/shaders/scene-graph-shader.cpp b/dali/internal/render/shaders/scene-graph-shader.cpp
index 3966d15..d8f1e86 100644 (file)
--- a/dali/internal/render/shaders/scene-graph-shader.cpp
+++ b/dali/internal/render/shaders/scene-graph-shader.cpp
@@ -35,7 +35,7 @@ namespace Internal
 namespace SceneGraph
 {
 
-Shader::Shader( Dali::Shader::ShaderHints& hints )
+Shader::Shader( Dali::Shader::Hint::Value& hints )
 : mHints( hints ),
   mProgram( NULL ),
   mConnectionObservers()

diff --git a/dali/internal/render/shaders/scene-graph-shader.h b/dali/internal/render/shaders/scene-graph-shader.h
index 278d5f2..148f412 100644 (file)
--- a/dali/internal/render/shaders/scene-graph-shader.h
+++ b/dali/internal/render/shaders/scene-graph-shader.h
@@ -49,7 +49,7 @@ public:
    * Constructor
    * @param hints Shader hints
    */
-  Shader( Dali::Shader::ShaderHints& hints );
+  Shader( Dali::Shader::Hint::Value& hints );
 
   /**
    * Virtual destructor
@@ -66,7 +66,7 @@ public:
    * @param[in] hint The hint to check.
    * @return True if the given hint is set.
    */
-  bool HintEnabled( Dali::Shader::ShaderHints hint ) const
+  bool HintEnabled( Dali::Shader::Hint::Value hint ) const
   {
     return mHints & hint;
   }
@@ -155,7 +155,7 @@ public: // UniformMap::Observer
 
 private: // Data
 
-  Dali::Shader::ShaderHints     mHints;
+  Dali::Shader::Hint::Value     mHints;
 
   Program*                       mProgram;
 

diff --git a/dali/internal/update/manager/prepare-render-instructions.cpp b/dali/internal/update/manager/prepare-render-instructions.cpp
index 76603b9..41616a1 100644 (file)
--- a/dali/internal/update/manager/prepare-render-instructions.cpp
+++ b/dali/internal/update/manager/prepare-render-instructions.cpp
@@ -70,7 +70,7 @@ inline void AddRendererToRenderList( BufferIndex updateBufferIndex,
                                      bool cull )
 {
   bool inside( true );
-  if ( cull && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::HINT_MODIFIES_GEOMETRY ) )
+  if ( cull && !renderable.mRenderer->GetShader().HintEnabled( Dali::Shader::Hint::MODIFIES_GEOMETRY ) )
   {
     const Vector4& boundingSphere = renderable.mNode->GetBoundingSphere();
     inside = (boundingSphere.w > Math::MACHINE_EPSILON_1000) &&

diff --git a/dali/internal/update/rendering/scene-graph-renderer.cpp b/dali/internal/update/rendering/scene-graph-renderer.cpp
index 2fd1cfb..17b402f 100644 (file)
--- a/dali/internal/update/rendering/scene-graph-renderer.cpp
+++ b/dali/internal/update/rendering/scene-graph-renderer.cpp
@@ -635,7 +635,7 @@ Renderer::Opacity Renderer::GetOpacity( BufferIndex updateBufferIndex, const Nod
     }
     case BlendMode::AUTO:
     {
-      bool shaderRequiresBlending( mShader->HintEnabled( Dali::Shader::HINT_OUTPUT_IS_TRANSPARENT ) );
+      bool shaderRequiresBlending( mShader->HintEnabled( Dali::Shader::Hint::OUTPUT_IS_TRANSPARENT ) );
       if( shaderRequiresBlending || ( mTextureSet && mTextureSet->HasAlpha() ) )
       {
         opacity = Renderer::TRANSLUCENT;

diff --git a/dali/public-api/render-tasks/render-task.h b/dali/public-api/render-tasks/render-task.h
index 68f241c..959c38d 100644 (file)
--- a/dali/public-api/render-tasks/render-task.h
+++ b/dali/public-api/render-tasks/render-task.h
@@ -438,8 +438,8 @@ public:
    * @SINCE_1_0.0
    * @param[in] cullMode True if the renderers should be culled.
    * @note The default mode is to cull actors.
-   * @note If the shader uses @ref Shader::HINT_MODIFIES_GEOMETRY then culling optimizations are disabled.
-   * @see Shader::ShaderHints
+   * @note If the shader uses @ref Shader::Hint::MODIFIES_GEOMETRY then culling optimizations are disabled.
+   * @see Shader::Hint
    */
   void SetCullMode( bool cullMode );
 

diff --git a/dali/public-api/rendering/shader.cpp b/dali/public-api/rendering/shader.cpp
index 98f3146..4a1751d 100644 (file)
--- a/dali/public-api/rendering/shader.cpp
+++ b/dali/public-api/rendering/shader.cpp
@@ -26,7 +26,7 @@ namespace Dali
 
 Shader Shader::New( const std::string& vertexShader,
                     const std::string& fragmentShader,
-                    ShaderHints hints )
+                    Hint::Value hints )
 {
   Internal::ShaderPtr renderer = Internal::Shader::New( vertexShader, fragmentShader, hints );
   return Shader( renderer.Get() );

diff --git a/dali/public-api/rendering/shader.h b/dali/public-api/rendering/shader.h
index 468b88d..a85bece 100644 (file)
--- a/dali/public-api/rendering/shader.h
+++ b/dali/public-api/rendering/shader.h
@@ -73,14 +73,17 @@ class DALI_IMPORT_API Shader : public Handle
 public:
 
   /**
-   * @brief Hints for rendering/subdividing geometry.
-   * @SINCE_1_1.43
+   * @brief Hints for rendering.
+   * @SINCE_1_1.45
    */
-  enum ShaderHints
+  struct Hint
   {
-    HINT_NONE                     = 0x00, ///< No hints                                                                          @SINCE_1_1.43
-    HINT_OUTPUT_IS_TRANSPARENT    = 0x01, ///< Might generate transparent alpha from opaque inputs                               @SINCE_1_1.43
-    HINT_MODIFIES_GEOMETRY        = 0x02, ///< Might change position of vertices, this option disables any culling optimizations @SINCE_1_1.43
+    enum Value
+    {
+      NONE                     = 0x00, ///< No hints                                                                          @SINCE_1_1.43
+      OUTPUT_IS_TRANSPARENT    = 0x01, ///< Might generate transparent alpha from opaque inputs                               @SINCE_1_1.43
+      MODIFIES_GEOMETRY        = 0x02, ///< Might change position of vertices, this option disables any culling optimizations @SINCE_1_1.43
+    };
   };
 
   /**
@@ -112,7 +115,7 @@ public:
    */
   static Shader New( const std::string& vertexShader,
                      const std::string& fragmentShader,
-                     ShaderHints hints = ShaderHints( HINT_NONE ) );
+                     Hint::Value hints = Hint::NONE );
 
   /**
    * @brief Default constructor, creates an empty handle