X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Frender%2Frenderers%2Frender-renderer.cpp;h=eea391ae4ff3512b73f5a10a2459d007bce2df58;hb=eed5e433c8112100e59412045f725be7a40df940;hp=b7db6ac4452271f3779f4885db600a9e4ca751ac;hpb=374053c4981c5f3e47dd014f9ce3e1134f78cd17;p=platform%2Fcore%2Fuifw%2Fdali-core.git

diff --git a/dali/internal/render/renderers/render-renderer.cpp b/dali/internal/render/renderers/render-renderer.cpp
index b7db6ac..eea391a 100644
--- a/dali/internal/render/renderers/render-renderer.cpp
+++ b/dali/internal/render/renderers/render-renderer.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2019 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.
@@ -25,8 +25,7 @@
 #include <dali/internal/render/shaders/scene-graph-shader.h>
 #include <dali/internal/render/shaders/program.h>
 #include <dali/internal/render/data-providers/node-data-provider.h>
-#include <dali/internal/render/gl-resources/texture-cache.h>
-#include <dali/internal/render/gl-resources/gl-texture.h>
+#include <dali/internal/render/common/render-instruction.h>
 
 namespace Dali
 {
@@ -37,8 +36,6 @@ namespace Internal
 namespace
 {
 
-static Matrix gModelViewProjectionMatrix( false ); ///< a shared matrix to calculate the MVP matrix, dont want to store it in object to reduce storage overhead
-static Matrix3 gNormalMatrix; ///< a shared matrix to calculate normal matrix, dont want to store it in object to reduce storage overhead
 
 /**
  * Helper to set view and projection matrices once per program
@@ -88,17 +85,19 @@ inline void SetMatrices( Program& program,
   loc = program.GetUniformLocation( Program::UNIFORM_MVP_MATRIX );
   if( Program::UNIFORM_UNKNOWN != loc )
   {
-    Matrix::Multiply( gModelViewProjectionMatrix, modelViewMatrix, projectionMatrix );
-    program.SetUniformMatrix4fv( loc, 1, gModelViewProjectionMatrix.AsFloat() );
+    Matrix modelViewProjectionMatrix(false);
+    Matrix::Multiply( modelViewProjectionMatrix, modelViewMatrix, projectionMatrix );
+    program.SetUniformMatrix4fv( loc, 1, modelViewProjectionMatrix.AsFloat() );
   }
 
   loc = program.GetUniformLocation( Program::UNIFORM_NORMAL_MATRIX );
   if( Program::UNIFORM_UNKNOWN != loc )
   {
-    gNormalMatrix = modelViewMatrix;
-    gNormalMatrix.Invert();
-    gNormalMatrix.Transpose();
-    program.SetUniformMatrix3fv( loc, 1, gNormalMatrix.AsFloat() );
+    Matrix3 normalMatrix;
+    normalMatrix = modelViewMatrix;
+    normalMatrix.Invert();
+    normalMatrix.Transpose();
+    program.SetUniformMatrix3fv( loc, 1, normalMatrix.AsFloat() );
   }
 }
 
@@ -109,8 +108,8 @@ namespace Render
 
 Renderer* Renderer::New( SceneGraph::RenderDataProvider* dataProvider,
                          Render::Geometry* geometry,
-                         unsigned int blendingBitmask,
-                         const Vector4* blendColor,
+                         uint32_t blendingBitmask,
+                         const Vector4& blendColor,
                          FaceCullingMode::Type faceCullingMode,
                          bool preMultipliedAlphaEnabled,
                          DepthWriteMode::Type depthWriteMode,
@@ -125,8 +124,8 @@ Renderer* Renderer::New( SceneGraph::RenderDataProvider* dataProvider,
 
 Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider,
                     Render::Geometry* geometry,
-                    unsigned int blendingBitmask,
-                    const Vector4* blendColor,
+                    uint32_t blendingBitmask,
+                    const Vector4& blendColor,
                     FaceCullingMode::Type faceCullingMode,
                     bool preMultipliedAlphaEnabled,
                     DepthWriteMode::Type depthWriteMode,
@@ -135,7 +134,6 @@ Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider,
                     StencilParameters& stencilParameters )
 : mRenderDataProvider( dataProvider ),
   mContext( NULL),
-  mTextureCache( NULL ),
   mGeometry( geometry ),
   mUniformIndexMap(),
   mAttributesLocation(),
@@ -149,35 +147,25 @@ Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider,
   mDepthTestMode( depthTestMode ),
   mUpdateAttributesLocation( true ),
   mPremultipledAlphaEnabled( preMultipliedAlphaEnabled ),
-  mBatchingEnabled( false )
+  mShaderChanged( false )
 {
-  if(  blendingBitmask != 0u )
+  if( blendingBitmask != 0u )
   {
     mBlendingOptions.SetBitmask( blendingBitmask );
   }
 
-  if( blendColor )
-  {
-    mBlendingOptions.SetBlendColor( *blendColor );
-  }
+  mBlendingOptions.SetBlendColor( blendColor );
 }
 
-void Renderer::Initialize( Context& context, SceneGraph::TextureCache& textureCache )
+void Renderer::Initialize( Context& context )
 {
   mContext = &context;
-  mTextureCache = &textureCache;
 }
 
 Renderer::~Renderer()
 {
 }
 
-void Renderer::SetRenderDataProvider( SceneGraph::RenderDataProvider* dataProvider )
-{
-  mRenderDataProvider = dataProvider;
-  mUpdateAttributesLocation = true;
-}
-
 void Renderer::SetGeometry( Render::Geometry* geometry )
 {
   mGeometry = geometry;
@@ -229,27 +217,32 @@ void Renderer::SetUniforms( BufferIndex bufferIndex, const SceneGraph::NodeDataP
   const SceneGraph::UniformMapDataProvider& uniformMapDataProvider = mRenderDataProvider->GetUniformMap();
 
   if( uniformMapDataProvider.GetUniformMapChanged( bufferIndex ) ||
-      node.GetUniformMapChanged(bufferIndex))
+      node.GetUniformMapChanged(bufferIndex) ||
+      mUniformIndexMap.Count() == 0 ||
+      mShaderChanged )
   {
+    // Reset shader pointer
+    mShaderChanged = false;
+
     const SceneGraph::CollectedUniformMap& uniformMap = uniformMapDataProvider.GetUniformMap( bufferIndex );
     const SceneGraph::CollectedUniformMap& uniformMapNode = node.GetUniformMap( bufferIndex );
 
-    unsigned int maxMaps = uniformMap.Count() + uniformMapNode.Count();
+    uint32_t maxMaps = static_cast<uint32_t>( uniformMap.Count() + uniformMapNode.Count() ); // 4,294,967,295 maps should be enough
     mUniformIndexMap.Clear(); // Clear contents, but keep memory if we don't change size
     mUniformIndexMap.Resize( maxMaps );
 
-    unsigned int mapIndex(0);
+    uint32_t mapIndex = 0;
     for(; mapIndex < uniformMap.Count() ; ++mapIndex )
     {
       mUniformIndexMap[mapIndex].propertyValue = uniformMap[mapIndex]->propertyPtr;
       mUniformIndexMap[mapIndex].uniformIndex = program.RegisterUniform( uniformMap[mapIndex]->uniformName );
     }
 
-    for( unsigned int nodeMapIndex = 0; nodeMapIndex < uniformMapNode.Count() ; ++nodeMapIndex )
+    for( uint32_t nodeMapIndex = 0; nodeMapIndex < uniformMapNode.Count() ; ++nodeMapIndex )
     {
-      unsigned int uniformIndex = program.RegisterUniform( uniformMapNode[nodeMapIndex]->uniformName );
+      uint32_t uniformIndex = program.RegisterUniform( uniformMapNode[nodeMapIndex]->uniformName );
       bool found(false);
-      for( unsigned int i(0); i<uniformMap.Count(); ++i )
+      for( uint32_t i = 0; i<uniformMap.Count(); ++i )
       {
         if( mUniformIndexMap[i].uniformIndex == uniformIndex )
         {
@@ -355,57 +348,21 @@ void Renderer::SetUniformFromProperty( BufferIndex bufferIndex, Program& program
   }
 }
 
-bool Renderer::BindTextures( Context& context, SceneGraph::TextureCache& textureCache, Program& program )
+bool Renderer::BindTextures( Context& context, Program& program, Vector<GLuint>& boundTextures )
 {
-  unsigned int textureUnit = 0;
+  uint32_t textureUnit = 0;
   bool result = true;
 
-  std::vector<Render::Sampler*>& samplers( mRenderDataProvider->GetSamplers() );
-
-  std::vector<Render::Texture>& textures( mRenderDataProvider->GetTextures() );
   GLint uniformLocation(-1);
-  for( size_t i(0); result && i<textures.size(); ++i )
-  {
-    ResourceId textureId = textures[i].GetTextureId();
-    Internal::Texture* texture = textureCache.GetTexture( textureId );
-    if( texture )
-    {
-      result = textureCache.BindTexture( texture, textureId, GL_TEXTURE_2D, (TextureUnit)textureUnit );
-
-      if( result )
-      {
-        GLint uniformLocation;
-
-        //TODO : This is a bug, result variable is being shadowed. Fix it!
-        bool result = program.GetSamplerUniformLocation( i, uniformLocation );
-        if( result && Program::UNIFORM_UNKNOWN != uniformLocation )
-        {
-          program.SetUniform1i( uniformLocation, textureUnit );
-
-          unsigned int samplerBitfield(ImageSampler::DEFAULT_BITFIELD);
-          const Render::Sampler* sampler(  samplers[i] );
-          if( sampler )
-          {
-            samplerBitfield = sampler->mBitfield;
-          }
-
-          texture->ApplySampler( (TextureUnit)textureUnit, samplerBitfield );
-
-          ++textureUnit;
-        }
-      }
-    }
-  }
-
-  std::vector<Render::NewTexture*>& newTextures( mRenderDataProvider->GetNewTextures() );
-  for( size_t i(0); result && i<newTextures.size(); ++i )
+  std::vector<Render::Sampler*>& samplers( mRenderDataProvider->GetSamplers() );
+  std::vector<Render::Texture*>& textures( mRenderDataProvider->GetTextures() );
+  for( uint32_t i = 0; i < static_cast<uint32_t>( textures.size() ) && result; ++i ) // not expecting more than uint32_t of textures
   {
-    if( newTextures[i] )
+    if( textures[i] )
     {
-      result = program.GetSamplerUniformLocation( i, uniformLocation ) &&
-               newTextures[i]->Bind(context, textureUnit, samplers[i] );
-
-      if( result )
+      result = textures[i]->Bind(context, textureUnit, samplers[i] );
+      boundTextures.PushBack( textures[i]->GetId() );
+      if( result && program.GetSamplerUniformLocation( i, uniformLocation ) )
       {
         program.SetUniform1i( uniformLocation, textureUnit );
         ++textureUnit;
@@ -421,22 +378,22 @@ void Renderer::SetFaceCullingMode( FaceCullingMode::Type mode )
   mFaceCullingMode =  mode;
 }
 
-void Renderer::SetBlendingBitMask( unsigned int bitmask )
+void Renderer::SetBlendingBitMask( uint32_t bitmask )
 {
   mBlendingOptions.SetBitmask( bitmask );
 }
 
-void Renderer::SetBlendColor( const Vector4* color )
+void Renderer::SetBlendColor( const Vector4& color )
 {
-  mBlendingOptions.SetBlendColor( *color );
+  mBlendingOptions.SetBlendColor( color );
 }
 
-void Renderer::SetIndexedDrawFirstElement( size_t firstElement )
+void Renderer::SetIndexedDrawFirstElement( uint32_t firstElement )
 {
   mIndexedDrawFirstElement = firstElement;
 }
 
-void Renderer::SetIndexedDrawElementsCount( size_t elementsCount )
+void Renderer::SetIndexedDrawElementsCount( uint32_t elementsCount )
 {
   mIndexedDrawElementsCount = elementsCount;
 }
@@ -556,40 +513,59 @@ StencilOperation::Type Renderer::GetStencilOperationOnZPass() const
   return mStencilParameters.stencilOperationOnZPass;
 }
 
-void Renderer::SetBatchingEnabled( bool batchingEnabled )
+void Renderer::Upload( Context& context )
 {
-  mBatchingEnabled = batchingEnabled;
+  mGeometry->Upload( context );
 }
 
 void Renderer::Render( Context& context,
-                       SceneGraph::TextureCache& textureCache,
                        BufferIndex bufferIndex,
                        const SceneGraph::NodeDataProvider& node,
-                       SceneGraph::Shader& defaultShader,
                        const Matrix& modelMatrix,
                        const Matrix& modelViewMatrix,
                        const Matrix& viewMatrix,
                        const Matrix& projectionMatrix,
                        const Vector3& size,
-                       Render::Geometry* externalGeometry,
-                       bool blend )
+                       bool blend,
+                       Vector<GLuint>& boundTextures,
+                       const Dali::Internal::SceneGraph::RenderInstruction& instruction )
 {
   // Get the program to use:
   Program* program = mRenderDataProvider->GetShader().GetProgram();
   if( !program )
   {
-    // if program is NULL it means this is a custom shader with non matching geometry type so we need to use default shaders program
-    program = defaultShader.GetProgram();
-    DALI_ASSERT_DEBUG( program && "Default shader should always have a program available." );
-    if( !program )
-    {
-      DALI_LOG_ERROR( "Failed to get program for shader at address %p.\n", (void*)&mRenderDataProvider->GetShader() );
-      return;
-    }
+    DALI_LOG_ERROR( "Failed to get program for shader at address %p.\n", reinterpret_cast< void* >( &mRenderDataProvider->GetShader() ) );
+    return;
   }
 
   //Set cull face  mode
-  context.CullFace( mFaceCullingMode );
+  const Dali::Internal::SceneGraph::Camera* cam = instruction.GetCamera();
+  if (cam->GetReflectionUsed())
+  {
+    auto adjFaceCullingMode = mFaceCullingMode;
+    switch( mFaceCullingMode )
+    {
+      case FaceCullingMode::Type::FRONT:
+      {
+        adjFaceCullingMode = FaceCullingMode::Type::BACK;
+        break;
+      }
+      case FaceCullingMode::Type::BACK:
+      {
+        adjFaceCullingMode = FaceCullingMode::Type::FRONT;
+        break;
+      }
+      default:
+      {
+        // nothing to do, leave culling as it is
+      }
+    }
+    context.CullFace( adjFaceCullingMode );
+  }
+  else
+  {
+    context.CullFace( mFaceCullingMode );
+  }
 
   //Set blending mode
   SetBlending( context, blend );
@@ -597,7 +573,7 @@ void Renderer::Render( Context& context,
   // Take the program into use so we can send uniforms to it
   program->Use();
 
-  if( DALI_LIKELY( BindTextures( context, textureCache, *program ) ) )
+  if( DALI_LIKELY( BindTextures( context, *program, boundTextures ) ) )
   {
     // Only set up and draw if we have textures and they are all valid
 
@@ -611,43 +587,43 @@ void Renderer::Render( Context& context,
       const Vector4& color = node.GetRenderColor( bufferIndex );
       if( mPremultipledAlphaEnabled )
       {
-        program->SetUniform4f( loc, color.r*color.a, color.g*color.a, color.b*color.a, color.a );
+        float alpha = color.a * mRenderDataProvider->GetOpacity( bufferIndex );
+        program->SetUniform4f( loc, color.r * alpha, color.g * alpha, color.b * alpha, alpha );
       }
       else
       {
-        program->SetUniform4f( loc, color.r, color.g, color.b, color.a );
+        program->SetUniform4f( loc, color.r, color.g, color.b, color.a * mRenderDataProvider->GetOpacity( bufferIndex ) );
       }
     }
 
     SetUniforms( bufferIndex, node, size, *program );
-    Render::Geometry* geometry = externalGeometry ? externalGeometry : mGeometry;
 
-    if( mUpdateAttributesLocation || geometry->AttributesChanged() )
+    if( mUpdateAttributesLocation || mGeometry->AttributesChanged() )
     {
-      geometry->GetAttributeLocationFromProgram( mAttributesLocation, *program, bufferIndex );
+      mGeometry->GetAttributeLocationFromProgram( mAttributesLocation, *program, bufferIndex );
       mUpdateAttributesLocation = false;
     }
 
-    geometry->UploadAndDraw( context, bufferIndex, mAttributesLocation, mIndexedDrawFirstElement, mIndexedDrawElementsCount );
+    mGeometry->Draw( context,
+                     bufferIndex,
+                     mAttributesLocation,
+                     mIndexedDrawFirstElement,
+                     mIndexedDrawElementsCount );
   }
 }
 
-void Renderer::SetSortAttributes( BufferIndex bufferIndex, SceneGraph::RenderInstructionProcessor::SortAttributes& sortAttributes ) const
+void Renderer::SetSortAttributes( BufferIndex bufferIndex,
+                                  SceneGraph::RenderInstructionProcessor::SortAttributes& sortAttributes ) const
 {
   sortAttributes.shader = &( mRenderDataProvider->GetShader() );
-  const std::vector<Render::Texture>& textures( mRenderDataProvider->GetTextures() );
-  if( !textures.empty() )
-  {
-    sortAttributes.textureResourceId = textures[0].GetTextureId();
-  }
-  else
-  {
-    sortAttributes.textureResourceId = Integration::InvalidResourceId;
-  }
-
   sortAttributes.geometry = mGeometry;
 }
 
+void Renderer::SetShaderChanged( bool value )
+{
+  mShaderChanged = value;
+}
+
 } // namespace SceneGraph
 
 } // namespace Internal