-//@version 100
-
-UNIFORM_BLOCK VanillaFrag
-{
-UNIFORM lowp vec4 uColor;
-};
-
-INPUT lowp vec2 vCoefficient;
+uniform lowp vec4 uColor;
+varying lowp vec2 vCoefficient;
void main()
{
-//@version 100
-
-INPUT mediump vec3 aCoefficient;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump vec3 uPosition[MAX_POINT_COUNT];
-};
-
-OUTPUT lowp vec2 vCoefficient;
+attribute mediump vec3 aCoefficient;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uPosition[MAX_POINT_COUNT];
+varying lowp vec2 vCoefficient;
void main()
{
-//@version 100
-
+uniform lowp vec4 uColor;
void main()
{
-//@version 100
-
-INPUT mediump vec2 aPosition;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM vec3 uSize;
-};
+attribute mediump vec2 aPosition;
+uniform mediump mat4 uMvpMatrix;
+uniform vec3 uSize;
void main()
{
-//@version 100
-
-UNIFORM sampler2D uTexture;
-
-UNIFORM_BLOCK VanFrag
-{
-UNIFORM mediump float uBrightness;
-};
-
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec3 vIllumination;
+uniform sampler2D uTexture;
+uniform mediump float uBrightness;
+varying mediump vec2 vTexCoord;
+varying mediump vec3 vIllumination;
mediump vec3 redistribute_rgb(mediump vec3 color)
{
void main()
{
- mediump vec4 texColor = TEXTURE( uTexture, vTexCoord );
+ mediump vec4 texColor = texture2D( uTexture, vTexCoord );
//mediump vec4 texColor = vec4(0.5,0.5,0.5,1.0);
//gl_FragColor = vec4(texColor.rgb, 1.0);
-//@version 100
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
-UNIFORM mediump mat4 uViewMatrix; // DALi shader builtin
-UNIFORM mediump mat4 uModelView; // DALi shader builtin
-UNIFORM mediump vec3 uSize; // DALi shader builtin
-};
-
-INPUT mediump vec3 aPosition; // DALi shader builtin
-INPUT mediump vec2 aTexCoord; // DALi shader builtin
-OUTPUT mediump vec3 vIllumination;
-OUTPUT mediump vec2 vTexCoord;
+attribute mediump vec3 aPosition; // DALi shader builtin
+attribute mediump vec2 aTexCoord; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump mat4 uViewMatrix; // DALi shader builtin
+uniform mediump mat4 uModelView; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+varying mediump vec3 vIllumination;
+varying mediump vec2 vTexCoord;
void main()
{
-//@version 100
-
// This fragment-shader does not output anything.
// It's for a control which is just going to clip as specified in the vertex shader.
-//@version 100
-
// This vertex-shader mixes in the quad and circle geometry depending on the value of uDelta.
//
// uDelta is used to mix in the Circle and the Quad positions.
// If uDelta is 0.0f, then the circle position is adopted and if it is 1.0f, then the quad position is adopted.
-INPUT mediump vec2 aPositionCircle;
-INPUT mediump vec2 aPositionQuad;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump float uDelta;
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump vec3 uSize;
-};
+attribute mediump vec2 aPositionCircle;
+attribute mediump vec2 aPositionQuad;
+uniform mediump float uDelta;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
void main()
{
-//@version 100
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
-UNIFORM sampler2D sTexture;
-
-UNIFORM_BLOCK VanillaFrag
-{
-UNIFORM lowp vec4 uColor;
-};
-
-INPUT lowp vec3 vColor;
+varying lowp vec3 vColor;
void main()
{
-//@version 100
+attribute mediump vec2 aPosition1;
+attribute mediump vec2 aPosition2;
+attribute lowp vec3 aColor;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump float uMorphAmount;
-INPUT mediump vec2 aPosition1;
-INPUT mediump vec2 aPosition2;
-INPUT lowp vec3 aColor;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump vec3 uSize;
-UNIFORM mediump float uMorphAmount;
-};
-
-OUTPUT lowp vec3 vColor;
+varying lowp vec3 vColor;
void main()
{
-//@version 100
-
-INPUT lowp vec4 vColor;
+varying lowp vec4 vColor;
void main()
{
-//@version 100
-
-INPUT mediump vec2 aInitPos;
-INPUT mediump vec2 aFinalPos;
-INPUT mediump vec3 aColor;
-
-OUTPUT lowp vec4 vColor;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump vec3 uSize;
-UNIFORM mediump float uDelta;
-UNIFORM lowp vec4 uColor;
-};
+attribute mediump vec2 aInitPos;
+attribute mediump vec2 aFinalPos;
+attribute mediump vec3 aColor;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump float uDelta;
+uniform lowp vec4 uColor;
+varying lowp vec4 vColor;
void main()
{
-//@version 100
-
//Fragment shader code for metaball and background composition with refraction effect
precision highp float;
-INPUT vec2 vTexCoord;
-
-UNIFORM sampler2D sTexture;
-UNIFORM sampler2D sEffect;
-
-UNIFORM_BLOCK VanillaFrag
-{
-UNIFORM vec2 uPositionMetaball;
-};
-
+varying vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform sampler2D sEffect;
+uniform vec2 uPositionMetaball;
void main()
{
vec2 zoomCoords;
vec3 color = vec3(1.0, 1.0, 1.0);
float ambient = 0.2;
- vec4 metaColor = TEXTURE(sEffect, vTexCoord);
+ vec4 metaColor = texture2D(sEffect, vTexCoord);
vec2 adjustedCoords = vTexCoord.xy * vec2(2.0) - vec2(1.0);
fakePos = adjustedCoords.xy - vec2(uPositionMetaball.x, -uPositionMetaball.y);
float specularFactor = max(0.0,dot(vertexToEye, lightReflect));
specularFactor = pow(specularFactor, 32.0) * 0.7;
- vec4 texColor = TEXTURE(sTexture, zoomCoords);
+ vec4 texColor = texture2D(sTexture, zoomCoords);
gl_FragColor.rgb = texColor.rgb * ambient + color.rgb * texColor.rgb * lightDiffuse + vec3(specularFactor);
gl_FragColor.a = 1.0;
}
-//@version 100
-
// Fragment shader code for metaball
precision mediump float;
-
-INPUT vec2 vTexCoord;
-
-UNIFORM_BLOCK VanillaFrag
-{
-UNIFORM vec2 uPositionMetaball;
-UNIFORM vec2 uPositionVar;
-UNIFORM vec2 uGravityVector;
-UNIFORM float uRadius;
-UNIFORM float uRadiusVar;
-};
+varying vec2 vTexCoord;
+uniform vec2 uPositionMetaball;
+uniform vec2 uPositionVar;
+uniform vec2 uGravityVector;
+uniform float uRadius;
+uniform float uRadiusVar;
void main()
{
-//@version 100
-
//Vertex shader code for metaball
-INPUT mediump vec2 aPosition;
-INPUT mediump vec2 aTexture;
-
-OUTPUT mediump vec2 vTexCoord;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump vec3 uSize;
-UNIFORM lowp vec4 uColor;
-};
+attribute mediump vec2 aPosition;
+attribute mediump vec2 aTexture;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform lowp vec4 uColor;
+varying mediump vec2 vTexCoord;
void main()
{
-//@version 100
-
// Fragment shader code when there's no effect
precision mediump float;
-
-INPUT vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
+varying vec2 vTexCoord;
+uniform sampler2D sTexture;
void main()
{
- gl_FragColor = TEXTURE(sTexture, vTexCoord);
+ gl_FragColor = texture2D(sTexture, vTexCoord);
}
-//@version 100
// Fragment shader code for metaball and background composition with refraction effect
precision mediump float;
-INPUT vec2 vTexCoord;
-
-UNIFORM sampler2D sTexture;
-UNIFORM sampler2D sEffect;
+varying vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform sampler2D sEffect;
void main()
{
- vec4 metaColor = TEXTURE(sEffect, vTexCoord);
+ vec4 metaColor = texture2D(sEffect, vTexCoord);
vec2 zoomCoords;
float bright = 1.0;
if (metaColor.r > 0.85)
zoomCoords = vTexCoord;
}
- gl_FragColor = TEXTURE(sTexture, zoomCoords) * bright;
+ gl_FragColor = texture2D(sTexture, zoomCoords) * bright;
}
-//@version 100
-
// Fragment shader for metaballs
precision mediump float;
-INPUT vec2 vTexCoord;
-
-UNIFORM_BLOCK VanillaFrag
-{
-UNIFORM vec2 uPositionMetaball;
-UNIFORM vec2 uPositionVar;
-UNIFORM vec2 uGravityVector;
-UNIFORM float uRadius;
-UNIFORM float uRadiusVar;
-UNIFORM float uAspect;
-};
+varying vec2 vTexCoord;
+uniform vec2 uPositionMetaball;
+uniform vec2 uPositionVar;
+uniform vec2 uGravityVector;
+uniform float uRadius;
+uniform float uRadiusVar;
+uniform float uAspect;
void main()
{
-//@version 100
// Vertex shader for metaballs
-INPUT mediump vec2 aPosition;
-INPUT mediump vec2 aTexture;
-OUTPUT mediump vec2 vTexCoord;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump vec3 uSize;
-UNIFORM lowp vec4 uColor;
-};
+attribute mediump vec2 aPosition;
+attribute mediump vec2 aTexture;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform lowp vec4 uColor;
+varying mediump vec2 vTexCoord;
void main()
{
-//@version 100
-
+#version 300 es
// Shader for an unlit, unfogged, textured mesh.
precision mediump float;
-
-UNIFORM_BLOCK VanillaFrag
-{
-UNIFORM vec4 uColor;
-};
+uniform vec4 uColor;
+out vec4 oFragColor;
void main()
{
- gl_FragColor = uColor;
+ oFragColor = uColor;
}
-//@version 100
-
+#version 300 es
// Shader for simple textured geometry.
precision mediump float;
-
-UNIFORM_BLOCK VertexBlock
-{
- UNIFORM mat4 uMvpMatrix; //by DALi
- UNIFORM vec3 uSize; // by DALi
-};
-
-INPUT vec3 aPosition;
+uniform mat4 uMvpMatrix;//by DALi
+uniform vec3 uSize; // by DALi
+in vec3 aPosition;
void main()
{
- gl_Position = uMvpMatrix * vec4(aPosition * uSize, 1.0);
+ gl_Position = uMvpMatrix * vec4(aPosition * uSize, 1.f);
}
-//@version 100
-
+#version 300 es
// Fragment shader for particles, which simulates depth of field using
// a combination of procedural texturing, alpha testing and alpha blending.
precision lowp float;
-
-UNIFORM_BLOCK VanillaFrag
-{
-UNIFORM float uAlphaTestRefValue;
-UNIFORM vec2 uFadeRange; // near, far
-};
-
-INPUT vec2 vUvUnit;
-INPUT flat float vDepth;
-INPUT flat float vFocalDistance;
-INPUT flat float vOpacity;
-INPUT flat vec3 vColor;
+uniform float uAlphaTestRefValue;
+uniform vec2 uFadeRange; // near, far
+in vec2 vUvUnit;
+flat in float vDepth;
+flat in float vFocalDistance;
+flat in float vOpacity;
+flat in vec3 vColor;
+out vec4 oFragColor;
const float REF_VALUE_THRESHOLD = 1. / 64.;
// Fade particles out as they get close to the near and far clipping planes
alpha *= smoothstep(.0f, uFadeRange.x, vDepth) * smoothstep(1.f, uFadeRange.y, vDepth);
- gl_FragColor = vec4(vColor, alpha);
+ oFragColor = vec4(vColor, alpha);
}
-//@version 100
-
+#version 300 es
// Shader for billboarded particles, where the vertices of the particles
// are supplied as vec3 position (particle position) + vec2 sub-position.
precision lowp float;
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mat4 uModelView; // DALi
-UNIFORM mat4 uProjection; // DALi
-UNIFORM vec3 uSize; // DALi
-UNIFORM vec4 uColor; // DALi
-};
-
-UNIFORM_BLOCK Billboard
-{
-UNIFORM vec3 uSecondaryColor;
-UNIFORM vec2 uDepthRange; // x is zNear, y is 1.f / (zFar - zNear)
-UNIFORM float uTwinkleFrequency;
-UNIFORM float uTwinkleSizeScale;
-UNIFORM float uTwinkleOpacityWeight;
-UNIFORM float uTime;
-UNIFORM float uFocalLength;
-UNIFORM float uAperture;
-UNIFORM float uPopulation;
-};
+uniform mat4 uModelView; // DALi
+uniform mat4 uProjection; // DALi
+uniform vec3 uSize; // DALi
+uniform vec4 uColor; // DALi
+
+uniform vec3 uSecondaryColor;
+uniform vec2 uDepthRange; // x is zNear, y is 1.f / (zFar - zNear)
+uniform float uTwinkleFrequency;
+uniform float uTwinkleSizeScale;
+uniform float uTwinkleOpacityWeight;
+uniform float uTime;
+uniform float uFocalLength;
+uniform float uAperture;
+uniform float uPopulation;
struct Scatter
{
};
const int SCATTER_VARS = 6; // Must match ParticleView::mScatterProps' size.
-
-UNIFORM_BLOCK ScatterBlock
-{
-UNIFORM Scatter uScatter[SCATTER_VARS];
-};
+uniform Scatter uScatter[SCATTER_VARS];
const int POPULATION_GRANULARITY = 128;
-UNIFORM_BLOCK OrderLookup
-{
-UNIFORM float uOrderLookUp[POPULATION_GRANULARITY];
-};
-
-INPUT vec3 aPosition;
-INPUT float aSeed;
-INPUT vec4 aPath;
-INPUT vec2 aSubPosition;
-INPUT float aSize;
-
-OUTPUT flat float vDepth;
-OUTPUT flat float vFocalDistance;
-OUTPUT vec2 vUvUnit;
-OUTPUT flat float vOpacity;
-OUTPUT flat vec3 vColor; // ignore alpha
+uniform float uOrderLookUp[POPULATION_GRANULARITY];
+
+in vec3 aPosition;
+in float aSeed;
+in vec4 aPath;
+in vec2 aSubPosition;
+in float aSize;
+
+flat out float vDepth;
+flat out float vFocalDistance;
+out vec2 vUvUnit;
+flat out float vOpacity;
+flat out vec3 vColor; // ignore alpha
float bezier(vec3 control, float alpha)
{
-//@version 100
-
-UNIFORM_BLOCK VanillaFrag
-{
-UNIFORM lowp vec4 uColor;
-}
-UNIFORM sampler2D sTexture;
-
-INPUT mediump vec2 vTexCoord;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
}
-//@version 100
-
-INPUT mediump vec2 aPosition;
-INPUT mediump vec2 aTexCoord;
-OUTPUT mediump vec2 vTexCoord;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump vec3 uSize;
-};
+attribute mediump vec2 aPosition;
+attribute mediump vec2 aTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+varying mediump vec2 vTexCoord;
void main()
{
-//@version 100
-
-INPUT mediump vec3 vVertexColor;
-INPUT mediump float vHue;
-
-UNIFORM sampler2D sTexture1;
-UNIFORM sampler2D sTexture2;
-
-UNIFORM_BLOCK FragUniforms
-{
-UNIFORM lowp vec4 uColor;
-UNIFORM lowp vec4 uFadeColor;
-};
+varying mediump vec3 vVertexColor;
+varying mediump float vHue;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture1;
+uniform sampler2D sTexture2;
+uniform lowp vec4 uFadeColor;
void main()
{
- mediump vec4 texCol1 = TEXTURE(sTexture1, gl_PointCoord);
- mediump vec4 texCol2 = TEXTURE(sTexture2, gl_PointCoord);
+ mediump vec4 texCol1 = texture2D(sTexture1, gl_PointCoord);
+ mediump vec4 texCol2 = texture2D(sTexture2, gl_PointCoord);
gl_FragColor = vec4(vVertexColor, 1.0) * ((texCol1 * vHue) + (texCol2 * (1.0 - vHue)));
}
-//@version 100
-
-INPUT mediump vec2 aPosition;
-INPUT highp float aHue;
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec3 vVertexColor;
-OUTPUT mediump float vHue;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump vec3 uSize;
-};
-
-UNIFORM_BLOCK Custom
-{
-UNIFORM mediump float uPointSize;
-};
+attribute mediump vec2 aPosition;
+attribute highp float aHue;
+varying mediump vec2 vTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump float uPointSize;
+uniform lowp vec4 uFadeColor;
+varying mediump vec3 vVertexColor;
+varying mediump float vHue;
vec3 hsv2rgb(vec3 c)
{
std::vector<char> fshShaderSource;
// VSH
- if(vsh[0] == '/' && vsh[1] != '/')
+ if(vsh[0] == '/')
{
std::string vshPath(DEMO_GAME_DIR);
vshPath += '/';
}
// FSH
- if(fsh[0] == '/' && fsh[1] != '/')
+ if(fsh[0] == '/')
{
std::string fshPath(DEMO_GAME_DIR);
fshPath += '/';
-//@version 100
-
precision mediump float;
+uniform sampler2D sTexture;
-UNIFORM sampler2D sTexture;
-
-UNIFORM_BLOCK Custom
-{
-UNIFORM float uTime;
-UNIFORM float uKFactor;
-UNIFORM mediump vec3 eyePos;
-UNIFORM mediump vec3 lightDir;
-};
-
-INPUT mediump vec3 vNormal;
-INPUT mediump vec3 vPosition;
-INPUT mediump vec2 vTexCoord;
+uniform float uTime;
+uniform float uKFactor;
+uniform mediump vec3 eyePos;
+uniform mediump vec3 lightDir;
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
+varying mediump vec2 vTexCoord;
void main()
{
v += sin(sqrt(c.x*c.x+c.y*c.y+1.0)+uTime);
v = v/2.0;
mediump vec3 col = vec3(1, sin(PI*v), cos(PI*v));
- gl_FragColor = (TEXTURE(sTexture, vTexCoord)) * (((col.r+col.g+col.b)/3.0)+1.0+intensity);
+ gl_FragColor = (texture2D(sTexture, vTexCoord)) * (((col.r+col.g+col.b)/3.0)+1.0+intensity);
}
-//@version 100
-
-UNIFORM_BLOCK VanillaFrag
-{
-UNIFORM lowp vec4 uColor;
-};
-
-UNIFORM sampler2D sTexture;
-
-INPUT mediump vec3 vNormal;
-INPUT mediump vec3 vPosition;
-INPUT mediump vec2 vTexCoord;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
+varying mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = TEXTURE(sTexture, vTexCoord) * 2.0;
+ gl_FragColor = texture2D(sTexture, vTexCoord) * 2.0;
}
-//@version 100
-
-UNIFORM sampler2D sTexture0;
-UNIFORM sampler2D sTexture1;
-
-UNIFORM_BLOCK Custom
-{
-UNIFORM lowp vec4 uColor;
-UNIFORM mediump vec3 eyePos;
-UNIFORM mediump vec3 lightDir;
-UNIFORM mediump vec2 uScreenSize;
-};
-
-INPUT mediump vec3 vNormal;
-INPUT mediump vec3 vPosition;
-INPUT mediump vec2 vTexCoord;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture0;
+uniform sampler2D sTexture1;
+uniform mediump vec3 eyePos;
+uniform mediump vec3 lightDir;
+uniform mediump vec2 uScreenSize;
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
+varying mediump vec2 vTexCoord;
mediump float rand(mediump vec2 co)
{
mediump float factor = gl_FragCoord.y / uScreenSize.y;
mediump float intensity = max(dot(n,l), 0.0);
mediump vec2 uv = tx;
- gl_FragColor = ((TEXTURE(sTexture0, vTexCoord) * factor ) +
- (TEXTURE(sTexture1, uv))) * intensity;
+ gl_FragColor = ((texture2D(sTexture0, vTexCoord) * factor ) +
+ (texture2D(sTexture1, uv))) * intensity;
}
-//@version 100
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+uniform mediump vec2 uScreenSize;
-UNIFORM sampler2D sTexture;
+uniform mediump vec3 eyePos;
+uniform mediump vec3 lightDir;
-UNIFORM_BLOCK Custom
-{
-UNIFORM lowp vec4 uColor;
-UNIFORM mediump vec2 uScreenSize;
-UNIFORM mediump vec3 eyePos;
-UNIFORM mediump vec3 lightDir;
-};
-
-INPUT mediump vec3 vNormal;
-INPUT mediump vec3 vPosition;
-INPUT mediump vec2 vTexCoord;
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
+varying mediump vec2 vTexCoord;
void main()
{
mediump vec3 l = normalize( lightDir );
mediump vec3 e = normalize( eyePos );
mediump float intensity = max(dot(n,l), 0.0);
- gl_FragColor = TEXTURE(sTexture, vTexCoord) * intensity;
+ gl_FragColor = texture2D(sTexture, vTexCoord) * intensity;
}
-//@version 100
-
-UNIFORM_BLOCK VanillaFrag
-{
-UNIFORM lowp vec4 uColor;
-};
-
-UNIFORM sampler2D sTexture;
-
-INPUT mediump vec3 vNormal;
-INPUT mediump vec3 vPosition;
-INPUT mediump vec2 vTexCoord;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
+varying mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = TEXTURE(sTexture, vTexCoord) * 50.0;
+ gl_FragColor = texture2D(sTexture, vTexCoord) * 50.0;
}
-//@version 100
+attribute mediump vec3 aPosition;
+attribute mediump vec3 aNormal;
+attribute mediump vec2 aTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump mat3 uNormalMatrix;
+uniform mediump vec3 uSize;
-INPUT mediump vec3 aPosition;
-INPUT mediump vec3 aNormal;
-INPUT mediump vec2 aTexCoord;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump mat3 uNormalMatrix;
-UNIFORM mediump vec3 uSize;
-};
-
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec3 vNormal;
-OUTPUT mediump vec3 vPosition;
+varying mediump vec2 vTexCoord;
+varying mediump vec3 vNormal;
+varying mediump vec3 vPosition;
void main()
{
-//@version 100
-
-UNIFORM_BLOCK VanillaFrag
-{
-UNIFORM lowp vec4 uColor;
-};
-
-UNIFORM sampler2D sTexture;
-
-INPUT mediump vec2 vTexCoord;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
}
-//@version 100
-
// The shader source is used when the MeshActor is not touched
-INPUT mediump vec3 aPosition;
-INPUT mediump vec3 aNormal;
-INPUT highp vec2 aTexCoord;
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-};
-
-OUTPUT mediump vec2 vTexCoord;
+attribute mediump vec3 aPosition;
+attribute mediump vec3 aNormal;
+attribute highp vec2 aTexCoord;
+uniform mediump mat4 uMvpMatrix;
+varying mediump vec2 vTexCoord;
void main()
{
-//@version 100
-
precision mediump float;
-UNIFORM_BLOCK Custom
-{
-UNIFORM mediump float uEffectStrength;
-UNIFORM mediump vec3 uLightPosition;
-UNIFORM mediump vec2 uLightXYOffset;
-UNIFORM mediump vec2 uLightSpinOffset;
-UNIFORM mediump float uLightIntensity;
-UNIFORM lowp vec4 uColor;
-};
-
-UNIFORM sampler2D sTexture;
-
-INPUT mediump vec4 vVertex;
-INPUT mediump vec3 vNormal;
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec2 vTextureOffset;
+uniform mediump float uEffectStrength;
+uniform mediump vec3 uLightPosition;
+uniform mediump vec2 uLightXYOffset;
+uniform mediump vec2 uLightSpinOffset;
+uniform mediump float uLightIntensity;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+varying mediump vec4 vVertex;
+varying mediump vec3 vNormal;
+varying mediump vec2 vTexCoord;
+varying mediump vec2 vTextureOffset;
vec3 rgb2hsl(vec3 rgb)
{
spotEffect = spotEffect * uEffectStrength;
mediump float lightDiffuse = ( ( dot( vecToLight, normal )-0.75 ) *uLightIntensity ) * spotEffect;
- lowp vec4 color = TEXTURE( sTexture, vTexCoord + vTextureOffset * spotEffect );
+ lowp vec4 color = texture2D( sTexture, vTexCoord + vTextureOffset * spotEffect );
vec3 lightedColor = hsl2rgb( rgb2hsl(color.rgb) + vec3(0.0,0.0,lightDiffuse) );
gl_FragColor = vec4( lightedColor, color.a ) * uColor;
-//@version 100
-
-INPUT mediump vec3 aPosition;
-INPUT mediump vec3 aNormal;
-INPUT highp vec2 aTexCoord;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-};
-
-OUTPUT mediump vec4 vVertex;
-OUTPUT mediump vec3 vNormal;
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec2 vTextureOffset;
+attribute mediump vec3 aPosition;
+attribute mediump vec3 aNormal;
+attribute highp vec2 aTexCoord;
+uniform mediump mat4 uMvpMatrix;
+varying mediump vec4 vVertex;
+varying mediump vec3 vNormal;
+varying mediump vec2 vTexCoord;
+varying mediump vec2 vTextureOffset;
void main()
{
-//@version 100
-
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec3 vIllumination;
-UNIFORM_BLOCK Color
-{
- UNIFORM lowp vec4 uColor;
-};
-
-UNIFORM sampler2D sTexture;
+varying mediump vec2 vTexCoord;
+varying mediump vec3 vIllumination;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
void main()
{
- gl_FragColor = vec4( TEXTURE( sTexture, vTexCoord ).rgb * vIllumination.rgb * uColor.rgb, uColor.a );
-}
\ No newline at end of file
+ gl_FragColor = vec4( texture2D( sTexture, vTexCoord ).rgb * vIllumination.rgb * uColor.rgb, uColor.a );
+}
-//@version 100
-
// Shader for basic, per-vertex lighting with texture (vertex):
-INPUT mediump vec3 aPosition;
-INPUT highp vec3 aNormal;
-INPUT highp vec2 aTexCoord;
-
-OUTPUT mediump vec3 vIllumination;
-OUTPUT mediump vec2 vTexCoord;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump vec3 uSize;
-UNIFORM mediump vec3 uObjectDimensions;
-UNIFORM mediump mat4 uModelView;
-UNIFORM mediump mat4 uViewMatrix;
-UNIFORM mediump mat3 uNormalMatrix;
-UNIFORM mediump vec3 uLightPosition;
-};
+attribute mediump vec3 aPosition;
+attribute highp vec3 aNormal;
+attribute highp vec2 aTexCoord;
+
+varying mediump vec2 vTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump vec3 uObjectDimensions;
+varying mediump vec3 vIllumination;
+uniform mediump mat4 uModelView;
+uniform mediump mat4 uViewMatrix;
+uniform mediump mat3 uNormalMatrix;
+uniform mediump vec3 uLightPosition;
void main()
{
-//@version 100
-
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec3 vIllumination;
-
-UNIFORM_BLOCK color
-{
- UNIFORM lowp vec4 uColor;
-};
-
-UNIFORM sampler2D sTexture;
+varying mediump vec2 vTexCoord;
+varying mediump vec3 vIllumination;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
void main()
{
-//@version 100
-
// Shader for basic, per-vertex lighting (vertex):
-INPUT mediump vec3 aPosition;
-INPUT highp vec3 aNormal;
-INPUT highp vec2 aTexCoord;
-
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec3 vIllumination;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump vec3 uSize;
-UNIFORM mediump vec3 uObjectDimensions;
-UNIFORM mediump mat4 uModelView;
-UNIFORM mediump mat4 uViewMatrix;
-UNIFORM mediump mat3 uNormalMatrix;
-UNIFORM mediump vec3 uLightPosition;
-};
+attribute mediump vec3 aPosition;
+attribute highp vec3 aNormal;
+attribute highp vec2 aTexCoord;
+
+varying mediump vec2 vTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump vec3 uObjectDimensions;
+varying mediump vec3 vIllumination;
+uniform mediump mat4 uModelView;
+uniform mediump mat4 uViewMatrix;
+uniform mediump mat3 uNormalMatrix;
+uniform mediump vec3 uLightPosition;
void main()
{
-//@version 100
-
-INPUT mediump vec3 vNormal;
-INPUT mediump vec3 vFragPos;
+varying mediump vec3 vNormal;
+varying mediump vec3 vFragPos;
+uniform mediump vec3 viewPos; // custom uniform
struct Material
{
mediump vec3 color;
};
-UNIFORM_BLOCK CustomFrag
-{
-UNIFORM mediump vec3 viewPos; // custom uniform
-UNIFORM Material material; // custom uniform
-UNIFORM Light light; // custom uniform
-};
+uniform Material material; // custom uniform
+uniform Light light; // custom uniform
void main()
{
-//@version 100
+attribute mediump vec3 aPosition; // DALi shader builtin
+attribute mediump vec3 aNormal; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+uniform mediump mat4 uModelView; // DALi shader builtin
+uniform mediump mat3 uNormalMatrix; // DALi shader builtin
-INPUT mediump vec3 aPosition; // DALi shader builtin
-INPUT mediump vec3 aNormal; // DALi shader builtin
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
-UNIFORM mediump vec3 uSize; // DALi shader builtin
-UNIFORM mediump mat4 uModelView; // DALi shader builtin
-UNIFORM mediump mat3 uNormalMatrix; // DALi shader builtin
-};
-
-OUTPUT mediump vec3 vNormal;
-OUTPUT mediump vec3 vFragPos;
+varying mediump vec3 vNormal;
+varying mediump vec3 vFragPos;
void main()
{
-//@version 100
-
-INPUT mediump vec4 vColor;
+varying mediump vec4 vColor;
void main()
{
-//@version 100
+attribute mediump vec3 aPosition; // DALi shader builtin
+attribute mediump vec3 aColor; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
-INPUT mediump vec3 aPosition; // DALi shader builtin
-INPUT mediump vec3 aColor; // DALi shader builtin
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
-UNIFORM mediump vec3 uSize; // DALi shader builtin
-};
-
-OUTPUT mediump vec4 vColor;
+varying mediump vec4 vColor;
void main()
{
-//@version 100
-
-UNIFORM_BLOCK Custom
-{
-UNIFORM mediump vec4 uColor;
-};
+uniform mediump vec4 uColor;
void main()
{
-//@version 100
-
-INPUT mediump vec2 aPosition; // DALi shader builtin
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
-UNIFORM mediump vec3 uSize; // DALi shader builtin
-};
+attribute mediump vec2 aPosition; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
void main()
{
-//@version 100
-
// Fragment shader for polygon
void main()
-//@version 100
-
// Vertex shader for polygon
-INPUT mediump vec3 aPosition;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
-UNIFORM mediump vec3 uSize; // DALi shader builtin
-UNIFORM mediump float uProgress;
-};
+attribute mediump vec3 aPosition;
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+uniform mediump float uProgress;
-OUTPUT mediump vec2 vTexCoord;
+varying mediump vec2 vTexCoord;
void main()
{
-//@version 100
-
// Fragment shaderfor textured quad
-UNIFORM sampler2D uTexture;
-INPUT mediump vec2 vTexCoord;
+uniform sampler2D uTexture;
+varying mediump vec2 vTexCoord;
void main()
{
- mediump vec4 texColor = TEXTURE( uTexture, vTexCoord );
+ mediump vec4 texColor = texture2D( uTexture, vTexCoord );
gl_FragColor = texColor;
}
-//@version 100
// Vertex shader for textured quad
-INPUT mediump vec2 aPosition;
+attribute mediump vec2 aPosition;
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
-UNIFORM mediump vec3 uSize; // DALi shader builtin
-};
-
-OUTPUT mediump vec2 vTexCoord;
+varying mediump vec2 vTexCoord;
void main()
{
-//@version 100
-
// Fragment shader for a textured cube
-UNIFORM sampler2D uTexture;
+uniform sampler2D uTexture;
-INPUT mediump vec2 vTexCoord;
+varying mediump vec2 vTexCoord;
void main()
{
- mediump vec4 texColor = TEXTURE( uTexture, vTexCoord );
+ mediump vec4 texColor = texture2D( uTexture, vTexCoord );
gl_FragColor = texColor;
}
-//@version 100
// Vertex shader for a textured cube
-INPUT mediump vec3 aPosition; // DALi shader builtin
-INPUT mediump vec2 aTexCoord; // DALi shader builtin
+attribute mediump vec3 aPosition; // DALi shader builtin
+attribute mediump vec2 aTexCoord; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
-UNIFORM mediump vec3 uSize; // DALi shader builtin
-};
-
-OUTPUT mediump vec2 vTexCoord;
+varying mediump vec2 vTexCoord;
void main()
{
-//@version 100
-
// Fragment shader for a skybox in equirectangular projection
precision mediump float;
-UNIFORM sampler2D uSkyBoxEquirectangularTexture;
+uniform sampler2D uSkyBoxEquirectangularTexture;
-INPUT vec3 vTexCoord;
+varying 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
// Flip the texture UVs vertically
vec2 uvFlippped = vec2(uv.x, 1.0 - uv.y);
- vec4 texColor = TEXTURE( uSkyBoxEquirectangularTexture, uvFlippped );
+ vec4 texColor = texture2D( uSkyBoxEquirectangularTexture, uvFlippped );
gl_FragColor = texColor;
}
-//@version 100
-
// Fragment shader for a skybox
-UNIFORM samplerCube uSkyBoxTexture;
+uniform samplerCube uSkyBoxTexture;
-INPUT mediump vec3 vTexCoord;
+varying mediump vec3 vTexCoord;
void main()
{
- mediump vec4 texColor = TEXTURE( uSkyBoxTexture, vTexCoord );
+ mediump vec4 texColor = textureCube( uSkyBoxTexture, vTexCoord );
gl_FragColor = texColor;
}
-//@version 100
-
// Vertex shader for a skybox
-INPUT mediump vec3 aPosition; // DALi shader builtin
-
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
-};
+attribute mediump vec3 aPosition; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
-OUTPUT mediump vec3 vTexCoord;
+varying mediump vec3 vTexCoord;
void main()
{
-//@version 100
-
-UNIFORM sampler2D uTexture;
-INPUT mediump vec2 vTexCoord;
+uniform sampler2D uTexture;
+varying mediump vec2 vTexCoord;
void main()
{
- mediump vec4 texColor = TEXTURE( uTexture, vTexCoord );
+ mediump vec4 texColor = texture2D( uTexture, vTexCoord );
gl_FragColor = texColor;
}
-//@version 100
+attribute mediump vec3 aPosition; // DALi shader builtin
+attribute mediump vec2 aTexCoord; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
-INPUT mediump vec3 aPosition; // DALi shader builtin
-INPUT mediump vec2 aTexCoord; // DALi shader builtin
-
-UNIFORM_BLOCK Vert
-{
-UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
-UNIFORM mediump vec3 uSize; // DALi shader builtin
-};
-
-OUTPUT mediump vec2 vTexCoord;
+varying mediump vec2 vTexCoord;
void main()
{
-//@version 100
-
-UNIFORM_BLOCK Custome
-{
-UNIFORM mediump vec4 uColor;
-};
+uniform mediump vec4 uColor;
void main()
{
-//@version 100
-
-INPUT mediump vec2 aPosition; // DALi shader builtin
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
-UNIFORM mediump vec3 uSize; // DALi shader builtin
-};
+attribute mediump vec2 aPosition; // DALi shader builtin
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
void main()
{
-//@version 100
-
precision highp float;
-UNIFORM sampler2D sTexture;
+uniform sampler2D sTexture;
+varying vec2 vTexCoord;
-INPUT vec2 vTexCoord;
-INPUT lowp vec4 vColor;
+varying lowp vec4 vColor;
void main()
{
gl_FragColor = vColor;
- gl_FragColor.a *= TEXTURE(sTexture, vTexCoord).a;
+ gl_FragColor.a *= texture2D(sTexture, vTexCoord).a;
}
-//@version 100
precision highp float;
-INPUT vec2 aTexCoord;
-INPUT vec2 aParticlePath0;
-INPUT vec2 aParticlePath1;
-INPUT vec2 aParticlePath2;
-INPUT vec2 aParticlePath3;
-INPUT vec2 aParticlePath4;
-INPUT vec2 aParticlePath5;
+attribute vec2 aTexCoord;
+uniform mat4 uMvpMatrix;
+varying vec2 vTexCoord;
-OUTPUT lowp vec4 vColor;
-OUTPUT vec2 vTexCoord;
+attribute vec2 aParticlePath0;
+attribute vec2 aParticlePath1;
+attribute vec2 aParticlePath2;
+attribute vec2 aParticlePath3;
+attribute vec2 aParticlePath4;
+attribute vec2 aParticlePath5;
-UNIFORM_BLOCK Custom
-{
-UNIFORM mat4 uMvpMatrix;
-UNIFORM float uPercentage;
-UNIFORM float uPercentageMarked;
-UNIFORM vec3 uParticleColors[NUM_COLOR];
-UNIFORM float uOpacity[NUM_PARTICLE];
-UNIFORM vec2 uTapIndices;
-UNIFORM float uTapOffset[MAXIMUM_ANIMATION_COUNT];
-UNIFORM vec2 uTapPoint[MAXIMUM_ANIMATION_COUNT];
-UNIFORM float uAcceleration;
-UNIFORM float uRadius;
-UNIFORM float uEffectScale;
-UNIFORM float uBreak;
-};
+uniform float uPercentage;
+uniform float uPercentageMarked;
+uniform vec3 uParticleColors[NUM_COLOR];
+uniform float uOpacity[NUM_PARTICLE];
+uniform vec2 uTapIndices;
+uniform float uTapOffset[MAXIMUM_ANIMATION_COUNT];
+uniform vec2 uTapPoint[MAXIMUM_ANIMATION_COUNT];
+uniform float uAcceleration;
+uniform float uRadius;
+uniform float uScale;
+uniform float uBreak;
+
+varying lowp vec4 vColor;
void main()
{
return;
}
- // As the movement along the b-curve has nonUNIFORM speed with a UNIFORM increasing parameter 'uPercentage'
+ // As the movement along the b-curve has nonuniform speed with a uniform increasing parameter 'uPercentage'
// we give different particles the different 'percentage' to make them looks more random
float increment = idx / float(NUM_PARTICLE)*5.0;
float percentage = mod(uPercentage +uAcceleration+increment, 1.0);
position = mix( position, vec2( 250.0,250.0 ),uBreak*(1.0-uOpacity[int(idx)]) ) ;
// vertex position on the mesh: (sign(aTexCoord.x), sign(aTexCoord.y))*PARTICLE_HALF_SIZE
- gl_Position = uMvpMatrix * vec4( position.x+sign(aTexCoord.x)*PARTICLE_HALF_SIZE/uEffectScale,
- position.y+sign(aTexCoord.y)*PARTICLE_HALF_SIZE/uEffectScale,
+ gl_Position = uMvpMatrix * vec4( position.x+sign(aTexCoord.x)*PARTICLE_HALF_SIZE/uScale,
+ position.y+sign(aTexCoord.y)*PARTICLE_HALF_SIZE/uScale,
0.0, 1.0 );
// we store the color index inside texCoord attribute
// prepare the animation by setting the uniform to the required value
mEffect.SetProperty(mEffect.GetPropertyIndex(BREAK_UNIFORM_NAME), 1.f);
mMeshActor.SetProperty(Actor::Property::SCALE, 0.01f);
- mEffect.SetProperty(mEffect.GetPropertyIndex("uEffectScale"), 0.01f);
+ mEffect.SetProperty(mEffect.GetPropertyIndex("uScale"), 0.01f);
mMeshActor.SetProperty(Actor::Property::POSITION, Vector3(0.f, 0.f, 1.f));
Animation breakAnimation = Animation::New(duration * 1.5f);
breakAnimation.AnimateTo(Property(mMeshActor, Actor::Property::SCALE), Vector3(ACTOR_SCALE, ACTOR_SCALE, ACTOR_SCALE), EaseOutSquare);
- breakAnimation.AnimateTo(Property(mEffect, "uEffectScale"), ACTOR_SCALE, EaseOutSquare);
+ breakAnimation.AnimateTo(Property(mEffect, "uScale"), ACTOR_SCALE, EaseOutSquare);
breakAnimation.AnimateTo(Property(mMeshActor, Actor::Property::POSITION), ACTOR_POSITION, EaseOutSquare);
breakAnimation.FinishedSignal().Connect(this, &SparkleEffectExample::OnBreakAnimationFinished);
handle.RegisterProperty(oss.str(), PARTICLE_COLORS[i].RGB);
}
handle.RegisterProperty("uRadius", 250.f);
- handle.RegisterProperty("uEffectScale", ACTOR_SCALE);
+ handle.RegisterProperty("uScale", ACTOR_SCALE);
// set the initial uniform values
-//@version 100
-
INPUT mediump vec2 vTexCoord;
-
-UNIFORM sampler2D sTexture;
-
-UNIFORM_BLOCK Custom
-{
-UNIFORM mediump vec4 uColor;
-UNIFORM mediump vec3 uChannels;
-};
+uniform sampler2D sTexture;
+uniform mediump vec4 uColor;
+uniform mediump vec3 uChannels;
void main()
{
- gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor * vec4(uChannels, 1.0) ;
+ OUT_COLOR = TEXTURE( sTexture, vTexCoord ) * uColor * vec4(uChannels, 1.0) ;
}
-//@version 100
-
-INPUT mediump vec2 vTexCoord;
-
-UNIFORM sampler2D sTexture;
-
-UNIFORM_BLOCK CustomColor
-{
-UNIFORM lowp vec4 uColor;
-UNIFORM lowp vec4 uFadeColor;
-};
+varying mediump vec2 vTexCoord;
+uniform lowp vec4 uColor;
+uniform sampler2D sTexture;
+uniform lowp vec4 uFadeColor;
void main()
{
- gl_FragColor = TEXTURE(sTexture, vTexCoord)* uColor * uFadeColor;
+ gl_FragColor = texture2D(sTexture, vTexCoord) * uColor * uFadeColor;
}
-//@version 100
-
-INPUT mediump vec2 aPosition;
-INPUT highp vec2 aTexCoord;
-
-OUTPUT mediump vec2 vTexCoord;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix;
-UNIFORM mediump vec3 uSize;
-};
+attribute mediump vec2 aPosition;
+attribute highp vec2 aTexCoord;
+varying mediump vec2 vTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform lowp vec4 uFadeColor;
void main()
{
mRenderer = Renderer::New(mGeometry, mShader);
mRenderer.SetTextures(mTextureSet1);
- mRenderer[Renderer::Property::FACE_CULLING_MODE] = FaceCullingMode::NONE;
mMeshActor = Actor::New();
mMeshActor.AddRenderer(mRenderer);
-//@version 100
-
-UNIFORM_BLOCK FragmentBlock
+layout(std140) uniform FragmentBlock
{
- UNIFORM lowp vec4 uColor;
- UNIFORM mediump vec4 uColorArray[1024];
- UNIFORM mediump int uColorIndex;
+ lowp vec4 uColor;
+ mediump vec4 uColorArray[1024];
+ mediump int uColorIndex;
};
void main()
{
// Test that the array color is the same as the actor color
- gl_FragColor = vec4(vec3(0.5, 0.5, 0.5) + vec3(uColorArray[uColorIndex].xyz-uColor.xyz)*0.5, 1.0);
+ fragColor = vec4(vec3(0.5, 0.5, 0.5) + vec3(uColorArray[uColorIndex].xyz-uColor.xyz)*0.5, 1.0);
}
-//@version 100
-
-UNIFORM_BLOCK FragmentBlock
+layout(std140) uniform FragmentBlock
{
-UNIFORM lowp vec4 uColor;
-UNIFORM mediump vec4 uColorArray[1024];
-UNIFORM mediump int uColorIndex;
+ lowp vec4 uColor;
+ mediump vec4 uColorArray[1024];
+ mediump int uColorIndex;
};
void main()
{
- gl_FragColor = uColorArray[uColorIndex];
+ fragColor = uColorArray[uColorIndex];
}
-//@version 100
-
INPUT vec2 aPosition;
-UNIFORM_BLOCK Vanilla
+layout(std140) uniform VertexBlock
{
-UNIFORM highp mat4 uMvpMatrix;
-UNIFORM highp vec3 uSize;
+ highp mat4 uMvpMatrix;
+ highp vec3 uSize;
};
void main()
-//@version 100
-
precision highp float;
-UNIFORM sampler2D uNormalMap; // DALi
-
-UNIFORM_BLOCK CustomFrag
-{
-UNIFORM vec4 uColor; // DALi
+uniform vec4 uColor; // DALi
+uniform sampler2D uNormalMap; // DALi
-UNIFORM vec3 uInvLightDir;
-UNIFORM vec3 uLightColorSqr;
-UNIFORM vec3 uAmbientColor;
+uniform vec3 uInvLightDir;
+uniform vec3 uLightColorSqr;
+uniform vec3 uAmbientColor;
-UNIFORM float uNormalMapWeight;
-UNIFORM float uSpecularity;
-};
+uniform float uNormalMapWeight;
+uniform float uSpecularity;
-INPUT vec2 vUv;
-INPUT vec3 vNormal;
-INPUT vec3 vViewPos;
-INPUT float vHeight;
+varying vec2 vUv;
+varying vec3 vNormal;
+varying vec3 vViewPos;
+varying float vHeight;
float Rand(vec2 co)
{
vec3 viewPos = normalize(vViewPos);
vec2 uv2 = vUv + vViewPos.xy / vViewPos.z * vHeight + vec2(.5, 0.);
- vec3 perturbNormal = TEXTURE(uNormalMap, vUv).rgb * 2. - 1.;
- vec3 perturbNormal2 = TEXTURE(uNormalMap, uv2).rgb * 2. - 1.;
+ vec3 perturbNormal = texture2D(uNormalMap, vUv).rgb * 2. - 1.;
+ vec3 perturbNormal2 = texture2D(uNormalMap, uv2).rgb * 2. - 1.;
vec3 normal = normalize(vNormal + perturbNormal * uNormalMapWeight);
vec3 normal2 = normalize(vNormal + perturbNormal2 * uNormalMapWeight);
-//@version 100
-
#define FMA(a, b, c) ((a) * (b) + (c)) // fused multiply-add
precision highp float;
const float kTile = 1.;
+
const float kPi = 3.1415926535;
const float kEpsilon = 1. / 32.;
// DALI uniforms
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM vec3 uSize;
-UNIFORM mat4 uModelView;
-UNIFORM mat4 uProjection;
-UNIFORM mat3 uNormalMatrix;
-};
-
-// our UNIFORMs
-UNIFORM_BLOCK CustomVert
-{
-UNIFORM float uTime;
-UNIFORM vec2 uScrollScale;
-UNIFORM float uWaveRate;
-UNIFORM float uWaveAmplitude;
-UNIFORM float uParallaxAmount;
-};
-
-INPUT vec2 aPosition;
-INPUT vec2 aTexCoord;
-
-OUTPUT vec2 vUv;
-OUTPUT vec3 vViewPos;
-OUTPUT vec3 vNormal;
-OUTPUT float vHeight;
+uniform vec3 uSize;
+uniform mat4 uModelView;
+uniform mat4 uProjection;
+uniform mat3 uNormalMatrix;
+
+// our uniforms
+uniform float uTime;
+uniform vec2 uScrollScale;
+uniform float uWaveRate;
+uniform float uWaveAmplitude;
+uniform float uParallaxAmount;
+
+attribute vec2 aPosition;
+attribute vec2 aTexCoord;
+
+varying vec2 vUv;
+varying vec3 vViewPos;
+varying vec3 vNormal;
+varying float vHeight;
float CubicHermite(float B, float C, float t)
{
-//@version 100
-
/*
* Fragment shader for textured quad
*/
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec2 vRayCastCoord;
+varying mediump vec2 vTexCoord;
+varying mediump vec2 vRayCastCoord;
-UNIFORM_BLOCK Custom
-{
-UNIFORM mediump float uRadius;
-UNIFORM mediump float uAdjuster;
-}
+uniform mediump float uRadius;
+uniform mediump float uAdjuster;
#define CAMERA_Z_POSITION 1.0 // gives us a FOV of 90 degrees if Plane of projection is at Z = 0 with size 2x2
#define SPHERE_Z_POSITION -1.0 // Sphere placed behind Plane of projection
-//@version 100
-
-INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vTexCoord;
-OUTPUT mediump vec2 vRayCastCoord;
-
-UNIFORM_BLOCK Vanilla
-{
-UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
-UNIFORM mediump vec3 uSize; // DALi shader builtin
-};
+attribute mediump vec2 aPosition;
+uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+uniform mediump vec3 uSize; // DALi shader builtin
+varying mediump vec2 vTexCoord;
+varying mediump vec2 vRayCastCoord;
void main()
{
mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
/*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
"shader":
{
"fragmentShader":[
- "//@version 100",
" varying mediump vec2 vTexCoord;",
- " UNIFORM sampler2D sTexture;",
- " UNIFORM_BLOCK FragBlock",
- " {",
- " UNIFORM lowp vec4 uColor;",
- " UNIFORM mediump vec3 uCustomPosition;",
- " };",
+ " uniform lowp vec4 uColor;",
+ " uniform sampler2D sTexture;",
+ " uniform mediump vec3 uCustomPosition;",
+ "",
" void main()",
" {",
- " if( TEXTURE( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
" {",
" discard;",
" }",
"",
" mediump vec2 wrapTexCoord = vec2( ( vTexCoord.x / 4.0 ) + ( uCustomPosition.x / 4.0 ) + ( uCustomPosition.z / 2.0 ), vTexCoord.y / 4.0 );",
- " mediump vec4 color = TEXTURE( sTexture, wrapTexCoord );",
+ " mediump vec4 color = texture2D( sTexture, wrapTexCoord );",
" mediump float positionWeight = ( uCustomPosition.y + 0.3 ) * color.r * 2.0;",
"",
" gl_FragColor = vec4( positionWeight, positionWeight, positionWeight, 0.9 ) * uColor + vec4( uColor.xyz, 0.0 );",
{
"fragmentShader":[
" varying mediump vec2 vTexCoord;",
- " UNIFORM sampler2D sTexture;",
- " UNIFORM_BLOCK FragBlock",
- " {",
- " UNIFORM lowp vec4 uColor;",
- " UNIFORM mediump vec3 uCustomPosition;",
- " };",
+ " uniform lowp vec4 uColor;",
+ " uniform sampler2D sTexture;",
+ " uniform mediump vec3 uCustomPosition;",
+ "",
" void main()",
" {",
- " if( TEXTURE( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
" {",
" discard;",
" }",
"",
" mediump vec2 wrapTexCoord = vec2( ( vTexCoord.x / 4.0 ) + ( uCustomPosition.x / 4.0 ) + ( uCustomPosition.z / 2.0 ), vTexCoord.y / 4.0 );",
- " mediump vec4 color = TEXTURE( sTexture, wrapTexCoord );",
+ " mediump vec4 color = texture2D( sTexture, wrapTexCoord );",
" mediump float positionWeight = ( uCustomPosition.y + 0.3 ) * color.r * 2.0;",
"",
" gl_FragColor = vec4( positionWeight, positionWeight, positionWeight, 0.9 ) * uColor + vec4( uColor.xyz, 0.0 );",
/*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
"shader":
{
"fragmentShader":[
- "//@version 100",
- " INPUT mediump vec2 vTexCoord;",
- " UNIFORM sampler2D sTexture;",
- " UNIFORM_BLOCK FragBlock",
- " {",
- " UNIFORM lowp vec4 uColor;",
- " UNIFORM mediump vec3 uCustomPosition;",
- " };",
+ " varying mediump vec2 vTexCoord;",
+ " uniform lowp vec4 uColor;",
+ " uniform sampler2D sTexture;",
+ " uniform mediump vec3 uCustomPosition;",
+ "",
" void main()",
" {",
- " if( TEXTURE( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
" {",
" discard;",
" }",
"",
" mediump vec2 wrapTexCoord = vec2( ( vTexCoord.x / 4.0 ) + ( uCustomPosition.x / 4.0 ) + ( uCustomPosition.z / 2.0 ), vTexCoord.y / 4.0 );",
- " mediump vec4 color = TEXTURE( sTexture, wrapTexCoord );",
+ " mediump vec4 color = texture2D( sTexture, wrapTexCoord );",
" mediump float positionWeight = ( uCustomPosition.y + 0.3 ) * color.r * 2.0;",
"",
" gl_FragColor = vec4( positionWeight, positionWeight, positionWeight, 0.9 ) * uColor + vec4( uColor.xyz, 0.0 );",
"shader":
{
"fragmentShader":[
- "//@version 100",
- " INPUT mediump vec2 vTexCoord;",
- " UNIFORM sampler2D sTexture;",
- " UNIFORM_BLOCK FragBlock",
- " {",
- " UNIFORM lowp vec4 uColor;",
- " UNIFORM mediump vec3 uCustomPosition;",
- " };",
+ " varying mediump vec2 vTexCoord;",
+ " uniform lowp vec4 uColor;",
+ " uniform sampler2D sTexture;",
+ " uniform mediump vec3 uCustomPosition;",
"",
" void main()",
" {",
- " if( TEXTURE( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
" {",
" discard;",
" }",
"",
" mediump vec2 wrapTexCoord = vec2( ( vTexCoord.x / 4.0 ) + ( uCustomPosition.x / 4.0 ) + ( uCustomPosition.z / 2.0 ), vTexCoord.y / 4.0 );",
- " mediump vec4 color = TEXTURE( sTexture, wrapTexCoord );",
+ " mediump vec4 color = texture2D( sTexture, wrapTexCoord );",
" mediump float positionWeight = ( uCustomPosition.y + 0.3 ) * color.r * 2.0;",
"",
" gl_FragColor = vec4( positionWeight, positionWeight, positionWeight, 0.9 ) * uColor + vec4( uColor.xyz, 0.0 );",
/*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd
+ * Copyright (c) 2019 Samsung Electronics Co., Ltd
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
"shader":
{
"fragmentShader":[
- "//@version 100",
- " INPUT mediump vec2 vTexCoord;",
- " UNIFORM sampler2D sTexture;",
- " UNIFORM_BLOCK FragmentBlock",
- " {",
- " UNIFORM lowp vec4 uColor;",
- " UNIFORM mediump vec3 uCustomPosition;",
- " };",
+ " varying mediump vec2 vTexCoord;",
+ " uniform lowp vec4 uColor;",
+ " uniform sampler2D sTexture;",
+ " uniform mediump vec3 uCustomPosition;",
+ "",
" void main()",
" {",
- " if( TEXTURE( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
" {",
" discard;",
" }",
"",
" mediump vec2 wrapTexCoord = vec2( ( vTexCoord.x / 4.0 ) + ( uCustomPosition.x / 4.0 ) + ( uCustomPosition.z / 2.0 ), vTexCoord.y / 4.0 );",
- " mediump vec4 color = TEXTURE( sTexture, wrapTexCoord );",
+ " mediump vec4 color = texture2D( sTexture, wrapTexCoord );",
" mediump float positionWeight = ( uCustomPosition.y + 0.3 ) * color.r * 2.0;",
"",
" gl_FragColor = vec4( positionWeight, positionWeight, positionWeight, 0.9 ) * uColor + vec4( uColor.xyz, 0.0 );",
"shader":
{
"fragmentShader":[
- "//@version 100",
- " INPUT mediump vec2 vTexCoord;",
- " UNIFORM sampler2D sTexture;",
- " UNIFORM_BLOCK FragmentBlock",
- " {",
- " UNIFORM lowp vec4 uColor;",
- " UNIFORM mediump vec3 uCustomPosition;",
- " };",
+ " varying mediump vec2 vTexCoord;",
+ " uniform lowp vec4 uColor;",
+ " uniform sampler2D sTexture;",
+ " uniform mediump vec3 uCustomPosition;",
+ "",
" void main()",
" {",
- " if( TEXTURE( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
" {",
" discard;",
" }",
"",
" mediump vec2 wrapTexCoord = vec2( ( vTexCoord.x / 4.0 ) + ( uCustomPosition.x / 4.0 ) + ( uCustomPosition.z / 2.0 ), vTexCoord.y / 4.0 );",
- " mediump vec4 color = TEXTURE( sTexture, wrapTexCoord );",
+ " mediump vec4 color = texture2D( sTexture, wrapTexCoord );",
" mediump float positionWeight = ( uCustomPosition.y + 0.3 ) * color.r * 2.0;",
"",
" gl_FragColor = vec4( positionWeight, positionWeight, positionWeight, 0.9 ) * uColor + vec4( uColor.xyz, 0.0 );",
projects / platform / core / uifw / dali-demo.git / commitdiff