X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali%2Finternal%2Frender%2Frenderers%2Frender-renderer.cpp;h=2222abd8eaca46afaa418da6e742e65bdcc68c64;hb=6d4b6de12867b318f41562184baba1022c487d4b;hp=42d748a7a0a1bea02fa16ecba58c6bca38f901f1;hpb=0fb5f4124e065cb93c2278d96260759fc463a51b;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 42d748a..2222abd 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,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/gl-resources/texture-cache.h>
-#include <dali/internal/render/gl-resources/gl-texture.h>
 
 namespace Dali
 {
@@ -109,8 +107,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 +123,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 +133,6 @@ Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider,
                     StencilParameters& stencilParameters )
 : mRenderDataProvider( dataProvider ),
   mContext( NULL),
-  mTextureCache( NULL ),
   mGeometry( geometry ),
   mUniformIndexMap(),
   mAttributesLocation(),
@@ -148,46 +145,25 @@ Renderer::Renderer( SceneGraph::RenderDataProvider* dataProvider,
   mDepthWriteMode( depthWriteMode ),
   mDepthTestMode( depthTestMode ),
   mUpdateAttributesLocation( true ),
-  mPremultipledAlphaEnabled( preMultipliedAlphaEnabled ),
-  mBatchingEnabled( false )
+  mPremultipledAlphaEnabled( preMultipliedAlphaEnabled )
 {
-  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;
-
-  //Check that the number of textures match the number of samplers in the shader
-  size_t textureCount =  dataProvider->GetTextures().size() + dataProvider->GetNewTextures().size();
-  Program* program = dataProvider->GetShader().GetProgram();
-  if( program && program->GetActiveSamplerCount() != textureCount )
-  {
-    DALI_LOG_ERROR("The number of active samplers in the shader(%lu) does not match the number of textures in the TextureSet(%lu)\n",
-                   program->GetActiveSamplerCount(),
-                   textureCount );
-  }
-}
-
 void Renderer::SetGeometry( Render::Geometry* geometry )
 {
   mGeometry = geometry;
@@ -239,27 +215,28 @@ 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)
   {
     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 )
         {
@@ -365,54 +342,19 @@ void Renderer::SetUniformFromProperty( BufferIndex bufferIndex, Program& program
   }
 }
 
-bool Renderer::BindTextures( Context& context, SceneGraph::TextureCache& textureCache, Program& program )
+bool Renderer::BindTextures( Context& context, Program& program )
 {
-  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); i<newTextures.size() && result; ++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 = newTextures[i]->Bind(context, textureUnit, samplers[i] );
+      result = textures[i]->Bind(context, textureUnit, samplers[i] );
       if( result && program.GetSamplerUniformLocation( i, uniformLocation ) )
       {
         program.SetUniform1i( uniformLocation, textureUnit );
@@ -429,22 +371,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;
 }
@@ -564,36 +506,27 @@ 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 )
 {
   // 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
@@ -605,7 +538,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 ) ) )
   {
     // Only set up and draw if we have textures and they are all valid
 
@@ -619,40 +552,35 @@ 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;
 }