dali-toolkit/internal/controls/renderers/control-renderer-data-impl.cpp

   1 /*
   2  * Copyright (c) 2015 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 // CLASS HEADER
  19 #include "control-renderer-data-impl.h"
  20
  21 // EXTERNAL HEADER
  22 #include <dali/public-api/common/dali-common.h>
  23 #include <dali/integration-api/debug.h>
  24 #include <dali/public-api/object/property-array.h>
  25
  26 // EXTERNAL HEADER
  27
  28 namespace Dali
  29 {
  30
  31 namespace Toolkit
  32 {
  33
  34 namespace Internal
  35 {
  36
  37 namespace
  38 {
  39 //custom shader
  40 const char * const CUSTOM_SHADER( "shader" );
  41 const char * const CUSTOM_VERTEX_SHADER( "vertexShader" );
  42 const char * const CUSTOM_FRAGMENT_SHADER( "fragmentShader" );
  43 const char * const CUSTOM_SUBDIVIDE_GRID_X( "subdivideGridX" );
  44 const char * const CUSTOM_SUBDIVIDE_GRID_Y( "subdivideGridY" );
  45 const char * const CUSTOM_SHADER_HINTS( "hints" ); ///< type STRING for a hint from the below hint strings or an ARRAY of of hint strings
  46
  47 /**
  48  * where hints should be contain strings of the following shader hints:
  49  *   "none"                    | corresponds to HINT_NONE
  50  *   "outputIsTransparent"     | corresponds to HINT_OUTPUT_IS_TRANSPARENT
  51  *   "modifiesGeometry"        | corresponds to HINT_MODIFIES_GEOMETRY
  52  */
  53
  54 Shader::ShaderHints HintFromString( std::string hintString )
  55 {
  56   if( hintString == "none" )
  57   {
  58     return Shader::HINT_NONE;
  59   }
  60   else if( hintString == "outputIsTransparent" )
  61   {
  62     return Shader::HINT_OUTPUT_IS_TRANSPARENT;
  63   }
  64   else if( hintString == "modifiesGeometry" )
  65   {
  66     return Shader::HINT_MODIFIES_GEOMETRY;
  67   }
  68   else
  69   {
  70     DALI_LOG_ERROR( "'%s' hint string is not recognised", hintString.c_str() );
  71   }
  72
  73   return Shader::HINT_NONE;
  74 }
  75
  76 }// unnamed namespace
  77
  78 Internal::ControlRenderer::Impl::Impl()
  79 : mCustomShader(NULL),
  80   mDepthIndex( 0.0f ),
  81   mFlags( 0 )
  82 {
  83 }
  84
  85 Internal::ControlRenderer::Impl::~Impl()
  86 {
  87   delete mCustomShader;
  88 }
  89
  90 Internal::ControlRenderer::Impl::CustomShader::CustomShader( const Property::Map& map )
  91 : mGridSize( 1, 1 ),
  92   mHints( Shader::HINT_NONE )
  93 {
  94   SetPropertyMap( map );
  95 }
  96
  97 void Internal::ControlRenderer::Impl::CustomShader::SetPropertyMap( const Property::Map& shaderMap )
  98 {
  99   mVertexShader.clear();
 100   mFragmentShader.clear();
 101   mGridSize = ImageDimensions( 1, 1 );
 102   mHints = Shader::HINT_NONE;
 103
 104   Property::Value* vertexShaderValue = shaderMap.Find( CUSTOM_VERTEX_SHADER );
 105   if( vertexShaderValue )
 106   {
 107     if( !vertexShaderValue->Get( mVertexShader ) )
 108     {
 109       DALI_LOG_ERROR( "'%s' parameter does not correctly specify a string", CUSTOM_VERTEX_SHADER );
 110     }
 111   }
 112
 113   Property::Value* fragmentShaderValue = shaderMap.Find( CUSTOM_FRAGMENT_SHADER );
 114   if( fragmentShaderValue )
 115   {
 116     if( !fragmentShaderValue->Get( mFragmentShader ) )
 117     {
 118       DALI_LOG_ERROR( "'%s' parameter does not correctly specify a string", CUSTOM_FRAGMENT_SHADER );
 119     }
 120   }
 121
 122   Property::Value* subdivideXValue = shaderMap.Find( CUSTOM_SUBDIVIDE_GRID_X );
 123   if( subdivideXValue )
 124   {
 125     int subdivideX;
 126     if( !subdivideXValue->Get( subdivideX ) || subdivideX < 1 )
 127     {
 128       DALI_LOG_ERROR( "'%s' parameter does not correctly specify a value greater than 1", CUSTOM_SUBDIVIDE_GRID_X );
 129     }
 130     else
 131     {
 132       mGridSize = ImageDimensions( subdivideX, mGridSize.GetY() );
 133     }
 134   }
 135
 136   Property::Value* subdivideYValue = shaderMap.Find( CUSTOM_SUBDIVIDE_GRID_Y );
 137   if( subdivideYValue )
 138   {
 139     int subdivideY;
 140     if( !subdivideYValue->Get( subdivideY ) || subdivideY < 1 )
 141     {
 142       DALI_LOG_ERROR( "'%s' parameter does not correctly specify a value greater than 1", CUSTOM_SUBDIVIDE_GRID_Y );
 143     }
 144     else
 145     {
 146       mGridSize = ImageDimensions( mGridSize.GetX(), subdivideY );
 147     }
 148   }
 149
 150   Property::Value* hintsValue = shaderMap.Find( CUSTOM_SHADER_HINTS );
 151   if( hintsValue )
 152   {
 153     std::string hintString;
 154     Property::Array hintsArray;
 155
 156     if( hintsValue->Get( hintString ) )
 157     {
 158       mHints = HintFromString( hintString );
 159     }
 160     else if( hintsValue->Get( hintsArray ) )
 161     {
 162       int hints = Shader::HINT_NONE;
 163       for( Property::Array::SizeType i = 0; i < hintsArray.Count(); ++i)
 164       {
 165         Property::Value hintValue = hintsArray[ i ];
 166         if( hintValue.Get( hintString ) )
 167         {
 168           hints |= static_cast< int >( HintFromString( hintString ) );
 169         }
 170         else
 171         {
 172           DALI_LOG_ERROR( "'%s' parameter does not correctly specify an hint string at index %d", CUSTOM_SHADER_HINTS, i );
 173         }
 174
 175         mHints = static_cast< Shader::ShaderHints >( hints );
 176       }
 177     }
 178     else
 179     {
 180       DALI_LOG_ERROR( "'%s' parameter does not correctly specify a hint string or an array of hint strings", CUSTOM_SHADER_HINTS );
 181     }
 182   }
 183 }
 184
 185 void Internal::ControlRenderer::Impl::CustomShader::CreatePropertyMap( Property::Map& map ) const
 186 {
 187   if( !mVertexShader.empty() || !mFragmentShader.empty() )
 188   {
 189     Property::Map customShader;
 190     if( !mVertexShader.empty() )
 191     {
 192       customShader.Insert(CUSTOM_VERTEX_SHADER, mVertexShader );
 193     }
 194     if( !mFragmentShader.empty() )
 195     {
 196       customShader.Insert(CUSTOM_FRAGMENT_SHADER, mFragmentShader );
 197     }
 198
 199     if( mGridSize.GetWidth() != 1 )
 200     {
 201       customShader.Insert(CUSTOM_SUBDIVIDE_GRID_X, mGridSize.GetWidth() );
 202     }
 203     if( mGridSize.GetHeight() != 1 )
 204     {
 205       customShader.Insert(CUSTOM_SUBDIVIDE_GRID_Y, mGridSize.GetHeight() );
 206     }
 207
 208     if( mHints != Dali::Shader::HINT_NONE )
 209     {
 210       customShader.Insert(CUSTOM_SHADER_HINTS, static_cast< int >(mHints) );
 211     }
 212
 213     map.Insert( CUSTOM_SHADER, customShader );
 214   }
 215 }
 216
 217 } // namespace Internal
 218
 219 } // namespace Toolkit
 220
 221 } // namespace Dali