Added custom vertex shader support for NinePatch

[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / visuals / npatch / npatch-visual.cpp

diff --git a/dali-toolkit/internal/visuals/npatch/npatch-visual.cpp b/dali-toolkit/internal/visuals/npatch/npatch-visual.cpp
old mode 100644 (file)
new mode 100755 (executable)
index 8751c3e..9235545
--- a/dali-toolkit/internal/visuals/npatch/npatch-visual.cpp
+++ b/dali-toolkit/internal/visuals/npatch/npatch-visual.cpp
@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2016 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2017 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.
@@ -19,14 +19,15 @@
 #include "npatch-visual.h"
 
 // EXTERNAL INCLUDES
-#include <dali/integration-api/platform-abstraction.h>
 #include <dali/public-api/images/buffer-image.h>
 #include <dali/public-api/images/resource-image.h>
 #include <dali/devel-api/images/texture-set-image.h>
+#include <dali/integration-api/debug.h>
 
 // INTERNAL INCLUDES
 #include <dali-toolkit/public-api/visuals/image-visual-properties.h>
 #include <dali-toolkit/devel-api/visuals/visual-properties-devel.h>
+#include <dali-toolkit/devel-api/visuals/image-visual-properties-devel.h>
 #include <dali-toolkit/internal/visuals/npatch-loader.h>
 #include <dali-toolkit/internal/visuals/visual-factory-impl.h>
 #include <dali-toolkit/internal/visuals/visual-factory-cache.h>
@@ -46,7 +47,8 @@ namespace Internal
 
 namespace
 {
-const char * const BORDER_ONLY("borderOnly");
+const char * const BORDER_ONLY( "borderOnly" );
+const char * const BORDER( "border" );
 
 const char* VERTEX_SHADER = DALI_COMPOSE_SHADER(
   attribute mediump vec2 aPosition;\n
@@ -109,8 +111,7 @@ const char* VERTEX_SHADER_3X3 = DALI_COMPOSE_SHADER(
       vec2 visualSize = mix(uSize.xy*size, size, offsetSizeMode.zw );\n
       vec2 visualOffset = mix( offset, offset/uSize.xy, offsetSizeMode.xy);\n
 
-      mediump vec2 scale        = vec2( length( uModelMatrix[ 0 ].xyz ), length( uModelMatrix[ 1 ].xyz ) );\n
-      mediump vec2 size         = visualSize.xy * scale;\n
+      mediump vec2 size         = visualSize.xy;\n
       \n
       mediump vec2 fixedFactor  = vec2( uFixed[ int( ( aPosition.x + 1.0 ) * 0.5 ) ].x, uFixed[ int( ( aPosition.y  + 1.0 ) * 0.5 ) ].y );\n
       mediump vec2 stretch      = floor( aPosition * 0.5 );\n
@@ -118,7 +119,7 @@ const char* VERTEX_SHADER_3X3 = DALI_COMPOSE_SHADER(
       \n
       mediump vec4 vertexPosition = vec4( fixedFactor + ( size - fixedTotal ) * stretch, 0.0, 1.0 );
       vertexPosition.xy -= size * vec2( 0.5, 0.5 );\n
-      vertexPosition.xy =  vertexPosition.xy / scale + anchorPoint*size + (visualOffset + origin)*uSize.xy;\
+      vertexPosition.xy =  vertexPosition.xy + anchorPoint*size + (visualOffset + origin)*uSize.xy;\
       \n
       vertexPosition = uMvpMatrix * vertexPosition;\n
       \n
@@ -132,10 +133,16 @@ const char* FRAGMENT_SHADER = DALI_COMPOSE_SHADER(
   varying mediump vec2 vTexCoord;\n
   uniform sampler2D sTexture;\n
   uniform lowp vec4 uColor;\n
-  \n
+  uniform lowp vec3 mixColor;\n
+  uniform lowp float opacity;\n
+  uniform lowp float preMultipliedAlpha;\n
+  lowp vec4 visualMixColor()\n
+  {\n
+    return vec4( mixColor * mix( 1.0, opacity, preMultipliedAlpha ), opacity );\n
+  }\n
   void main()\n
   {\n
-    gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;\n
+    gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * visualMixColor();\n
   }\n
 );
 
@@ -226,19 +233,28 @@ void RegisterStretchProperties( Renderer& renderer, const char * uniformName, co
 
 /////////////////NPatchVisual////////////////
 
-NPatchVisualPtr NPatchVisual::New( VisualFactoryCache& factoryCache, const std::string& imageUrl )
+NPatchVisualPtr NPatchVisual::New( VisualFactoryCache& factoryCache, const VisualUrl& imageUrl, const Property::Map& properties )
 {
-  NPatchVisual* nPatchVisual = new NPatchVisual( factoryCache );
+  NPatchVisualPtr nPatchVisual( new NPatchVisual( factoryCache ) );
   nPatchVisual->mImageUrl = imageUrl;
+  nPatchVisual->SetProperties( properties );
 
   return nPatchVisual;
 }
 
-NPatchVisualPtr NPatchVisual::New( VisualFactoryCache& factoryCache, NinePatchImage image )
+NPatchVisualPtr NPatchVisual::New( VisualFactoryCache& factoryCache, const VisualUrl& imageUrl )
 {
-  NPatchVisual* nPatchVisual = new NPatchVisual( factoryCache );
-  nPatchVisual->mImageUrl = image.GetUrl();
+  NPatchVisualPtr nPatchVisual( new NPatchVisual( factoryCache ) );
+  nPatchVisual->mImageUrl = imageUrl;
+
+  return nPatchVisual;
+}
 
+NPatchVisualPtr NPatchVisual::New( VisualFactoryCache& factoryCache, NinePatchImage image )
+{
+  NPatchVisualPtr nPatchVisual( new NPatchVisual( factoryCache ) );
+  VisualUrl visualUrl( image.GetUrl() );
+  nPatchVisual->mImageUrl = visualUrl;
   return nPatchVisual;
 }
 
@@ -246,10 +262,11 @@ void NPatchVisual::GetNaturalSize( Vector2& naturalSize )
 {
   naturalSize.x = 0u;
   naturalSize.y = 0u;
+
   // load now if not already loaded
-  if( NPatchLoader::UNINITIALIZED_ID == mId )
+  if( NPatchLoader::UNINITIALIZED_ID == mId && mImageUrl.IsLocal() )
   {
-    mId = mLoader.Load( mImageUrl );
+    mId = mLoader.Load( mImageUrl.GetUrl(), mBorder );
   }
   const NPatchLoader::Data* data;
   if( mLoader.GetNPatchData( mId, data ) )
@@ -268,14 +285,28 @@ void NPatchVisual::DoSetProperties( const Property::Map& propertyMap )
   {
     borderOnlyValue->Get( mBorderOnly );
   }
+
+  Property::Value* borderValue = propertyMap.Find( Toolkit::DevelImageVisual::Property::BORDER, BORDER );
+  if( borderValue && ! borderValue->Get( mBorder ) ) // If value exists and is rect, just set mBorder
+  {
+    // Not a rect so try vector4
+    Vector4 border;
+    if( borderValue->Get( border ) )
+    {
+      mBorder.left = static_cast< int >( border.x );
+      mBorder.right = static_cast< int >( border.y );
+      mBorder.bottom = static_cast< int >( border.z );
+      mBorder.top = static_cast< int >( border.w );
+    }
+  }
 }
 
 void NPatchVisual::DoSetOnStage( Actor& actor )
 {
   // load when first go on stage
-  if( NPatchLoader::UNINITIALIZED_ID == mId )
+  if( NPatchLoader::UNINITIALIZED_ID == mId && mImageUrl.IsLocal() )
   {
-    mId = mLoader.Load( mImageUrl );
+    mId = mLoader.Load( mImageUrl.GetUrl(), mBorder );
   }
 
   Geometry geometry = CreateGeometry();
@@ -285,6 +316,9 @@ void NPatchVisual::DoSetOnStage( Actor& actor )
   ApplyTextureAndUniforms();
 
   actor.AddRenderer( mImpl->mRenderer );
+
+  // npatch loaded and ready to display
+  ResourceReady();
 }
 
 void NPatchVisual::DoSetOffStage( Actor& actor )
@@ -304,9 +338,15 @@ void NPatchVisual::OnSetTransform()
 void NPatchVisual::DoCreatePropertyMap( Property::Map& map ) const
 {
   map.Clear();
-  map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::Visual::IMAGE );
-  map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl );
+  map.Insert( Toolkit::DevelVisual::Property::TYPE, Toolkit::DevelVisual::N_PATCH );
+  map.Insert( Toolkit::ImageVisual::Property::URL, mImageUrl.GetUrl() );
   map.Insert( Toolkit::ImageVisual::Property::BORDER_ONLY, mBorderOnly );
+  map.Insert( Toolkit::DevelImageVisual::Property::BORDER, mBorder );
+}
+
+void NPatchVisual::DoCreateInstancePropertyMap( Property::Map& map ) const
+{
+  // Do nothing
 }
 
 NPatchVisual::NPatchVisual( VisualFactoryCache& factoryCache )
@@ -314,7 +354,8 @@ NPatchVisual::NPatchVisual( VisualFactoryCache& factoryCache )
   mLoader( factoryCache.GetNPatchLoader() ),
   mImageUrl(),
   mId( NPatchLoader::UNINITIALIZED_ID ),
-  mBorderOnly( false )
+  mBorderOnly( false ),
+  mBorder()
 {
 }
 
@@ -402,10 +443,17 @@ Shader NPatchVisual::CreateShader()
     }
     hints = mImpl->mCustomShader->mHints;
 
+    /* Apply Custom Vertex Shader only if image is 9-patch */
     if( ( xStretchCount == 1 && yStretchCount == 1 ) ||
         ( xStretchCount == 0 && yStretchCount == 0 ) )
     {
-      shader = Shader::New( VERTEX_SHADER_3X3, fragmentShader, hints );
+      const char* vertexShader = VERTEX_SHADER_3X3;
+
+      if( !mImpl->mCustomShader->mVertexShader.empty() )
+      {
+        vertexShader = mImpl->mCustomShader->mVertexShader.c_str();
+      }
+      shader = Shader::New( vertexShader, fragmentShader, hints );
     }
     else if( xStretchCount > 0 || yStretchCount > 0)
     {
@@ -453,7 +501,7 @@ void NPatchVisual::ApplyTextureAndUniforms()
   }
   else
   {
-    DALI_LOG_ERROR("The N patch image '%s' is not a valid N patch image\n", mImageUrl.c_str() );
+    DALI_LOG_ERROR("The N patch image '%s' is not a valid N patch image\n", mImageUrl.GetUrl().c_str() );
     TextureSet textureSet = TextureSet::New();
     mImpl->mRenderer.SetTextures( textureSet );
     Image croppedImage = VisualFactoryCache::GetBrokenVisualImage();