-uniform lowp vec4 uColor;
-varying lowp vec2 vCoefficient;
+//@version 100
+
+UNIFORM_BLOCK VanillaFrag
+{
+UNIFORM lowp vec4 uColor;
+};
+
+INPUT lowp vec2 vCoefficient;
void main()
{
-attribute mediump vec3 aCoefficient;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uPosition[MAX_POINT_COUNT];
-varying lowp vec2 vCoefficient;
+//@version 100
+
+INPUT mediump vec3 aCoefficient;
+
+UNIFORM_BLOCK Vanilla
+{
+UNIFORM mediump mat4 uMvpMatrix;
+UNIFORM mediump vec3 uPosition[MAX_POINT_COUNT];
+};
+
+OUTPUT lowp vec2 vCoefficient;
void main()
{
-uniform lowp vec4 uColor;
+//@version 100
+
void main()
{
-attribute mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
-uniform vec3 uSize;
+//@version 100
+
+INPUT mediump vec2 aPosition;
+
+UNIFORM_BLOCK Vanilla
+{
+UNIFORM mediump mat4 uMvpMatrix;
+UNIFORM vec3 uSize;
+};
void main()
{
-uniform sampler2D uTexture;
-uniform mediump float uBrightness;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
+//@version 100
+
+UNIFORM sampler2D uTexture;
+
+UNIFORM_BLOCK VanFrag
+{
+UNIFORM mediump float uBrightness;
+};
+
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec3 vIllumination;
mediump vec3 redistribute_rgb(mediump vec3 color)
{
void main()
{
- mediump vec4 texColor = texture2D( uTexture, vTexCoord );
+ mediump vec4 texColor = TEXTURE( uTexture, vTexCoord );
//mediump vec4 texColor = vec4(0.5,0.5,0.5,1.0);
//gl_FragColor = vec4(texColor.rgb, 1.0);
-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;
+//@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;
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.
-attribute mediump vec2 aPositionCircle;
-attribute mediump vec2 aPositionQuad;
-uniform mediump float uDelta;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
+INPUT mediump vec2 aPositionCircle;
+INPUT mediump vec2 aPositionQuad;
+
+UNIFORM_BLOCK Vanilla
+{
+UNIFORM mediump float uDelta;
+UNIFORM mediump mat4 uMvpMatrix;
+UNIFORM mediump vec3 uSize;
+};
void main()
{
-uniform lowp vec4 uColor;
-uniform sampler2D sTexture;
+//@version 100
-varying lowp vec3 vColor;
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK VanillaFrag
+{
+UNIFORM lowp vec4 uColor;
+};
+
+INPUT lowp vec3 vColor;
void main()
{
-attribute mediump vec2 aPosition1;
-attribute mediump vec2 aPosition2;
-attribute lowp vec3 aColor;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform mediump float uMorphAmount;
+//@version 100
-varying lowp vec3 vColor;
+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;
void main()
{
-varying lowp vec4 vColor;
+//@version 100
+
+INPUT lowp vec4 vColor;
void main()
{
-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;
+//@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;
+};
void main()
{
+//@version 100
+
//Fragment shader code for metaball and background composition with refraction effect
precision highp float;
-varying vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform sampler2D sEffect;
-uniform vec2 uPositionMetaball;
+INPUT vec2 vTexCoord;
+
+UNIFORM sampler2D sTexture;
+UNIFORM sampler2D sEffect;
+
+UNIFORM_BLOCK VanillaFrag
+{
+UNIFORM vec2 uPositionMetaball;
+};
+
void main()
{
vec2 zoomCoords;
vec3 color = vec3(1.0, 1.0, 1.0);
float ambient = 0.2;
- vec4 metaColor = texture2D(sEffect, vTexCoord);
+ vec4 metaColor = TEXTURE(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 = texture2D(sTexture, zoomCoords);
+ vec4 texColor = TEXTURE(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;
-varying vec2 vTexCoord;
-uniform vec2 uPositionMetaball;
-uniform vec2 uPositionVar;
-uniform vec2 uGravityVector;
-uniform float uRadius;
-uniform float uRadiusVar;
+
+INPUT vec2 vTexCoord;
+
+UNIFORM_BLOCK VanillaFrag
+{
+UNIFORM vec2 uPositionMetaball;
+UNIFORM vec2 uPositionVar;
+UNIFORM vec2 uGravityVector;
+UNIFORM float uRadius;
+UNIFORM float uRadiusVar;
+};
void main()
{
+//@version 100
+
//Vertex shader code for metaball
-attribute mediump vec2 aPosition;
-attribute mediump vec2 aTexture;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform lowp vec4 uColor;
-varying mediump vec2 vTexCoord;
+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;
+};
void main()
{
+//@version 100
+
// Fragment shader code when there's no effect
precision mediump float;
-varying vec2 vTexCoord;
-uniform sampler2D sTexture;
+
+INPUT vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
void main()
{
- gl_FragColor = texture2D(sTexture, vTexCoord);
+ gl_FragColor = TEXTURE(sTexture, vTexCoord);
}
+//@version 100
// Fragment shader code for metaball and background composition with refraction effect
precision mediump float;
-varying vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform sampler2D sEffect;
+INPUT vec2 vTexCoord;
+
+UNIFORM sampler2D sTexture;
+UNIFORM sampler2D sEffect;
void main()
{
- vec4 metaColor = texture2D(sEffect, vTexCoord);
+ vec4 metaColor = TEXTURE(sEffect, vTexCoord);
vec2 zoomCoords;
float bright = 1.0;
if (metaColor.r > 0.85)
zoomCoords = vTexCoord;
}
- gl_FragColor = texture2D(sTexture, zoomCoords) * bright;
+ gl_FragColor = TEXTURE(sTexture, zoomCoords) * bright;
}
+//@version 100
+
// Fragment shader for metaballs
precision mediump float;
-varying vec2 vTexCoord;
-uniform vec2 uPositionMetaball;
-uniform vec2 uPositionVar;
-uniform vec2 uGravityVector;
-uniform float uRadius;
-uniform float uRadiusVar;
-uniform float uAspect;
+INPUT vec2 vTexCoord;
+
+UNIFORM_BLOCK VanillaFrag
+{
+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
-attribute mediump vec2 aPosition;
-attribute mediump vec2 aTexture;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform lowp vec4 uColor;
-varying mediump vec2 vTexCoord;
+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;
+};
void main()
{
-#version 300 es
+//@version 100
+
// Shader for an unlit, unfogged, textured mesh.
precision mediump float;
-uniform vec4 uColor;
-out vec4 oFragColor;
+
+UNIFORM_BLOCK VanillaFrag
+{
+UNIFORM vec4 uColor;
+};
void main()
{
- oFragColor = uColor;
+ gl_FragColor = uColor;
}
-#version 300 es
+//@version 100
+
// Shader for simple textured geometry.
precision mediump float;
-uniform mat4 uMvpMatrix;//by DALi
-uniform vec3 uSize; // by DALi
-in vec3 aPosition;
+
+UNIFORM_BLOCK VertexBlock
+{
+ UNIFORM mat4 uMvpMatrix; //by DALi
+ UNIFORM vec3 uSize; // by DALi
+};
+
+INPUT vec3 aPosition;
void main()
{
- gl_Position = uMvpMatrix * vec4(aPosition * uSize, 1.f);
+ gl_Position = uMvpMatrix * vec4(aPosition * uSize, 1.0);
}
-#version 300 es
+//@version 100
+
// Fragment shader for particles, which simulates depth of field using
// a combination of procedural texturing, alpha testing and alpha blending.
precision lowp float;
-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;
+
+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;
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);
- oFragColor = vec4(vColor, alpha);
+ gl_FragColor = vec4(vColor, alpha);
}
-#version 300 es
+//@version 100
+
// Shader for billboarded particles, where the vertices of the particles
// are supplied as vec3 position (particle position) + vec2 sub-position.
precision lowp float;
-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;
+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;
+};
struct Scatter
{
};
const int SCATTER_VARS = 6; // Must match ParticleView::mScatterProps' size.
-uniform Scatter uScatter[SCATTER_VARS];
+
+UNIFORM_BLOCK ScatterBlock
+{
+UNIFORM Scatter uScatter[SCATTER_VARS];
+};
const int POPULATION_GRANULARITY = 128;
-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
+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
float bezier(vec3 control, float alpha)
{
-uniform lowp vec4 uColor;
-uniform sampler2D sTexture;
-varying mediump vec2 vTexCoord;
+//@version 100
+
+UNIFORM_BLOCK VanillaFrag
+{
+UNIFORM lowp vec4 uColor;
+}
+UNIFORM sampler2D sTexture;
+
+INPUT mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
}
-attribute mediump vec2 aPosition;
-attribute mediump vec2 aTexCoord;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-varying mediump vec2 vTexCoord;
+//@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;
+};
void main()
{
-varying mediump vec3 vVertexColor;
-varying mediump float vHue;
-uniform lowp vec4 uColor;
-uniform sampler2D sTexture1;
-uniform sampler2D sTexture2;
-uniform lowp vec4 uFadeColor;
+//@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;
+};
void main()
{
- mediump vec4 texCol1 = texture2D(sTexture1, gl_PointCoord);
- mediump vec4 texCol2 = texture2D(sTexture2, gl_PointCoord);
+ mediump vec4 texCol1 = TEXTURE(sTexture1, gl_PointCoord);
+ mediump vec4 texCol2 = TEXTURE(sTexture2, gl_PointCoord);
gl_FragColor = vec4(vVertexColor, 1.0) * ((texCol1 * vHue) + (texCol2 * (1.0 - vHue)));
}
-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;
+//@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;
+};
vec3 hsv2rgb(vec3 c)
{
std::vector<char> fshShaderSource;
// VSH
- if(vsh[0] == '/')
+ if(vsh[0] == '/' && vsh[1] != '/')
{
std::string vshPath(DEMO_GAME_DIR);
vshPath += '/';
}
// FSH
- if(fsh[0] == '/')
+ if(fsh[0] == '/' && fsh[1] != '/')
{
std::string fshPath(DEMO_GAME_DIR);
fshPath += '/';
+//@version 100
+
precision mediump float;
-uniform sampler2D sTexture;
-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;
+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;
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 = (texture2D(sTexture, vTexCoord)) * (((col.r+col.g+col.b)/3.0)+1.0+intensity);
+ gl_FragColor = (TEXTURE(sTexture, vTexCoord)) * (((col.r+col.g+col.b)/3.0)+1.0+intensity);
}
-uniform lowp vec4 uColor;
-uniform sampler2D sTexture;
-varying mediump vec3 vNormal;
-varying mediump vec3 vPosition;
-varying mediump vec2 vTexCoord;
+//@version 100
+
+UNIFORM_BLOCK VanillaFrag
+{
+UNIFORM lowp vec4 uColor;
+};
+
+UNIFORM sampler2D sTexture;
+
+INPUT mediump vec3 vNormal;
+INPUT mediump vec3 vPosition;
+INPUT mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = texture2D(sTexture, vTexCoord) * 2.0;
+ gl_FragColor = TEXTURE(sTexture, vTexCoord) * 2.0;
}
-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;
+//@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;
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 = ((texture2D(sTexture0, vTexCoord) * factor ) +
- (texture2D(sTexture1, uv))) * intensity;
+ gl_FragColor = ((TEXTURE(sTexture0, vTexCoord) * factor ) +
+ (TEXTURE(sTexture1, uv))) * intensity;
}
-uniform lowp vec4 uColor;
-uniform sampler2D sTexture;
-uniform mediump vec2 uScreenSize;
+//@version 100
-uniform mediump vec3 eyePos;
-uniform mediump vec3 lightDir;
+UNIFORM sampler2D sTexture;
-varying mediump vec3 vNormal;
-varying mediump vec3 vPosition;
-varying mediump vec2 vTexCoord;
+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;
void main()
{
mediump vec3 l = normalize( lightDir );
mediump vec3 e = normalize( eyePos );
mediump float intensity = max(dot(n,l), 0.0);
- gl_FragColor = texture2D(sTexture, vTexCoord) * intensity;
+ gl_FragColor = TEXTURE(sTexture, vTexCoord) * intensity;
}
-uniform lowp vec4 uColor;
-uniform sampler2D sTexture;
-varying mediump vec3 vNormal;
-varying mediump vec3 vPosition;
-varying mediump vec2 vTexCoord;
+//@version 100
+
+UNIFORM_BLOCK VanillaFrag
+{
+UNIFORM lowp vec4 uColor;
+};
+
+UNIFORM sampler2D sTexture;
+
+INPUT mediump vec3 vNormal;
+INPUT mediump vec3 vPosition;
+INPUT mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = texture2D(sTexture, vTexCoord) * 50.0;
+ gl_FragColor = TEXTURE(sTexture, vTexCoord) * 50.0;
}
-attribute mediump vec3 aPosition;
-attribute mediump vec3 aNormal;
-attribute mediump vec2 aTexCoord;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump vec3 uSize;
+//@version 100
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vNormal;
-varying mediump vec3 vPosition;
+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;
void main()
{
-uniform lowp vec4 uColor;
-uniform sampler2D sTexture;
-varying mediump vec2 vTexCoord;
+//@version 100
+
+UNIFORM_BLOCK VanillaFrag
+{
+UNIFORM lowp vec4 uColor;
+};
+
+UNIFORM sampler2D sTexture;
+
+INPUT mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
}
+//@version 100
+
// The shader source is used when the MeshActor is not touched
-attribute mediump vec3 aPosition;
-attribute mediump vec3 aNormal;
-attribute highp vec2 aTexCoord;
-uniform mediump mat4 uMvpMatrix;
-varying mediump vec2 vTexCoord;
+INPUT mediump vec3 aPosition;
+INPUT mediump vec3 aNormal;
+INPUT highp vec2 aTexCoord;
+UNIFORM_BLOCK Vanilla
+{
+UNIFORM mediump mat4 uMvpMatrix;
+};
+
+OUTPUT mediump vec2 vTexCoord;
void main()
{
+//@version 100
+
precision mediump float;
-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;
+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;
vec3 rgb2hsl(vec3 rgb)
{
spotEffect = spotEffect * uEffectStrength;
mediump float lightDiffuse = ( ( dot( vecToLight, normal )-0.75 ) *uLightIntensity ) * spotEffect;
- lowp vec4 color = texture2D( sTexture, vTexCoord + vTextureOffset * spotEffect );
+ lowp vec4 color = TEXTURE( sTexture, vTexCoord + vTextureOffset * spotEffect );
vec3 lightedColor = hsl2rgb( rgb2hsl(color.rgb) + vec3(0.0,0.0,lightDiffuse) );
gl_FragColor = vec4( lightedColor, color.a ) * uColor;
-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;
+//@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;
void main()
{
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-uniform lowp vec4 uColor;
-uniform sampler2D sTexture;
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec3 vIllumination;
+UNIFORM_BLOCK Color
+{
+ UNIFORM lowp vec4 uColor;
+};
+
+UNIFORM sampler2D sTexture;
void main()
{
- gl_FragColor = vec4( texture2D( sTexture, vTexCoord ).rgb * vIllumination.rgb * uColor.rgb, uColor.a );
-}
+ gl_FragColor = vec4( TEXTURE( sTexture, vTexCoord ).rgb * vIllumination.rgb * uColor.rgb, uColor.a );
+}
\ No newline at end of file
+//@version 100
+
// Shader for basic, per-vertex lighting with texture (vertex):
-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;
+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;
+};
void main()
{
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-uniform lowp vec4 uColor;
-uniform sampler2D sTexture;
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec3 vIllumination;
+
+UNIFORM_BLOCK color
+{
+ UNIFORM lowp vec4 uColor;
+};
+
+UNIFORM sampler2D sTexture;
void main()
{
+//@version 100
+
// Shader for basic, per-vertex lighting (vertex):
-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;
+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;
+};
void main()
{
-varying mediump vec3 vNormal;
-varying mediump vec3 vFragPos;
-uniform mediump vec3 viewPos; // custom uniform
+//@version 100
+
+INPUT mediump vec3 vNormal;
+INPUT mediump vec3 vFragPos;
struct Material
{
mediump vec3 color;
};
-uniform Material material; // custom uniform
-uniform Light light; // custom uniform
+UNIFORM_BLOCK CustomFrag
+{
+UNIFORM mediump vec3 viewPos; // custom uniform
+UNIFORM Material material; // custom uniform
+UNIFORM Light light; // custom uniform
+};
void main()
{
-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
+//@version 100
-varying mediump vec3 vNormal;
-varying mediump vec3 vFragPos;
+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;
void main()
{
-varying mediump vec4 vColor;
+//@version 100
+
+INPUT mediump vec4 vColor;
void main()
{
-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
+//@version 100
-varying mediump vec4 vColor;
+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;
void main()
{
-uniform mediump vec4 uColor;
+//@version 100
+
+UNIFORM_BLOCK Custom
+{
+UNIFORM mediump vec4 uColor;
+};
void main()
{
-attribute mediump vec2 aPosition; // DALi shader builtin
-uniform mediump mat4 uMvpMatrix; // DALi shader builtin
-uniform mediump vec3 uSize; // DALi shader builtin
+//@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
+};
void main()
{
+//@version 100
+
// Fragment shader for polygon
void main()
+//@version 100
+
// Vertex shader for polygon
-attribute mediump vec3 aPosition;
-uniform mediump mat4 uMvpMatrix; // DALi shader builtin
-uniform mediump vec3 uSize; // DALi shader builtin
-uniform mediump float uProgress;
+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;
+};
-varying mediump vec2 vTexCoord;
+OUTPUT mediump vec2 vTexCoord;
void main()
{
+//@version 100
+
// Fragment shaderfor textured quad
-uniform sampler2D uTexture;
-varying mediump vec2 vTexCoord;
+UNIFORM sampler2D uTexture;
+INPUT mediump vec2 vTexCoord;
void main()
{
- mediump vec4 texColor = texture2D( uTexture, vTexCoord );
+ mediump vec4 texColor = TEXTURE( uTexture, vTexCoord );
gl_FragColor = texColor;
}
+//@version 100
// Vertex shader for textured quad
-attribute mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix; // DALi shader builtin
-uniform mediump vec3 uSize; // DALi shader builtin
+INPUT mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
+UNIFORM_BLOCK Vanilla
+{
+UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
+UNIFORM mediump vec3 uSize; // DALi shader builtin
+};
+
+OUTPUT mediump vec2 vTexCoord;
void main()
{
+//@version 100
+
// Fragment shader for a textured cube
-uniform sampler2D uTexture;
+UNIFORM sampler2D uTexture;
-varying mediump vec2 vTexCoord;
+INPUT mediump vec2 vTexCoord;
void main()
{
- mediump vec4 texColor = texture2D( uTexture, vTexCoord );
+ mediump vec4 texColor = TEXTURE( uTexture, vTexCoord );
gl_FragColor = texColor;
}
+//@version 100
// Vertex shader for a textured cube
-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
-varying mediump vec2 vTexCoord;
+UNIFORM_BLOCK Vanilla
+{
+UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
+UNIFORM mediump vec3 uSize; // DALi shader builtin
+};
+
+OUTPUT mediump vec2 vTexCoord;
void main()
{
+//@version 100
+
// Fragment shader for a skybox in equirectangular projection
precision mediump float;
-uniform sampler2D uSkyBoxEquirectangularTexture;
+UNIFORM sampler2D uSkyBoxEquirectangularTexture;
-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
// Flip the texture UVs vertically
vec2 uvFlippped = vec2(uv.x, 1.0 - uv.y);
- vec4 texColor = texture2D( uSkyBoxEquirectangularTexture, uvFlippped );
+ vec4 texColor = TEXTURE( uSkyBoxEquirectangularTexture, uvFlippped );
gl_FragColor = texColor;
}
+//@version 100
+
// Fragment shader for a skybox
-uniform samplerCube uSkyBoxTexture;
+UNIFORM samplerCube uSkyBoxTexture;
-varying mediump vec3 vTexCoord;
+INPUT mediump vec3 vTexCoord;
void main()
{
- mediump vec4 texColor = textureCube( uSkyBoxTexture, vTexCoord );
+ mediump vec4 texColor = TEXTURE( uSkyBoxTexture, vTexCoord );
gl_FragColor = texColor;
}
+//@version 100
+
// Vertex shader for a skybox
-attribute mediump vec3 aPosition; // DALi shader builtin
-uniform mediump mat4 uMvpMatrix; // DALi shader builtin
+INPUT mediump vec3 aPosition; // DALi shader builtin
+
+
+UNIFORM_BLOCK Vanilla
+{
+UNIFORM mediump mat4 uMvpMatrix; // DALi shader builtin
+};
-varying mediump vec3 vTexCoord;
+OUTPUT mediump vec3 vTexCoord;
void main()
{
-uniform sampler2D uTexture;
-varying mediump vec2 vTexCoord;
+//@version 100
+
+UNIFORM sampler2D uTexture;
+INPUT mediump vec2 vTexCoord;
void main()
{
- mediump vec4 texColor = texture2D( uTexture, vTexCoord );
+ mediump vec4 texColor = TEXTURE( uTexture, vTexCoord );
gl_FragColor = texColor;
}
-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
+//@version 100
-varying mediump vec2 vTexCoord;
+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;
void main()
{
-uniform mediump vec4 uColor;
+//@version 100
+
+UNIFORM_BLOCK Custome
+{
+UNIFORM mediump vec4 uColor;
+};
void main()
{
-attribute mediump vec2 aPosition; // DALi shader builtin
-uniform mediump mat4 uMvpMatrix; // DALi shader builtin
-uniform mediump vec3 uSize; // DALi shader builtin
+//@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
+};
void main()
{
+//@version 100
+
precision highp float;
-uniform sampler2D sTexture;
-varying vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
-varying lowp vec4 vColor;
+INPUT vec2 vTexCoord;
+INPUT lowp vec4 vColor;
void main()
{
gl_FragColor = vColor;
- gl_FragColor.a *= texture2D(sTexture, vTexCoord).a;
+ gl_FragColor.a *= TEXTURE(sTexture, vTexCoord).a;
}
+//@version 100
precision highp float;
-attribute vec2 aTexCoord;
-uniform mat4 uMvpMatrix;
-varying vec2 vTexCoord;
+INPUT vec2 aTexCoord;
+INPUT vec2 aParticlePath0;
+INPUT vec2 aParticlePath1;
+INPUT vec2 aParticlePath2;
+INPUT vec2 aParticlePath3;
+INPUT vec2 aParticlePath4;
+INPUT vec2 aParticlePath5;
-attribute vec2 aParticlePath0;
-attribute vec2 aParticlePath1;
-attribute vec2 aParticlePath2;
-attribute vec2 aParticlePath3;
-attribute vec2 aParticlePath4;
-attribute vec2 aParticlePath5;
+OUTPUT lowp vec4 vColor;
+OUTPUT vec2 vTexCoord;
-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;
+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;
+};
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/uScale,
- position.y+sign(aTexCoord.y)*PARTICLE_HALF_SIZE/uScale,
+ gl_Position = uMvpMatrix * vec4( position.x+sign(aTexCoord.x)*PARTICLE_HALF_SIZE/uEffectScale,
+ position.y+sign(aTexCoord.y)*PARTICLE_HALF_SIZE/uEffectScale,
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("uScale"), 0.01f);
+ mEffect.SetProperty(mEffect.GetPropertyIndex("uEffectScale"), 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, "uScale"), ACTOR_SCALE, EaseOutSquare);
+ breakAnimation.AnimateTo(Property(mEffect, "uEffectScale"), 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("uScale", ACTOR_SCALE);
+ handle.RegisterProperty("uEffectScale", ACTOR_SCALE);
// set the initial uniform values
+//@version 100
+
INPUT mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform mediump vec4 uColor;
-uniform mediump vec3 uChannels;
+
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK Custom
+{
+UNIFORM mediump vec4 uColor;
+UNIFORM mediump vec3 uChannels;
+};
void main()
{
- OUT_COLOR = TEXTURE( sTexture, vTexCoord ) * uColor * vec4(uChannels, 1.0) ;
+ gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor * vec4(uChannels, 1.0) ;
}
-varying mediump vec2 vTexCoord;
-uniform lowp vec4 uColor;
-uniform sampler2D sTexture;
-uniform lowp vec4 uFadeColor;
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK CustomColor
+{
+UNIFORM lowp vec4 uColor;
+UNIFORM lowp vec4 uFadeColor;
+};
void main()
{
- gl_FragColor = texture2D(sTexture, vTexCoord) * uColor * uFadeColor;
+ gl_FragColor = TEXTURE(sTexture, vTexCoord)* uColor * uFadeColor;
}
-attribute mediump vec2 aPosition;
-attribute highp vec2 aTexCoord;
-varying mediump vec2 vTexCoord;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform lowp vec4 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;
+};
void main()
{
mRenderer = Renderer::New(mGeometry, mShader);
mRenderer.SetTextures(mTextureSet1);
+ mRenderer[Renderer::Property::FACE_CULLING_MODE] = FaceCullingMode::NONE;
mMeshActor = Actor::New();
mMeshActor.AddRenderer(mRenderer);
-layout(std140) uniform FragmentBlock
+//@version 100
+
+UNIFORM_BLOCK FragmentBlock
{
- lowp vec4 uColor;
- mediump vec4 uColorArray[1024];
- mediump int uColorIndex;
+ UNIFORM lowp vec4 uColor;
+ UNIFORM mediump vec4 uColorArray[1024];
+ UNIFORM mediump int uColorIndex;
};
void main()
{
// Test that the array color is the same as the actor color
- fragColor = vec4(vec3(0.5, 0.5, 0.5) + vec3(uColorArray[uColorIndex].xyz-uColor.xyz)*0.5, 1.0);
+ gl_FragColor = vec4(vec3(0.5, 0.5, 0.5) + vec3(uColorArray[uColorIndex].xyz-uColor.xyz)*0.5, 1.0);
}
-layout(std140) uniform FragmentBlock
+//@version 100
+
+UNIFORM_BLOCK FragmentBlock
{
- lowp vec4 uColor;
- mediump vec4 uColorArray[1024];
- mediump int uColorIndex;
+UNIFORM lowp vec4 uColor;
+UNIFORM mediump vec4 uColorArray[1024];
+UNIFORM mediump int uColorIndex;
};
void main()
{
- fragColor = uColorArray[uColorIndex];
+ gl_FragColor = uColorArray[uColorIndex];
}
+//@version 100
+
INPUT vec2 aPosition;
-layout(std140) uniform VertexBlock
+UNIFORM_BLOCK Vanilla
{
- highp mat4 uMvpMatrix;
- highp vec3 uSize;
+UNIFORM highp mat4 uMvpMatrix;
+UNIFORM highp vec3 uSize;
};
void main()
+//@version 100
+
precision highp float;
-uniform vec4 uColor; // DALi
-uniform sampler2D uNormalMap; // DALi
+UNIFORM sampler2D uNormalMap; // DALi
+
+UNIFORM_BLOCK CustomFrag
+{
+UNIFORM vec4 uColor; // 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;
+};
-varying vec2 vUv;
-varying vec3 vNormal;
-varying vec3 vViewPos;
-varying float vHeight;
+INPUT vec2 vUv;
+INPUT vec3 vNormal;
+INPUT vec3 vViewPos;
+INPUT float vHeight;
float Rand(vec2 co)
{
vec3 viewPos = normalize(vViewPos);
vec2 uv2 = vUv + vViewPos.xy / vViewPos.z * vHeight + vec2(.5, 0.);
- vec3 perturbNormal = texture2D(uNormalMap, vUv).rgb * 2. - 1.;
- vec3 perturbNormal2 = texture2D(uNormalMap, uv2).rgb * 2. - 1.;
+ vec3 perturbNormal = TEXTURE(uNormalMap, vUv).rgb * 2. - 1.;
+ vec3 perturbNormal2 = TEXTURE(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 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;
+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;
float CubicHermite(float B, float C, float t)
{
+//@version 100
+
/*
* Fragment shader for textured quad
*/
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vRayCastCoord;
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec2 vRayCastCoord;
-uniform mediump float uRadius;
-uniform mediump float uAdjuster;
+UNIFORM_BLOCK Custom
+{
+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
-attribute mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix; // DALi shader builtin
-uniform mediump vec3 uSize; // DALi shader builtin
+//@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
+};
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vRayCastCoord;
void main()
{
mediump vec4 vertexPosition = vec4(aPosition, 0.0, 1.0);
/*
- * Copyright (c) 2019 Samsung Electronics Co., Ltd
+ * Copyright (c) 2024 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 lowp vec4 uColor;",
- " uniform sampler2D sTexture;",
- " uniform mediump vec3 uCustomPosition;",
- "",
+ " UNIFORM sampler2D sTexture;",
+ " UNIFORM_BLOCK FragBlock",
+ " {",
+ " UNIFORM lowp vec4 uColor;",
+ " UNIFORM mediump vec3 uCustomPosition;",
+ " };",
" void main()",
" {",
- " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( TEXTURE( 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 = texture2D( sTexture, wrapTexCoord );",
+ " mediump vec4 color = TEXTURE( 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 lowp vec4 uColor;",
- " uniform sampler2D sTexture;",
- " uniform mediump vec3 uCustomPosition;",
- "",
+ " UNIFORM sampler2D sTexture;",
+ " UNIFORM_BLOCK FragBlock",
+ " {",
+ " UNIFORM lowp vec4 uColor;",
+ " UNIFORM mediump vec3 uCustomPosition;",
+ " };",
" void main()",
" {",
- " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( TEXTURE( 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 = texture2D( sTexture, wrapTexCoord );",
+ " mediump vec4 color = TEXTURE( 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) 2019 Samsung Electronics Co., Ltd
+ * Copyright (c) 2024 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":[
- " varying mediump vec2 vTexCoord;",
- " uniform lowp vec4 uColor;",
- " uniform sampler2D sTexture;",
- " uniform mediump vec3 uCustomPosition;",
- "",
+ "//@version 100",
+ " INPUT mediump vec2 vTexCoord;",
+ " UNIFORM sampler2D sTexture;",
+ " UNIFORM_BLOCK FragBlock",
+ " {",
+ " UNIFORM lowp vec4 uColor;",
+ " UNIFORM mediump vec3 uCustomPosition;",
+ " };",
" void main()",
" {",
- " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( TEXTURE( 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 = texture2D( sTexture, wrapTexCoord );",
+ " mediump vec4 color = TEXTURE( 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":[
- " varying mediump vec2 vTexCoord;",
- " uniform lowp vec4 uColor;",
- " uniform sampler2D sTexture;",
- " uniform mediump vec3 uCustomPosition;",
+ "//@version 100",
+ " INPUT mediump vec2 vTexCoord;",
+ " UNIFORM sampler2D sTexture;",
+ " UNIFORM_BLOCK FragBlock",
+ " {",
+ " UNIFORM lowp vec4 uColor;",
+ " UNIFORM mediump vec3 uCustomPosition;",
+ " };",
"",
" void main()",
" {",
- " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( TEXTURE( 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 = texture2D( sTexture, wrapTexCoord );",
+ " mediump vec4 color = TEXTURE( 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) 2019 Samsung Electronics Co., Ltd
+ * Copyright (c) 2024 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":[
- " varying mediump vec2 vTexCoord;",
- " uniform lowp vec4 uColor;",
- " uniform sampler2D sTexture;",
- " uniform mediump vec3 uCustomPosition;",
- "",
+ "//@version 100",
+ " INPUT mediump vec2 vTexCoord;",
+ " UNIFORM sampler2D sTexture;",
+ " UNIFORM_BLOCK FragmentBlock",
+ " {",
+ " UNIFORM lowp vec4 uColor;",
+ " UNIFORM mediump vec3 uCustomPosition;",
+ " };",
" void main()",
" {",
- " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( TEXTURE( 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 = texture2D( sTexture, wrapTexCoord );",
+ " mediump vec4 color = TEXTURE( 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":[
- " varying mediump vec2 vTexCoord;",
- " uniform lowp vec4 uColor;",
- " uniform sampler2D sTexture;",
- " uniform mediump vec3 uCustomPosition;",
- "",
+ "//@version 100",
+ " INPUT mediump vec2 vTexCoord;",
+ " UNIFORM sampler2D sTexture;",
+ " UNIFORM_BLOCK FragmentBlock",
+ " {",
+ " UNIFORM lowp vec4 uColor;",
+ " UNIFORM mediump vec3 uCustomPosition;",
+ " };",
" void main()",
" {",
- " if( texture2D( sTexture, vTexCoord ).a <= 0.0001 )",
+ " if( TEXTURE( 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 = texture2D( sTexture, wrapTexCoord );",
+ " mediump vec4 color = TEXTURE( 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