From: Adam Bialogonski <adam.b@samsung.com>
Date: Tue, 12 Nov 2024 15:39:23 +0000 (+0000)
Subject: Upgraded DALi Toolkit shaders
X-Git-Tag: accepted/tizen/unified/20241120.162300~2^2~2
X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=2b31ca718be062d58c07aa9d5a40aa3ed814f876;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git

Upgraded DALi Toolkit shaders

Change-Id: Ib9f1d3b085a3b86b9ba82ceec5bbc654daff4ea1
---

diff --git a/dali-scene3d/internal/graphics/shaders/default-physically-based-shader.frag b/dali-scene3d/internal/graphics/shaders/default-physically-based-shader.frag
index e9d48648ca..c357696b8c 100644
--- a/dali-scene3d/internal/graphics/shaders/default-physically-based-shader.frag
+++ b/dali-scene3d/internal/graphics/shaders/default-physically-based-shader.frag
@@ -1,3 +1,4 @@
+//@version 100
 
 // Original Code
 // https://github.com/KhronosGroup/glTF-Sample-Viewer/blob/glTF-WebGL-PBR/shaders/pbr-frag.glsl
@@ -30,97 +31,127 @@ precision mediump float;
 #define ROUGHNESS a
 #endif //GLTF_CHANNELS
 
-uniform lowp vec4 uColor; // Color from SceneGraph
-uniform lowp vec4 uColorFactor; // Color from material
-uniform lowp float uMetallicFactor;
-uniform lowp float uRoughnessFactor;
-uniform lowp float uDielectricSpecular;
-
 #ifdef THREE_TEX
 #ifdef BASECOLOR_TEX
-uniform sampler2D sAlbedoAlpha;
-uniform float uBaseColorTextureTransformAvailable;
-uniform mat3 uBaseColorTextureTransform;
-#endif // BASECOLOR_TEX
+UNIFORM sampler2D sAlbedoAlpha;
+#endif
 #ifdef METALLIC_ROUGHNESS_TEX
-uniform sampler2D sMetalRoughness;
-uniform float uMetalRoughnessTextureTransformAvailable;
-uniform mat3 uMetalRoughnessTextureTransform;
-#endif // METALLIC_ROUGHNESS_TEX
+UNIFORM sampler2D sMetalRoughness;
+#endif
 #ifdef NORMAL_TEX
-uniform sampler2D sNormal;
-uniform float uNormalTextureTransformAvailable;
-uniform mat3 uNormalTextureTransform;
-uniform float uNormalScale;
-#endif // NORMAL_TEX
-#else // THREE_TEX
-uniform sampler2D sAlbedoMetal;
-uniform float uBaseColorTextureTransformAvailable;
-uniform mat3 uBaseColorTextureTransform;
-uniform sampler2D sNormalRoughness;
-uniform float uNormalRoughnessTextureTransformAvailable;
-uniform mat3 uNormalRoughnessTextureTransform;
+UNIFORM sampler2D sNormal;
+#endif
+#else
+UNIFORM sampler2D sAlbedoMetal;
+UNIFORM sampler2D sNormalRoughness;
 #endif
-
-
 
 #ifdef OCCLUSION
-uniform sampler2D sOcclusion;
-uniform float uOcclusionTextureTransformAvailable;
-uniform mat3 uOcclusionTextureTransform;
-uniform float uOcclusionStrength;
+UNIFORM sampler2D sOcclusion;
 #endif
 
 #ifdef EMISSIVE_TEXTURE
-uniform sampler2D sEmissive;
-uniform float uEmissiveTextureTransformAvailable;
-uniform mat3 uEmissiveTextureTransform;
+UNIFORM sampler2D sEmissive;
 #endif
-uniform vec3 uEmissiveFactor;
 
-uniform float uSpecularFactor;
-uniform vec3  uSpecularColorFactor;
 #ifdef MATERIAL_SPECULAR_TEXTURE
-uniform sampler2D sSpecular;
+UNIFORM sampler2D sSpecular;
 #endif
 #ifdef MATERIAL_SPECULAR_COLOR_TEXTURE
-uniform sampler2D sSpecularColor;
+UNIFORM sampler2D sSpecularColor;
 #endif
 
+/// For shadowmap
+UNIFORM sampler2D sShadowMap;
+
+//// For IBL
+UNIFORM sampler2D sbrdfLUT;
+UNIFORM samplerCube sDiffuseEnvSampler;
+UNIFORM samplerCube sSpecularEnvSampler;
+
+UNIFORM_BLOCK FragBlock0
+{
+  UNIFORM lowp vec4 uColor;// Color from SceneGraph
+  UNIFORM lowp vec4 uColorFactor;// Color from material
+  UNIFORM lowp float uMetallicFactor;
+  UNIFORM lowp float uRoughnessFactor;
+  UNIFORM lowp float uDielectricSpecular;
+
+#ifdef THREE_TEX
+#ifdef BASECOLOR_TEX
+  UNIFORM float uBaseColorTextureTransformAvailable;
+  UNIFORM mat3 uBaseColorTextureTransform;
+#endif// BASECOLOR_TEX
+#ifdef METALLIC_ROUGHNESS_TEX
+  UNIFORM float uMetalRoughnessTextureTransformAvailable;
+  UNIFORM mat3 uMetalRoughnessTextureTransform;
+#endif// METALLIC_ROUGHNESS_TEX
+#ifdef NORMAL_TEX
+  UNIFORM float uNormalTextureTransformAvailable;
+  UNIFORM mat3 uNormalTextureTransform;
+  UNIFORM float uNormalScale;
+#endif// NORMAL_TEX
+#else// THREE_TEX
+  UNIFORM float uBaseColorTextureTransformAvailable;
+  UNIFORM mat3 uBaseColorTextureTransform;
+  UNIFORM float uNormalRoughnessTextureTransformAvailable;
+  UNIFORM mat3 uNormalRoughnessTextureTransform;
+#endif
+
+#ifdef OCCLUSION
+  UNIFORM float uOcclusionTextureTransformAvailable;
+  UNIFORM mat3 uOcclusionTextureTransform;
+  UNIFORM float uOcclusionStrength;
+#endif
+
+#ifdef EMISSIVE_TEXTURE
+  UNIFORM float uEmissiveTextureTransformAvailable;
+  UNIFORM mat3 uEmissiveTextureTransform;
+#endif
+  UNIFORM vec3 uEmissiveFactor;
+  UNIFORM float uSpecularFactor;
+  UNIFORM vec3  uSpecularColorFactor;
+
 // For Light (Currently Directional Only)
 #define MAX_LIGHTS 5
-uniform mediump int uLightCount;
-uniform mediump vec3 uLightDirection[MAX_LIGHTS];
-uniform mediump vec3 uLightColor[MAX_LIGHTS];
+  UNIFORM mediump int uLightCount;
+  UNIFORM mediump vec3 uLightDirection[MAX_LIGHTS];
+  UNIFORM mediump vec3 uLightColor[MAX_LIGHTS];
 
 // For Shadow Map
-uniform lowp int uIsShadowEnabled;
-uniform sampler2D sShadowMap;
-uniform lowp int uIsShadowReceiving;
+  UNIFORM lowp int uIsShadowReceiving;
 #ifdef SL_VERSION_LOW
-uniform int uShadowMapWidth;
-uniform int uShadowMapHeight;
+  UNIFORM int uShadowMapWidth;
+  UNIFORM int uShadowMapHeight;
 #endif
-INPUT highp vec3 positionFromLightView;
 
 //// For IBL
-uniform sampler2D sbrdfLUT;
-uniform samplerCube sDiffuseEnvSampler;
-uniform samplerCube sSpecularEnvSampler;
-uniform float uIblIntensity;
-uniform mediump vec3 uYDirection;
-uniform float uMaxLOD;
+  UNIFORM float uIblIntensity;
+  UNIFORM float uMaxLOD;
 
 // For Alpha Mode.
-uniform lowp float uOpaque;
-uniform lowp float uMask;
-uniform lowp float uAlphaThreshold;
+  UNIFORM lowp float uOpaque;
+  UNIFORM lowp float uMask;
+  UNIFORM lowp float uAlphaThreshold;
+};
+
+UNIFORM_BLOCK YDirection
+{
+  UNIFORM mediump vec3 uYDirection;
+};
+
+UNIFORM_BLOCK ShadowEnabled
+{
+  UNIFORM lowp int uIsShadowEnabled;
+};
+
 
 // TODO: Multiple texture coordinate will be supported.
 INPUT mediump vec2 vUV;
 INPUT lowp mat3 vTBN;
 INPUT lowp vec4 vColor;
 INPUT highp vec3 vPositionToCamera;
+INPUT highp vec3 positionFromLightView;
 
 const float c_MinRoughness = 0.04;
 const float M_PI = 3.141592653589793;
@@ -137,10 +168,10 @@ const float kSinPcfTheta = sin(kPcfTheta);
 const float kCosPcfTheta = cos(kPcfTheta);
 
 
-uniform mediump int uShadowLightIndex;
-uniform lowp int uEnableShadowSoftFiltering;
-uniform mediump float uShadowIntensity;
-uniform highp float uShadowBias;
+UNIFORM mediump int uShadowLightIndex;
+UNIFORM lowp int uEnableShadowSoftFiltering;
+UNIFORM mediump float uShadowIntensity;
+UNIFORM highp float uShadowBias;
 
 vec3 linear(vec3 color)
 {
@@ -357,5 +388,5 @@ void main()
 #endif // EMISSIVE_TEXTURE
   color += emissive;
 
-  OUT_COLOR = vec4(pow(color, vec3(1.0 / 2.2)), baseColor.a) * uColor;
+  gl_FragColor = vec4(pow(color, vec3(1.0 / 2.2)), baseColor.a) * uColor;
 }
diff --git a/dali-scene3d/internal/graphics/shaders/default-physically-based-shader.vert b/dali-scene3d/internal/graphics/shaders/default-physically-based-shader.vert
index 8ee1bf4282..2ce2410710 100644
--- a/dali-scene3d/internal/graphics/shaders/default-physically-based-shader.vert
+++ b/dali-scene3d/internal/graphics/shaders/default-physically-based-shader.vert
@@ -1,3 +1,4 @@
+//@version 100
 
 // Original Code
 // https://github.com/KhronosGroup/glTF-Sample-Viewer/blob/glTF-WebGL-PBR/shaders/pbr-vert.glsl
@@ -37,56 +38,76 @@ ADD_EXTRA_SKINNING_ATTRIBUTES
 #endif
 
 #ifdef MORPH
-uniform highp sampler2D sBlendShapeGeometry;
+UNIFORM highp sampler2D sBlendShapeGeometry;
+#endif
+
+UNIFORM_BLOCK VertBlock0
+{
+#ifdef MORPH
 #ifdef SL_VERSION_LOW
-uniform int uBlendShapeGeometryWidth;
-uniform int uBlendShapeGeometryHeight;
+    UNIFORM int uBlendShapeGeometryWidth;
+    UNIFORM int uBlendShapeGeometryHeight;
 #endif
 #endif
 
-OUTPUT mediump vec2 vUV;
-OUTPUT highp mat3 vTBN;
-OUTPUT lowp vec4 vColor;
-OUTPUT highp vec3 vPositionToCamera;
-
-uniform highp mat4 uViewMatrix;
-uniform highp mat3 uNormalMatrix;
-uniform highp mat4 uModelMatrix;
-uniform highp mat4 uProjection;
+    UNIFORM highp mat4 uViewMatrix;
+    UNIFORM highp mat3 uNormalMatrix;
+    UNIFORM highp mat4 uModelMatrix;
+    UNIFORM highp mat4 uProjection;
 
 #ifdef SKINNING
 
 #ifdef SL_VERSION_LOW
-#define MAX_BONES 80
-uniform highp mat4 uBone[MAX_BONES];
-#else
-#define MAX_BONES 256
-layout(std140) uniform Bones
-{
-  mat4 uBone[MAX_BONES];
-};
+    #define MAX_BONES 80
+    UNIFORM highp mat4 uBone[MAX_BONES];
 #endif
-
-uniform mediump vec3 uYDirection;
 #endif
 
 #ifdef MORPH
 #define MAX_BLEND_SHAPE_NUMBER 256
-uniform int uNumberOfBlendShapes;                                         ///< Total number of blend shapes loaded.
-uniform highp float uBlendShapeWeight[MAX_BLEND_SHAPE_NUMBER];            ///< The weight of each blend shape.
+UNIFORM int uNumberOfBlendShapes;///< Total number of blend shapes loaded.
+UNIFORM highp float uBlendShapeWeight[MAX_BLEND_SHAPE_NUMBER];///< The weight of each blend shape.
 #ifdef MORPH_VERSION_2_0
-uniform highp float uBlendShapeUnnormalizeFactor;                         ///< Factor used to unnormalize the geometry of the blend shape.
+UNIFORM highp float uBlendShapeUnnormalizeFactor;///< Factor used to unnormalize the geometry of the blend shape.
 #else
-uniform highp float uBlendShapeUnnormalizeFactor[MAX_BLEND_SHAPE_NUMBER]; ///< Factor used to unnormalize the geometry of the blend shape.
+UNIFORM highp float uBlendShapeUnnormalizeFactor[MAX_BLEND_SHAPE_NUMBER];///< Factor used to unnormalize the geometry of the blend shape.
 #endif
-uniform highp int uBlendShapeComponentSize;                               ///< The size in the texture of either the vertices, normals or tangents. Used to calculate the offset to address them.
+UNIFORM highp int uBlendShapeComponentSize;///< The size in the texture of either the vertices, normals or tangents. Used to calculate the offset to address them.
 #endif
 
 // Shadow
-uniform lowp int uIsShadowEnabled;
-uniform highp mat4 uShadowLightViewProjectionMatrix;
+UNIFORM highp mat4 uShadowLightViewProjectionMatrix;
+};
+
+#ifdef SKINNING
+UNIFORM_BLOCK YDirection
+{
+    UNIFORM mediump vec3 uYDirection;
+};
+#endif
+
+UNIFORM_BLOCK ShadowEnabled
+{
+    UNIFORM lowp int uIsShadowEnabled;
+};
+
+// Additional uniform block if using more bones
+#ifdef SKINNING
+#ifndef SL_VERSION_LOW
+#define MAX_BONES 256
+UNIFORM_BLOCK Bones
+{
+  UNIFORM mat4 uBone[MAX_BONES];
+};
+#endif
+#endif
 OUTPUT highp vec3 positionFromLightView;
 
+OUTPUT mediump vec2 vUV;
+OUTPUT highp mat3 vTBN;
+OUTPUT lowp vec4 vColor;
+OUTPUT highp vec3 vPositionToCamera;
+
 void main()
 {
   highp vec4 position = vec4(aPosition, 1.0);
diff --git a/dali-scene3d/internal/graphics/shaders/scene3d-joint-debug.frag b/dali-scene3d/internal/graphics/shaders/scene3d-joint-debug.frag
index 3ce016bd7b..3a4cbc833b 100644
--- a/dali-scene3d/internal/graphics/shaders/scene3d-joint-debug.frag
+++ b/dali-scene3d/internal/graphics/shaders/scene3d-joint-debug.frag
@@ -1,10 +1,14 @@
+//@version 100
 
 precision mediump float;
-uniform lowp vec4 uColor;
-FLAT INPUT float vColor;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
+INPUT flat float vColor;
 
 void main()
 {
   vec3 rgb = vec3(fract(vColor), fract(vColor * 0.00390625), fract(vColor * 0.00390625 * 0.00390625));
-  OUT_COLOR = vec4(rgb, 1.) * uColor;
+  gl_FragColor = vec4(rgb, 1.) * uColor;
 }
\ No newline at end of file
diff --git a/dali-scene3d/internal/graphics/shaders/scene3d-joint-debug.vert b/dali-scene3d/internal/graphics/shaders/scene3d-joint-debug.vert
index 49860c8a27..eef29cc407 100644
--- a/dali-scene3d/internal/graphics/shaders/scene3d-joint-debug.vert
+++ b/dali-scene3d/internal/graphics/shaders/scene3d-joint-debug.vert
@@ -1,9 +1,13 @@
+//@version 100
 
 precision mediump float;
-uniform mat4 uMvpMatrix;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mat4 uMvpMatrix;
+};
 INPUT vec3 aPosition;
 INPUT float aColor;
-FLAT OUTPUT float vColor;
+OUTPUT flat float vColor;
 
 void main()
 {
diff --git a/dali-scene3d/internal/graphics/shaders/shadow-map-shader.frag b/dali-scene3d/internal/graphics/shaders/shadow-map-shader.frag
index 7d72c367f1..c69c4e98eb 100644
--- a/dali-scene3d/internal/graphics/shaders/shadow-map-shader.frag
+++ b/dali-scene3d/internal/graphics/shaders/shadow-map-shader.frag
@@ -1,24 +1,24 @@
+//@version 100
 
-uniform lowp vec4 uColorFactor; // Color from material
-uniform lowp float uMask;
-uniform lowp float uAlphaThreshold;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColorFactor;// Color from material
+  UNIFORM lowp float uMask;
+  UNIFORM lowp float uAlphaThreshold;
+  UNIFORM int uIsShadowCasting;
+};
 
 INPUT mediump vec2 vUV;
 INPUT lowp vec4 vColor;
 
-//INPUT highp float depth;
-//OUTPUT highp vec4 FragColor;
-
 #ifdef THREE_TEX
 #ifdef BASECOLOR_TEX
-uniform sampler2D sAlbedoAlpha;
+UNIFORM sampler2D sAlbedoAlpha;
 #endif // BASECOLOR_TEX
 #else // THREE_TEX
-uniform sampler2D sAlbedoMetal;
+UNIFORM sampler2D sAlbedoMetal;
 #endif
 
-uniform int uIsShadowCasting;
-
 lowp vec3 linear(lowp vec3 color)
 {
   return pow(color, vec3(2.2));
diff --git a/dali-scene3d/internal/graphics/shaders/shadow-map-shader.vert b/dali-scene3d/internal/graphics/shaders/shadow-map-shader.vert
index 521870098c..1ba11dcfb1 100644
--- a/dali-scene3d/internal/graphics/shaders/shadow-map-shader.vert
+++ b/dali-scene3d/internal/graphics/shaders/shadow-map-shader.vert
@@ -1,3 +1,5 @@
+//@version 100
+
 #define MORPH defined(MORPH_POSITION) || defined(MORPH_NORMAL) || defined(MORPH_TANGENT)
 
 #define ADD_EXTRA_SKINNING_ATTRIBUTES
@@ -20,49 +22,57 @@ ADD_EXTRA_SKINNING_ATTRIBUTES;
 #endif
 
 #ifdef MORPH
-uniform highp sampler2D sBlendShapeGeometry;
-#ifdef SL_VERSION_LOW
-uniform int uBlendShapeGeometryWidth;
-uniform int uBlendShapeGeometryHeight;
+UNIFORM highp sampler2D sBlendShapeGeometry;
+#endif
+
+#ifdef SKINNING
+#ifndef SL_VERSION_LOW
+#define MAX_BONES 256
+UNIFORM_BLOCK Bones
+{
+  UNIFORM mat4 uBone[MAX_BONES];
+};
 #endif
 #endif
 
 OUTPUT mediump vec2 vUV;
 OUTPUT lowp vec4 vColor;
 
-uniform highp mat4 uViewMatrix;
-uniform highp mat4 uModelMatrix;
-uniform highp mat4 uProjection;
+UNIFORM_BLOCK VertBlock
+{
+#ifdef MORPH
+#ifdef SL_VERSION_LOW
+    UNIFORM int uBlendShapeGeometryWidth;
+    UNIFORM int uBlendShapeGeometryHeight;
+#endif
+#endif
 
-#ifdef SKINNING
+    UNIFORM highp mat4 uViewMatrix;
+    UNIFORM highp mat4 uModelMatrix;
+    UNIFORM highp mat4 uProjection;
 
+#ifdef SKINNING
 #ifdef SL_VERSION_LOW
 #define MAX_BONES 80
-uniform mat4 uBone[MAX_BONES];
-#else
-#define MAX_BONES 256
-layout(std140) uniform Bones
-{
-  mat4 uBone[MAX_BONES];
-};
+    UNIFORM mat4 uBone[MAX_BONES];
 #endif
-
-uniform mediump vec3 uYDirection;
+UNIFORM mediump vec3 uYDirection;
 #endif
 
 #ifdef MORPH
 #define MAX_BLEND_SHAPE_NUMBER 256
-uniform int uNumberOfBlendShapes;                                         ///< Total number of blend shapes loaded.
-uniform highp float uBlendShapeWeight[MAX_BLEND_SHAPE_NUMBER];            ///< The weight of each blend shape.
+UNIFORM int uNumberOfBlendShapes;///< Total number of blend shapes loaded.
+UNIFORM highp float uBlendShapeWeight[MAX_BLEND_SHAPE_NUMBER];///< The weight of each blend shape.
 #ifdef MORPH_VERSION_2_0
-uniform highp float uBlendShapeUnnormalizeFactor;                         ///< Factor used to unnormalize the geometry of the blend shape.
+UNIFORM highp float uBlendShapeUnnormalizeFactor;///< Factor used to unnormalize the geometry of the blend shape.
 #else
-uniform highp float uBlendShapeUnnormalizeFactor[MAX_BLEND_SHAPE_NUMBER]; ///< Factor used to unnormalize the geometry of the blend shape.
+UNIFORM highp float uBlendShapeUnnormalizeFactor[MAX_BLEND_SHAPE_NUMBER];///< Factor used to unnormalize the geometry of the blend shape.
 #endif
-uniform highp int uBlendShapeComponentSize;                               ///< The size in the texture of either the vertices, normals or tangents. Used to calculate the offset to address them.
+UNIFORM highp int uBlendShapeComponentSize;///< The size in the texture of either the vertices, normals or tangents. Used to calculate the offset to address them.
 #endif
 
-uniform highp mat4 uShadowLightViewProjectionMatrix;
+UNIFORM highp mat4 uShadowLightViewProjectionMatrix;
+};
 
 void main()
 {
diff --git a/dali-scene3d/internal/graphics/shaders/skybox-equirectangular-shader.frag b/dali-scene3d/internal/graphics/shaders/skybox-equirectangular-shader.frag
index c57c608b08..7663afc46f 100644
--- a/dali-scene3d/internal/graphics/shaders/skybox-equirectangular-shader.frag
+++ b/dali-scene3d/internal/graphics/shaders/skybox-equirectangular-shader.frag
@@ -1,12 +1,15 @@
 // Fragment shader for a skybox in equirectangular projection
 precision mediump float;
 
-uniform sampler2D uSkyBoxEquirectangularTexture;
+UNIFORM sampler2D uSkyBoxEquirectangularTexture;
 
-uniform vec4  uColor;
-uniform float uIntensity;
+UNIFORM_BLOCK FragBlock
+{
+    UNIFORM vec4  uColor;
+    UNIFORM float uIntensity;
+};
 
-varying vec3 vTexCoord;
+INPUT vec3 vTexCoord;
 
 // Take the sample direction as interpolated from the cube's local position,
 // and use this direction vector and the spherical to cartesian coordinate
@@ -33,6 +36,6 @@ void main()
   // Flip the texture UVs vertically
   vec2 uvFlippped = vec2(uv.x, 1.0 - uv.y);
 
-  vec4 texColor = texture2D( uSkyBoxEquirectangularTexture, uvFlippped ) * uIntensity;
+  vec4 texColor = TEXTURE( uSkyBoxEquirectangularTexture, uvFlippped ) * uIntensity;
   gl_FragColor = texColor * uColor;
 }
diff --git a/dali-scene3d/internal/graphics/shaders/skybox-shader.frag b/dali-scene3d/internal/graphics/shaders/skybox-shader.frag
index 7bf6e421f8..834898af1d 100644
--- a/dali-scene3d/internal/graphics/shaders/skybox-shader.frag
+++ b/dali-scene3d/internal/graphics/shaders/skybox-shader.frag
@@ -1,10 +1,16 @@
-uniform samplerCube   uSkyBoxTexture;
-uniform lowp    vec4  uColor;
-uniform mediump float uIntensity;
-varying mediump vec3  vTexCoord;
+//@version 100
+
+UNIFORM samplerCube   uSkyBoxTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp    vec4  uColor;
+  UNIFORM mediump float uIntensity;
+};
+
+INPUT mediump vec3  vTexCoord;
 
 void main()
 {
-  mediump vec4 texColor = textureCube(uSkyBoxTexture, vTexCoord) * uIntensity;
+  mediump vec4 texColor = TEXTURE_CUBE(uSkyBoxTexture, vTexCoord) * uIntensity;
   gl_FragColor = texColor * uColor;
 }
\ No newline at end of file
diff --git a/dali-scene3d/internal/graphics/shaders/skybox-shader.vert b/dali-scene3d/internal/graphics/shaders/skybox-shader.vert
index 944bbb0089..e0a29db99f 100644
--- a/dali-scene3d/internal/graphics/shaders/skybox-shader.vert
+++ b/dali-scene3d/internal/graphics/shaders/skybox-shader.vert
@@ -1,10 +1,15 @@
-attribute mediump vec3 aPosition;
-uniform   mediump mat4 uModelView;
-uniform   mediump mat4 uModelMatrix;
-uniform   mediump mat4 uViewMatrix;
-uniform   mediump mat4 uProjection;
-uniform   mediump mat4 uMvpMatrix;
-varying   mediump vec3 vTexCoord;
+//@version 100
+
+INPUT mediump vec3 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM   mediump mat4 uModelView;
+  UNIFORM   mediump mat4 uModelMatrix;
+  UNIFORM   mediump mat4 uViewMatrix;
+  UNIFORM   mediump mat4 uProjection;
+  UNIFORM   mediump mat4 uMvpMatrix;
+};
+OUTPUT   mediump vec3 vTexCoord;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/alpha-discard-effect.frag b/dali-toolkit/internal/graphics/shaders/alpha-discard-effect.frag
index d9b3d5af6c..0412762784 100644
--- a/dali-toolkit/internal/graphics/shaders/alpha-discard-effect.frag
+++ b/dali-toolkit/internal/graphics/shaders/alpha-discard-effect.frag
@@ -1,7 +1,14 @@
-varying mediump vec2 vTexCoord;
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+UNIFORM lowp vec4 uColor;
+};
 
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/animated-gradient-visual-shader.frag b/dali-toolkit/internal/graphics/shaders/animated-gradient-visual-shader.frag
index 7855bf055c..f9c1acba52 100644
--- a/dali-toolkit/internal/graphics/shaders/animated-gradient-visual-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/animated-gradient-visual-shader.frag
@@ -1,12 +1,19 @@
-precision mediump float;
+//@name animated-gradient-visual-shader.frag
+
+//@version 100
 
-uniform mediump vec4 start_color;
-uniform mediump vec4 end_color;
-uniform mediump float gradient_offset;
+precision mediump float;
 
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vStart;
-varying mediump vec2 vEnd;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM mediump vec4 start_color;
+  UNIFORM mediump vec4 end_color;
+  UNIFORM mediump float gradient_offset;
+};
+
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec2 vStart;
+INPUT mediump vec2 vEnd;
 
 float get_position(vec2 x, vec2 s, vec2 e)
 {
diff --git a/dali-toolkit/internal/graphics/shaders/animated-gradient-visual-shader.vert b/dali-toolkit/internal/graphics/shaders/animated-gradient-visual-shader.vert
index 5faf423eb8..0a36bf37a0 100644
--- a/dali-toolkit/internal/graphics/shaders/animated-gradient-visual-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/animated-gradient-visual-shader.vert
@@ -1,15 +1,21 @@
-attribute mediump vec2 aPosition;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+//@name animated-gradient-visual-shader.vert
 
-uniform mediump vec2 start_point;
-uniform mediump vec2 end_point;
-uniform mediump vec2 rotate_center;
-uniform mediump float rotate_angle;
+//@version 100
 
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vStart;
-varying mediump vec2 vEnd;
+INPUT mediump vec2 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
+  UNIFORM mediump vec2 start_point;
+  UNIFORM mediump vec2 end_point;
+  UNIFORM mediump vec2 rotate_center;
+  UNIFORM mediump float rotate_angle;
+};
+
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec2 vStart;
+OUTPUT mediump vec2 vEnd;
 
 vec2 rotate(vec2 x, vec2 c, float a)
 {
@@ -28,11 +34,14 @@ vec2 rotate(vec2 x, vec2 c, float a)
 }
 
 //Visual size and offset
-uniform mediump vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+UNIFORM_BLOCK VisualBlock
+{
+  UNIFORM mediump vec2 offset;
+  UNIFORM highp vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+};
 
 vec4 ComputeVertexPosition()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/arc-visual-butt-cap-shader.frag b/dali-toolkit/internal/graphics/shaders/arc-visual-butt-cap-shader.frag
index 4720ae8f29..766120c4eb 100644
--- a/dali-toolkit/internal/graphics/shaders/arc-visual-butt-cap-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/arc-visual-butt-cap-shader.frag
@@ -1,10 +1,17 @@
+//@name arc-visual-butt-cap-shader.frag
+
+//@version 100
+
 INPUT mediump vec2 vPosition;
 
-uniform lowp vec4 uColor;
-uniform mediump float thickness;
-uniform mediump float radius;
-uniform mediump float startAngle;
-uniform mediump float sweepAngle;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM mediump float thickness;
+  UNIFORM mediump float radius;
+  UNIFORM mediump float startAngle;
+  UNIFORM mediump float sweepAngle;
+};
 
 const mediump float M_PI_OVER_2 = 1.57079632679;
 const mediump float M_PI = 3.14159265359;
@@ -29,6 +36,6 @@ mediump float GetOpacity()
 
 void main()
 {
-  OUT_COLOR = uColor;
-  OUT_COLOR.a *= GetOpacity();
+  gl_FragColor = uColor;
+  gl_FragColor.a *= GetOpacity();
 }
diff --git a/dali-toolkit/internal/graphics/shaders/arc-visual-round-cap-shader.frag b/dali-toolkit/internal/graphics/shaders/arc-visual-round-cap-shader.frag
index a73cc94084..2cf77abd6e 100644
--- a/dali-toolkit/internal/graphics/shaders/arc-visual-round-cap-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/arc-visual-round-cap-shader.frag
@@ -1,10 +1,17 @@
+//@name arc-visual-round-cap-shader.frag
+
+//@version 100
+
 INPUT mediump vec2 vPosition;
 
-uniform lowp vec4 uColor;
-uniform mediump float thickness;
-uniform mediump float radius;
-uniform mediump float startAngle;
-uniform mediump float sweepAngle;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM mediump float thickness;
+  UNIFORM mediump float radius;
+  UNIFORM mediump float startAngle;
+  UNIFORM mediump float sweepAngle;
+};
 
 const mediump float M_PI_OVER_2 = 1.57079632679;
 const mediump float M_PI_2 = 6.28318530718;
@@ -26,6 +33,6 @@ mediump float GetOpacity()
 
 void main()
 {
-  OUT_COLOR = uColor;
-  OUT_COLOR.a *= GetOpacity();
+  gl_FragColor = uColor;
+  gl_FragColor.a *= GetOpacity();
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/arc-visual-shader.vert b/dali-toolkit/internal/graphics/shaders/arc-visual-shader.vert
index 4f6dab5789..77dad610c9 100644
--- a/dali-toolkit/internal/graphics/shaders/arc-visual-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/arc-visual-shader.vert
@@ -1,15 +1,23 @@
+//@name arc-visual-shader.vert
+
+//@version 100
+
 INPUT mediump vec2 aPosition;
 OUTPUT mediump vec2 vPosition;
 
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
 
 //Visual size and offset
-uniform mediump vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+  UNIFORM mediump vec2 offset;
+  UNIFORM highp vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+};
+
 
 vec4 ComputeVertexPosition()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/bloom-view-composite-shader.frag b/dali-toolkit/internal/graphics/shaders/bloom-view-composite-shader.frag
index ff5778b8f4..affb1571bf 100644
--- a/dali-toolkit/internal/graphics/shaders/bloom-view-composite-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/bloom-view-composite-shader.frag
@@ -1,12 +1,20 @@
+//@name bloom-view-composite-shader.frag
+
+//@version 100
+
 precision mediump float;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform sampler2D sEffect;
-uniform lowp vec4 uColor;
-uniform float uBloomIntensity;
-uniform float uImageIntensity;
-uniform float uBloomSaturation;
-uniform float uImageSaturation;
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM sampler2D sEffect;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM float uBloomIntensity;
+  UNIFORM float uImageIntensity;
+  UNIFORM float uBloomSaturation;
+  UNIFORM float uImageSaturation;
+};
 
 vec4 ChangeSaturation(vec4 col, float sat)
 {
@@ -18,8 +26,8 @@ void main()
 {
   mediump vec4 image;
   mediump vec4 bloom;
-  image = texture2D(sTexture, vTexCoord);
-  bloom = texture2D(sEffect, vTexCoord);
+  image = TEXTURE(sTexture, vTexCoord);
+  bloom = TEXTURE(sEffect, vTexCoord);
   image = ChangeSaturation(image, uImageSaturation) * uImageIntensity;
   bloom = ChangeSaturation(bloom, uBloomSaturation) * uBloomIntensity;
   image *= 1.0 - clamp(bloom, 0.0, 1.0); // darken base where bloom is strong, to prevent excessive burn-out of result
diff --git a/dali-toolkit/internal/graphics/shaders/bloom-view-extract-shader.frag b/dali-toolkit/internal/graphics/shaders/bloom-view-extract-shader.frag
index 98439ed87d..d65579704c 100644
--- a/dali-toolkit/internal/graphics/shaders/bloom-view-extract-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/bloom-view-extract-shader.frag
@@ -1,13 +1,20 @@
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
-uniform mediump float uBloomThreshold;
-uniform mediump float uRecipOneMinusBloomThreshold;
+//@name bloom-view-extract-shader.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM mediump float uBloomThreshold;
+  UNIFORM mediump float uRecipOneMinusBloomThreshold;
+};
 
 void main()
 {
   mediump vec4 col;
-  col = texture2D(sTexture, vTexCoord);
+  col = TEXTURE(sTexture, vTexCoord);
   col = (col - uBloomThreshold) * uRecipOneMinusBloomThreshold; // remove intensities lower than the thresold and remap intensities above the threshold to [0..1]
   gl_FragColor = clamp(col, 0.0, 1.0);
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/blur-effect.frag b/dali-toolkit/internal/graphics/shaders/blur-effect.frag
index 0f0ca14c22..ebe3511f8b 100644
--- a/dali-toolkit/internal/graphics/shaders/blur-effect.frag
+++ b/dali-toolkit/internal/graphics/shaders/blur-effect.frag
@@ -1,14 +1,21 @@
-varying highp vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform highp vec2 uSampleOffsets[NUM_SAMPLES];
-uniform highp float uSampleWeights[NUM_SAMPLES];
+//@name blur-effect.frag
+
+//@version 100
+
+INPUT highp vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM highp vec2 uSampleOffsets[NUM_SAMPLES];
+  UNIFORM highp float uSampleWeights[NUM_SAMPLES];
+};
 
 void main()
 {
   highp vec4 col = vec4(0.0);
   for (int i=0; i<NUM_SAMPLES; ++i)
   {
-    col += (texture2D(sTexture, vTexCoord + uSampleOffsets[i]) + texture2D(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
+    col += (TEXTURE(sTexture, vTexCoord + uSampleOffsets[i]) + TEXTURE(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
   }
   gl_FragColor = col;
 }
diff --git a/dali-toolkit/internal/graphics/shaders/blur-two-images-shader.frag b/dali-toolkit/internal/graphics/shaders/blur-two-images-shader.frag
index 7572a28e0a..765780eef4 100644
--- a/dali-toolkit/internal/graphics/shaders/blur-two-images-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/blur-two-images-shader.frag
@@ -1,11 +1,20 @@
+//@name blur-two-images-shader.frag
+
+//@version 100
+
 precision highp float;
-uniform float uBlurStrength;
-uniform sampler2D sTexture;
-uniform sampler2D sEffect;
-varying mediump vec2 vTexCoord;
+
+UNIFORM_BLOCK FragBlock
+{
+    UNIFORM float uBlurStrength;
+};
+
+UNIFORM sampler2D sTexture;
+UNIFORM sampler2D sEffect;
+INPUT mediump vec2 vTexCoord;
 
 void main()
 {
-  gl_FragColor = texture2D( sTexture, vTexCoord ) * uBlurStrength
-               + texture2D( sEffect, vTexCoord )*(1.0-uBlurStrength);
+  gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uBlurStrength
+               + TEXTURE( sEffect, vTexCoord )*(1.0-uBlurStrength);
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/blur-two-pass-shader.frag b/dali-toolkit/internal/graphics/shaders/blur-two-pass-shader.frag
index 0017e28533..733335ed1c 100644
--- a/dali-toolkit/internal/graphics/shaders/blur-two-pass-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/blur-two-pass-shader.frag
@@ -1,15 +1,22 @@
+//@name blur-two-pass-shader.frag
+
+//@version 100
+
 precision highp float;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform vec2 uSampleOffsets[NUM_SAMPLES];
-uniform float uSampleWeights[NUM_SAMPLES];
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM vec2 uSampleOffsets[NUM_SAMPLES];
+  UNIFORM float uSampleWeights[NUM_SAMPLES];
+};
 
 void main()
 {
   vec4 color = vec4(0.0);
   for( int i = 0; i < NUM_SAMPLES; ++i )
   {
-    color += texture2D( sTexture, vTexCoord + uSampleOffsets[i] ) * uSampleWeights[i];
+    color += TEXTURE( sTexture, vTexCoord + uSampleOffsets[i] ) * uSampleWeights[i];
   }
   gl_FragColor = color;
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/border-visual-anti-aliasing-shader.frag b/dali-toolkit/internal/graphics/shaders/border-visual-anti-aliasing-shader.frag
index 11950925c8..9fe7a27216 100644
--- a/dali-toolkit/internal/graphics/shaders/border-visual-anti-aliasing-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/border-visual-anti-aliasing-shader.frag
@@ -1,11 +1,18 @@
+//@name border-visual-anti-aliasing-shader.frag
+
+//@version 100
+
 INPUT mediump float vAlpha;
 
-uniform lowp vec4 uColor;
-uniform lowp vec4 borderColor;
-uniform mediump float borderSize;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM lowp vec4 borderColor;
+  UNIFORM mediump float borderSize;
+};
 
 void main()
 {
-  OUT_COLOR = borderColor * uColor;
-  OUT_COLOR.a *= smoothstep(0.0, 1.5, vAlpha) * smoothstep( borderSize + 1.5, borderSize, vAlpha );
+  gl_FragColor = borderColor * uColor;
+  gl_FragColor.a *= smoothstep(0.0, 1.5, vAlpha) * smoothstep( borderSize + 1.5, borderSize, vAlpha );
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/border-visual-anti-aliasing-shader.vert b/dali-toolkit/internal/graphics/shaders/border-visual-anti-aliasing-shader.vert
index e573f37916..4e8573dcae 100644
--- a/dali-toolkit/internal/graphics/shaders/border-visual-anti-aliasing-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/border-visual-anti-aliasing-shader.vert
@@ -1,10 +1,23 @@
+//@name border-visual-anti-aliasing-shader.vert
+
+//@version 100
+
 INPUT mediump vec2 aPosition;
 INPUT mediump vec2 aDrift;
 OUTPUT mediump float vAlpha;
 
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform mediump float borderSize;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
+}
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM lowp vec4 borderColor;
+  UNIFORM mediump float borderSize;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/border-visual-shader.frag b/dali-toolkit/internal/graphics/shaders/border-visual-shader.frag
index de9da9894d..8fc99cd757 100644
--- a/dali-toolkit/internal/graphics/shaders/border-visual-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/border-visual-shader.frag
@@ -1,7 +1,14 @@
-uniform lowp vec4 uColor;
-uniform lowp vec4 borderColor;
+//@name border-visual-shader.frag
+
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM lowp vec4 borderColor;
+};
 
 void main()
 {
-  OUT_COLOR = borderColor * uColor;
+  gl_FragColor = borderColor * uColor;
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/border-visual-shader.vert b/dali-toolkit/internal/graphics/shaders/border-visual-shader.vert
index 6bf08fac45..96b3a84c49 100644
--- a/dali-toolkit/internal/graphics/shaders/border-visual-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/border-visual-shader.vert
@@ -1,16 +1,23 @@
+//@name border-visual-shader.vert
+
+//@version 100
+
 INPUT mediump vec2 aPosition;
 INPUT mediump vec2 aDrift;
 
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform mediump float borderSize;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
+  UNIFORM mediump float borderSize;
 
 //Visual size and offset
-uniform mediump vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+  UNIFORM mediump vec2 offset;
+  UNIFORM highp vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+};
 
 vec2 ComputeVertexPosition()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/bouncing-effect-mesh-shader.frag b/dali-toolkit/internal/graphics/shaders/bouncing-effect-mesh-shader.frag
index b62f151af5..b9b939876d 100644
--- a/dali-toolkit/internal/graphics/shaders/bouncing-effect-mesh-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/bouncing-effect-mesh-shader.frag
@@ -1,5 +1,12 @@
+//@name bouncing-effect-mesh-shader.frag
+
+//@version 100
+
 // Use the actor color to paint every layer
-uniform lowp vec4 uColor;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/bouncing-effect-mesh-shader.vert b/dali-toolkit/internal/graphics/shaders/bouncing-effect-mesh-shader.vert
index da6933200f..fa5ba13a18 100644
--- a/dali-toolkit/internal/graphics/shaders/bouncing-effect-mesh-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/bouncing-effect-mesh-shader.vert
@@ -1,9 +1,16 @@
+//@name bouncing-effect-mesh-shader.vert
+
+//@version 100
+
 // Modify the vertex position according to the bounce coefficient
-attribute mediump vec3    aPosition1;
-attribute mediump vec3    aPosition2;
-uniform   mediump mat4    uMvpMatrix;
-uniform   mediump vec3    uSize;
-uniform   mediump float   uBounceCoefficient;
+INPUT mediump vec3    aPosition1;
+INPUT mediump vec3    aPosition2;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM   mediump mat4    uMvpMatrix;
+  UNIFORM   mediump vec3    uSize;
+  UNIFORM   mediump float   uBounceCoefficient;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/bubble-effect-color-adjuster.frag b/dali-toolkit/internal/graphics/shaders/bubble-effect-color-adjuster.frag
index 69ff187aa8..3d881d868b 100644
--- a/dali-toolkit/internal/graphics/shaders/bubble-effect-color-adjuster.frag
+++ b/dali-toolkit/internal/graphics/shaders/bubble-effect-color-adjuster.frag
@@ -1,8 +1,17 @@
+//@name bubble-effect-color-adjuster.frag
+
+//@version 100
+
 precision highp float;
-uniform vec3 uHSVDelta;
-uniform float uIgnoreAlpha;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM vec3 uHSVDelta;
+  UNIFORM float uIgnoreAlpha;
+};
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
 
 float rand(vec2 co)
 {
@@ -29,7 +38,7 @@ vec3 hsv2rgb(vec3 c)
 
 void main()
 {
-  vec4 color = texture2D(sTexture, vTexCoord);
+  vec4 color = TEXTURE(sTexture, vTexCoord);
   vec3 hsvColor = rgb2hsv( color.rgb );
   // modify the hsv Value
   hsvColor += uHSVDelta * rand(vTexCoord);
diff --git a/dali-toolkit/internal/graphics/shaders/bubble-effect.frag b/dali-toolkit/internal/graphics/shaders/bubble-effect.frag
index fa06063367..17772c8bd3 100644
--- a/dali-toolkit/internal/graphics/shaders/bubble-effect.frag
+++ b/dali-toolkit/internal/graphics/shaders/bubble-effect.frag
@@ -1,18 +1,26 @@
-varying mediump vec2 vTexCoord;
-uniform lowp vec4 uColor;
-uniform sampler2D sBackground;
-uniform sampler2D sBubbleShape;
-varying mediump float vPercentage;
-varying mediump vec2 vEffectTexCoord;
+//@name bubble-effect.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sBackground;
+UNIFORM sampler2D sBubbleShape;
+INPUT mediump float vPercentage;
+INPUT mediump vec2 vEffectTexCoord;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
   // Get the emit pisition color, and Mix with the actor color
-  mediump vec4 fragColor = texture2D(sBackground, vEffectTexCoord)*uColor;
+  mediump vec4 fragColor = TEXTURE(sBackground, vEffectTexCoord)*uColor;
 
   // Apply the shape defined by the texture contained sBubbleShape
   // And make the opacity being 0.7, and animate from 0.7 to 0 during the last 1/3 of movement
-  fragColor.a*= texture2D(sBubbleShape, vTexCoord).a * ( 2.1 - max( vPercentage*2.1, 1.4 ) );
+  fragColor.a*= TEXTURE(sBubbleShape, vTexCoord).a * ( 2.1 - max( vPercentage*2.1, 1.4 ) );
 
   gl_FragColor = fragColor;
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/bubble-effect.vert b/dali-toolkit/internal/graphics/shaders/bubble-effect.vert
index 538d282a0d..c4d113535f 100644
--- a/dali-toolkit/internal/graphics/shaders/bubble-effect.vert
+++ b/dali-toolkit/internal/graphics/shaders/bubble-effect.vert
@@ -1,24 +1,32 @@
-attribute mediump float aIndex;
-attribute mediump vec2  aPosition;
-attribute highp   vec2  aTexCoord;
-varying   mediump vec2  vTexCoord;
-uniform   mediump mat4  uMvpMatrix;
+//@name bubble-effect.vert
+
+//@version 100
+
+INPUT mediump float aIndex;
+INPUT mediump vec2  aPosition;
+INPUT highp   vec2  aTexCoord;
+OUTPUT   mediump vec2  vTexCoord;
+
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM   mediump mat4  uMvpMatrix;
 // the gravity applied to the y direction
-uniform mediump float uGravity;
+  UNIFORM mediump float uGravity;
 // xy: the emit position of the bubble; zw: the destination of the bubble.
 // The bubble is moving from (xy) to (zw plus the y drop influenced by gravity).
-uniform vec4 uStartEndPosition[NUMBER_OF_BUBBLE];
+  UNIFORM vec4 uStartEndPosition[NUMBER_OF_BUBBLE];
 // The undergoing percentage of the bubble movement. 0.0: start from emit position, 1.0: reach the destination
-uniform float uPercentage[NUMBER_OF_BUBBLE];
-uniform vec2 uInvertedMovementArea;
-// The bubble number is restricted by the available uniform num.
-// To increase the displayed bubble, every uStartEndPosition and uPercentage uniform is applied to a small bunch of bubbles (9 here)
+  UNIFORM float uPercentage[NUMBER_OF_BUBBLE];
+  UNIFORM vec2 uInvertedMovementArea;
+// The bubble number is restricted by the available UNIFORM num.
+// To increase the displayed bubble, every uStartEndPosition and uPercentage UNIFORM is applied to a small bunch of bubbles (9 here)
 // The offset defines the random offset between bubbles within the bunch.
-uniform vec2 uOffset[9];
-// This uniform is used to change the bubble size during running time
-uniform float uDynamicScale;
-varying float vPercentage;
-varying vec2  vEffectTexCoord;
+  UNIFORM vec2 uOffset[9];
+// This UNIFORM is used to change the bubble size during running time
+  UNIFORM float uDynamicScale;
+};
+OUTPUT float vPercentage;
+OUTPUT vec2  vEffectTexCoord;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/bubble-emitter.frag b/dali-toolkit/internal/graphics/shaders/bubble-emitter.frag
index 06690f8779..e66b29fa20 100644
--- a/dali-toolkit/internal/graphics/shaders/bubble-emitter.frag
+++ b/dali-toolkit/internal/graphics/shaders/bubble-emitter.frag
@@ -1,7 +1,16 @@
+//@name bubble-emitter.frag
+
+//@version 100
+
 precision highp float;
-uniform vec3 uHSVDelta;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM vec3 uHSVDelta;
+};
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
 
 float rand(vec2 co)
 {
@@ -28,7 +37,7 @@ vec3 hsv2rgb(vec3 c)
 
 void main()
 {
-  vec4 color = texture2D(sTexture, vTexCoord);
+  vec4 color = TEXTURE(sTexture, vTexCoord);
   vec3 hsvColor = rgb2hsv( color.rgb );
   // modify the hsv Value
   hsvColor += uHSVDelta * rand(vTexCoord);
diff --git a/dali-toolkit/internal/graphics/shaders/bubble-emitter.vert b/dali-toolkit/internal/graphics/shaders/bubble-emitter.vert
index f7bd5779bf..9b296039cd 100644
--- a/dali-toolkit/internal/graphics/shaders/bubble-emitter.vert
+++ b/dali-toolkit/internal/graphics/shaders/bubble-emitter.vert
@@ -1,8 +1,15 @@
-attribute mediump vec2 aPosition;
-attribute mediump vec2 aTexCoord;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-varying mediump vec2 vTexCoord;
+//@name bubble-emitter.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+INPUT mediump vec2 aTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump vec3 uSize;
+  UNIFORM mediump mat4 uMvpMatrix;
+};
+OUTPUT mediump vec2 vTexCoord;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/canvas-view.frag b/dali-toolkit/internal/graphics/shaders/canvas-view.frag
index e122bca414..eb74278693 100644
--- a/dali-toolkit/internal/graphics/shaders/canvas-view.frag
+++ b/dali-toolkit/internal/graphics/shaders/canvas-view.frag
@@ -1,8 +1,16 @@
-uniform lowp vec4 uColor;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
+//@name canvas-view.frag
+
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
 
 void main()
 {
-  gl_FragColor = texture2D(sTexture, vTexCoord) * uColor;
+  gl_FragColor = TEXTURE(sTexture, vTexCoord) * uColor;
 }
diff --git a/dali-toolkit/internal/graphics/shaders/canvas-view.vert b/dali-toolkit/internal/graphics/shaders/canvas-view.vert
index 69889936da..dca16ef288 100644
--- a/dali-toolkit/internal/graphics/shaders/canvas-view.vert
+++ b/dali-toolkit/internal/graphics/shaders/canvas-view.vert
@@ -1,7 +1,14 @@
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+//@name canvas-view.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/color-visual-shader.frag b/dali-toolkit/internal/graphics/shaders/color-visual-shader.frag
index f5dee44074..8c17ae5d89 100644
--- a/dali-toolkit/internal/graphics/shaders/color-visual-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/color-visual-shader.frag
@@ -1,37 +1,52 @@
+//@name color-visual-shader.frag
+
+//@version 100
+
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
 INPUT highp vec2 vPosition;
-FLAT INPUT highp vec2 vRectSize;
-FLAT INPUT highp vec2 vOptRectSize;
-FLAT INPUT highp float vAliasMargin;
+INPUT flat highp vec2 vRectSize;
+INPUT flat highp vec2 vOptRectSize;
+INPUT flat highp float vAliasMargin;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT INPUT highp vec4 vCornerRadius;
+INPUT flat highp vec4 vCornerRadius;
 #endif
 #endif
 #if defined(IS_REQUIRED_CUTOUT)
 INPUT highp vec2 vPositionFromCenter;
 #if defined(IS_REQUIRED_ROUNDED_CORNER)
-FLAT INPUT highp vec4 vCutoutCornerRadius;
+INPUT flat highp vec4 vCutoutCornerRadius;
 #endif
 #endif
 
-uniform lowp vec4 uColor;
-#ifdef IS_REQUIRED_BLUR
-uniform highp float blurRadius;
-#elif defined(IS_REQUIRED_BORDERLINE)
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
-uniform lowp vec4 borderlineColor;
-uniform lowp vec4 uActorColor;
+UNIFORM_BLOCK FragBlock
+{
+    UNIFORM lowp vec4 uColor;
+#if defined(IS_REQUIRED_BORDERLINE)
+    UNIFORM lowp vec4 uActorColor;
+#endif
+
+#if defined(IS_REQUIRED_CUTOUT)
+    UNIFORM lowp int uCutoutWithCornerRadius;
 #endif
 
 #ifdef IS_REQUIRED_SQUIRCLE_CORNER
-uniform highp vec4 cornerSquareness;
+    UNIFORM highp vec4 cornerSquareness;
 #endif
+};
 
-#if defined(IS_REQUIRED_CUTOUT)
-uniform highp vec3 uSize;
-uniform lowp int uCutoutWithCornerRadius;
+UNIFORM_BLOCK SharedBlock
+{
+    UNIFORM highp vec3 uSize;
+
+#ifdef IS_REQUIRED_BLUR
+    UNIFORM highp float blurRadius;
+#elif defined(IS_REQUIRED_BORDERLINE)
+    UNIFORM highp float borderlineWidth;
+    UNIFORM highp float borderlineOffset;
+    UNIFORM lowp vec4 borderlineColor;
 #endif
+};
+
 
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
 // Global values both rounded corner and borderline use
@@ -370,7 +385,7 @@ void main()
   // skip most potential calculate for performance
   if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
   {
-    OUT_COLOR = targetColor;
+    gl_FragColor = targetColor;
   }
   else
   {
@@ -388,17 +403,17 @@ void main()
     calculatePotential();
     setupMinMaxPotential(tempBorderlineWidth);
 
-    OUT_COLOR = targetColor;
+    gl_FragColor = targetColor;
 
     mediump float opacity = calculateBlurOpacity();
-    OUT_COLOR *= opacity;
+    gl_FragColor *= opacity;
 #else
 #if defined(IS_REQUIRED_ROUNDED_CORNER) && !defined(IS_REQUIRED_BORDERLINE)
     // skip rounded corner calculate for performance
     if(gFragmentPosition.x + gFragmentPosition.y < -(gRadius + vAliasMargin) * 2.0)
     {
       // Do nothing.
-      OUT_COLOR = targetColor;
+      gl_FragColor = targetColor;
     }
     else
 #endif
@@ -416,11 +431,11 @@ void main()
 #endif
 #endif
 
-      OUT_COLOR = targetColor;
+      gl_FragColor = targetColor;
 
 #ifdef IS_REQUIRED_ROUNDED_CORNER
       mediump float opacity = calculateCornerOpacity();
-      OUT_COLOR *= opacity;
+      gl_FragColor *= opacity;
 #endif
     }
 #endif
@@ -430,6 +445,6 @@ void main()
 #endif
 
 #ifdef IS_REQUIRED_CUTOUT
-  OUT_COLOR *= discardOpacity;
+  gl_FragColor *= discardOpacity;
 #endif
 }
diff --git a/dali-toolkit/internal/graphics/shaders/color-visual-shader.vert b/dali-toolkit/internal/graphics/shaders/color-visual-shader.vert
index 0e02279307..e2c21da1d0 100644
--- a/dali-toolkit/internal/graphics/shaders/color-visual-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/color-visual-shader.vert
@@ -1,45 +1,60 @@
+//@name color-visual-shader.vert
+
+//@version 100
+
 INPUT mediump vec2 aPosition;
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
 OUTPUT highp vec2 vPosition;
-FLAT OUTPUT highp vec2 vRectSize;
-FLAT OUTPUT highp vec2 vOptRectSize;
-FLAT OUTPUT highp float vAliasMargin;
+OUTPUT flat highp vec2 vRectSize;
+OUTPUT flat highp vec2 vOptRectSize;
+OUTPUT flat highp float vAliasMargin;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT OUTPUT highp vec4 vCornerRadius;
+OUTPUT flat highp vec4 vCornerRadius;
 #endif
 #endif
 #if defined(IS_REQUIRED_CUTOUT)
 OUTPUT highp vec2 vPositionFromCenter;
 #if defined(IS_REQUIRED_ROUNDED_CORNER)
-FLAT OUTPUT highp vec4 vCutoutCornerRadius;
+OUTPUT flat highp vec4 vCutoutCornerRadius;
 #endif
 #endif
 
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+
+  #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
+  // Be used when we calculate anti-alias range near 1 pixel.
+  UNIFORM highp vec3 uScale;
+  #endif
 
-#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
-// Be used when we calculate anti-alias range near 1 pixel.
-uniform highp vec3 uScale;
+  //Visual size and offset
+  UNIFORM highp vec2 offset;
+  UNIFORM highp vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+
+#ifdef IS_REQUIRED_ROUNDED_CORNER
+  UNIFORM highp vec4 cornerRadius;
+  UNIFORM mediump float cornerRadiusPolicy;
 #endif
+  UNIFORM highp vec2 extraSize;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+    UNIFORM highp vec3 uSize;
 
-//Visual size and offset
-uniform highp vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
 #ifdef IS_REQUIRED_BLUR
-uniform highp float blurRadius;
+    UNIFORM highp float blurRadius;
 #elif defined(IS_REQUIRED_BORDERLINE)
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
+    UNIFORM highp float borderlineWidth;
+    UNIFORM highp float borderlineOffset;
+    UNIFORM lowp vec4 borderlineColor;
 #endif
-#ifdef IS_REQUIRED_ROUNDED_CORNER
-uniform highp vec4 cornerRadius;
-uniform mediump float cornerRadiusPolicy;
-#endif
-uniform highp vec2 extraSize;
+};
+
 
 vec4 ComputeVertexPosition()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/control-renderers.frag b/dali-toolkit/internal/graphics/shaders/control-renderers.frag
index e0d08bf397..1d7852d793 100644
--- a/dali-toolkit/internal/graphics/shaders/control-renderers.frag
+++ b/dali-toolkit/internal/graphics/shaders/control-renderers.frag
@@ -1,10 +1,16 @@
-precision highp float;
-varying highp vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform vec4 uColor;
+//@name control-renderers.frag
+
+//@version 100
 
+precision highp float;
+INPUT highp vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragColor
+{
+  UNIFORM vec4 uColor;
+};
 void main()
 {
-  gl_FragColor = texture2D(sTexture, vTexCoord);
+  gl_FragColor = TEXTURE(sTexture, vTexCoord);
   gl_FragColor *= uColor;
 }
diff --git a/dali-toolkit/internal/graphics/shaders/control-renderers.vert b/dali-toolkit/internal/graphics/shaders/control-renderers.vert
index 0183ee45a9..5b52919e76 100644
--- a/dali-toolkit/internal/graphics/shaders/control-renderers.vert
+++ b/dali-toolkit/internal/graphics/shaders/control-renderers.vert
@@ -1,9 +1,15 @@
-precision highp float;
-attribute highp vec2 aPosition;
-varying highp vec2 vTexCoord;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+//@name control-renderers.vert
+
+//@version 100
 
+precision highp float;
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
+};
 void main()
 {
   highp vec4 vertexPosition = vec4(aPosition * uSize.xy, 0.0, 1.0);
diff --git a/dali-toolkit/internal/graphics/shaders/cube-transition-effect.frag b/dali-toolkit/internal/graphics/shaders/cube-transition-effect.frag
index b8b19ac5a6..532cb1178c 100644
--- a/dali-toolkit/internal/graphics/shaders/cube-transition-effect.frag
+++ b/dali-toolkit/internal/graphics/shaders/cube-transition-effect.frag
@@ -1,9 +1,16 @@
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
-uniform lowp vec4 uSamplerRect;
+//@name cube-transition-effect.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM lowp vec4 uSamplerRect;
+};
 
 void main()
 {
-  gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+  gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
 }
diff --git a/dali-toolkit/internal/graphics/shaders/cube-transition-effect.vert b/dali-toolkit/internal/graphics/shaders/cube-transition-effect.vert
index fccd0355e0..2ede71ca99 100644
--- a/dali-toolkit/internal/graphics/shaders/cube-transition-effect.vert
+++ b/dali-toolkit/internal/graphics/shaders/cube-transition-effect.vert
@@ -1,8 +1,15 @@
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform mediump vec4 uTextureRect;
+//@name cube-transition-effect.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM mediump vec3 uSize;
+  UNIFORM mediump vec4 uTextureRect;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/dissolve-effect.frag b/dali-toolkit/internal/graphics/shaders/dissolve-effect.frag
index e28a074879..ca8f4f9d72 100644
--- a/dali-toolkit/internal/graphics/shaders/dissolve-effect.frag
+++ b/dali-toolkit/internal/graphics/shaders/dissolve-effect.frag
@@ -1,9 +1,15 @@
-varying float        vPercentage;
-varying mediump vec2 vTexCoord;
+//@name dissolve-effect.frag
 
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
-uniform vec4 uTextureRect;
+//@version 100
+
+INPUT float        vPercentage;
+INPUT mediump vec2 vTexCoord;
+
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 float rand(vec2 co)
 {
@@ -16,6 +22,6 @@ void main()
   float  offsetS = rand(vTexCoord * vPercentage) - vTexCoord.s;
   float offsetT = rand(vec2(vTexCoord.t * vPercentage, vTexCoord.s * vPercentage)) - vTexCoord.t;
   vec2 lookupCoord = vTexCoord + vec2(offsetS, offsetT) * vPercentage;
-  gl_FragColor = texture2D(sTexture, lookupCoord) * uColor;
+  gl_FragColor = TEXTURE(sTexture, lookupCoord) * uColor;
   gl_FragColor.a *= 1.0 - vPercentage;
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/dissolve-effect.vert b/dali-toolkit/internal/graphics/shaders/dissolve-effect.vert
index be8c3dfc77..e03d9c551b 100644
--- a/dali-toolkit/internal/graphics/shaders/dissolve-effect.vert
+++ b/dali-toolkit/internal/graphics/shaders/dissolve-effect.vert
@@ -1,17 +1,25 @@
-attribute mediump vec2 aPosition;
+//@name dissolve-effect.vert
 
-uniform mediump mat4   uMvpMatrix;
-uniform vec3           uSize;
-uniform vec4           uTextureRect;
+//@version 100
 
-uniform float          uPercentage;
-uniform vec3           uSaddleParam;
-uniform vec2           uTranslation;
-uniform vec2           uRotation;
-uniform float          uToNext;
+INPUT mediump vec2 aPosition;
 
-varying float          vPercentage;
-varying vec2           vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump mat4   uMvpMatrix;
+  UNIFORM vec3           uSize;
+
+  UNIFORM float          uPercentage;
+  UNIFORM vec3           uSaddleParam;
+  UNIFORM vec2           uTranslation;
+  UNIFORM vec2           uRotation;
+  UNIFORM float          uToNext;
+};
+
+
+
+OUTPUT float          vPercentage;
+OUTPUT vec2           vTexCoord;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/distance-field-effect.frag b/dali-toolkit/internal/graphics/shaders/distance-field-effect.frag
index 82c294da23..8c83c138f5 100644
--- a/dali-toolkit/internal/graphics/shaders/distance-field-effect.frag
+++ b/dali-toolkit/internal/graphics/shaders/distance-field-effect.frag
@@ -1,24 +1,31 @@
-varying mediump vec2 vTexCoord;
+//@name distance-field-effect.frag
 
-uniform mediump float uGlowBoundary;
-uniform mediump vec2  uOutlineParams;
-uniform lowp    vec4  uOutlineColor;
-uniform lowp    vec4  uShadowColor;
-uniform mediump vec2  uShadowOffset;
-uniform lowp    vec4  uGlowColor;
-uniform lowp    float uDoOutline;
-uniform lowp    float uDoShadow;
-uniform lowp    float uDoGlow;
+//@version 100
 
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM mediump float uGlowBoundary;
+  UNIFORM mediump vec2  uOutlineParams;
+  UNIFORM lowp    vec4  uOutlineColor;
+  UNIFORM lowp    vec4  uShadowColor;
+  UNIFORM mediump vec2  uShadowOffset;
+  UNIFORM lowp    vec4  uGlowColor;
+  UNIFORM lowp    float uDoOutline;
+  UNIFORM lowp    float uDoShadow;
+  UNIFORM lowp    float uDoGlow;
+  UNIFORM lowp    vec4 uColor;
+};
+
+UNIFORM sampler2D sTexture;
 
 void main()
 {
   // sample distance field
   mediump float smoothing = 0.5;
 
-  mediump float distance = texture2D(sTexture, vTexCoord).a;
+  mediump float distance = TEXTURE(sTexture, vTexCoord).a;
   mediump float smoothWidth = fwidth(distance);
   mediump float alphaFactor = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, distance);
   lowp    vec4  color;
@@ -48,7 +55,7 @@ void main()
 
   else // (uDoShadow > 0.0)
   {
-    mediump float shadowDistance = texture2D(sTexture, vTexCoord - uShadowOffset).a;
+    mediump float shadowDistance = TEXTURE(sTexture, vTexCoord - uShadowOffset).a;
     mediump float inText = alphaFactor;
     mediump float inShadow = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, shadowDistance);
 
diff --git a/dali-toolkit/internal/graphics/shaders/effects-view.frag b/dali-toolkit/internal/graphics/shaders/effects-view.frag
index 9c66b3b2a9..bf6f369194 100644
--- a/dali-toolkit/internal/graphics/shaders/effects-view.frag
+++ b/dali-toolkit/internal/graphics/shaders/effects-view.frag
@@ -1,9 +1,17 @@
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 effectColor;
+//@name effects-view.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 effectColor;
+};
 
 void main()
 {
   gl_FragColor = effectColor;
-  gl_FragColor.a *= texture2D( sTexture, vTexCoord).a;
+  gl_FragColor.a *= TEXTURE( sTexture, vTexCoord).a;
 }
diff --git a/dali-toolkit/internal/graphics/shaders/effects-view.vert b/dali-toolkit/internal/graphics/shaders/effects-view.vert
index e8b7984db9..0b3975e01b 100644
--- a/dali-toolkit/internal/graphics/shaders/effects-view.vert
+++ b/dali-toolkit/internal/graphics/shaders/effects-view.vert
@@ -1,8 +1,15 @@
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform mediump vec3 effectOffset;
+//@name effects-view.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM mediump vec3 uSize;
+  UNIFORM mediump vec3 effectOffset;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/emboss-filter-composite-shader.frag b/dali-toolkit/internal/graphics/shaders/emboss-filter-composite-shader.frag
index 1ef9fc19a8..0dca02b109 100644
--- a/dali-toolkit/internal/graphics/shaders/emboss-filter-composite-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/emboss-filter-composite-shader.frag
@@ -1,9 +1,16 @@
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uEffectColor;
+//@name emboss-filter-composite-shader.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uEffectColor;
+};
 
 void main()
 {
   gl_FragColor = uEffectColor;
-  gl_FragColor.a *= texture2D( sTexture, vTexCoord).a;
+  gl_FragColor.a *= TEXTURE( sTexture, vTexCoord).a;
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/emboss-filter-shader.frag b/dali-toolkit/internal/graphics/shaders/emboss-filter-shader.frag
index 2a6761aea4..b73e22f724 100644
--- a/dali-toolkit/internal/graphics/shaders/emboss-filter-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/emboss-filter-shader.frag
@@ -1,13 +1,20 @@
+//@name emboss-filter-shader.frag
+
+//@version 100
+
 precision highp float;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform vec2 uTexScale;
-uniform vec3 uCoefficient;
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM vec2 uTexScale;
+  UNIFORM vec3 uCoefficient;
+};
 
 void main()
 {
-  vec4 color  = uCoefficient.x * texture2D( sTexture, vTexCoord + vec2(0.0, -uTexScale.y) );
-  color += uCoefficient.y * texture2D( sTexture, vTexCoord );
-  color += uCoefficient.z * texture2D( sTexture, vTexCoord + vec2(0.0, uTexScale.y) );
+  vec4 color  = uCoefficient.x * TEXTURE( sTexture, vTexCoord + vec2(0.0, -uTexScale.y) );
+  color += uCoefficient.y * TEXTURE( sTexture, vTexCoord );
+  color += uCoefficient.z * TEXTURE( sTexture, vTexCoord + vec2(0.0, uTexScale.y) );
   gl_FragColor = color;
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/gaussian-blur-view.frag b/dali-toolkit/internal/graphics/shaders/gaussian-blur-view.frag
index 0f0ca14c22..438042cbdf 100644
--- a/dali-toolkit/internal/graphics/shaders/gaussian-blur-view.frag
+++ b/dali-toolkit/internal/graphics/shaders/gaussian-blur-view.frag
@@ -1,14 +1,21 @@
-varying highp vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform highp vec2 uSampleOffsets[NUM_SAMPLES];
-uniform highp float uSampleWeights[NUM_SAMPLES];
+//@name gaussian-blur-view.frag
+
+//@version 100
+
+INPUT highp vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM highp vec2 uSampleOffsets[NUM_SAMPLES];
+  UNIFORM highp float uSampleWeights[NUM_SAMPLES];
+};
 
 void main()
 {
   highp vec4 col = vec4(0.0);
   for (int i=0; i<NUM_SAMPLES; ++i)
   {
-    col += (texture2D(sTexture, vTexCoord + uSampleOffsets[i]) + texture2D(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
+    col += (TEXTURE(sTexture, vTexCoord + uSampleOffsets[i]) + TEXTURE(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
   }
   gl_FragColor = col;
 }
diff --git a/dali-toolkit/internal/graphics/shaders/gl-view.frag b/dali-toolkit/internal/graphics/shaders/gl-view.frag
index 9b0b917552..6b1f51bfe3 100644
--- a/dali-toolkit/internal/graphics/shaders/gl-view.frag
+++ b/dali-toolkit/internal/graphics/shaders/gl-view.frag
@@ -1,8 +1,15 @@
-uniform lowp vec4          uColor;
-varying mediump vec2       vTexCoord;
-uniform samplerExternalOES sTexture;
+//@name gl-view.frag
+
+//@version 100
+INPUT mediump vec2       vTexCoord;
+UNIFORM samplerExternalOES sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4          uColor;
+};
 
 void main()
 {
-  gl_FragColor = texture2D(sTexture, vTexCoord) * uColor;
+  gl_FragColor = TEXTURE(sTexture, vTexCoord) * uColor;
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/gl-view.vert b/dali-toolkit/internal/graphics/shaders/gl-view.vert
index eeec383732..60f7d33049 100644
--- a/dali-toolkit/internal/graphics/shaders/gl-view.vert
+++ b/dali-toolkit/internal/graphics/shaders/gl-view.vert
@@ -1,7 +1,14 @@
-attribute mediump vec2 aPosition;
-uniform mediump mat4   uMvpMatrix;
-uniform mediump vec3   uSize;
-varying mediump vec2   vTexCoord;
+//@name gl-view.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump mat4   uMvpMatrix;
+  UNIFORM mediump vec3   uSize;
+};
+OUTPUT mediump vec2   vTexCoord;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/gltf-basecolor-texture.def b/dali-toolkit/internal/graphics/shaders/gltf-basecolor-texture.def
index b5d47f8709..41797cc8df 100644
--- a/dali-toolkit/internal/graphics/shaders/gltf-basecolor-texture.def
+++ b/dali-toolkit/internal/graphics/shaders/gltf-basecolor-texture.def
@@ -1,4 +1,8 @@
 #define TEXTURE_BASECOLOR
 
-uniform sampler2D uBaseColorSampler;
-uniform int uBaseColorTexCoordIndex;
+UNIFORM sampler2D uBaseColorSampler;
+
+UNIFORM_BLOCK FragBlockBaseColor
+{
+  UNIFORM int uBaseColorTexCoordIndex;
+};
diff --git a/dali-toolkit/internal/graphics/shaders/gltf-emit-texture.def b/dali-toolkit/internal/graphics/shaders/gltf-emit-texture.def
index 8cfce1969c..e0bf297405 100644
--- a/dali-toolkit/internal/graphics/shaders/gltf-emit-texture.def
+++ b/dali-toolkit/internal/graphics/shaders/gltf-emit-texture.def
@@ -1,5 +1,8 @@
 #define TEXTURE_EMIT
 
-uniform sampler2D uEmissiveSampler;
-uniform int uEmissiveTexCoordIndex;
-uniform vec3 uEmissiveFactor;
+UNIFORM sampler2D uEmissiveSampler;
+UNIFORM_BLOCK FragBlockEmissive
+{
+  UNIFORM int  uEmissiveTexCoordIndex;
+  UNIFORM vec3 uEmissiveFactor;
+};
diff --git a/dali-toolkit/internal/graphics/shaders/gltf-gles-version-300.def b/dali-toolkit/internal/graphics/shaders/gltf-gles-version-300.def
index c6e148bc07..ea842618f4 100644
--- a/dali-toolkit/internal/graphics/shaders/gltf-gles-version-300.def
+++ b/dali-toolkit/internal/graphics/shaders/gltf-gles-version-300.def
@@ -1,2 +1,2 @@
-#version 300 es
+//#version 300 es
 precision highp float;
diff --git a/dali-toolkit/internal/graphics/shaders/gltf-ibl-texture.def b/dali-toolkit/internal/graphics/shaders/gltf-ibl-texture.def
index c6a6302bfb..617e882802 100644
--- a/dali-toolkit/internal/graphics/shaders/gltf-ibl-texture.def
+++ b/dali-toolkit/internal/graphics/shaders/gltf-ibl-texture.def
@@ -1,7 +1,11 @@
 #define TEXTURE_IBL
 
-uniform sampler2D ubrdfLUT;
-uniform samplerCube uDiffuseEnvSampler;
-uniform samplerCube uSpecularEnvSampler;
-uniform vec4 uScaleIBLAmbient;
-uniform highp float uMipmapLevel;
+UNIFORM sampler2D ubrdfLUT;
+UNIFORM samplerCube uDiffuseEnvSampler;
+UNIFORM samplerCube uSpecularEnvSampler;
+
+UNIFORM_BLOCK FragBlockIBL
+{
+  UNIFORM vec4        uScaleIBLAmbient;
+  UNIFORM highp float uMipmapLevel;
+};
diff --git a/dali-toolkit/internal/graphics/shaders/gltf-metallicroughness-texture.def b/dali-toolkit/internal/graphics/shaders/gltf-metallicroughness-texture.def
index 7c065db385..4df8eba31a 100644
--- a/dali-toolkit/internal/graphics/shaders/gltf-metallicroughness-texture.def
+++ b/dali-toolkit/internal/graphics/shaders/gltf-metallicroughness-texture.def
@@ -1,4 +1,8 @@
 #define TEXTURE_METALLICROUGHNESS
 
-uniform sampler2D uMetallicRoughnessSampler;
-uniform int uMetallicRoughnessTexCoordIndex;
+UNIFORM sampler2D uMetallicRoughnessSampler;
+
+UNIFORM_BLOCK FragBlockMetRough
+{
+  UNIFORM int uMetallicRoughnessTexCoordIndex;
+};
diff --git a/dali-toolkit/internal/graphics/shaders/gltf-normal-texture.def b/dali-toolkit/internal/graphics/shaders/gltf-normal-texture.def
index 16c851a564..b469b3b39e 100644
--- a/dali-toolkit/internal/graphics/shaders/gltf-normal-texture.def
+++ b/dali-toolkit/internal/graphics/shaders/gltf-normal-texture.def
@@ -1,5 +1,8 @@
 #define TEXTURE_NORMAL
 
-uniform sampler2D uNormalSampler;
-uniform float uNormalScale;
-uniform int uNormalTexCoordIndex;
+UNIFORM sampler2D uNormalSampler;
+UNIFORM_BLOCK     FragBlockNormal
+{
+  UNIFORM float uNormalScale;
+  UNIFORM int   uNormalTexCoordIndex;
+};
diff --git a/dali-toolkit/internal/graphics/shaders/gltf-occulusion-texture.def b/dali-toolkit/internal/graphics/shaders/gltf-occulusion-texture.def
index 2003d47ddb..828252b714 100644
--- a/dali-toolkit/internal/graphics/shaders/gltf-occulusion-texture.def
+++ b/dali-toolkit/internal/graphics/shaders/gltf-occulusion-texture.def
@@ -1,5 +1,8 @@
 #define TEXTURE_OCCLUSION
 
-uniform sampler2D uOcclusionSampler;
-uniform int uOcclusionTexCoordIndex;
-uniform float uOcclusionStrength;
+UNIFORM sampler2D uOcclusionSampler;
+UNIFORM_BLOCK     FragBlockOcclusion
+{
+  UNIFORM int   uOcclusionTexCoordIndex;
+  UNIFORM float uOcclusionStrength;
+};
diff --git a/dali-toolkit/internal/graphics/shaders/gltf-physically-based-shader.frag b/dali-toolkit/internal/graphics/shaders/gltf-physically-based-shader.frag
index 9477e408e2..8c1672daf3 100644
--- a/dali-toolkit/internal/graphics/shaders/gltf-physically-based-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/gltf-physically-based-shader.frag
@@ -1,17 +1,24 @@
-uniform lowp vec3 uLightColor;
-uniform lowp vec4 uBaseColorFactor;
-uniform lowp vec2 uMetallicRoughnessFactors;
-uniform lowp float alphaCutoff;
-uniform lowp float uAlphaMode;
-uniform lowp float uHasLightSource;
+//@name gltf-physically-based-shader.frag
 
-in lowp vec2 vUV[2];
-in lowp mat3 vTBN;
-in lowp vec4 vColor;
-in highp vec3 vLightDirection;
-in highp vec3 vPositionToCamera;
+//@version 100
 
-out vec4 FragColor;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec3 uLightColor;
+  UNIFORM lowp vec4 uBaseColorFactor;
+  UNIFORM lowp vec2 uMetallicRoughnessFactors;
+  UNIFORM lowp float alphaCutoff;
+  UNIFORM lowp float uAlphaMode;
+  UNIFORM lowp float uHasLightSource;
+};
+
+INPUT lowp vec2 vUV[2];
+INPUT lowp mat3 vTBN;
+INPUT lowp vec4 vColor;
+INPUT highp vec3 vLightDirection;
+INPUT highp vec3 vPositionToCamera;
+
+OUTPUT vec4 FragColor;
 
 struct PBRInfo
 {
@@ -75,7 +82,7 @@ void main()
   lowp float perceptualRoughness = uMetallicRoughnessFactors.y;
 
   // Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
-  // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
+  // This layOUTPUT intentionally reserves the 'r' channel for (optional) occlusion map data
 #ifdef TEXTURE_METALLICROUGHNESS
   lowp vec4 metrou = texture(uMetallicRoughnessSampler, vUV[uMetallicRoughnessTexCoordIndex]);
   metallic = metrou.b * metallic;
diff --git a/dali-toolkit/internal/graphics/shaders/gltf-physically-based-shader.vert b/dali-toolkit/internal/graphics/shaders/gltf-physically-based-shader.vert
index 095e8392eb..7d4b5b8837 100644
--- a/dali-toolkit/internal/graphics/shaders/gltf-physically-based-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/gltf-physically-based-shader.vert
@@ -1,23 +1,30 @@
-in highp vec3 aPosition;
-in mediump vec2 aTexCoord0;
-in mediump vec2 aTexCoord1;
-in lowp vec3 aNormal;
-in lowp vec4 aTangent;
-in lowp vec4 aVertexColor;
-
-uniform mediump vec3 uSize;
-uniform mediump mat4 uModelMatrix;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat4 uProjection;
-uniform mediump vec3 uLightVector;
-uniform lowp float uIsPointLight;
-uniform lowp float uHasVertexColor;
-
-out lowp vec2 vUV[2];
-out lowp mat3 vTBN;
-out lowp vec4 vColor;
-out highp vec3 vLightDirection;
-out highp vec3 vPositionToCamera;
+//@name gltf-physically-based-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT mediump vec2 aTexCoord0;
+INPUT mediump vec2 aTexCoord1;
+INPUT lowp vec3 aNormal;
+INPUT lowp vec4 aTangent;
+INPUT lowp vec4 aVertexColor;
+
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump vec3 uSize;
+  UNIFORM mediump mat4 uModelMatrix;
+  UNIFORM mediump mat4 uViewMatrix;
+  UNIFORM mediump mat4 uProjection;
+  UNIFORM mediump vec3 uLightVector;
+  UNIFORM lowp float uIsPointLight;
+  UNIFORM lowp float uHasVertexColor;
+};
+
+OUTPUT lowp vec2 vUV[2];
+OUTPUT lowp mat3 vTBN;
+OUTPUT lowp vec4 vColor;
+OUTPUT highp vec3 vLightDirection;
+OUTPUT highp vec3 vPositionToCamera;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/glyphy-shader-fragment-prefix.frag b/dali-toolkit/internal/graphics/shaders/glyphy-shader-fragment-prefix.frag
index 4cb1423485..553846f86a 100644
--- a/dali-toolkit/internal/graphics/shaders/glyphy-shader-fragment-prefix.frag
+++ b/dali-toolkit/internal/graphics/shaders/glyphy-shader-fragment-prefix.frag
@@ -1,3 +1,7 @@
+//@name glyphy-shader-fragment-prefix.frag
+
+//@version 100
+
 struct Material
 {
   mediump float mOpacity;
@@ -8,17 +12,17 @@ struct Material
   lowp    vec4  mEmissive;
 };
 
-uniform sampler2D     sTexture;
-uniform sampler2D     sOpacityTexture;
-uniform sampler2D     sNormalMapTexture;
-uniform sampler2D     sEffect;
-varying mediump vec2 vTexCoord;
-uniform Material      uMaterial;
-uniform lowp  vec4    uColor;
-varying highp vec4    vVertex;
-varying highp vec3    vNormal;
-varying mediump vec4  vColor;
-uniform vec4 u_atlas_info;
+UNIFORM sampler2D     sTexture;
+UNIFORM sampler2D     sOpacityTexture;
+UNIFORM sampler2D     sNormalMapTexture;
+UNIFORM sampler2D     sEffect;
+INPUT mediump vec2 vTexCoord;
+UNIFORM Material      uMaterial;
+UNIFORM lowp  vec4    uColor;
+INPUT highp vec4    vVertex;
+INPUT highp vec3    vNormal;
+INPUT mediump vec4  vColor;
+UNIFORM vec4 u_atlas_info;
 
 #define GLYPHY_TEXTURE1D_EXTRA_DECLS , sampler2D _tex, ivec4 _atlas_info, ivec2 _atlas_pos
 #define GLYPHY_TEXTURE1D_EXTRA_ARGS , _tex, _atlas_info, _atlas_pos
@@ -30,5 +34,5 @@ vec4 glyphy_texture1D_func (int offset GLYPHY_TEXTURE1D_EXTRA_DECLS)
   vec2 pos = (vec2 (_atlas_pos.xy * item_geom +
                     ivec2 (mod (float (offset), float (item_geom.x)), offset / item_geom.x)) +
              + vec2 (.5, .5)) / vec2(_atlas_info.xy);
-  return texture2D (_tex, pos);
+  return TEXTURE (_tex, pos);
 }
diff --git a/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.frag b/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.frag
index 4fc43da682..22d14361fb 100644
--- a/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.frag
+++ b/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.frag
@@ -1,10 +1,14 @@
-uniform float u_contrast;
-uniform float u_gamma_adjust;
-uniform float u_outline_thickness;
-uniform float u_outline;
-uniform float u_boldness;
+//@name glyphy-shader-main.frag
 
-varying vec4 v_glyph;
+//@version 100
+
+UNIFORM float u_contrast;
+UNIFORM float u_gamma_adjust;
+UNIFORM float u_outline_thickness;
+UNIFORM float u_outline;
+UNIFORM float u_boldness;
+
+INPUT vec4 v_glyph;
 
 #define SQRT2_2 0.70711 /* 1 / sqrt(2.) */
 #define SQRT2   1.41421
diff --git a/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.vert b/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.vert
index 9b0f342c91..8f26a2164c 100644
--- a/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.vert
+++ b/dali-toolkit/internal/graphics/shaders/glyphy-shader-main.vert
@@ -1,18 +1,22 @@
-uniform   mediump mat4    uProjection;
-uniform   mediump mat4    uModelView;
-uniform   mediump mat4    uMvpMatrix;
-uniform           bool    uTextureMapped;
-uniform   mediump vec4    uCustomTextureCoords;
-attribute highp   vec2    aTexCoord;
-varying   mediump vec2    vTexCoord;
-uniform   mat3            uModelViewIT;
-attribute mediump vec3    aNormal;
-varying   mediump vec3    vNormal;
-attribute mediump vec2    aPosition;
-varying   mediump vec4    vVertex;
-attribute mediump vec4    aColor;
-varying   mediump vec4    vColor;
-varying vec4 v_glyph;
+//@name glyphy-shader-main.vert
+
+//@version 100
+
+UNIFORM   mediump mat4    uProjection;
+UNIFORM   mediump mat4    uModelView;
+UNIFORM   mediump mat4    uMvpMatrix;
+UNIFORM           bool    uTextureMapped;
+UNIFORM   mediump vec4    uCustomTextureCoords;
+INPUT highp   vec2    aTexCoord;
+OUTPUT   mediump vec2    vTexCoord;
+UNIFORM   mat3            uModelViewIT;
+INPUT mediump vec3    aNormal;
+OUTPUT   mediump vec3    vNormal;
+INPUT mediump vec2    aPosition;
+OUTPUT   mediump vec4    vVertex;
+INPUT mediump vec4    aColor;
+OUTPUT   mediump vec4    vColor;
+OUTPUT vec4 v_glyph;
 
 vec4 glyph_vertex_transcode (vec2 v)
 {
diff --git a/dali-toolkit/internal/graphics/shaders/gradient-visual-shader.frag b/dali-toolkit/internal/graphics/shaders/gradient-visual-shader.frag
index 44d4d7c8d2..30424bae26 100644
--- a/dali-toolkit/internal/graphics/shaders/gradient-visual-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/gradient-visual-shader.frag
@@ -1,24 +1,35 @@
+//@name gradient-visual-shader.frag
+
+//@version 100
+
 INPUT mediump vec2 vTexCoord;
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
 INPUT highp vec2 vPosition;
-FLAT INPUT highp vec2 vRectSize;
-FLAT INPUT highp vec2 vOptRectSize;
-FLAT INPUT highp float vAliasMargin;
+INPUT flat highp vec2 vRectSize;
+INPUT flat highp vec2 vOptRectSize;
+INPUT flat highp float vAliasMargin;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT INPUT highp vec4 vCornerRadius;
+INPUT flat highp vec4 vCornerRadius;
 #endif
 #endif
 
-// scale factor to fit start and end position of gradient.
-uniform mediump float uTextureCoordinateScaleFactor;
+UNIFORM sampler2D sTexture; // sampler1D?
+
+UNIFORM_BLOCK FragBlock
+{
+  // scale factor to fit start and end position of gradient.
+  UNIFORM mediump float uTextureCoordinateScaleFactor;
+  UNIFORM lowp vec4 uColor;
+};
 
-uniform sampler2D sTexture; // sampler1D?
-uniform lowp vec4 uColor;
 #ifdef IS_REQUIRED_BORDERLINE
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
-uniform lowp vec4 borderlineColor;
-uniform lowp vec4 uActorColor;
+UNIFORM_BLOCK SharedBlock
+{
+  UNIFORM highp float borderlineWidth;
+  UNIFORM highp float borderlineOffset;
+  UNIFORM lowp vec4   borderlineColor;
+  UNIFORM lowp vec4   uActorColor;
+};
 #endif
 
 #ifdef IS_REQUIRED_SQUIRCLE_CORNER
@@ -248,7 +259,7 @@ void main()
   // skip most potential calculate for performance
   if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
   {
-    OUT_COLOR = textureColor;
+    gl_FragColor = textureColor;
   }
   else
   {
@@ -261,7 +272,7 @@ void main()
     if(gFragmentPosition.x + gFragmentPosition.y < -(gRadius + vAliasMargin) * 2.0)
     {
       // Do nothing.
-      OUT_COLOR = textureColor;
+      gl_FragColor = textureColor;
     }
     else
 #endif
@@ -275,11 +286,11 @@ void main()
 #ifdef IS_REQUIRED_BORDERLINE
       textureColor = convertBorderlineColor(textureColor);
 #endif
-      OUT_COLOR = textureColor;
+      gl_FragColor = textureColor;
 
 #ifdef IS_REQUIRED_ROUNDED_CORNER
       mediump float opacity = calculateCornerOpacity();
-      OUT_COLOR *= opacity;
+      gl_FragColor *= opacity;
 #endif
     }
 
diff --git a/dali-toolkit/internal/graphics/shaders/gradient-visual-shader.vert b/dali-toolkit/internal/graphics/shaders/gradient-visual-shader.vert
index 95feb12b7e..06ec2bc0fc 100644
--- a/dali-toolkit/internal/graphics/shaders/gradient-visual-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/gradient-visual-shader.vert
@@ -1,38 +1,51 @@
+//@name gradient-visual-shader.vert
+
+//@version 100
+
 INPUT mediump vec2 aPosition;
 OUTPUT mediump vec2 vTexCoord;
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
 OUTPUT highp vec2 vPosition;
-FLAT OUTPUT highp vec2 vRectSize;
-FLAT OUTPUT highp vec2 vOptRectSize;
-FLAT OUTPUT highp float vAliasMargin;
+OUTPUT flat highp vec2 vRectSize;
+OUTPUT flat highp vec2 vOptRectSize;
+OUTPUT flat highp float vAliasMargin;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT OUTPUT highp vec4 vCornerRadius;
+OUTPUT flat highp vec4 vCornerRadius;
 #endif
 #endif
 
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform mediump mat3 uAlignmentMatrix;
-
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4   uMvpMatrix;
+  UNIFORM highp vec3   uSize;
+  UNIFORM mediump mat3 uAlignmentMatrix;
 #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
-// Be used when we calculate anti-alias range near 1 pixel.
-uniform highp vec3 uScale;
+  // Be used when we calculate anti-alias range near 1 pixel.
+  UNIFORM highp vec3 uScale;
 #endif
 
-//Visual size and offset
-uniform highp vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
-#ifdef IS_REQUIRED_BORDERLINE
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
-#endif
+  // Visual size and offset
+  UNIFORM highp vec2   offset;
+  UNIFORM highp vec2   size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-uniform highp vec4 cornerRadius;
-uniform mediump float cornerRadiusPolicy;
+  UNIFORM highp vec4    cornerRadius;
+  UNIFORM mediump float cornerRadiusPolicy;
 #endif
+};
+
+#ifdef IS_REQUIRED_BORDERLINE
+UNIFORM_BLOCK SharedBlock
+{
+  UNIFORM highp float borderlineWidth;
+  UNIFORM highp float borderlineOffset;
+  UNIFORM lowp vec4   borderlineColor;
+  UNIFORM lowp vec4   uActorColor;
+};
+#endif
+
 
 vec4 ComputeVertexPosition()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/image-region-effect.vert b/dali-toolkit/internal/graphics/shaders/image-region-effect.vert
index 5997336c3f..9ec5ca5c32 100644
--- a/dali-toolkit/internal/graphics/shaders/image-region-effect.vert
+++ b/dali-toolkit/internal/graphics/shaders/image-region-effect.vert
@@ -1,13 +1,19 @@
-attribute mediump vec2 aPosition;
+//@name image-region-effect.vert
 
-uniform mediump mat4 uMvpMatrix;
-uniform vec3 uSize;
-uniform vec4 uTextureRect;
+//@version 100
 
-varying vec2 vTexCoord;
+INPUT mediump vec2 aPosition;
 
-uniform mediump vec2 uTopLeft;
-uniform mediump vec2 uBottomRight;
+OUTPUT vec2 vTexCoord;
+
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump vec2 uTopLeft;
+  UNIFORM mediump vec2 uBottomRight;
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM vec3 uSize;
+  UNIFORM vec4 uTextureRect;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/image-visual-shader.frag b/dali-toolkit/internal/graphics/shaders/image-visual-shader.frag
index 679902983d..dbf5a76309 100644
--- a/dali-toolkit/internal/graphics/shaders/image-visual-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/image-visual-shader.frag
@@ -1,11 +1,13 @@
+//@version 100
+
 INPUT mediump vec2 vTexCoord;
 #if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER) || defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
 INPUT highp vec2 vPosition;
-FLAT INPUT highp vec2 vRectSize;
-FLAT INPUT highp vec2 vOptRectSize;
-FLAT INPUT highp float vAliasMargin;
+INPUT flat highp vec2 vRectSize;
+INPUT flat highp vec2 vOptRectSize;
+INPUT flat highp float vAliasMargin;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT INPUT highp vec4 vCornerRadius;
+INPUT flat highp vec4 vCornerRadius;
 #endif
 #endif
 #ifdef IS_REQUIRED_DEBUG_VISUAL_SHADER
@@ -13,41 +15,54 @@ FLAT INPUT highp vec4 vCornerRadius;
 DEBUG_EXTRA_VARYINGS
 #endif
 
-uniform sampler2D sTexture;
+UNIFORM sampler2D sTexture;
 #if defined(IS_REQUIRED_YUV_TO_RGB) || defined(IS_REQUIRED_UNIFIED_YUV_AND_RGB)
-uniform sampler2D sTextureU;
-uniform sampler2D sTextureV;
+UNIFORM sampler2D sTextureU;
+UNIFORM sampler2D sTextureV;
 #endif
 
 #ifdef IS_REQUIRED_ALPHA_MASKING
-uniform sampler2D sMaskTexture;
-uniform lowp float uYFlipMaskTexture;
+UNIFORM sampler2D sMaskTexture;
 INPUT mediump vec2 vMaskTexCoord;
 #endif
 
+UNIFORM_BLOCK FragBlock
+{
+#ifdef IS_REQUIRED_ALPHA_MASKING
+  UNIFORM lowp float uYFlipMaskTexture;
+#endif
+
 #ifdef ATLAS_DEFAULT_WARP
-uniform mediump vec4 uAtlasRect;
+  UNIFORM mediump vec4 uAtlasRect;
+
 #elif defined(ATLAS_CUSTOM_WARP)
-// WrapMode -- 0: CLAMP; 1: REPEAT; 2: REFLECT;
-uniform lowp vec2 wrapMode;
+  // WrapMode -- 0: CLAMP; 1: REPEAT; 2: REFLECT;
+  UNIFORM lowp vec2 wrapMode;
 #endif
 
-
 #if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER)
-uniform highp vec3 uScale;
+  UNIFORM highp vec3 uScale;
 #endif
 
-uniform lowp vec4 uColor;
-uniform lowp float premultipliedAlpha;
+  UNIFORM lowp vec4  uColor;
+  UNIFORM lowp float premultipliedAlpha;
+
 #ifdef IS_REQUIRED_BORDERLINE
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
-uniform lowp vec4 borderlineColor;
-uniform lowp vec4 uActorColor;
+  UNIFORM lowp vec4   borderlineColor;
+  UNIFORM lowp vec4   uActorColor;
 #endif
 
 #ifdef IS_REQUIRED_SQUIRCLE_CORNER
-uniform highp vec4 cornerSquareness;
+  UNIFORM highp vec4 cornerSquareness;
+#endif
+};
+
+#ifdef IS_REQUIRED_BORDERLINE
+UNIFORM_BLOCK Borderline
+{
+  UNIFORM highp float borderlineWidth;
+  UNIFORM highp float borderlineOffset;
+};
 #endif
 
 #ifdef ATLAS_CUSTOM_WARP
@@ -282,9 +297,9 @@ lowp vec4 ConvertYuvToRgba(mediump vec2 texCoord)
   }
 #endif
 
-  lowp float y = TEXTURE(sTexture, texCoord).r;
-  lowp float u = TEXTURE(sTextureU, texCoord).r - 0.5;
-  lowp float v = TEXTURE(sTextureV, texCoord).r - 0.5;
+  lowp float y = texture(sTexture, texCoord).r;
+  lowp float u = texture(sTextureU, texCoord).r - 0.5;
+  lowp float v = texture(sTextureV, texCoord).r - 0.5;
   lowp vec4 rgba;
   rgba.r = y + (1.403 * v);
   rgba.g = y - (0.344 * u) - (0.714 * v);
@@ -448,7 +463,7 @@ void main()
   // skip most potential calculate for performance
   if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
   {
-    OUT_COLOR = textureColor;
+    gl_FragColor = textureColor;
   }
   else
 #endif
@@ -462,7 +477,7 @@ void main()
     if(gFragmentPosition.x + gFragmentPosition.y < -(gRadius + vAliasMargin) * 2.0)
     {
       // Do nothing.
-      OUT_COLOR = textureColor;
+      gl_FragColor = textureColor;
     }
     else
 #endif
@@ -476,12 +491,12 @@ void main()
 #ifdef IS_REQUIRED_BORDERLINE
       textureColor = convertBorderlineColor(textureColor);
 #endif
-      OUT_COLOR = textureColor;
+      gl_FragColor = textureColor;
 
 #ifdef IS_REQUIRED_ROUNDED_CORNER
       mediump float opacity = calculateCornerOpacity();
-      OUT_COLOR.a *= opacity;
-      OUT_COLOR.rgb *= mix(1.0, opacity, premultipliedAlpha);
+      gl_FragColor.a *= opacity;
+      gl_FragColor.rgb *= mix(1.0, opacity, premultipliedAlpha);
 #endif
     }
 
@@ -490,6 +505,6 @@ void main()
 #endif
 
 #ifdef IS_REQUIRED_DEBUG_VISUAL_SHADER
-  OUT_COLOR.rgb = ApplyDebugMixColor(OUT_COLOR);
+  gl_FragColor.rgb = ApplyDebugMixColor(gl_FragColor);
 #endif
 }
diff --git a/dali-toolkit/internal/graphics/shaders/image-visual-shader.vert b/dali-toolkit/internal/graphics/shaders/image-visual-shader.vert
index 8885cf771f..7d6daada52 100644
--- a/dali-toolkit/internal/graphics/shaders/image-visual-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/image-visual-shader.vert
@@ -1,15 +1,21 @@
+//@version 100
+
 INPUT mediump vec2 aPosition;
 OUTPUT mediump vec2 vTexCoord;
 #if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER) || defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
 OUTPUT highp vec2 vPosition;
-FLAT OUTPUT highp vec2 vRectSize;
-FLAT OUTPUT highp vec2 vOptRectSize;
-FLAT OUTPUT highp float vAliasMargin;
+OUTPUT flat highp vec2 vRectSize;
+OUTPUT flat highp vec2 vOptRectSize;
+OUTPUT flat highp float vAliasMargin;
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT OUTPUT highp vec4 vCornerRadius;
+OUTPUT flat highp vec4 vCornerRadius;
 #endif
 #endif
 
+#ifdef IS_REQUIRED_ALPHA_MASKING
+OUTPUT  mediump vec2  vMaskTexCoord;
+#endif
+
 #ifdef IS_REQUIRED_DEBUG_VISUAL_SHADER
 #define DEBUG_EXTRA_ATTRIBUTES
 #define DEBUG_EXTRA_VARYINGS
@@ -18,35 +24,42 @@ DEBUG_EXTRA_ATTRIBUTES
 DEBUG_EXTRA_VARYINGS
 #endif
 
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform highp vec4 pixelArea;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
+  UNIFORM highp vec4 pixelArea;
 
 #if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER) || defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
-// Be used when we calculate anti-alias range near 1 pixel.
-uniform highp vec3 uScale;
+  // Be used when we calculate anti-alias range near 1 pixel.
+  UNIFORM highp vec3 uScale;
 #endif
 
-//Visual size and offset
-uniform highp vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
-#ifdef IS_REQUIRED_BORDERLINE
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
-#endif
+  // Visual size and offset
+  UNIFORM highp vec2   offset;
+  UNIFORM highp vec2   size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+
 #ifdef IS_REQUIRED_ROUNDED_CORNER
-uniform highp vec4 cornerRadius;
-uniform mediump float cornerRadiusPolicy;
+  UNIFORM highp vec4    cornerRadius;
+  UNIFORM mediump float cornerRadiusPolicy;
 #endif
 #ifdef IS_REQUIRED_ALPHA_MASKING
-OUTPUT  mediump vec2  vMaskTexCoord;
-uniform lowp    float cropToMask;
-uniform mediump vec2  maskTextureRatio;
+  UNIFORM lowp float   cropToMask;
+  UNIFORM mediump vec2 maskTextureRatio;
+#endif
+  UNIFORM highp vec2 extraSize;
+};
+
+#ifdef IS_REQUIRED_BORDERLINE
+UNIFORM_BLOCK Borderline
+{
+  UNIFORM highp float borderlineWidth;
+  UNIFORM highp float borderlineOffset;
+};
 #endif
-uniform highp vec2 extraSize;
 
 vec4 ComputeVertexPosition()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/mesh-visual-normal-map-shader.frag b/dali-toolkit/internal/graphics/shaders/mesh-visual-normal-map-shader.frag
index b482d8c806..b66e74f375 100644
--- a/dali-toolkit/internal/graphics/shaders/mesh-visual-normal-map-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/mesh-visual-normal-map-shader.frag
@@ -1,22 +1,29 @@
+//@name mesh-visual-normal-map-shader.frag
+
+//@version 100
+
 precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
-uniform sampler2D sDiffuse;
-uniform sampler2D sNormal;
-uniform sampler2D sGloss;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec3 vLightDirection;
+INPUT mediump vec3 vHalfVector;
+UNIFORM sampler2D sDiffuse;
+UNIFORM sampler2D sNormal;
+UNIFORM sampler2D sGloss;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
-  vec4 texture = texture2D( sDiffuse, vTexCoord );
-  vec3 normal = normalize( texture2D( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
-  vec4 glossMap = texture2D( sGloss, vTexCoord );
+  vec4 tex = TEXTURE( sDiffuse, vTexCoord );
+  vec3 normal = normalize( TEXTURE( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
+  vec4 glossMap = TEXTURE( sGloss, vTexCoord );
 
   float lightDiffuse = max( 0.0, dot( normal, normalize( vLightDirection ) ) );
   lightDiffuse = lightDiffuse * 0.5 + 0.5;
 
   float shininess = pow ( max ( dot ( normalize( vHalfVector ), normal ), 0.0 ), 16.0 );
 
-  gl_FragColor = vec4( texture.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a );
+  gl_FragColor = vec4( tex.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, tex.a * uColor.a );
 }
diff --git a/dali-toolkit/internal/graphics/shaders/mesh-visual-normal-map-shader.vert b/dali-toolkit/internal/graphics/shaders/mesh-visual-normal-map-shader.vert
index bc9ac8af0a..472d03cdcb 100644
--- a/dali-toolkit/internal/graphics/shaders/mesh-visual-normal-map-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/mesh-visual-normal-map-shader.vert
@@ -1,26 +1,33 @@
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-attribute highp vec3 aTangent;
-attribute highp vec3 aBiNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+//@name mesh-visual-normal-map-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+INPUT highp vec3 aTangent;
+INPUT highp vec3 aBiNormal;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec3 vLightDirection;
+OUTPUT mediump vec3 vHalfVector;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump vec3 uSize;
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM mediump mat4 uModelView;
+  UNIFORM mediump mat4 uViewMatrix;
+  UNIFORM mediump mat3 uNormalMatrix;
+  UNIFORM mediump mat4 uObjectMatrix;
+  UNIFORM mediump vec3 lightPosition;
+  UNIFORM mediump vec2 uStageOffset;
 
 //Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+  UNIFORM mediump vec2 offset;
+  UNIFORM mediump vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+};
 
 vec4 ComputeVertexPosition()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/mesh-visual-shader.frag b/dali-toolkit/internal/graphics/shaders/mesh-visual-shader.frag
index fd240fede5..7922573e23 100644
--- a/dali-toolkit/internal/graphics/shaders/mesh-visual-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/mesh-visual-shader.frag
@@ -1,12 +1,19 @@
+//@name mesh-visual-shader.frag
+
+//@version 100
+
 precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
-uniform sampler2D sDiffuse;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec3 vIllumination;
+INPUT mediump float vSpecular;
+UNIFORM sampler2D sDiffuse;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
-  vec4 texture = texture2D( sDiffuse, vTexCoord );
-  gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb + vSpecular * 0.3, texture.a * uColor.a );
+  vec4 tex = TEXTURE( sDiffuse, vTexCoord );
+  gl_FragColor = vec4( vIllumination.rgb * tex.rgb * uColor.rgb + vSpecular * 0.3, tex.a * uColor.a );
 }
diff --git a/dali-toolkit/internal/graphics/shaders/mesh-visual-shader.vert b/dali-toolkit/internal/graphics/shaders/mesh-visual-shader.vert
index 858c92dc0f..5ba26c1732 100644
--- a/dali-toolkit/internal/graphics/shaders/mesh-visual-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/mesh-visual-shader.vert
@@ -1,24 +1,31 @@
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+//@name mesh-visual-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec3 vIllumination;
+OUTPUT mediump float vSpecular;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump vec3 uSize;
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM mediump mat4 uModelView;
+  UNIFORM mediump mat4 uViewMatrix;
+  UNIFORM mediump mat3 uNormalMatrix;
+  UNIFORM mediump mat4 uObjectMatrix;
+  UNIFORM mediump vec3 lightPosition;
+  UNIFORM mediump vec2 uStageOffset;
 
 //Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+  UNIFORM mediump vec2 offset;
+  UNIFORM mediump vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+};
 
 vec4 ComputeVertexPosition()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/mesh-visual-simple-shader.frag b/dali-toolkit/internal/graphics/shaders/mesh-visual-simple-shader.frag
index 3f344a7568..b28c0ee77e 100644
--- a/dali-toolkit/internal/graphics/shaders/mesh-visual-simple-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/mesh-visual-simple-shader.frag
@@ -1,6 +1,13 @@
+//@name mesh-visual-simple-shader.frag
+
+//@version 100
+
 precision mediump float;
-varying mediump vec3 vIllumination;
-uniform lowp vec4 uColor;
+INPUT mediump vec3 vIllumination;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/mesh-visual-simple-shader.vert b/dali-toolkit/internal/graphics/shaders/mesh-visual-simple-shader.vert
index 0541a164eb..a5d1221a3b 100644
--- a/dali-toolkit/internal/graphics/shaders/mesh-visual-simple-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/mesh-visual-simple-shader.vert
@@ -1,21 +1,28 @@
-attribute highp vec3 aPosition;
-attribute highp vec3 aNormal;
-varying mediump vec3 vIllumination;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+//@name mesh-visual-simple-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec3 aNormal;
+OUTPUT mediump vec3 vIllumination;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump vec3 uSize;
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM mediump mat4 uModelView;
+  UNIFORM mediump mat4 uViewMatrix;
+  UNIFORM mediump mat3 uNormalMatrix;
+  UNIFORM mediump mat4 uObjectMatrix;
+  UNIFORM mediump vec3 lightPosition;
+  UNIFORM mediump vec2 uStageOffset;
 
 //Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+  UNIFORM mediump vec2 offset;
+  UNIFORM mediump vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+};
 
 vec4 ComputeVertexPosition()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/model3d-view-nrmmap-shader.frag b/dali-toolkit/internal/graphics/shaders/model3d-view-nrmmap-shader.frag
index b2db8e9c60..2fde9654fc 100644
--- a/dali-toolkit/internal/graphics/shaders/model3d-view-nrmmap-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/model3d-view-nrmmap-shader.frag
@@ -1,22 +1,29 @@
+//@name model3d-view-nrmmap-shader.frag
+
+//@version 100
+
 precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
-uniform sampler2D sDiffuse;
-uniform sampler2D sNormal;
-uniform sampler2D sGloss;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec3 vLightDirection;
+INPUT mediump vec3 vHalfVector;
+UNIFORM sampler2D sDiffuse;
+UNIFORM sampler2D sNormal;
+UNIFORM sampler2D sGloss;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
-  vec4 texture = texture2D( sDiffuse, vTexCoord );
-  vec3 normal = normalize( texture2D( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
-  vec4 glossMap = texture2D( sGloss, vTexCoord );
+  vec4 tex = TEXTURE( sDiffuse, vTexCoord );
+  vec3 normal = normalize( TEXTURE( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
+  vec4 glossMap = TEXTURE( sGloss, vTexCoord );
 
   float lightDiffuse = max( 0.0, dot( normal, normalize(vLightDirection) ) );
   lightDiffuse = lightDiffuse * 0.5 + 0.5;
 
   float shininess = pow (max (dot (normalize( vHalfVector ), normal), 0.0), 16.0);
 
-  gl_FragColor = vec4( texture.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a);
+  gl_FragColor = vec4( tex.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, tex.a * uColor.a);
 }
diff --git a/dali-toolkit/internal/graphics/shaders/model3d-view-nrmmap-shader.vert b/dali-toolkit/internal/graphics/shaders/model3d-view-nrmmap-shader.vert
index 3e00350cac..198322a972 100644
--- a/dali-toolkit/internal/graphics/shaders/model3d-view-nrmmap-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/model3d-view-nrmmap-shader.vert
@@ -1,17 +1,24 @@
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-attribute highp vec3 aTangent;
-attribute highp vec3 aBiNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 uLightPosition;
+//@name model3d-view-nrmmap-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+INPUT highp vec3 aTangent;
+INPUT highp vec3 aBiNormal;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec3 vLightDirection;
+OUTPUT mediump vec3 vHalfVector;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump vec3 uSize;
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM mediump mat4 uModelView;
+  UNIFORM mediump mat3 uNormalMatrix;
+  UNIFORM mediump mat4 uObjectMatrix;
+  UNIFORM mediump vec3 uLightPosition;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/model3d-view-shader.frag b/dali-toolkit/internal/graphics/shaders/model3d-view-shader.frag
index 0c48098c83..a3209f4da0 100644
--- a/dali-toolkit/internal/graphics/shaders/model3d-view-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/model3d-view-shader.frag
@@ -1,12 +1,19 @@
+//@name model3d-view-shader.frag
+
+//@version 100
+
 precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
-uniform sampler2D sDiffuse;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec3 vIllumination;
+INPUT mediump float vSpecular;
+UNIFORM sampler2D sDiffuse;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
-  vec4 texture = texture2D( sDiffuse, vTexCoord );
+  vec4 texture = TEXTURE( sDiffuse, vTexCoord );
   gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb + vSpecular * 0.3, texture.a * uColor.a);
 }
diff --git a/dali-toolkit/internal/graphics/shaders/model3d-view-shader.vert b/dali-toolkit/internal/graphics/shaders/model3d-view-shader.vert
index 7987a18459..4e63eedf5f 100644
--- a/dali-toolkit/internal/graphics/shaders/model3d-view-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/model3d-view-shader.vert
@@ -1,15 +1,22 @@
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 uLightPosition;
+//@name model3d-view-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec3 vIllumination;
+OUTPUT mediump float vSpecular;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump vec3 uSize;
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM mediump mat4 uModelView;
+  UNIFORM mediump mat3 uNormalMatrix;
+  UNIFORM mediump mat4 uObjectMatrix;
+  UNIFORM mediump vec3 uLightPosition;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/model3d-view-simple-shader.frag b/dali-toolkit/internal/graphics/shaders/model3d-view-simple-shader.frag
index d7be96f051..2fb0094cf5 100644
--- a/dali-toolkit/internal/graphics/shaders/model3d-view-simple-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/model3d-view-simple-shader.frag
@@ -1,6 +1,13 @@
+//@name model3d-view-simple-shader.frag
+
+//@version 100
+
 precision mediump float;
-varying mediump vec3 vIllumination;
-uniform lowp vec4 uColor;
+INPUT mediump vec3 vIllumination;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/model3d-view-simple-shader.vert b/dali-toolkit/internal/graphics/shaders/model3d-view-simple-shader.vert
index a94619e68d..6f63114e30 100644
--- a/dali-toolkit/internal/graphics/shaders/model3d-view-simple-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/model3d-view-simple-shader.vert
@@ -1,13 +1,20 @@
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-varying mediump vec3 vIllumination;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 uLightPosition;
+//@name model3d-view-simple-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+OUTPUT mediump vec3 vIllumination;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump vec3 uSize;
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM mediump mat4 uModelView;
+  UNIFORM mediump mat3 uNormalMatrix;
+  UNIFORM mediump mat4 uObjectMatrix;
+  UNIFORM mediump vec3 uLightPosition;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/motion-blur-effect.frag b/dali-toolkit/internal/graphics/shaders/motion-blur-effect.frag
index b2c0857cb1..aebb9c0433 100644
--- a/dali-toolkit/internal/graphics/shaders/motion-blur-effect.frag
+++ b/dali-toolkit/internal/graphics/shaders/motion-blur-effect.frag
@@ -1,21 +1,28 @@
+//@name motion-blur-effect.frag
+
+//@version 100
+
 precision mediump float;
 
-uniform sampler2D sTexture;
-uniform vec4 uColor;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM vec4 uColor;
 
-uniform vec2 uObjectFadeStart;
-uniform vec2 uObjectFadeEnd;
-uniform float uAlphaScale;
-uniform float uBlurTexCoordScale;
-uniform float uNumSamples;
-uniform float uRecipNumSamples;
-uniform float uRecipNumSamplesMinusOne;
+  UNIFORM vec2 uObjectFadeStart;
+  UNIFORM vec2 uObjectFadeEnd;
+  UNIFORM float uAlphaScale;
+  UNIFORM float uBlurTexCoordScale;
+  UNIFORM float uNumSamples;
+  UNIFORM float uRecipNumSamples;
+  UNIFORM float uRecipNumSamplesMinusOne;
+};
 
 // inputs
-varying vec2 vModelSpaceCenterToPos;
-varying vec2 vScreenSpaceVelocityVector;
-varying float vSpeed;
-varying vec2 vTexCoord;
+INPUT vec2 vModelSpaceCenterToPos;
+INPUT vec2 vScreenSpaceVelocityVector;
+INPUT float vSpeed;
+INPUT vec2 vTexCoord;
 
 void main()
 {
@@ -30,14 +37,14 @@ void main()
   vec2 velocity = vScreenSpaceVelocityVector * uBlurTexCoordScale;
 
   // standard actor texel
-  vec4 colActor = texture2D(sTexture, vTexCoord);
+  vec4 colActor = TEXTURE(sTexture, vTexCoord);
 
   // blurred actor - gather texture samples from the actor texture in the direction of motion
   vec4 col = colActor * uRecipNumSamples;
   for(float i = 1.0; i < uNumSamples; i += 1.0)
   {
     float t = i * uRecipNumSamplesMinusOne;
-    col += texture2D(sTexture, vTexCoord + (velocity * t)) * uRecipNumSamples;
+    col += TEXTURE(sTexture, vTexCoord + (velocity * t)) * uRecipNumSamples;
   }
   gl_FragColor = mix(colActor, col, vSpeed); // lerp blurred and non-blurred actor based on speed of motion
   gl_FragColor.a = fadeToEdgesScale;//colActor.a * fadeToEdgesScale; // fade blurred actor to its edges based on speed of motion
diff --git a/dali-toolkit/internal/graphics/shaders/motion-blur-effect.vert b/dali-toolkit/internal/graphics/shaders/motion-blur-effect.vert
index ed3ca94f58..f55f6b6516 100644
--- a/dali-toolkit/internal/graphics/shaders/motion-blur-effect.vert
+++ b/dali-toolkit/internal/graphics/shaders/motion-blur-effect.vert
@@ -1,24 +1,32 @@
+//@name motion-blur-effect.vert
+
+//@version 100
+
 precision mediump float;
 
-attribute vec2 aPosition;
+INPUT vec2 aPosition;
+
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mat4 uMvpMatrix;
+  UNIFORM mat4 uModelView;
+  UNIFORM mat4 uViewMatrix;
+  UNIFORM mat4 uProjection;
+  UNIFORM vec3 uSize;
 
-uniform mat4 uMvpMatrix;
-uniform mat4 uModelView;
-uniform mat4 uViewMatrix;
-uniform mat4 uProjection;
-uniform vec3 uSize;
+  UNIFORM mat4 uModelLastFrame;
+  UNIFORM float uGeometryStretchFactor;
+  UNIFORM float uSpeedScalingFactor;
+};
 
-uniform mat4 uModelLastFrame;
 float timeDelta = 0.0167;
 
-uniform float uGeometryStretchFactor;
-uniform float uSpeedScalingFactor;
 
 // outputs
-varying vec2 vModelSpaceCenterToPos;
-varying vec2 vScreenSpaceVelocityVector;
-varying float vSpeed;
-varying vec2 vTexCoord;
+OUTPUT vec2 vModelSpaceCenterToPos;
+OUTPUT vec2 vScreenSpaceVelocityVector;
+OUTPUT float vSpeed;
+OUTPUT vec2 vTexCoord;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/motion-stretch-effect.frag b/dali-toolkit/internal/graphics/shaders/motion-stretch-effect.frag
index 8754a4fb70..ad55ae0988 100644
--- a/dali-toolkit/internal/graphics/shaders/motion-stretch-effect.frag
+++ b/dali-toolkit/internal/graphics/shaders/motion-stretch-effect.frag
@@ -1,17 +1,24 @@
+//@name motion-stretch-effect.frag
+
+//@version 100
+
 precision mediump float;
 
-uniform sampler2D sTexture;
-uniform vec4 uColor;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM vec4 uColor;
 
-uniform vec2 uObjectFadeStart;
-uniform vec2 uObjectFadeEnd;
-uniform float uAlphaScale;
+  UNIFORM vec2 uObjectFadeStart;//@blah
+  UNIFORM vec2 uObjectFadeEnd;//@input
+  UNIFORM float uAlphaScale;//@output
+};
 
 // inputs
-varying vec2 vModelSpaceCenterToPos;
-varying vec2 vScreenSpaceVelocityVector;
-varying float vSpeed;
-varying vec2 vTexCoord;
+INPUT vec2 vModelSpaceCenterToPos;//@version
+INPUT vec2 vScreenSpaceVelocityVector; //@Notjhing
+INPUT float vSpeed;
+INPUT vec2 vTexCoord;
 
 void main()
 {
@@ -23,7 +30,7 @@ void main()
   fadeToEdgesScale = mix(1.0, fadeToEdgesScale, vSpeed);                // fade proportional to speed, so opaque when at rest
 
   // standard actor texel
-  vec4 colActor = texture2D(sTexture, vTexCoord);
+  vec4 colActor = TEXTURE(sTexture, vTexCoord);
   gl_FragColor = colActor;
   gl_FragColor.a *= fadeToEdgesScale; // fade actor to its edges based on speed of motion
   gl_FragColor *= uColor;
diff --git a/dali-toolkit/internal/graphics/shaders/motion-stretch-effect.vert b/dali-toolkit/internal/graphics/shaders/motion-stretch-effect.vert
index 3ac7364111..9fba6a2b4d 100644
--- a/dali-toolkit/internal/graphics/shaders/motion-stretch-effect.vert
+++ b/dali-toolkit/internal/graphics/shaders/motion-stretch-effect.vert
@@ -1,24 +1,33 @@
+//@name motion-stretch-effect.vert
+
+//@version 100
+
 precision mediump float;
 
-attribute vec2 aPosition;
+INPUT vec2 aPosition;//Stuff, things
+
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mat4 uMvpMatrix;
+  UNIFORM mat4 uModelView;
+  UNIFORM mat4 uViewMatrix;
+  UNIFORM mat4 uProjection;
+  UNIFORM vec3 uSize;
+
+  UNIFORM mat4  uModelLastFrame;
 
-uniform mat4 uMvpMatrix;
-uniform mat4 uModelView;
-uniform mat4 uViewMatrix;
-uniform mat4 uProjection;
-uniform vec3 uSize;
+  UNIFORM float uGeometryStretchFactor;
+  UNIFORM float uSpeedScalingFactor;
+};
 
-uniform mat4  uModelLastFrame;
 float timeDelta = 0.0167;
 
-uniform float uGeometryStretchFactor;
-uniform float uSpeedScalingFactor;
 
 // outputs
-varying vec2 vModelSpaceCenterToPos;
-varying vec2 vScreenSpaceVelocityVector;
-varying float vSpeed;
-varying vec2 vTexCoord;
+OUTPUT vec2 vModelSpaceCenterToPos;
+OUTPUT vec2 vScreenSpaceVelocityVector;
+OUTPUT float vSpeed;
+OUTPUT vec2 vTexCoord;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/npatch-visual-3x3-shader.vert b/dali-toolkit/internal/graphics/shaders/npatch-visual-3x3-shader.vert
index c3db474995..94909504f9 100644
--- a/dali-toolkit/internal/graphics/shaders/npatch-visual-3x3-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/npatch-visual-3x3-shader.vert
@@ -1,19 +1,25 @@
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vMaskTexCoord;
-
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform highp vec2 uFixed[3];
-uniform highp vec2 uStretchTotal;
-
-//Visual size and offset
-uniform highp vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
-uniform highp vec2 extraSize;
+//@name npatch-visual-3x3-shader.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec2 vMaskTexCoord;
+
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
+  UNIFORM highp vec2 uFixed[3];
+  UNIFORM highp vec2 uStretchTotal;
+  //Visual size and offset
+  UNIFORM highp   vec2 offset;
+  UNIFORM highp   vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+  UNIFORM highp vec2 extraSize;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/npatch-visual-mask-shader.frag b/dali-toolkit/internal/graphics/shaders/npatch-visual-mask-shader.frag
index fbb4bdf8aa..6ca69c02c1 100644
--- a/dali-toolkit/internal/graphics/shaders/npatch-visual-mask-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/npatch-visual-mask-shader.frag
@@ -1,10 +1,17 @@
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vMaskTexCoord;
-uniform sampler2D sTexture;
-uniform sampler2D sMask;
-uniform lowp vec4 uColor;
-uniform lowp float premultipliedAlpha;
-uniform mediump float auxiliaryImageAlpha;
+//@name npatch-visual-mask-shader.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec2 vMaskTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM sampler2D sMask;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM lowp float premultipliedAlpha;
+  UNIFORM mediump float auxiliaryImageAlpha;
+};
 
 void main()
 {
@@ -13,8 +20,8 @@ void main()
   // where mask is translucent, less of background should be shown.
   // auxiliaryImageAlpha controls how much of mask is visible
 
-  mediump vec4 color = texture2D(sTexture, vTexCoord);
-  mediump vec4 mask = texture2D(sMask, vMaskTexCoord);
+  mediump vec4 color = TEXTURE(sTexture, vTexCoord);
+  mediump vec4 mask = TEXTURE(sMask, vMaskTexCoord);
 
   mediump float maskAlpha = mask.a * auxiliaryImageAlpha;
 
diff --git a/dali-toolkit/internal/graphics/shaders/npatch-visual-shader.frag b/dali-toolkit/internal/graphics/shaders/npatch-visual-shader.frag
index 93f8fbce6c..9371ddba82 100644
--- a/dali-toolkit/internal/graphics/shaders/npatch-visual-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/npatch-visual-shader.frag
@@ -1,8 +1,16 @@
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
+//@name npatch-visual-shader.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
-  gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+  gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
 }
diff --git a/dali-toolkit/internal/graphics/shaders/npatch-visual-shader.vert b/dali-toolkit/internal/graphics/shaders/npatch-visual-shader.vert
index d571a6406d..2bb31683b8 100644
--- a/dali-toolkit/internal/graphics/shaders/npatch-visual-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/npatch-visual-shader.vert
@@ -1,18 +1,25 @@
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vMaskTexCoord;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform highp vec2 uNinePatchFactorsX[FACTOR_SIZE_X];
-uniform highp vec2 uNinePatchFactorsY[FACTOR_SIZE_Y];
-
-// Visual size and offset
-uniform highp vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
-uniform highp vec2 extraSize;
+//@name npatch-visual-shader.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec2 vMaskTexCoord;
+
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
+  UNIFORM highp vec2 uNinePatchFactorsX[FACTOR_SIZE_X];
+  UNIFORM highp vec2 uNinePatchFactorsY[FACTOR_SIZE_Y];
+  // Visual size and offset
+  UNIFORM highp vec2 offset;
+  UNIFORM highp vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+  UNIFORM highp vec2 extraSize;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/page-turn-book-spine-effect.frag b/dali-toolkit/internal/graphics/shaders/page-turn-book-spine-effect.frag
index c4544aa3c5..4e355bdea1 100644
--- a/dali-toolkit/internal/graphics/shaders/page-turn-book-spine-effect.frag
+++ b/dali-toolkit/internal/graphics/shaders/page-turn-book-spine-effect.frag
@@ -1,19 +1,31 @@
+//@name page-turn-book-spine-effect.frag
+
+//@version 100
+
 precision mediump float;
-varying mediump vec2 vTexCoord;
-uniform vec3 uSize;
-uniform vec2 uSpineShadowParameter;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM vec2 uSpineShadowParameter;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+UNIFORM vec3 uSize;
+};
 
 void main()
 {
   if( gl_FrontFacing ) // display front side
   {
-    gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+    gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
   }
   else // display back side, flip the image horizontally by changing the x component of the texture coordinate
   {
-    gl_FragColor = texture2D( sTexture, vec2( 1.0 - vTexCoord.x, vTexCoord.y ) ) * uColor;
+    gl_FragColor = TEXTURE( sTexture, vec2( 1.0 - vTexCoord.x, vTexCoord.y ) ) * uColor;
   }
   // display book spine, a stripe of shadowed texture
   float pixelPos = vTexCoord.x * uSize.x;
diff --git a/dali-toolkit/internal/graphics/shaders/page-turn-book-spine-effect.vert b/dali-toolkit/internal/graphics/shaders/page-turn-book-spine-effect.vert
index 900aeb9ace..13b9a766ff 100644
--- a/dali-toolkit/internal/graphics/shaders/page-turn-book-spine-effect.vert
+++ b/dali-toolkit/internal/graphics/shaders/page-turn-book-spine-effect.vert
@@ -1,9 +1,21 @@
+//@name page-turn-book-spine-effect.vert
+
+//@version 100
+
 precision mediump float;
-attribute mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
-uniform vec3 uSize;
-uniform float uTextureWidth;
-varying vec2 vTexCoord;
+INPUT mediump vec2 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM float uTextureWidth;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+UNIFORM vec3 uSize;
+};
+
+OUTPUT vec2 vTexCoord;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/page-turn-effect.frag b/dali-toolkit/internal/graphics/shaders/page-turn-effect.frag
index 8fa6e776a9..d351a5de23 100644
--- a/dali-toolkit/internal/graphics/shaders/page-turn-effect.frag
+++ b/dali-toolkit/internal/graphics/shaders/page-turn-effect.frag
@@ -1,13 +1,25 @@
+//@name page-turn-effect.frag
+
+//@version 100
+
 precision mediump float;
 
-varying mediump vec2 vTexCoord;
+INPUT mediump vec2 vTexCoord;
+
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM vec2 uSpineShadowParameter;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+  UNIFORM vec3 uSize;
+};
 
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
-uniform vec3 uSize;
-uniform vec2 uSpineShadowParameter;
-varying vec3 vNormal;
-varying vec4 vPosition;
+INPUT vec3 vNormal;
+INPUT vec4 vPosition;
 
 void main()
 {
@@ -16,9 +28,9 @@ void main()
   // display page content
   vec4 texel;
   // display back image of the page, flip the texture
-  if(  dot(vPosition.xyz, normal) > 0.0 ) texel = texture2D( sTexture, vec2( 1.0 - vTexCoord.x, vTexCoord.y ) );
+  if(  dot(vPosition.xyz, normal) > 0.0 ) texel = TEXTURE( sTexture, vec2( 1.0 - vTexCoord.x, vTexCoord.y ) );
   // display front image of the page
-  else texel = texture2D( sTexture, vTexCoord );
+  else texel = TEXTURE( sTexture, vTexCoord );
 
   // display book spine, a stripe of shadowed texture
   float pixelPos = vTexCoord.x * uSize.x;
diff --git a/dali-toolkit/internal/graphics/shaders/page-turn-effect.vert b/dali-toolkit/internal/graphics/shaders/page-turn-effect.vert
index 9705061796..1ee681ff7a 100644
--- a/dali-toolkit/internal/graphics/shaders/page-turn-effect.vert
+++ b/dali-toolkit/internal/graphics/shaders/page-turn-effect.vert
@@ -1,3 +1,7 @@
+//@name page-turn-effect.vert
+
+//@version 100
+
 /*
  * The common parameters for all the vertices, calculate in CPU then pass into the shader as uniforms
  *
@@ -18,20 +22,28 @@
 
 precision mediump float;
 
-attribute mediump vec2 aPosition;
+INPUT mediump vec2 aPosition;
 
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uModelView;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM mediump mat3 uNormalMatrix;
+  UNIFORM mediump mat4 uModelView;
 
-uniform mat4 uCommonParameters;
+  UNIFORM mat4 uCommonParameters;
 
-uniform vec3 uSize;
-uniform float uIsTurningBack;
-uniform float uTextureWidth;
-varying vec3 vNormal;
-varying vec4 vPosition;
-varying mediump vec2 vTexCoord;
+  UNIFORM float uIsTurningBack;
+  UNIFORM float uTextureWidth;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+  UNIFORM vec3 uSize;
+};
+
+OUTPUT vec3 vNormal;
+OUTPUT vec4 vPosition;
+OUTPUT mediump vec2 vTexCoord;
 
 void main()
 {
@@ -156,7 +168,8 @@ void main()
   }
   vNormal =  uNormalMatrix * normal;
   gl_Position = uMvpMatrix * position;
-  // varying parameters for fragment shader
+
+  // out parameters for fragment shader
   vTexCoord = aPosition + vec2(0.5);
   vTexCoord.x /= uTextureWidth;
   vPosition = uModelView * position;
diff --git a/dali-toolkit/internal/graphics/shaders/primitive-visual-shader.frag b/dali-toolkit/internal/graphics/shaders/primitive-visual-shader.frag
index 751f52773f..c7e144a3c1 100644
--- a/dali-toolkit/internal/graphics/shaders/primitive-visual-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/primitive-visual-shader.frag
@@ -1,8 +1,16 @@
+//@name primitive-visual-shader.frag
+
+//@version 100
+
 //Very simple fragment shader that merely applies the vertex shading to the color at each fragment.
 
 precision mediump float;
-varying mediump vec3 vIllumination;
-uniform lowp vec4 uColor;
+INPUT mediump vec3 vIllumination;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/primitive-visual-shader.vert b/dali-toolkit/internal/graphics/shaders/primitive-visual-shader.vert
index 12002941dd..aae2d7f003 100644
--- a/dali-toolkit/internal/graphics/shaders/primitive-visual-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/primitive-visual-shader.vert
@@ -1,25 +1,32 @@
+//@name primitive-visual-shader.vert
+
+//@version 100
+
 //A simple shader that applies diffuse lighting to a mono-coloured object.
 
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-varying mediump vec3 vIllumination;
-uniform mediump vec3 uSize;
-uniform mediump vec3 uObjectDimensions;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+OUTPUT mediump vec3 vIllumination;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump vec3 uSize;
+  UNIFORM mediump vec3 uObjectDimensions;
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM mediump mat4 uModelView;
+  UNIFORM mediump mat4 uViewMatrix;
+  UNIFORM mediump mat3 uNormalMatrix;
+  UNIFORM mediump mat4 uObjectMatrix;
+  UNIFORM mediump vec3 lightPosition;
+  UNIFORM mediump vec2 uStageOffset;
 
 //Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+  UNIFORM mediump vec2 offset;
+  UNIFORM mediump vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+};
 
 vec4 ComputeVertexPosition()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/render-effect.frag b/dali-toolkit/internal/graphics/shaders/render-effect.frag
index 40968e0e53..4bf0d811e3 100644
--- a/dali-toolkit/internal/graphics/shaders/render-effect.frag
+++ b/dali-toolkit/internal/graphics/shaders/render-effect.frag
@@ -1,12 +1,24 @@
+//@name render-effect.frag
+
+//@version 100
+
 precision highp float;
-varying highp vec2 vTexCoord;
-varying highp vec2 vOptRectSize;
-varying highp vec4 vCornerRadius;
+INPUT highp vec2 vTexCoord;
+INPUT highp vec2 vOptRectSize;
+INPUT highp vec4 vCornerRadius;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM highp vec4 uCornerSquareness;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+  UNIFORM highp vec3 uSize;
+};
 
-uniform lowp vec4 uColor;
-uniform highp vec3 uSize;
-uniform highp vec4 uCornerSquareness;
-uniform sampler2D sTexture;
+UNIFORM sampler2D sTexture;
 
 highp float nrand(const in vec2 uv)
 {
@@ -55,7 +67,7 @@ float roundedBoxSDF(vec2 pixelPositionFromCenter, vec2 rectangleEdgePositionFrom
 
 void main()
 {
-  gl_FragColor = texture2D(sTexture, vTexCoord) * uColor;
+  gl_FragColor = TEXTURE(sTexture, vTexCoord) * uColor;
   gl_FragColor.rgb = applyDithering(gl_FragColor.rgb);
 
   highp vec2 location = (vTexCoord.xy - vec2(0.5)) * uSize.xy;
diff --git a/dali-toolkit/internal/graphics/shaders/render-effect.vert b/dali-toolkit/internal/graphics/shaders/render-effect.vert
index c46d0dd68f..01dc50449b 100644
--- a/dali-toolkit/internal/graphics/shaders/render-effect.vert
+++ b/dali-toolkit/internal/graphics/shaders/render-effect.vert
@@ -1,15 +1,26 @@
+//@name render-effect.vert
+
+//@version 100
+
 precision highp float;
 
-attribute highp vec2 aPosition;
+INPUT highp vec2 aPosition;
 
-varying highp vec2 vTexCoord;
-varying highp vec2 vOptRectSize;
-varying highp vec4 vCornerRadius; //output
+OUTPUT highp vec2 vTexCoord;
+OUTPUT highp vec2 vOptRectSize;
+OUTPUT highp vec4 vCornerRadius; //output
 
-uniform highp mat4 uMvpMatrix;
-uniform highp vec4 uCornerRadius; //input
-uniform lowp float uCornerRadiusPolicy;
-uniform highp vec3 uSize;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec4 uCornerRadius;//input
+  UNIFORM lowp float uCornerRadiusPolicy;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+UNIFORM highp vec3 uSize;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/shadow-view-render-shader.frag b/dali-toolkit/internal/graphics/shaders/shadow-view-render-shader.frag
index d193acfb4a..bcc39f7d19 100644
--- a/dali-toolkit/internal/graphics/shaders/shadow-view-render-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/shadow-view-render-shader.frag
@@ -1,10 +1,17 @@
-varying mediump vec2 vTexCoord;
-uniform lowp vec4 uShadowColor;
-uniform sampler2D sTexture;
+//@name shadow-view-render-shader.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uShadowColor;
+};
+UNIFORM sampler2D sTexture;
 
 void main()
 {
   lowp float alpha;
-  alpha = texture2D(sTexture, vec2(vTexCoord.x, vTexCoord.y)).a;
+  alpha = TEXTURE(sTexture, vec2(vTexCoord.x, vTexCoord.y)).a;
   gl_FragColor = vec4(uShadowColor.rgb, uShadowColor.a * alpha);
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/shadow-view-render-shader.vert b/dali-toolkit/internal/graphics/shaders/shadow-view-render-shader.vert
index 4b38884c9a..6ed9c9bc9e 100644
--- a/dali-toolkit/internal/graphics/shaders/shadow-view-render-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/shadow-view-render-shader.vert
@@ -1,11 +1,18 @@
-attribute mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelMatrix;
-uniform vec3 uSize;
-varying vec2 vTexCoord;
+//@name shadow-view-render-shader.vert
 
-uniform mediump mat4 uLightCameraProjectionMatrix;
-uniform mediump mat4 uLightCameraViewMatrix;
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT vec2 vTexCoord;
+
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump mat4 uMvpMatrix;
+  UNIFORM mediump mat4 uModelMatrix;
+  UNIFORM vec3 uSize;
+  UNIFORM mediump mat4 uLightCameraProjectionMatrix;
+  UNIFORM mediump mat4 uLightCameraViewMatrix;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/spread-filter-shader.frag b/dali-toolkit/internal/graphics/shaders/spread-filter-shader.frag
index ac8276323d..a6a19d6cd3 100644
--- a/dali-toolkit/internal/graphics/shaders/spread-filter-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/spread-filter-shader.frag
@@ -1,17 +1,24 @@
+//@name spread-filter-shader.frag
+
+//@version 100
+
 precision highp float;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform int uSpread;
-uniform vec2 uTexScale;
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM int uSpread;
+  UNIFORM vec2 uTexScale;
+};
 
 void main()
 {
-  vec4 color = texture2D( sTexture, vTexCoord);
+  vec4 color = TEXTURE( sTexture, vTexCoord);
   for( int i = 1; i <= uSpread; ++i )
   {
     vec2 offset = uTexScale * float(i);
-    color = max( texture2D( sTexture, vTexCoord + offset), color );
-    color = max( texture2D( sTexture, vTexCoord - offset), color );
+    color = max( TEXTURE( sTexture, vTexCoord + offset), color );
+    color = max( TEXTURE( sTexture, vTexCoord - offset), color );
   }
   gl_FragColor = color;
 }
\ No newline at end of file
diff --git a/dali-toolkit/internal/graphics/shaders/super-blur-view.frag b/dali-toolkit/internal/graphics/shaders/super-blur-view.frag
index aad41e1a54..591287e90f 100644
--- a/dali-toolkit/internal/graphics/shaders/super-blur-view.frag
+++ b/dali-toolkit/internal/graphics/shaders/super-blur-view.frag
@@ -1,10 +1,17 @@
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
-uniform lowp float uAlpha;
+//@name super-blur-view.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+  UNIFORM lowp float uAlpha;
+};
 
 void main()
 {
-  gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+  gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
   gl_FragColor.a *= uAlpha;
 }
diff --git a/dali-toolkit/internal/graphics/shaders/text-atlas-l8-shader.frag b/dali-toolkit/internal/graphics/shaders/text-atlas-l8-shader.frag
index e42de21e5b..9140b69f88 100644
--- a/dali-toolkit/internal/graphics/shaders/text-atlas-l8-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/text-atlas-l8-shader.frag
@@ -1,11 +1,18 @@
-uniform lowp    vec4      uColor;
-uniform lowp    vec4      textColorAnimatable;
-uniform         sampler2D sTexture;
-varying mediump vec2      vTexCoord;
-varying mediump vec4      vColor;
+//@name text-atlas-l8-shader.frag
+
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp    vec4      uColor;
+  UNIFORM lowp    vec4      textColorAnimatable;
+};
+UNIFORM         sampler2D sTexture;
+INPUT mediump vec2      vTexCoord;
+INPUT mediump vec4      vColor;
 
 void main()
 {
-  mediump vec4 color = texture2D( sTexture, vTexCoord );
+  mediump vec4 color = TEXTURE( sTexture, vTexCoord );
   gl_FragColor = vec4( vColor.rgb * uColor.rgb * textColorAnimatable.rgb, uColor.a * vColor.a * textColorAnimatable.a * color.r );
 }
diff --git a/dali-toolkit/internal/graphics/shaders/text-atlas-rgba-shader.frag b/dali-toolkit/internal/graphics/shaders/text-atlas-rgba-shader.frag
index 966ee90555..d63b685b38 100644
--- a/dali-toolkit/internal/graphics/shaders/text-atlas-rgba-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/text-atlas-rgba-shader.frag
@@ -1,9 +1,16 @@
-uniform lowp    vec4      uColor;
-uniform lowp    vec4      textColorAnimatable;
-uniform         sampler2D sTexture;
-varying mediump vec2      vTexCoord;
+//@name text-atlas-rgba-shader.frag
+
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4      uColor;
+  UNIFORM lowp vec4      textColorAnimatable;
+};
+UNIFORM         sampler2D sTexture;
+INPUT mediump vec2      vTexCoord;
 
 void main()
 {
-  gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * textColorAnimatable;
+  gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor * textColorAnimatable;
 }
diff --git a/dali-toolkit/internal/graphics/shaders/text-atlas-shader.vert b/dali-toolkit/internal/graphics/shaders/text-atlas-shader.vert
index 0d2d621688..9edcda8b50 100644
--- a/dali-toolkit/internal/graphics/shaders/text-atlas-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/text-atlas-shader.vert
@@ -1,10 +1,18 @@
-attribute   highp vec2    aPosition;
-attribute mediump vec2    aTexCoord;
-attribute mediump vec4    aColor;
-uniform   mediump vec2    uOffset;
-uniform     highp mat4    uMvpMatrix;
-varying   mediump vec2    vTexCoord;
-varying   mediump vec4    vColor;
+//@name text-atlas-shader.vert
+
+//@version 100
+
+INPUT   highp vec2    aPosition;
+INPUT mediump vec2    aTexCoord;
+INPUT mediump vec4    aColor;
+
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM mediump vec2    uOffset;
+  UNIFORM highp mat4    uMvpMatrix;
+};
+OUTPUT   mediump vec2    vTexCoord;
+OUTPUT   mediump vec4    vColor;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/text-controller-background-shader.frag b/dali-toolkit/internal/graphics/shaders/text-controller-background-shader.frag
index c935d22108..4cc103b661 100644
--- a/dali-toolkit/internal/graphics/shaders/text-controller-background-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/text-controller-background-shader.frag
@@ -1,5 +1,12 @@
-varying mediump vec4      vColor;
-uniform lowp    vec4      uColor;
+//@name text-controller-background-shader.frag
+
+//@version 100
+
+INPUT mediump vec4      vColor;
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp    vec4      uColor;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/text-controller-background-shader.vert b/dali-toolkit/internal/graphics/shaders/text-controller-background-shader.vert
index 9ce403cba9..60b51171db 100644
--- a/dali-toolkit/internal/graphics/shaders/text-controller-background-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/text-controller-background-shader.vert
@@ -1,7 +1,14 @@
-attribute mediump vec2    aPosition;
-attribute mediump vec4    aColor;
-varying   mediump vec4    vColor;
-uniform   highp mat4      uMvpMatrix;
+//@name text-controller-background-shader.vert
+
+//@version 100
+
+INPUT mediump vec2    aPosition;
+INPUT mediump vec4    aColor;
+OUTPUT   mediump vec4    vColor;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM   highp mat4      uMvpMatrix;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/text-decorator-shader.frag b/dali-toolkit/internal/graphics/shaders/text-decorator-shader.frag
index 7402ddef75..836e39f2fc 100644
--- a/dali-toolkit/internal/graphics/shaders/text-decorator-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/text-decorator-shader.frag
@@ -1,5 +1,11 @@
-uniform      lowp vec4 uColor;
+//@name text-decorator-shader.frag
 
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 void main()
 {
   gl_FragColor = uColor;
diff --git a/dali-toolkit/internal/graphics/shaders/text-decorator-shader.vert b/dali-toolkit/internal/graphics/shaders/text-decorator-shader.vert
index 6afdfca6aa..ef08b5e1ad 100644
--- a/dali-toolkit/internal/graphics/shaders/text-decorator-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/text-decorator-shader.vert
@@ -1,6 +1,12 @@
-attribute mediump vec2    aPosition;
-uniform   highp mat4      uMvpMatrix;
+//@name text-decorator-shader.vert
 
+//@version 100
+
+INPUT mediump vec2    aPosition;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4      uMvpMatrix;
+};
 void main()
 {
   mediump vec4 position = vec4( aPosition, 0.0, 1.0 );
diff --git a/dali-toolkit/internal/graphics/shaders/text-scroller-shader.frag b/dali-toolkit/internal/graphics/shaders/text-scroller-shader.frag
index 876628abc3..cc7689db0d 100644
--- a/dali-toolkit/internal/graphics/shaders/text-scroller-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/text-scroller-shader.frag
@@ -1,13 +1,21 @@
-varying highp vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
+//@name text-scroller-shader.frag
+
+//@version 100
+
+INPUT highp vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
   if ( vTexCoord.y > 1.0 )
     discard;
 
-  mediump vec4 textTexture = texture2D( sTexture, vTexCoord );
+  mediump vec4 textTexture = TEXTURE( sTexture, vTexCoord );
 
   gl_FragColor = textTexture * uColor;
 }
diff --git a/dali-toolkit/internal/graphics/shaders/text-scroller-shader.vert b/dali-toolkit/internal/graphics/shaders/text-scroller-shader.vert
index c152b5e3be..ef61fd01fe 100644
--- a/dali-toolkit/internal/graphics/shaders/text-scroller-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/text-scroller-shader.vert
@@ -1,21 +1,27 @@
-attribute mediump vec2 aPosition;
-varying highp vec2 vTexCoord;
-uniform highp vec3 uSize;
-uniform highp float uDelta;
-uniform mediump vec2 uTextureSize;
-uniform highp float uGap;
-uniform mediump float uHorizontalAlign;
-uniform mediump float uVerticalAlign;
+//@name text-scroller-shader.vert
 
-uniform highp mat4 uMvpMatrix;
+//@version 100
 
-//Visual size and offset
-uniform mediump vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+INPUT mediump vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
 
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp vec3 uSize;
+  UNIFORM highp float uDelta;
+  UNIFORM mediump vec2 uTextureSize;
+  UNIFORM highp float uGap;
+  UNIFORM mediump float uHorizontalAlign;
+  UNIFORM mediump float uVerticalAlign;
+  UNIFORM highp mat4 uMvpMatrix;
+
+  //Visual size and offset
+  UNIFORM mediump vec2 offset;
+  UNIFORM highp vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+};
 void main()
 {
   highp vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw);
diff --git a/dali-toolkit/internal/graphics/shaders/text-visual-shader.frag b/dali-toolkit/internal/graphics/shaders/text-visual-shader.frag
index 8cd690a3ca..924d90417c 100644
--- a/dali-toolkit/internal/graphics/shaders/text-visual-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/text-visual-shader.frag
@@ -1,20 +1,32 @@
+//@name text-visual-shader.frag
+
+//@version 100
+
 INPUT mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
+UNIFORM sampler2D sTexture;
 #ifdef IS_REQUIRED_STYLE
-uniform sampler2D sStyle;
+UNIFORM sampler2D sStyle;
 #endif
 #ifdef IS_REQUIRED_OVERLAY
-uniform sampler2D sOverlayStyle;
+UNIFORM sampler2D sOverlayStyle;
 #endif
+
 #ifdef IS_REQUIRED_MULTI_COLOR
 #elif defined(IS_REQUIRED_EMOJI)
 // Single color with emoji.
-uniform sampler2D sMask;
-uniform lowp float uHasMultipleTextColors;
+UNIFORM sampler2D sMask;
 #endif
-uniform lowp vec4 uTextColorAnimatable;
-uniform lowp vec4 uColor;
 
+UNIFORM_BLOCK FragBlock
+{
+  #ifdef IS_REQUIRED_MULTI_COLOR
+  #elif defined(IS_REQUIRED_EMOJI)
+  // Single color with emoji.
+  UNIFORM lowp float uHasMultipleTextColors;
+  #endif
+  UNIFORM lowp vec4 uTextColorAnimatable;
+  UNIFORM lowp vec4 uColor;
+};
 void main()
 {
 #ifdef IS_REQUIRED_STYLE
@@ -47,7 +59,7 @@ void main()
 #endif
 
   // Draw the text as overlay above the style
-  OUT_COLOR = uColor * (
+  gl_FragColor = uColor * (
 #ifdef IS_REQUIRED_OVERLAY
                    (
 #endif
diff --git a/dali-toolkit/internal/graphics/shaders/text-visual-shader.vert b/dali-toolkit/internal/graphics/shaders/text-visual-shader.vert
index 68503a9af2..04c7152a72 100644
--- a/dali-toolkit/internal/graphics/shaders/text-visual-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/text-visual-shader.vert
@@ -1,15 +1,22 @@
-INPUT mediump vec2 aPosition;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+//@name text-visual-shader.vert
+
+//@version 100
 
+INPUT mediump vec2 aPosition;
 OUTPUT mediump vec2 vTexCoord;
 
-//Visual size and offset
-uniform mediump vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
+
+  //Visual size and offset
+  UNIFORM mediump vec2 offset;
+  UNIFORM highp vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+};
 
 vec4 ComputeVertexPosition()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/video-view-texture.frag b/dali-toolkit/internal/graphics/shaders/video-view-texture.frag
index 306f12e7e1..3be448dedc 100644
--- a/dali-toolkit/internal/graphics/shaders/video-view-texture.frag
+++ b/dali-toolkit/internal/graphics/shaders/video-view-texture.frag
@@ -1,8 +1,16 @@
-uniform lowp vec4 uColor;
-varying mediump vec2 vTexCoord;
-uniform samplerExternalOES sTexture;
+//@name video-view-texture.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM samplerExternalOES sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
-  gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+  gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
 }
diff --git a/dali-toolkit/internal/graphics/shaders/video-view-texture.vert b/dali-toolkit/internal/graphics/shaders/video-view-texture.vert
index 79cbb23937..5493474794 100644
--- a/dali-toolkit/internal/graphics/shaders/video-view-texture.vert
+++ b/dali-toolkit/internal/graphics/shaders/video-view-texture.vert
@@ -1,8 +1,15 @@
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-varying mediump vec2 sTexCoordRect;
+//@name video-view-texture.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
+};
+OUTPUT mediump vec2 sTexCoordRect;
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/video-view.frag b/dali-toolkit/internal/graphics/shaders/video-view.frag
index 8045c0def0..3baad97289 100644
--- a/dali-toolkit/internal/graphics/shaders/video-view.frag
+++ b/dali-toolkit/internal/graphics/shaders/video-view.frag
@@ -1,3 +1,7 @@
+//@name video-view.frag
+
+//@version 100
+
 void main()
 {
   gl_FragColor = vec4(0.0);
diff --git a/dali-toolkit/internal/graphics/shaders/video-view.vert b/dali-toolkit/internal/graphics/shaders/video-view.vert
index 3f824dd1b0..7723ddc679 100644
--- a/dali-toolkit/internal/graphics/shaders/video-view.vert
+++ b/dali-toolkit/internal/graphics/shaders/video-view.vert
@@ -1,6 +1,13 @@
-attribute mediump vec2 aPosition;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+//@name video-view.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM highp mat4 uMvpMatrix;
+  UNIFORM highp vec3 uSize;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/wireframe-visual-shader.frag b/dali-toolkit/internal/graphics/shaders/wireframe-visual-shader.frag
index c75da53311..ed173fa340 100644
--- a/dali-toolkit/internal/graphics/shaders/wireframe-visual-shader.frag
+++ b/dali-toolkit/internal/graphics/shaders/wireframe-visual-shader.frag
@@ -1,4 +1,11 @@
-uniform lowp vec4 uColor;
+//@name wireframe-visual-shader.frag
+
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+  UNIFORM lowp vec4 uColor;
+};
 
 void main()
 {
diff --git a/dali-toolkit/internal/graphics/shaders/wireframe-visual-shader.vert b/dali-toolkit/internal/graphics/shaders/wireframe-visual-shader.vert
index 9a9975cda1..74c29b7e84 100644
--- a/dali-toolkit/internal/graphics/shaders/wireframe-visual-shader.vert
+++ b/dali-toolkit/internal/graphics/shaders/wireframe-visual-shader.vert
@@ -1,13 +1,20 @@
-attribute mediump vec2  aPosition;
-uniform   highp   mat4  uMvpMatrix;
-uniform   highp   vec3  uSize;
+//@name wireframe-visual-shader.vert
+
+//@version 100
+
+INPUT mediump vec2  aPosition;
+UNIFORM_BLOCK VertBlock
+{
+  UNIFORM   highp   mat4  uMvpMatrix;
+  UNIFORM   highp   vec3  uSize;
 
 //Visual size and offset
-uniform mediump vec2 offset;
-uniform highp   vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+  UNIFORM mediump vec2 offset;
+  UNIFORM highp   vec2 size;
+  UNIFORM mediump vec4 offsetSizeMode;
+  UNIFORM mediump vec2 origin;
+  UNIFORM mediump vec2 anchorPoint;
+};
 
 vec4 ComputeVertexPosition()
 {