X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Frender%2Frenderers%2Frender-renderer.cpp;h=9324d86c3bb083e5b1f8003d52190a3d410b72cb;hb=baef81c81217e013c1cc253ac636f154c7e61370;hp=01c03e391ed916570c567c788574e870ae490e42;hpb=22bbf88067ca1c914055b2aa91f469760f12502f;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 01c03e3..9324d86 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,10 +25,6 @@
 #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/data-providers/uniform-name-cache.h>
-#include <dali/internal/render/gl-resources/texture-cache.h>
-#include <dali/public-api/actors/blending.h>
-#include <dali/internal/render/gl-resources/gl-texture.h>
 
 namespace Dali
 {
@@ -111,36 +107,32 @@ 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,
                          DepthTestMode::Type depthTestMode,
                          DepthFunction::Type depthFunction,
-                         StencilParameters& stencilParameters,
-                         bool writeToColorBuffer )
+                         StencilParameters& stencilParameters )
 {
   return new Renderer( dataProvider, geometry, blendingBitmask, blendColor,
                        faceCullingMode, preMultipliedAlphaEnabled, depthWriteMode, depthTestMode,
-                       depthFunction, stencilParameters, writeToColorBuffer );
+                       depthFunction, stencilParameters );
 }
 
 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,
                     DepthTestMode::Type depthTestMode,
                     DepthFunction::Type depthFunction,
-                    StencilParameters& stencilParameters,
-                    bool writeToColorBuffer )
+                    StencilParameters& stencilParameters )
 : mRenderDataProvider( dataProvider ),
   mContext( NULL),
-  mTextureCache( NULL ),
-  mUniformNameCache( NULL ),
   mGeometry( geometry ),
   mUniformIndexMap(),
   mAttributesLocation(),
@@ -152,38 +144,27 @@ Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider,
   mFaceCullingMode( faceCullingMode ),
   mDepthWriteMode( depthWriteMode ),
   mDepthTestMode( depthTestMode ),
-  mWriteToColorBuffer( writeToColorBuffer ),
   mUpdateAttributesLocation( true ),
-  mPremultipledAlphaEnabled( preMultipliedAlphaEnabled )
+  mPremultipledAlphaEnabled( preMultipliedAlphaEnabled ),
+  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, Render::UniformNameCache& uniformNameCache )
+void Renderer::Initialize( Context& context )
 {
   mContext = &context;
-  mTextureCache = &textureCache;
-  mUniformNameCache = &uniformNameCache;
 }
 
 Renderer::~Renderer()
 {
 }
 
-void Renderer::SetRenderDataProvider( SceneGraph::RenderDataProvider* dataProvider )
-{
-  mRenderDataProvider = dataProvider;
-  mUpdateAttributesLocation = true;
-}
-
 void Renderer::SetGeometry( Render::Geometry* geometry )
 {
   mGeometry = geometry;
@@ -235,27 +216,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 )
         {
@@ -361,57 +347,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;
@@ -427,22 +377,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;
 }
@@ -482,14 +432,14 @@ DepthFunction::Type Renderer::GetDepthFunction() const
   return mDepthFunction;
 }
 
-void Renderer::SetStencilMode( StencilMode::Type stencilMode )
+void Renderer::SetRenderMode( RenderMode::Type renderMode )
 {
-  mStencilParameters.stencilMode = stencilMode;
+  mStencilParameters.renderMode = renderMode;
 }
 
-StencilMode::Type Renderer::GetStencilMode() const
+RenderMode::Type Renderer::GetRenderMode() const
 {
-  return mStencilParameters.stencilMode;
+  return mStencilParameters.renderMode;
 }
 
 void Renderer::SetStencilFunction( StencilFunction::Type stencilFunction )
@@ -562,40 +512,28 @@ StencilOperation::Type Renderer::GetStencilOperationOnZPass() const
   return mStencilParameters.stencilOperationOnZPass;
 }
 
-void Renderer::SetWriteToColorBuffer( bool writeToColorBuffer )
+void Renderer::Upload( Context& context )
 {
-  mWriteToColorBuffer = writeToColorBuffer;
-}
-
-bool Renderer::GetWriteToColorBuffer() const
-{
-  return mWriteToColorBuffer;
+  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,
-                       bool blend )
+                       bool blend,
+                       Vector<GLuint>& boundTextures )
 {
   // 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.", (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
@@ -607,7 +545,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
 
@@ -621,11 +559,12 @@ 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 ) );
       }
     }
 
@@ -637,26 +576,26 @@ void Renderer::Render( Context& context,
       mUpdateAttributesLocation = false;
     }
 
-    mGeometry->UploadAndDraw( context, bufferIndex, mAttributesLocation, mIndexedDrawFirstElement, mIndexedDrawElementsCount );
+    mGeometry->Draw( context,
+                     bufferIndex,
+                     mAttributesLocation,
+                     mIndexedDrawFirstElement,
+                     mIndexedDrawElementsCount );
   }
 }
 
-void Renderer::SetSortAttributes( BufferIndex bufferIndex, SceneGraph::RendererWithSortAttributes& 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