+//@version 100
// Original Code
// https://github.com/KhronosGroup/glTF-Sample-Viewer/blob/glTF-WebGL-PBR/shaders/pbr-frag.glsl
#define ROUGHNESS a
#endif //GLTF_CHANNELS
-uniform lowp vec4 uColor; // Color from SceneGraph
-uniform lowp vec4 uColorFactor; // Color from material
-uniform lowp float uMetallicFactor;
-uniform lowp float uRoughnessFactor;
-uniform lowp float uDielectricSpecular;
-
#ifdef THREE_TEX
#ifdef BASECOLOR_TEX
-uniform sampler2D sAlbedoAlpha;
-uniform float uBaseColorTextureTransformAvailable;
-uniform mat3 uBaseColorTextureTransform;
-#endif // BASECOLOR_TEX
+UNIFORM sampler2D sAlbedoAlpha;
+#endif
#ifdef METALLIC_ROUGHNESS_TEX
-uniform sampler2D sMetalRoughness;
-uniform float uMetalRoughnessTextureTransformAvailable;
-uniform mat3 uMetalRoughnessTextureTransform;
-#endif // METALLIC_ROUGHNESS_TEX
+UNIFORM sampler2D sMetalRoughness;
+#endif
#ifdef NORMAL_TEX
-uniform sampler2D sNormal;
-uniform float uNormalTextureTransformAvailable;
-uniform mat3 uNormalTextureTransform;
-uniform float uNormalScale;
-#endif // NORMAL_TEX
-#else // THREE_TEX
-uniform sampler2D sAlbedoMetal;
-uniform float uBaseColorTextureTransformAvailable;
-uniform mat3 uBaseColorTextureTransform;
-uniform sampler2D sNormalRoughness;
-uniform float uNormalRoughnessTextureTransformAvailable;
-uniform mat3 uNormalRoughnessTextureTransform;
+UNIFORM sampler2D sNormal;
+#endif
+#else
+UNIFORM sampler2D sAlbedoMetal;
+UNIFORM sampler2D sNormalRoughness;
#endif
-
-
#ifdef OCCLUSION
-uniform sampler2D sOcclusion;
-uniform float uOcclusionTextureTransformAvailable;
-uniform mat3 uOcclusionTextureTransform;
-uniform float uOcclusionStrength;
+UNIFORM sampler2D sOcclusion;
#endif
#ifdef EMISSIVE_TEXTURE
-uniform sampler2D sEmissive;
-uniform float uEmissiveTextureTransformAvailable;
-uniform mat3 uEmissiveTextureTransform;
+UNIFORM sampler2D sEmissive;
#endif
-uniform vec3 uEmissiveFactor;
-uniform float uSpecularFactor;
-uniform vec3 uSpecularColorFactor;
#ifdef MATERIAL_SPECULAR_TEXTURE
-uniform sampler2D sSpecular;
+UNIFORM sampler2D sSpecular;
#endif
#ifdef MATERIAL_SPECULAR_COLOR_TEXTURE
-uniform sampler2D sSpecularColor;
+UNIFORM sampler2D sSpecularColor;
#endif
+/// For shadowmap
+UNIFORM sampler2D sShadowMap;
+
+//// For IBL
+UNIFORM sampler2D sbrdfLUT;
+UNIFORM samplerCube sDiffuseEnvSampler;
+UNIFORM samplerCube sSpecularEnvSampler;
+
+UNIFORM_BLOCK FragBlock0
+{
+ UNIFORM lowp vec4 uColor;// Color from SceneGraph
+ UNIFORM lowp vec4 uColorFactor;// Color from material
+ UNIFORM lowp float uMetallicFactor;
+ UNIFORM lowp float uRoughnessFactor;
+ UNIFORM lowp float uDielectricSpecular;
+
+#ifdef THREE_TEX
+#ifdef BASECOLOR_TEX
+ UNIFORM float uBaseColorTextureTransformAvailable;
+ UNIFORM mat3 uBaseColorTextureTransform;
+#endif// BASECOLOR_TEX
+#ifdef METALLIC_ROUGHNESS_TEX
+ UNIFORM float uMetalRoughnessTextureTransformAvailable;
+ UNIFORM mat3 uMetalRoughnessTextureTransform;
+#endif// METALLIC_ROUGHNESS_TEX
+#ifdef NORMAL_TEX
+ UNIFORM float uNormalTextureTransformAvailable;
+ UNIFORM mat3 uNormalTextureTransform;
+ UNIFORM float uNormalScale;
+#endif// NORMAL_TEX
+#else// THREE_TEX
+ UNIFORM float uBaseColorTextureTransformAvailable;
+ UNIFORM mat3 uBaseColorTextureTransform;
+ UNIFORM float uNormalRoughnessTextureTransformAvailable;
+ UNIFORM mat3 uNormalRoughnessTextureTransform;
+#endif
+
+#ifdef OCCLUSION
+ UNIFORM float uOcclusionTextureTransformAvailable;
+ UNIFORM mat3 uOcclusionTextureTransform;
+ UNIFORM float uOcclusionStrength;
+#endif
+
+#ifdef EMISSIVE_TEXTURE
+ UNIFORM float uEmissiveTextureTransformAvailable;
+ UNIFORM mat3 uEmissiveTextureTransform;
+#endif
+ UNIFORM vec3 uEmissiveFactor;
+ UNIFORM float uSpecularFactor;
+ UNIFORM vec3 uSpecularColorFactor;
+
// For Light (Currently Directional Only)
#define MAX_LIGHTS 5
-uniform mediump int uLightCount;
-uniform mediump vec3 uLightDirection[MAX_LIGHTS];
-uniform mediump vec3 uLightColor[MAX_LIGHTS];
+ UNIFORM mediump int uLightCount;
+ UNIFORM mediump vec3 uLightDirection[MAX_LIGHTS];
+ UNIFORM mediump vec3 uLightColor[MAX_LIGHTS];
// For Shadow Map
-uniform lowp int uIsShadowEnabled;
-uniform sampler2D sShadowMap;
-uniform lowp int uIsShadowReceiving;
+ UNIFORM lowp int uIsShadowReceiving;
#ifdef SL_VERSION_LOW
-uniform int uShadowMapWidth;
-uniform int uShadowMapHeight;
+ UNIFORM int uShadowMapWidth;
+ UNIFORM int uShadowMapHeight;
#endif
-INPUT highp vec3 positionFromLightView;
//// For IBL
-uniform sampler2D sbrdfLUT;
-uniform samplerCube sDiffuseEnvSampler;
-uniform samplerCube sSpecularEnvSampler;
-uniform float uIblIntensity;
-uniform mediump vec3 uYDirection;
-uniform float uMaxLOD;
+ UNIFORM float uIblIntensity;
+ UNIFORM float uMaxLOD;
// For Alpha Mode.
-uniform lowp float uOpaque;
-uniform lowp float uMask;
-uniform lowp float uAlphaThreshold;
+ UNIFORM lowp float uOpaque;
+ UNIFORM lowp float uMask;
+ UNIFORM lowp float uAlphaThreshold;
+};
+
+UNIFORM_BLOCK YDirection
+{
+ UNIFORM mediump vec3 uYDirection;
+};
+
+UNIFORM_BLOCK ShadowEnabled
+{
+ UNIFORM lowp int uIsShadowEnabled;
+};
+
// TODO: Multiple texture coordinate will be supported.
INPUT mediump vec2 vUV;
INPUT lowp mat3 vTBN;
INPUT lowp vec4 vColor;
INPUT highp vec3 vPositionToCamera;
+INPUT highp vec3 positionFromLightView;
const float c_MinRoughness = 0.04;
const float M_PI = 3.141592653589793;
const float kCosPcfTheta = cos(kPcfTheta);
-uniform mediump int uShadowLightIndex;
-uniform lowp int uEnableShadowSoftFiltering;
-uniform mediump float uShadowIntensity;
-uniform highp float uShadowBias;
+UNIFORM mediump int uShadowLightIndex;
+UNIFORM lowp int uEnableShadowSoftFiltering;
+UNIFORM mediump float uShadowIntensity;
+UNIFORM highp float uShadowBias;
vec3 linear(vec3 color)
{
#endif // EMISSIVE_TEXTURE
color += emissive;
- OUT_COLOR = vec4(pow(color, vec3(1.0 / 2.2)), baseColor.a) * uColor;
+ gl_FragColor = vec4(pow(color, vec3(1.0 / 2.2)), baseColor.a) * uColor;
}
+//@version 100
// Original Code
// https://github.com/KhronosGroup/glTF-Sample-Viewer/blob/glTF-WebGL-PBR/shaders/pbr-vert.glsl
#endif
#ifdef MORPH
-uniform highp sampler2D sBlendShapeGeometry;
+UNIFORM highp sampler2D sBlendShapeGeometry;
+#endif
+
+UNIFORM_BLOCK VertBlock0
+{
+#ifdef MORPH
#ifdef SL_VERSION_LOW
-uniform int uBlendShapeGeometryWidth;
-uniform int uBlendShapeGeometryHeight;
+ UNIFORM int uBlendShapeGeometryWidth;
+ UNIFORM int uBlendShapeGeometryHeight;
#endif
#endif
-OUTPUT mediump vec2 vUV;
-OUTPUT highp mat3 vTBN;
-OUTPUT lowp vec4 vColor;
-OUTPUT highp vec3 vPositionToCamera;
-
-uniform highp mat4 uViewMatrix;
-uniform highp mat3 uNormalMatrix;
-uniform highp mat4 uModelMatrix;
-uniform highp mat4 uProjection;
+ UNIFORM highp mat4 uViewMatrix;
+ UNIFORM highp mat3 uNormalMatrix;
+ UNIFORM highp mat4 uModelMatrix;
+ UNIFORM highp mat4 uProjection;
#ifdef SKINNING
#ifdef SL_VERSION_LOW
-#define MAX_BONES 80
-uniform highp mat4 uBone[MAX_BONES];
-#else
-#define MAX_BONES 256
-layout(std140) uniform Bones
-{
- mat4 uBone[MAX_BONES];
-};
+ #define MAX_BONES 80
+ UNIFORM highp mat4 uBone[MAX_BONES];
#endif
-
-uniform mediump vec3 uYDirection;
#endif
#ifdef MORPH
#define MAX_BLEND_SHAPE_NUMBER 256
-uniform int uNumberOfBlendShapes; ///< Total number of blend shapes loaded.
-uniform highp float uBlendShapeWeight[MAX_BLEND_SHAPE_NUMBER]; ///< The weight of each blend shape.
+UNIFORM int uNumberOfBlendShapes;///< Total number of blend shapes loaded.
+UNIFORM highp float uBlendShapeWeight[MAX_BLEND_SHAPE_NUMBER];///< The weight of each blend shape.
#ifdef MORPH_VERSION_2_0
-uniform highp float uBlendShapeUnnormalizeFactor; ///< Factor used to unnormalize the geometry of the blend shape.
+UNIFORM highp float uBlendShapeUnnormalizeFactor;///< Factor used to unnormalize the geometry of the blend shape.
#else
-uniform highp float uBlendShapeUnnormalizeFactor[MAX_BLEND_SHAPE_NUMBER]; ///< Factor used to unnormalize the geometry of the blend shape.
+UNIFORM highp float uBlendShapeUnnormalizeFactor[MAX_BLEND_SHAPE_NUMBER];///< Factor used to unnormalize the geometry of the blend shape.
#endif
-uniform highp int uBlendShapeComponentSize; ///< The size in the texture of either the vertices, normals or tangents. Used to calculate the offset to address them.
+UNIFORM highp int uBlendShapeComponentSize;///< The size in the texture of either the vertices, normals or tangents. Used to calculate the offset to address them.
#endif
// Shadow
-uniform lowp int uIsShadowEnabled;
-uniform highp mat4 uShadowLightViewProjectionMatrix;
+UNIFORM highp mat4 uShadowLightViewProjectionMatrix;
+};
+
+#ifdef SKINNING
+UNIFORM_BLOCK YDirection
+{
+ UNIFORM mediump vec3 uYDirection;
+};
+#endif
+
+UNIFORM_BLOCK ShadowEnabled
+{
+ UNIFORM lowp int uIsShadowEnabled;
+};
+
+// Additional uniform block if using more bones
+#ifdef SKINNING
+#ifndef SL_VERSION_LOW
+#define MAX_BONES 256
+UNIFORM_BLOCK Bones
+{
+ UNIFORM mat4 uBone[MAX_BONES];
+};
+#endif
+#endif
OUTPUT highp vec3 positionFromLightView;
+OUTPUT mediump vec2 vUV;
+OUTPUT highp mat3 vTBN;
+OUTPUT lowp vec4 vColor;
+OUTPUT highp vec3 vPositionToCamera;
+
void main()
{
highp vec4 position = vec4(aPosition, 1.0);
+//@version 100
precision mediump float;
-uniform lowp vec4 uColor;
-FLAT INPUT float vColor;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
+INPUT flat float vColor;
void main()
{
vec3 rgb = vec3(fract(vColor), fract(vColor * 0.00390625), fract(vColor * 0.00390625 * 0.00390625));
- OUT_COLOR = vec4(rgb, 1.) * uColor;
+ gl_FragColor = vec4(rgb, 1.) * uColor;
}
\ No newline at end of file
+//@version 100
precision mediump float;
-uniform mat4 uMvpMatrix;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mat4 uMvpMatrix;
+};
INPUT vec3 aPosition;
INPUT float aColor;
-FLAT OUTPUT float vColor;
+OUTPUT flat float vColor;
void main()
{
+//@version 100
-uniform lowp vec4 uColorFactor; // Color from material
-uniform lowp float uMask;
-uniform lowp float uAlphaThreshold;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColorFactor;// Color from material
+ UNIFORM lowp float uMask;
+ UNIFORM lowp float uAlphaThreshold;
+ UNIFORM int uIsShadowCasting;
+};
INPUT mediump vec2 vUV;
INPUT lowp vec4 vColor;
-//INPUT highp float depth;
-//OUTPUT highp vec4 FragColor;
-
#ifdef THREE_TEX
#ifdef BASECOLOR_TEX
-uniform sampler2D sAlbedoAlpha;
+UNIFORM sampler2D sAlbedoAlpha;
#endif // BASECOLOR_TEX
#else // THREE_TEX
-uniform sampler2D sAlbedoMetal;
+UNIFORM sampler2D sAlbedoMetal;
#endif
-uniform int uIsShadowCasting;
-
lowp vec3 linear(lowp vec3 color)
{
return pow(color, vec3(2.2));
+//@version 100
+
#define MORPH defined(MORPH_POSITION) || defined(MORPH_NORMAL) || defined(MORPH_TANGENT)
#define ADD_EXTRA_SKINNING_ATTRIBUTES
#endif
#ifdef MORPH
-uniform highp sampler2D sBlendShapeGeometry;
-#ifdef SL_VERSION_LOW
-uniform int uBlendShapeGeometryWidth;
-uniform int uBlendShapeGeometryHeight;
+UNIFORM highp sampler2D sBlendShapeGeometry;
+#endif
+
+#ifdef SKINNING
+#ifndef SL_VERSION_LOW
+#define MAX_BONES 256
+UNIFORM_BLOCK Bones
+{
+ UNIFORM mat4 uBone[MAX_BONES];
+};
#endif
#endif
OUTPUT mediump vec2 vUV;
OUTPUT lowp vec4 vColor;
-uniform highp mat4 uViewMatrix;
-uniform highp mat4 uModelMatrix;
-uniform highp mat4 uProjection;
+UNIFORM_BLOCK VertBlock
+{
+#ifdef MORPH
+#ifdef SL_VERSION_LOW
+ UNIFORM int uBlendShapeGeometryWidth;
+ UNIFORM int uBlendShapeGeometryHeight;
+#endif
+#endif
-#ifdef SKINNING
+ UNIFORM highp mat4 uViewMatrix;
+ UNIFORM highp mat4 uModelMatrix;
+ UNIFORM highp mat4 uProjection;
+#ifdef SKINNING
#ifdef SL_VERSION_LOW
#define MAX_BONES 80
-uniform mat4 uBone[MAX_BONES];
-#else
-#define MAX_BONES 256
-layout(std140) uniform Bones
-{
- mat4 uBone[MAX_BONES];
-};
+ UNIFORM mat4 uBone[MAX_BONES];
#endif
-
-uniform mediump vec3 uYDirection;
+UNIFORM mediump vec3 uYDirection;
#endif
#ifdef MORPH
#define MAX_BLEND_SHAPE_NUMBER 256
-uniform int uNumberOfBlendShapes; ///< Total number of blend shapes loaded.
-uniform highp float uBlendShapeWeight[MAX_BLEND_SHAPE_NUMBER]; ///< The weight of each blend shape.
+UNIFORM int uNumberOfBlendShapes;///< Total number of blend shapes loaded.
+UNIFORM highp float uBlendShapeWeight[MAX_BLEND_SHAPE_NUMBER];///< The weight of each blend shape.
#ifdef MORPH_VERSION_2_0
-uniform highp float uBlendShapeUnnormalizeFactor; ///< Factor used to unnormalize the geometry of the blend shape.
+UNIFORM highp float uBlendShapeUnnormalizeFactor;///< Factor used to unnormalize the geometry of the blend shape.
#else
-uniform highp float uBlendShapeUnnormalizeFactor[MAX_BLEND_SHAPE_NUMBER]; ///< Factor used to unnormalize the geometry of the blend shape.
+UNIFORM highp float uBlendShapeUnnormalizeFactor[MAX_BLEND_SHAPE_NUMBER];///< Factor used to unnormalize the geometry of the blend shape.
#endif
-uniform highp int uBlendShapeComponentSize; ///< The size in the texture of either the vertices, normals or tangents. Used to calculate the offset to address them.
+UNIFORM highp int uBlendShapeComponentSize;///< The size in the texture of either the vertices, normals or tangents. Used to calculate the offset to address them.
#endif
-uniform highp mat4 uShadowLightViewProjectionMatrix;
+UNIFORM highp mat4 uShadowLightViewProjectionMatrix;
+};
void main()
{
// Fragment shader for a skybox in equirectangular projection
precision mediump float;
-uniform sampler2D uSkyBoxEquirectangularTexture;
+UNIFORM sampler2D uSkyBoxEquirectangularTexture;
-uniform vec4 uColor;
-uniform float uIntensity;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM vec4 uColor;
+ UNIFORM float uIntensity;
+};
-varying vec3 vTexCoord;
+INPUT vec3 vTexCoord;
// Take the sample direction as interpolated from the cube's local position,
// and use this direction vector and the spherical to cartesian coordinate
// Flip the texture UVs vertically
vec2 uvFlippped = vec2(uv.x, 1.0 - uv.y);
- vec4 texColor = texture2D( uSkyBoxEquirectangularTexture, uvFlippped ) * uIntensity;
+ vec4 texColor = TEXTURE( uSkyBoxEquirectangularTexture, uvFlippped ) * uIntensity;
gl_FragColor = texColor * uColor;
}
-uniform samplerCube uSkyBoxTexture;
-uniform lowp vec4 uColor;
-uniform mediump float uIntensity;
-varying mediump vec3 vTexCoord;
+//@version 100
+
+UNIFORM samplerCube uSkyBoxTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM mediump float uIntensity;
+};
+
+INPUT mediump vec3 vTexCoord;
void main()
{
- mediump vec4 texColor = textureCube(uSkyBoxTexture, vTexCoord) * uIntensity;
+ mediump vec4 texColor = TEXTURE_CUBE(uSkyBoxTexture, vTexCoord) * uIntensity;
gl_FragColor = texColor * uColor;
}
\ No newline at end of file
-attribute mediump vec3 aPosition;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uModelMatrix;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat4 uProjection;
-uniform mediump mat4 uMvpMatrix;
-varying mediump vec3 vTexCoord;
+//@version 100
+
+INPUT mediump vec3 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump mat4 uModelView;
+ UNIFORM mediump mat4 uModelMatrix;
+ UNIFORM mediump mat4 uViewMatrix;
+ UNIFORM mediump mat4 uProjection;
+ UNIFORM mediump mat4 uMvpMatrix;
+};
+OUTPUT mediump vec3 vTexCoord;
void main()
{
-varying mediump vec2 vTexCoord;
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+UNIFORM lowp vec4 uColor;
+};
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
void main()
{
-precision mediump float;
+//@name animated-gradient-visual-shader.frag
+
+//@version 100
-uniform mediump vec4 start_color;
-uniform mediump vec4 end_color;
-uniform mediump float gradient_offset;
+precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vStart;
-varying mediump vec2 vEnd;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM mediump vec4 start_color;
+ UNIFORM mediump vec4 end_color;
+ UNIFORM mediump float gradient_offset;
+};
+
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec2 vStart;
+INPUT mediump vec2 vEnd;
float get_position(vec2 x, vec2 s, vec2 e)
{
-attribute mediump vec2 aPosition;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+//@name animated-gradient-visual-shader.vert
-uniform mediump vec2 start_point;
-uniform mediump vec2 end_point;
-uniform mediump vec2 rotate_center;
-uniform mediump float rotate_angle;
+//@version 100
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vStart;
-varying mediump vec2 vEnd;
+INPUT mediump vec2 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+ UNIFORM mediump vec2 start_point;
+ UNIFORM mediump vec2 end_point;
+ UNIFORM mediump vec2 rotate_center;
+ UNIFORM mediump float rotate_angle;
+};
+
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec2 vStart;
+OUTPUT mediump vec2 vEnd;
vec2 rotate(vec2 x, vec2 c, float a)
{
}
//Visual size and offset
-uniform mediump vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+UNIFORM_BLOCK VisualBlock
+{
+ UNIFORM mediump vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+};
vec4 ComputeVertexPosition()
{
+//@name arc-visual-butt-cap-shader.frag
+
+//@version 100
+
INPUT mediump vec2 vPosition;
-uniform lowp vec4 uColor;
-uniform mediump float thickness;
-uniform mediump float radius;
-uniform mediump float startAngle;
-uniform mediump float sweepAngle;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM mediump float thickness;
+ UNIFORM mediump float radius;
+ UNIFORM mediump float startAngle;
+ UNIFORM mediump float sweepAngle;
+};
const mediump float M_PI_OVER_2 = 1.57079632679;
const mediump float M_PI = 3.14159265359;
void main()
{
- OUT_COLOR = uColor;
- OUT_COLOR.a *= GetOpacity();
+ gl_FragColor = uColor;
+ gl_FragColor.a *= GetOpacity();
}
+//@name arc-visual-round-cap-shader.frag
+
+//@version 100
+
INPUT mediump vec2 vPosition;
-uniform lowp vec4 uColor;
-uniform mediump float thickness;
-uniform mediump float radius;
-uniform mediump float startAngle;
-uniform mediump float sweepAngle;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM mediump float thickness;
+ UNIFORM mediump float radius;
+ UNIFORM mediump float startAngle;
+ UNIFORM mediump float sweepAngle;
+};
const mediump float M_PI_OVER_2 = 1.57079632679;
const mediump float M_PI_2 = 6.28318530718;
void main()
{
- OUT_COLOR = uColor;
- OUT_COLOR.a *= GetOpacity();
+ gl_FragColor = uColor;
+ gl_FragColor.a *= GetOpacity();
}
\ No newline at end of file
+//@name arc-visual-shader.vert
+
+//@version 100
+
INPUT mediump vec2 aPosition;
OUTPUT mediump vec2 vPosition;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
//Visual size and offset
-uniform mediump vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+ UNIFORM mediump vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+};
+
vec4 ComputeVertexPosition()
{
+//@name bloom-view-composite-shader.frag
+
+//@version 100
+
precision mediump float;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform sampler2D sEffect;
-uniform lowp vec4 uColor;
-uniform float uBloomIntensity;
-uniform float uImageIntensity;
-uniform float uBloomSaturation;
-uniform float uImageSaturation;
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM sampler2D sEffect;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM float uBloomIntensity;
+ UNIFORM float uImageIntensity;
+ UNIFORM float uBloomSaturation;
+ UNIFORM float uImageSaturation;
+};
vec4 ChangeSaturation(vec4 col, float sat)
{
{
mediump vec4 image;
mediump vec4 bloom;
- image = texture2D(sTexture, vTexCoord);
- bloom = texture2D(sEffect, vTexCoord);
+ image = TEXTURE(sTexture, vTexCoord);
+ bloom = TEXTURE(sEffect, vTexCoord);
image = ChangeSaturation(image, uImageSaturation) * uImageIntensity;
bloom = ChangeSaturation(bloom, uBloomSaturation) * uBloomIntensity;
image *= 1.0 - clamp(bloom, 0.0, 1.0); // darken base where bloom is strong, to prevent excessive burn-out of result
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
-uniform mediump float uBloomThreshold;
-uniform mediump float uRecipOneMinusBloomThreshold;
+//@name bloom-view-extract-shader.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM mediump float uBloomThreshold;
+ UNIFORM mediump float uRecipOneMinusBloomThreshold;
+};
void main()
{
mediump vec4 col;
- col = texture2D(sTexture, vTexCoord);
+ col = TEXTURE(sTexture, vTexCoord);
col = (col - uBloomThreshold) * uRecipOneMinusBloomThreshold; // remove intensities lower than the thresold and remap intensities above the threshold to [0..1]
gl_FragColor = clamp(col, 0.0, 1.0);
}
\ No newline at end of file
-varying highp vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform highp vec2 uSampleOffsets[NUM_SAMPLES];
-uniform highp float uSampleWeights[NUM_SAMPLES];
+//@name blur-effect.frag
+
+//@version 100
+
+INPUT highp vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM highp vec2 uSampleOffsets[NUM_SAMPLES];
+ UNIFORM highp float uSampleWeights[NUM_SAMPLES];
+};
void main()
{
highp vec4 col = vec4(0.0);
for (int i=0; i<NUM_SAMPLES; ++i)
{
- col += (texture2D(sTexture, vTexCoord + uSampleOffsets[i]) + texture2D(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
+ col += (TEXTURE(sTexture, vTexCoord + uSampleOffsets[i]) + TEXTURE(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
}
gl_FragColor = col;
}
+//@name blur-two-images-shader.frag
+
+//@version 100
+
precision highp float;
-uniform float uBlurStrength;
-uniform sampler2D sTexture;
-uniform sampler2D sEffect;
-varying mediump vec2 vTexCoord;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM float uBlurStrength;
+};
+
+UNIFORM sampler2D sTexture;
+UNIFORM sampler2D sEffect;
+INPUT mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uBlurStrength
- + texture2D( sEffect, vTexCoord )*(1.0-uBlurStrength);
+ gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uBlurStrength
+ + TEXTURE( sEffect, vTexCoord )*(1.0-uBlurStrength);
}
\ No newline at end of file
+//@name blur-two-pass-shader.frag
+
+//@version 100
+
precision highp float;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform vec2 uSampleOffsets[NUM_SAMPLES];
-uniform float uSampleWeights[NUM_SAMPLES];
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM vec2 uSampleOffsets[NUM_SAMPLES];
+ UNIFORM float uSampleWeights[NUM_SAMPLES];
+};
void main()
{
vec4 color = vec4(0.0);
for( int i = 0; i < NUM_SAMPLES; ++i )
{
- color += texture2D( sTexture, vTexCoord + uSampleOffsets[i] ) * uSampleWeights[i];
+ color += TEXTURE( sTexture, vTexCoord + uSampleOffsets[i] ) * uSampleWeights[i];
}
gl_FragColor = color;
}
\ No newline at end of file
+//@name border-visual-anti-aliasing-shader.frag
+
+//@version 100
+
INPUT mediump float vAlpha;
-uniform lowp vec4 uColor;
-uniform lowp vec4 borderColor;
-uniform mediump float borderSize;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM lowp vec4 borderColor;
+ UNIFORM mediump float borderSize;
+};
void main()
{
- OUT_COLOR = borderColor * uColor;
- OUT_COLOR.a *= smoothstep(0.0, 1.5, vAlpha) * smoothstep( borderSize + 1.5, borderSize, vAlpha );
+ gl_FragColor = borderColor * uColor;
+ gl_FragColor.a *= smoothstep(0.0, 1.5, vAlpha) * smoothstep( borderSize + 1.5, borderSize, vAlpha );
}
\ No newline at end of file
+//@name border-visual-anti-aliasing-shader.vert
+
+//@version 100
+
INPUT mediump vec2 aPosition;
INPUT mediump vec2 aDrift;
OUTPUT mediump float vAlpha;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform mediump float borderSize;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+}
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM lowp vec4 borderColor;
+ UNIFORM mediump float borderSize;
+};
void main()
{
-uniform lowp vec4 uColor;
-uniform lowp vec4 borderColor;
+//@name border-visual-shader.frag
+
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM lowp vec4 borderColor;
+};
void main()
{
- OUT_COLOR = borderColor * uColor;
+ gl_FragColor = borderColor * uColor;
}
\ No newline at end of file
+//@name border-visual-shader.vert
+
+//@version 100
+
INPUT mediump vec2 aPosition;
INPUT mediump vec2 aDrift;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform mediump float borderSize;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+ UNIFORM mediump float borderSize;
//Visual size and offset
-uniform mediump vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+ UNIFORM mediump vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+};
vec2 ComputeVertexPosition()
{
+//@name bouncing-effect-mesh-shader.frag
+
+//@version 100
+
// Use the actor color to paint every layer
-uniform lowp vec4 uColor;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
+//@name bouncing-effect-mesh-shader.vert
+
+//@version 100
+
// Modify the vertex position according to the bounce coefficient
-attribute mediump vec3 aPosition1;
-attribute mediump vec3 aPosition2;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform mediump float uBounceCoefficient;
+INPUT mediump vec3 aPosition1;
+INPUT mediump vec3 aPosition2;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump float uBounceCoefficient;
+};
void main()
{
+//@name bubble-effect-color-adjuster.frag
+
+//@version 100
+
precision highp float;
-uniform vec3 uHSVDelta;
-uniform float uIgnoreAlpha;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM vec3 uHSVDelta;
+ UNIFORM float uIgnoreAlpha;
+};
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
float rand(vec2 co)
{
void main()
{
- vec4 color = texture2D(sTexture, vTexCoord);
+ vec4 color = TEXTURE(sTexture, vTexCoord);
vec3 hsvColor = rgb2hsv( color.rgb );
// modify the hsv Value
hsvColor += uHSVDelta * rand(vTexCoord);
-varying mediump vec2 vTexCoord;
-uniform lowp vec4 uColor;
-uniform sampler2D sBackground;
-uniform sampler2D sBubbleShape;
-varying mediump float vPercentage;
-varying mediump vec2 vEffectTexCoord;
+//@name bubble-effect.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sBackground;
+UNIFORM sampler2D sBubbleShape;
+INPUT mediump float vPercentage;
+INPUT mediump vec2 vEffectTexCoord;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
// Get the emit pisition color, and Mix with the actor color
- mediump vec4 fragColor = texture2D(sBackground, vEffectTexCoord)*uColor;
+ mediump vec4 fragColor = TEXTURE(sBackground, vEffectTexCoord)*uColor;
// Apply the shape defined by the texture contained sBubbleShape
// And make the opacity being 0.7, and animate from 0.7 to 0 during the last 1/3 of movement
- fragColor.a*= texture2D(sBubbleShape, vTexCoord).a * ( 2.1 - max( vPercentage*2.1, 1.4 ) );
+ fragColor.a*= TEXTURE(sBubbleShape, vTexCoord).a * ( 2.1 - max( vPercentage*2.1, 1.4 ) );
gl_FragColor = fragColor;
}
\ No newline at end of file
-attribute mediump float aIndex;
-attribute mediump vec2 aPosition;
-attribute highp vec2 aTexCoord;
-varying mediump vec2 vTexCoord;
-uniform mediump mat4 uMvpMatrix;
+//@name bubble-effect.vert
+
+//@version 100
+
+INPUT mediump float aIndex;
+INPUT mediump vec2 aPosition;
+INPUT highp vec2 aTexCoord;
+OUTPUT mediump vec2 vTexCoord;
+
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump mat4 uMvpMatrix;
// the gravity applied to the y direction
-uniform mediump float uGravity;
+ UNIFORM mediump float uGravity;
// xy: the emit position of the bubble; zw: the destination of the bubble.
// The bubble is moving from (xy) to (zw plus the y drop influenced by gravity).
-uniform vec4 uStartEndPosition[NUMBER_OF_BUBBLE];
+ UNIFORM vec4 uStartEndPosition[NUMBER_OF_BUBBLE];
// The undergoing percentage of the bubble movement. 0.0: start from emit position, 1.0: reach the destination
-uniform float uPercentage[NUMBER_OF_BUBBLE];
-uniform vec2 uInvertedMovementArea;
-// The bubble number is restricted by the available uniform num.
-// To increase the displayed bubble, every uStartEndPosition and uPercentage uniform is applied to a small bunch of bubbles (9 here)
+ UNIFORM float uPercentage[NUMBER_OF_BUBBLE];
+ UNIFORM vec2 uInvertedMovementArea;
+// The bubble number is restricted by the available UNIFORM num.
+// To increase the displayed bubble, every uStartEndPosition and uPercentage UNIFORM is applied to a small bunch of bubbles (9 here)
// The offset defines the random offset between bubbles within the bunch.
-uniform vec2 uOffset[9];
-// This uniform is used to change the bubble size during running time
-uniform float uDynamicScale;
-varying float vPercentage;
-varying vec2 vEffectTexCoord;
+ UNIFORM vec2 uOffset[9];
+// This UNIFORM is used to change the bubble size during running time
+ UNIFORM float uDynamicScale;
+};
+OUTPUT float vPercentage;
+OUTPUT vec2 vEffectTexCoord;
void main()
{
+//@name bubble-emitter.frag
+
+//@version 100
+
precision highp float;
-uniform vec3 uHSVDelta;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM vec3 uHSVDelta;
+};
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
float rand(vec2 co)
{
void main()
{
- vec4 color = texture2D(sTexture, vTexCoord);
+ vec4 color = TEXTURE(sTexture, vTexCoord);
vec3 hsvColor = rgb2hsv( color.rgb );
// modify the hsv Value
hsvColor += uHSVDelta * rand(vTexCoord);
-attribute mediump vec2 aPosition;
-attribute mediump vec2 aTexCoord;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-varying mediump vec2 vTexCoord;
+//@name bubble-emitter.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+INPUT mediump vec2 aTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump mat4 uMvpMatrix;
+};
+OUTPUT mediump vec2 vTexCoord;
void main()
{
-uniform lowp vec4 uColor;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
+//@name canvas-view.frag
+
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
void main()
{
- gl_FragColor = texture2D(sTexture, vTexCoord) * uColor;
+ gl_FragColor = TEXTURE(sTexture, vTexCoord) * uColor;
}
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+//@name canvas-view.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+};
void main()
{
+//@name color-visual-shader.frag
+
+//@version 100
+
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
INPUT highp vec2 vPosition;
-FLAT INPUT highp vec2 vRectSize;
-FLAT INPUT highp vec2 vOptRectSize;
-FLAT INPUT highp float vAliasMargin;
+INPUT flat highp vec2 vRectSize;
+INPUT flat highp vec2 vOptRectSize;
+INPUT flat highp float vAliasMargin;
#ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT INPUT highp vec4 vCornerRadius;
+INPUT flat highp vec4 vCornerRadius;
#endif
#endif
#if defined(IS_REQUIRED_CUTOUT)
INPUT highp vec2 vPositionFromCenter;
#if defined(IS_REQUIRED_ROUNDED_CORNER)
-FLAT INPUT highp vec4 vCutoutCornerRadius;
+INPUT flat highp vec4 vCutoutCornerRadius;
#endif
#endif
-uniform lowp vec4 uColor;
-#ifdef IS_REQUIRED_BLUR
-uniform highp float blurRadius;
-#elif defined(IS_REQUIRED_BORDERLINE)
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
-uniform lowp vec4 borderlineColor;
-uniform lowp vec4 uActorColor;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+#if defined(IS_REQUIRED_BORDERLINE)
+ UNIFORM lowp vec4 uActorColor;
+#endif
+
+#if defined(IS_REQUIRED_CUTOUT)
+ UNIFORM lowp int uCutoutWithCornerRadius;
#endif
#ifdef IS_REQUIRED_SQUIRCLE_CORNER
-uniform highp vec4 cornerSquareness;
+ UNIFORM highp vec4 cornerSquareness;
#endif
+};
-#if defined(IS_REQUIRED_CUTOUT)
-uniform highp vec3 uSize;
-uniform lowp int uCutoutWithCornerRadius;
+UNIFORM_BLOCK SharedBlock
+{
+ UNIFORM highp vec3 uSize;
+
+#ifdef IS_REQUIRED_BLUR
+ UNIFORM highp float blurRadius;
+#elif defined(IS_REQUIRED_BORDERLINE)
+ UNIFORM highp float borderlineWidth;
+ UNIFORM highp float borderlineOffset;
+ UNIFORM lowp vec4 borderlineColor;
#endif
+};
+
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
// Global values both rounded corner and borderline use
// skip most potential calculate for performance
if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
{
- OUT_COLOR = targetColor;
+ gl_FragColor = targetColor;
}
else
{
calculatePotential();
setupMinMaxPotential(tempBorderlineWidth);
- OUT_COLOR = targetColor;
+ gl_FragColor = targetColor;
mediump float opacity = calculateBlurOpacity();
- OUT_COLOR *= opacity;
+ gl_FragColor *= opacity;
#else
#if defined(IS_REQUIRED_ROUNDED_CORNER) && !defined(IS_REQUIRED_BORDERLINE)
// skip rounded corner calculate for performance
if(gFragmentPosition.x + gFragmentPosition.y < -(gRadius + vAliasMargin) * 2.0)
{
// Do nothing.
- OUT_COLOR = targetColor;
+ gl_FragColor = targetColor;
}
else
#endif
#endif
#endif
- OUT_COLOR = targetColor;
+ gl_FragColor = targetColor;
#ifdef IS_REQUIRED_ROUNDED_CORNER
mediump float opacity = calculateCornerOpacity();
- OUT_COLOR *= opacity;
+ gl_FragColor *= opacity;
#endif
}
#endif
#endif
#ifdef IS_REQUIRED_CUTOUT
- OUT_COLOR *= discardOpacity;
+ gl_FragColor *= discardOpacity;
#endif
}
+//@name color-visual-shader.vert
+
+//@version 100
+
INPUT mediump vec2 aPosition;
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
OUTPUT highp vec2 vPosition;
-FLAT OUTPUT highp vec2 vRectSize;
-FLAT OUTPUT highp vec2 vOptRectSize;
-FLAT OUTPUT highp float vAliasMargin;
+OUTPUT flat highp vec2 vRectSize;
+OUTPUT flat highp vec2 vOptRectSize;
+OUTPUT flat highp float vAliasMargin;
#ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT OUTPUT highp vec4 vCornerRadius;
+OUTPUT flat highp vec4 vCornerRadius;
#endif
#endif
#if defined(IS_REQUIRED_CUTOUT)
OUTPUT highp vec2 vPositionFromCenter;
#if defined(IS_REQUIRED_ROUNDED_CORNER)
-FLAT OUTPUT highp vec4 vCutoutCornerRadius;
+OUTPUT flat highp vec4 vCutoutCornerRadius;
#endif
#endif
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+
+ #if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
+ // Be used when we calculate anti-alias range near 1 pixel.
+ UNIFORM highp vec3 uScale;
+ #endif
-#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE) || defined(IS_REQUIRED_BLUR)
-// Be used when we calculate anti-alias range near 1 pixel.
-uniform highp vec3 uScale;
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+
+#ifdef IS_REQUIRED_ROUNDED_CORNER
+ UNIFORM highp vec4 cornerRadius;
+ UNIFORM mediump float cornerRadiusPolicy;
#endif
+ UNIFORM highp vec2 extraSize;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+ UNIFORM highp vec3 uSize;
-//Visual size and offset
-uniform highp vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
#ifdef IS_REQUIRED_BLUR
-uniform highp float blurRadius;
+ UNIFORM highp float blurRadius;
#elif defined(IS_REQUIRED_BORDERLINE)
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
+ UNIFORM highp float borderlineWidth;
+ UNIFORM highp float borderlineOffset;
+ UNIFORM lowp vec4 borderlineColor;
#endif
-#ifdef IS_REQUIRED_ROUNDED_CORNER
-uniform highp vec4 cornerRadius;
-uniform mediump float cornerRadiusPolicy;
-#endif
-uniform highp vec2 extraSize;
+};
+
vec4 ComputeVertexPosition()
{
-precision highp float;
-varying highp vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform vec4 uColor;
+//@name control-renderers.frag
+
+//@version 100
+precision highp float;
+INPUT highp vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragColor
+{
+ UNIFORM vec4 uColor;
+};
void main()
{
- gl_FragColor = texture2D(sTexture, vTexCoord);
+ gl_FragColor = TEXTURE(sTexture, vTexCoord);
gl_FragColor *= uColor;
}
-precision highp float;
-attribute highp vec2 aPosition;
-varying highp vec2 vTexCoord;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+//@name control-renderers.vert
+
+//@version 100
+precision highp float;
+INPUT highp vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+};
void main()
{
highp vec4 vertexPosition = vec4(aPosition * uSize.xy, 0.0, 1.0);
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
-uniform lowp vec4 uSamplerRect;
+//@name cube-transition-effect.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM lowp vec4 uSamplerRect;
+};
void main()
{
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
}
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform mediump vec4 uTextureRect;
+//@name cube-transition-effect.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump vec4 uTextureRect;
+};
void main()
{
-varying float vPercentage;
-varying mediump vec2 vTexCoord;
+//@name dissolve-effect.frag
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
-uniform vec4 uTextureRect;
+//@version 100
+
+INPUT float vPercentage;
+INPUT mediump vec2 vTexCoord;
+
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
float rand(vec2 co)
{
float offsetS = rand(vTexCoord * vPercentage) - vTexCoord.s;
float offsetT = rand(vec2(vTexCoord.t * vPercentage, vTexCoord.s * vPercentage)) - vTexCoord.t;
vec2 lookupCoord = vTexCoord + vec2(offsetS, offsetT) * vPercentage;
- gl_FragColor = texture2D(sTexture, lookupCoord) * uColor;
+ gl_FragColor = TEXTURE(sTexture, lookupCoord) * uColor;
gl_FragColor.a *= 1.0 - vPercentage;
}
\ No newline at end of file
-attribute mediump vec2 aPosition;
+//@name dissolve-effect.vert
-uniform mediump mat4 uMvpMatrix;
-uniform vec3 uSize;
-uniform vec4 uTextureRect;
+//@version 100
-uniform float uPercentage;
-uniform vec3 uSaddleParam;
-uniform vec2 uTranslation;
-uniform vec2 uRotation;
-uniform float uToNext;
+INPUT mediump vec2 aPosition;
-varying float vPercentage;
-varying vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM vec3 uSize;
+
+ UNIFORM float uPercentage;
+ UNIFORM vec3 uSaddleParam;
+ UNIFORM vec2 uTranslation;
+ UNIFORM vec2 uRotation;
+ UNIFORM float uToNext;
+};
+
+
+
+OUTPUT float vPercentage;
+OUTPUT vec2 vTexCoord;
void main()
{
-varying mediump vec2 vTexCoord;
+//@name distance-field-effect.frag
-uniform mediump float uGlowBoundary;
-uniform mediump vec2 uOutlineParams;
-uniform lowp vec4 uOutlineColor;
-uniform lowp vec4 uShadowColor;
-uniform mediump vec2 uShadowOffset;
-uniform lowp vec4 uGlowColor;
-uniform lowp float uDoOutline;
-uniform lowp float uDoShadow;
-uniform lowp float uDoGlow;
+//@version 100
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM mediump float uGlowBoundary;
+ UNIFORM mediump vec2 uOutlineParams;
+ UNIFORM lowp vec4 uOutlineColor;
+ UNIFORM lowp vec4 uShadowColor;
+ UNIFORM mediump vec2 uShadowOffset;
+ UNIFORM lowp vec4 uGlowColor;
+ UNIFORM lowp float uDoOutline;
+ UNIFORM lowp float uDoShadow;
+ UNIFORM lowp float uDoGlow;
+ UNIFORM lowp vec4 uColor;
+};
+
+UNIFORM sampler2D sTexture;
void main()
{
// sample distance field
mediump float smoothing = 0.5;
- mediump float distance = texture2D(sTexture, vTexCoord).a;
+ mediump float distance = TEXTURE(sTexture, vTexCoord).a;
mediump float smoothWidth = fwidth(distance);
mediump float alphaFactor = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, distance);
lowp vec4 color;
else // (uDoShadow > 0.0)
{
- mediump float shadowDistance = texture2D(sTexture, vTexCoord - uShadowOffset).a;
+ mediump float shadowDistance = TEXTURE(sTexture, vTexCoord - uShadowOffset).a;
mediump float inText = alphaFactor;
mediump float inShadow = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, shadowDistance);
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 effectColor;
+//@name effects-view.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 effectColor;
+};
void main()
{
gl_FragColor = effectColor;
- gl_FragColor.a *= texture2D( sTexture, vTexCoord).a;
+ gl_FragColor.a *= TEXTURE( sTexture, vTexCoord).a;
}
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-uniform mediump vec3 effectOffset;
+//@name effects-view.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump vec3 effectOffset;
+};
void main()
{
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uEffectColor;
+//@name emboss-filter-composite-shader.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uEffectColor;
+};
void main()
{
gl_FragColor = uEffectColor;
- gl_FragColor.a *= texture2D( sTexture, vTexCoord).a;
+ gl_FragColor.a *= TEXTURE( sTexture, vTexCoord).a;
}
\ No newline at end of file
+//@name emboss-filter-shader.frag
+
+//@version 100
+
precision highp float;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform vec2 uTexScale;
-uniform vec3 uCoefficient;
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM vec2 uTexScale;
+ UNIFORM vec3 uCoefficient;
+};
void main()
{
- vec4 color = uCoefficient.x * texture2D( sTexture, vTexCoord + vec2(0.0, -uTexScale.y) );
- color += uCoefficient.y * texture2D( sTexture, vTexCoord );
- color += uCoefficient.z * texture2D( sTexture, vTexCoord + vec2(0.0, uTexScale.y) );
+ vec4 color = uCoefficient.x * TEXTURE( sTexture, vTexCoord + vec2(0.0, -uTexScale.y) );
+ color += uCoefficient.y * TEXTURE( sTexture, vTexCoord );
+ color += uCoefficient.z * TEXTURE( sTexture, vTexCoord + vec2(0.0, uTexScale.y) );
gl_FragColor = color;
}
\ No newline at end of file
-varying highp vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform highp vec2 uSampleOffsets[NUM_SAMPLES];
-uniform highp float uSampleWeights[NUM_SAMPLES];
+//@name gaussian-blur-view.frag
+
+//@version 100
+
+INPUT highp vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM highp vec2 uSampleOffsets[NUM_SAMPLES];
+ UNIFORM highp float uSampleWeights[NUM_SAMPLES];
+};
void main()
{
highp vec4 col = vec4(0.0);
for (int i=0; i<NUM_SAMPLES; ++i)
{
- col += (texture2D(sTexture, vTexCoord + uSampleOffsets[i]) + texture2D(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
+ col += (TEXTURE(sTexture, vTexCoord + uSampleOffsets[i]) + TEXTURE(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
}
gl_FragColor = col;
}
-uniform lowp vec4 uColor;
-varying mediump vec2 vTexCoord;
-uniform samplerExternalOES sTexture;
+//@name gl-view.frag
+
+//@version 100
+INPUT mediump vec2 vTexCoord;
+UNIFORM samplerExternalOES sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
- gl_FragColor = texture2D(sTexture, vTexCoord) * uColor;
+ gl_FragColor = TEXTURE(sTexture, vTexCoord) * uColor;
}
\ No newline at end of file
-attribute mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump vec3 uSize;
-varying mediump vec2 vTexCoord;
+//@name gl-view.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump vec3 uSize;
+};
+OUTPUT mediump vec2 vTexCoord;
void main()
{
#define TEXTURE_BASECOLOR
-uniform sampler2D uBaseColorSampler;
-uniform int uBaseColorTexCoordIndex;
+UNIFORM sampler2D uBaseColorSampler;
+
+UNIFORM_BLOCK FragBlockBaseColor
+{
+ UNIFORM int uBaseColorTexCoordIndex;
+};
#define TEXTURE_EMIT
-uniform sampler2D uEmissiveSampler;
-uniform int uEmissiveTexCoordIndex;
-uniform vec3 uEmissiveFactor;
+UNIFORM sampler2D uEmissiveSampler;
+UNIFORM_BLOCK FragBlockEmissive
+{
+ UNIFORM int uEmissiveTexCoordIndex;
+ UNIFORM vec3 uEmissiveFactor;
+};
-#version 300 es
+//#version 300 es
precision highp float;
#define TEXTURE_IBL
-uniform sampler2D ubrdfLUT;
-uniform samplerCube uDiffuseEnvSampler;
-uniform samplerCube uSpecularEnvSampler;
-uniform vec4 uScaleIBLAmbient;
-uniform highp float uMipmapLevel;
+UNIFORM sampler2D ubrdfLUT;
+UNIFORM samplerCube uDiffuseEnvSampler;
+UNIFORM samplerCube uSpecularEnvSampler;
+
+UNIFORM_BLOCK FragBlockIBL
+{
+ UNIFORM vec4 uScaleIBLAmbient;
+ UNIFORM highp float uMipmapLevel;
+};
#define TEXTURE_METALLICROUGHNESS
-uniform sampler2D uMetallicRoughnessSampler;
-uniform int uMetallicRoughnessTexCoordIndex;
+UNIFORM sampler2D uMetallicRoughnessSampler;
+
+UNIFORM_BLOCK FragBlockMetRough
+{
+ UNIFORM int uMetallicRoughnessTexCoordIndex;
+};
#define TEXTURE_NORMAL
-uniform sampler2D uNormalSampler;
-uniform float uNormalScale;
-uniform int uNormalTexCoordIndex;
+UNIFORM sampler2D uNormalSampler;
+UNIFORM_BLOCK FragBlockNormal
+{
+ UNIFORM float uNormalScale;
+ UNIFORM int uNormalTexCoordIndex;
+};
#define TEXTURE_OCCLUSION
-uniform sampler2D uOcclusionSampler;
-uniform int uOcclusionTexCoordIndex;
-uniform float uOcclusionStrength;
+UNIFORM sampler2D uOcclusionSampler;
+UNIFORM_BLOCK FragBlockOcclusion
+{
+ UNIFORM int uOcclusionTexCoordIndex;
+ UNIFORM float uOcclusionStrength;
+};
-uniform lowp vec3 uLightColor;
-uniform lowp vec4 uBaseColorFactor;
-uniform lowp vec2 uMetallicRoughnessFactors;
-uniform lowp float alphaCutoff;
-uniform lowp float uAlphaMode;
-uniform lowp float uHasLightSource;
+//@name gltf-physically-based-shader.frag
-in lowp vec2 vUV[2];
-in lowp mat3 vTBN;
-in lowp vec4 vColor;
-in highp vec3 vLightDirection;
-in highp vec3 vPositionToCamera;
+//@version 100
-out vec4 FragColor;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec3 uLightColor;
+ UNIFORM lowp vec4 uBaseColorFactor;
+ UNIFORM lowp vec2 uMetallicRoughnessFactors;
+ UNIFORM lowp float alphaCutoff;
+ UNIFORM lowp float uAlphaMode;
+ UNIFORM lowp float uHasLightSource;
+};
+
+INPUT lowp vec2 vUV[2];
+INPUT lowp mat3 vTBN;
+INPUT lowp vec4 vColor;
+INPUT highp vec3 vLightDirection;
+INPUT highp vec3 vPositionToCamera;
+
+OUTPUT vec4 FragColor;
struct PBRInfo
{
lowp float perceptualRoughness = uMetallicRoughnessFactors.y;
// Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
- // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
+ // This layOUTPUT intentionally reserves the 'r' channel for (optional) occlusion map data
#ifdef TEXTURE_METALLICROUGHNESS
lowp vec4 metrou = texture(uMetallicRoughnessSampler, vUV[uMetallicRoughnessTexCoordIndex]);
metallic = metrou.b * metallic;
-in highp vec3 aPosition;
-in mediump vec2 aTexCoord0;
-in mediump vec2 aTexCoord1;
-in lowp vec3 aNormal;
-in lowp vec4 aTangent;
-in lowp vec4 aVertexColor;
-
-uniform mediump vec3 uSize;
-uniform mediump mat4 uModelMatrix;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat4 uProjection;
-uniform mediump vec3 uLightVector;
-uniform lowp float uIsPointLight;
-uniform lowp float uHasVertexColor;
-
-out lowp vec2 vUV[2];
-out lowp mat3 vTBN;
-out lowp vec4 vColor;
-out highp vec3 vLightDirection;
-out highp vec3 vPositionToCamera;
+//@name gltf-physically-based-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT mediump vec2 aTexCoord0;
+INPUT mediump vec2 aTexCoord1;
+INPUT lowp vec3 aNormal;
+INPUT lowp vec4 aTangent;
+INPUT lowp vec4 aVertexColor;
+
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump mat4 uModelMatrix;
+ UNIFORM mediump mat4 uViewMatrix;
+ UNIFORM mediump mat4 uProjection;
+ UNIFORM mediump vec3 uLightVector;
+ UNIFORM lowp float uIsPointLight;
+ UNIFORM lowp float uHasVertexColor;
+};
+
+OUTPUT lowp vec2 vUV[2];
+OUTPUT lowp mat3 vTBN;
+OUTPUT lowp vec4 vColor;
+OUTPUT highp vec3 vLightDirection;
+OUTPUT highp vec3 vPositionToCamera;
void main()
{
+//@name glyphy-shader-fragment-prefix.frag
+
+//@version 100
+
struct Material
{
mediump float mOpacity;
lowp vec4 mEmissive;
};
-uniform sampler2D sTexture;
-uniform sampler2D sOpacityTexture;
-uniform sampler2D sNormalMapTexture;
-uniform sampler2D sEffect;
-varying mediump vec2 vTexCoord;
-uniform Material uMaterial;
-uniform lowp vec4 uColor;
-varying highp vec4 vVertex;
-varying highp vec3 vNormal;
-varying mediump vec4 vColor;
-uniform vec4 u_atlas_info;
+UNIFORM sampler2D sTexture;
+UNIFORM sampler2D sOpacityTexture;
+UNIFORM sampler2D sNormalMapTexture;
+UNIFORM sampler2D sEffect;
+INPUT mediump vec2 vTexCoord;
+UNIFORM Material uMaterial;
+UNIFORM lowp vec4 uColor;
+INPUT highp vec4 vVertex;
+INPUT highp vec3 vNormal;
+INPUT mediump vec4 vColor;
+UNIFORM vec4 u_atlas_info;
#define GLYPHY_TEXTURE1D_EXTRA_DECLS , sampler2D _tex, ivec4 _atlas_info, ivec2 _atlas_pos
#define GLYPHY_TEXTURE1D_EXTRA_ARGS , _tex, _atlas_info, _atlas_pos
vec2 pos = (vec2 (_atlas_pos.xy * item_geom +
ivec2 (mod (float (offset), float (item_geom.x)), offset / item_geom.x)) +
+ vec2 (.5, .5)) / vec2(_atlas_info.xy);
- return texture2D (_tex, pos);
+ return TEXTURE (_tex, pos);
}
-uniform float u_contrast;
-uniform float u_gamma_adjust;
-uniform float u_outline_thickness;
-uniform float u_outline;
-uniform float u_boldness;
+//@name glyphy-shader-main.frag
-varying vec4 v_glyph;
+//@version 100
+
+UNIFORM float u_contrast;
+UNIFORM float u_gamma_adjust;
+UNIFORM float u_outline_thickness;
+UNIFORM float u_outline;
+UNIFORM float u_boldness;
+
+INPUT vec4 v_glyph;
#define SQRT2_2 0.70711 /* 1 / sqrt(2.) */
#define SQRT2 1.41421
-uniform mediump mat4 uProjection;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uMvpMatrix;
-uniform bool uTextureMapped;
-uniform mediump vec4 uCustomTextureCoords;
-attribute highp vec2 aTexCoord;
-varying mediump vec2 vTexCoord;
-uniform mat3 uModelViewIT;
-attribute mediump vec3 aNormal;
-varying mediump vec3 vNormal;
-attribute mediump vec2 aPosition;
-varying mediump vec4 vVertex;
-attribute mediump vec4 aColor;
-varying mediump vec4 vColor;
-varying vec4 v_glyph;
+//@name glyphy-shader-main.vert
+
+//@version 100
+
+UNIFORM mediump mat4 uProjection;
+UNIFORM mediump mat4 uModelView;
+UNIFORM mediump mat4 uMvpMatrix;
+UNIFORM bool uTextureMapped;
+UNIFORM mediump vec4 uCustomTextureCoords;
+INPUT highp vec2 aTexCoord;
+OUTPUT mediump vec2 vTexCoord;
+UNIFORM mat3 uModelViewIT;
+INPUT mediump vec3 aNormal;
+OUTPUT mediump vec3 vNormal;
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec4 vVertex;
+INPUT mediump vec4 aColor;
+OUTPUT mediump vec4 vColor;
+OUTPUT vec4 v_glyph;
vec4 glyph_vertex_transcode (vec2 v)
{
+//@name gradient-visual-shader.frag
+
+//@version 100
+
INPUT mediump vec2 vTexCoord;
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
INPUT highp vec2 vPosition;
-FLAT INPUT highp vec2 vRectSize;
-FLAT INPUT highp vec2 vOptRectSize;
-FLAT INPUT highp float vAliasMargin;
+INPUT flat highp vec2 vRectSize;
+INPUT flat highp vec2 vOptRectSize;
+INPUT flat highp float vAliasMargin;
#ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT INPUT highp vec4 vCornerRadius;
+INPUT flat highp vec4 vCornerRadius;
#endif
#endif
-// scale factor to fit start and end position of gradient.
-uniform mediump float uTextureCoordinateScaleFactor;
+UNIFORM sampler2D sTexture; // sampler1D?
+
+UNIFORM_BLOCK FragBlock
+{
+ // scale factor to fit start and end position of gradient.
+ UNIFORM mediump float uTextureCoordinateScaleFactor;
+ UNIFORM lowp vec4 uColor;
+};
-uniform sampler2D sTexture; // sampler1D?
-uniform lowp vec4 uColor;
#ifdef IS_REQUIRED_BORDERLINE
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
-uniform lowp vec4 borderlineColor;
-uniform lowp vec4 uActorColor;
+UNIFORM_BLOCK SharedBlock
+{
+ UNIFORM highp float borderlineWidth;
+ UNIFORM highp float borderlineOffset;
+ UNIFORM lowp vec4 borderlineColor;
+ UNIFORM lowp vec4 uActorColor;
+};
#endif
#ifdef IS_REQUIRED_SQUIRCLE_CORNER
// skip most potential calculate for performance
if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
{
- OUT_COLOR = textureColor;
+ gl_FragColor = textureColor;
}
else
{
if(gFragmentPosition.x + gFragmentPosition.y < -(gRadius + vAliasMargin) * 2.0)
{
// Do nothing.
- OUT_COLOR = textureColor;
+ gl_FragColor = textureColor;
}
else
#endif
#ifdef IS_REQUIRED_BORDERLINE
textureColor = convertBorderlineColor(textureColor);
#endif
- OUT_COLOR = textureColor;
+ gl_FragColor = textureColor;
#ifdef IS_REQUIRED_ROUNDED_CORNER
mediump float opacity = calculateCornerOpacity();
- OUT_COLOR *= opacity;
+ gl_FragColor *= opacity;
#endif
}
+//@name gradient-visual-shader.vert
+
+//@version 100
+
INPUT mediump vec2 aPosition;
OUTPUT mediump vec2 vTexCoord;
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
OUTPUT highp vec2 vPosition;
-FLAT OUTPUT highp vec2 vRectSize;
-FLAT OUTPUT highp vec2 vOptRectSize;
-FLAT OUTPUT highp float vAliasMargin;
+OUTPUT flat highp vec2 vRectSize;
+OUTPUT flat highp vec2 vOptRectSize;
+OUTPUT flat highp float vAliasMargin;
#ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT OUTPUT highp vec4 vCornerRadius;
+OUTPUT flat highp vec4 vCornerRadius;
#endif
#endif
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform mediump mat3 uAlignmentMatrix;
-
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+ UNIFORM mediump mat3 uAlignmentMatrix;
#if defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
-// Be used when we calculate anti-alias range near 1 pixel.
-uniform highp vec3 uScale;
+ // Be used when we calculate anti-alias range near 1 pixel.
+ UNIFORM highp vec3 uScale;
#endif
-//Visual size and offset
-uniform highp vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
-#ifdef IS_REQUIRED_BORDERLINE
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
-#endif
+ // Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
#ifdef IS_REQUIRED_ROUNDED_CORNER
-uniform highp vec4 cornerRadius;
-uniform mediump float cornerRadiusPolicy;
+ UNIFORM highp vec4 cornerRadius;
+ UNIFORM mediump float cornerRadiusPolicy;
#endif
+};
+
+#ifdef IS_REQUIRED_BORDERLINE
+UNIFORM_BLOCK SharedBlock
+{
+ UNIFORM highp float borderlineWidth;
+ UNIFORM highp float borderlineOffset;
+ UNIFORM lowp vec4 borderlineColor;
+ UNIFORM lowp vec4 uActorColor;
+};
+#endif
+
vec4 ComputeVertexPosition()
{
-attribute mediump vec2 aPosition;
+//@name image-region-effect.vert
-uniform mediump mat4 uMvpMatrix;
-uniform vec3 uSize;
-uniform vec4 uTextureRect;
+//@version 100
-varying vec2 vTexCoord;
+INPUT mediump vec2 aPosition;
-uniform mediump vec2 uTopLeft;
-uniform mediump vec2 uBottomRight;
+OUTPUT vec2 vTexCoord;
+
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump vec2 uTopLeft;
+ UNIFORM mediump vec2 uBottomRight;
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM vec3 uSize;
+ UNIFORM vec4 uTextureRect;
+};
void main()
{
+//@version 100
+
INPUT mediump vec2 vTexCoord;
#if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER) || defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
INPUT highp vec2 vPosition;
-FLAT INPUT highp vec2 vRectSize;
-FLAT INPUT highp vec2 vOptRectSize;
-FLAT INPUT highp float vAliasMargin;
+INPUT flat highp vec2 vRectSize;
+INPUT flat highp vec2 vOptRectSize;
+INPUT flat highp float vAliasMargin;
#ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT INPUT highp vec4 vCornerRadius;
+INPUT flat highp vec4 vCornerRadius;
#endif
#endif
#ifdef IS_REQUIRED_DEBUG_VISUAL_SHADER
DEBUG_EXTRA_VARYINGS
#endif
-uniform sampler2D sTexture;
+UNIFORM sampler2D sTexture;
#if defined(IS_REQUIRED_YUV_TO_RGB) || defined(IS_REQUIRED_UNIFIED_YUV_AND_RGB)
-uniform sampler2D sTextureU;
-uniform sampler2D sTextureV;
+UNIFORM sampler2D sTextureU;
+UNIFORM sampler2D sTextureV;
#endif
#ifdef IS_REQUIRED_ALPHA_MASKING
-uniform sampler2D sMaskTexture;
-uniform lowp float uYFlipMaskTexture;
+UNIFORM sampler2D sMaskTexture;
INPUT mediump vec2 vMaskTexCoord;
#endif
+UNIFORM_BLOCK FragBlock
+{
+#ifdef IS_REQUIRED_ALPHA_MASKING
+ UNIFORM lowp float uYFlipMaskTexture;
+#endif
+
#ifdef ATLAS_DEFAULT_WARP
-uniform mediump vec4 uAtlasRect;
+ UNIFORM mediump vec4 uAtlasRect;
+
#elif defined(ATLAS_CUSTOM_WARP)
-// WrapMode -- 0: CLAMP; 1: REPEAT; 2: REFLECT;
-uniform lowp vec2 wrapMode;
+ // WrapMode -- 0: CLAMP; 1: REPEAT; 2: REFLECT;
+ UNIFORM lowp vec2 wrapMode;
#endif
-
#if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER)
-uniform highp vec3 uScale;
+ UNIFORM highp vec3 uScale;
#endif
-uniform lowp vec4 uColor;
-uniform lowp float premultipliedAlpha;
+ UNIFORM lowp vec4 uColor;
+ UNIFORM lowp float premultipliedAlpha;
+
#ifdef IS_REQUIRED_BORDERLINE
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
-uniform lowp vec4 borderlineColor;
-uniform lowp vec4 uActorColor;
+ UNIFORM lowp vec4 borderlineColor;
+ UNIFORM lowp vec4 uActorColor;
#endif
#ifdef IS_REQUIRED_SQUIRCLE_CORNER
-uniform highp vec4 cornerSquareness;
+ UNIFORM highp vec4 cornerSquareness;
+#endif
+};
+
+#ifdef IS_REQUIRED_BORDERLINE
+UNIFORM_BLOCK Borderline
+{
+ UNIFORM highp float borderlineWidth;
+ UNIFORM highp float borderlineOffset;
+};
#endif
#ifdef ATLAS_CUSTOM_WARP
}
#endif
- lowp float y = TEXTURE(sTexture, texCoord).r;
- lowp float u = TEXTURE(sTextureU, texCoord).r - 0.5;
- lowp float v = TEXTURE(sTextureV, texCoord).r - 0.5;
+ lowp float y = texture(sTexture, texCoord).r;
+ lowp float u = texture(sTextureU, texCoord).r - 0.5;
+ lowp float v = texture(sTextureV, texCoord).r - 0.5;
lowp vec4 rgba;
rgba.r = y + (1.403 * v);
rgba.g = y - (0.344 * u) - (0.714 * v);
// skip most potential calculate for performance
if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
{
- OUT_COLOR = textureColor;
+ gl_FragColor = textureColor;
}
else
#endif
if(gFragmentPosition.x + gFragmentPosition.y < -(gRadius + vAliasMargin) * 2.0)
{
// Do nothing.
- OUT_COLOR = textureColor;
+ gl_FragColor = textureColor;
}
else
#endif
#ifdef IS_REQUIRED_BORDERLINE
textureColor = convertBorderlineColor(textureColor);
#endif
- OUT_COLOR = textureColor;
+ gl_FragColor = textureColor;
#ifdef IS_REQUIRED_ROUNDED_CORNER
mediump float opacity = calculateCornerOpacity();
- OUT_COLOR.a *= opacity;
- OUT_COLOR.rgb *= mix(1.0, opacity, premultipliedAlpha);
+ gl_FragColor.a *= opacity;
+ gl_FragColor.rgb *= mix(1.0, opacity, premultipliedAlpha);
#endif
}
#endif
#ifdef IS_REQUIRED_DEBUG_VISUAL_SHADER
- OUT_COLOR.rgb = ApplyDebugMixColor(OUT_COLOR);
+ gl_FragColor.rgb = ApplyDebugMixColor(gl_FragColor);
#endif
}
+//@version 100
+
INPUT mediump vec2 aPosition;
OUTPUT mediump vec2 vTexCoord;
#if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER) || defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
OUTPUT highp vec2 vPosition;
-FLAT OUTPUT highp vec2 vRectSize;
-FLAT OUTPUT highp vec2 vOptRectSize;
-FLAT OUTPUT highp float vAliasMargin;
+OUTPUT flat highp vec2 vRectSize;
+OUTPUT flat highp vec2 vOptRectSize;
+OUTPUT flat highp float vAliasMargin;
#ifdef IS_REQUIRED_ROUNDED_CORNER
-FLAT OUTPUT highp vec4 vCornerRadius;
+OUTPUT flat highp vec4 vCornerRadius;
#endif
#endif
+#ifdef IS_REQUIRED_ALPHA_MASKING
+OUTPUT mediump vec2 vMaskTexCoord;
+#endif
+
#ifdef IS_REQUIRED_DEBUG_VISUAL_SHADER
#define DEBUG_EXTRA_ATTRIBUTES
#define DEBUG_EXTRA_VARYINGS
DEBUG_EXTRA_VARYINGS
#endif
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform highp vec4 pixelArea;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+ UNIFORM highp vec4 pixelArea;
#if defined(IS_REQUIRED_DEBUG_VISUAL_SHADER) || defined(IS_REQUIRED_ROUNDED_CORNER) || defined(IS_REQUIRED_BORDERLINE)
-// Be used when we calculate anti-alias range near 1 pixel.
-uniform highp vec3 uScale;
+ // Be used when we calculate anti-alias range near 1 pixel.
+ UNIFORM highp vec3 uScale;
#endif
-//Visual size and offset
-uniform highp vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
-#ifdef IS_REQUIRED_BORDERLINE
-uniform highp float borderlineWidth;
-uniform highp float borderlineOffset;
-#endif
+ // Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+
#ifdef IS_REQUIRED_ROUNDED_CORNER
-uniform highp vec4 cornerRadius;
-uniform mediump float cornerRadiusPolicy;
+ UNIFORM highp vec4 cornerRadius;
+ UNIFORM mediump float cornerRadiusPolicy;
#endif
#ifdef IS_REQUIRED_ALPHA_MASKING
-OUTPUT mediump vec2 vMaskTexCoord;
-uniform lowp float cropToMask;
-uniform mediump vec2 maskTextureRatio;
+ UNIFORM lowp float cropToMask;
+ UNIFORM mediump vec2 maskTextureRatio;
+#endif
+ UNIFORM highp vec2 extraSize;
+};
+
+#ifdef IS_REQUIRED_BORDERLINE
+UNIFORM_BLOCK Borderline
+{
+ UNIFORM highp float borderlineWidth;
+ UNIFORM highp float borderlineOffset;
+};
#endif
-uniform highp vec2 extraSize;
vec4 ComputeVertexPosition()
{
+//@name mesh-visual-normal-map-shader.frag
+
+//@version 100
+
precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
-uniform sampler2D sDiffuse;
-uniform sampler2D sNormal;
-uniform sampler2D sGloss;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec3 vLightDirection;
+INPUT mediump vec3 vHalfVector;
+UNIFORM sampler2D sDiffuse;
+UNIFORM sampler2D sNormal;
+UNIFORM sampler2D sGloss;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
- vec4 texture = texture2D( sDiffuse, vTexCoord );
- vec3 normal = normalize( texture2D( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
- vec4 glossMap = texture2D( sGloss, vTexCoord );
+ vec4 tex = TEXTURE( sDiffuse, vTexCoord );
+ vec3 normal = normalize( TEXTURE( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
+ vec4 glossMap = TEXTURE( sGloss, vTexCoord );
float lightDiffuse = max( 0.0, dot( normal, normalize( vLightDirection ) ) );
lightDiffuse = lightDiffuse * 0.5 + 0.5;
float shininess = pow ( max ( dot ( normalize( vHalfVector ), normal ), 0.0 ), 16.0 );
- gl_FragColor = vec4( texture.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a );
+ gl_FragColor = vec4( tex.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, tex.a * uColor.a );
}
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-attribute highp vec3 aTangent;
-attribute highp vec3 aBiNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+//@name mesh-visual-normal-map-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+INPUT highp vec3 aTangent;
+INPUT highp vec3 aBiNormal;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec3 vLightDirection;
+OUTPUT mediump vec3 vHalfVector;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump mat4 uModelView;
+ UNIFORM mediump mat4 uViewMatrix;
+ UNIFORM mediump mat3 uNormalMatrix;
+ UNIFORM mediump mat4 uObjectMatrix;
+ UNIFORM mediump vec3 lightPosition;
+ UNIFORM mediump vec2 uStageOffset;
//Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+ UNIFORM mediump vec2 offset;
+ UNIFORM mediump vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+};
vec4 ComputeVertexPosition()
{
+//@name mesh-visual-shader.frag
+
+//@version 100
+
precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
-uniform sampler2D sDiffuse;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec3 vIllumination;
+INPUT mediump float vSpecular;
+UNIFORM sampler2D sDiffuse;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
- vec4 texture = texture2D( sDiffuse, vTexCoord );
- gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb + vSpecular * 0.3, texture.a * uColor.a );
+ vec4 tex = TEXTURE( sDiffuse, vTexCoord );
+ gl_FragColor = vec4( vIllumination.rgb * tex.rgb * uColor.rgb + vSpecular * 0.3, tex.a * uColor.a );
}
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+//@name mesh-visual-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec3 vIllumination;
+OUTPUT mediump float vSpecular;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump mat4 uModelView;
+ UNIFORM mediump mat4 uViewMatrix;
+ UNIFORM mediump mat3 uNormalMatrix;
+ UNIFORM mediump mat4 uObjectMatrix;
+ UNIFORM mediump vec3 lightPosition;
+ UNIFORM mediump vec2 uStageOffset;
//Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+ UNIFORM mediump vec2 offset;
+ UNIFORM mediump vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+};
vec4 ComputeVertexPosition()
{
+//@name mesh-visual-simple-shader.frag
+
+//@version 100
+
precision mediump float;
-varying mediump vec3 vIllumination;
-uniform lowp vec4 uColor;
+INPUT mediump vec3 vIllumination;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
-attribute highp vec3 aPosition;
-attribute highp vec3 aNormal;
-varying mediump vec3 vIllumination;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+//@name mesh-visual-simple-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec3 aNormal;
+OUTPUT mediump vec3 vIllumination;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump mat4 uModelView;
+ UNIFORM mediump mat4 uViewMatrix;
+ UNIFORM mediump mat3 uNormalMatrix;
+ UNIFORM mediump mat4 uObjectMatrix;
+ UNIFORM mediump vec3 lightPosition;
+ UNIFORM mediump vec2 uStageOffset;
//Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+ UNIFORM mediump vec2 offset;
+ UNIFORM mediump vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+};
vec4 ComputeVertexPosition()
{
+//@name model3d-view-nrmmap-shader.frag
+
+//@version 100
+
precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
-uniform sampler2D sDiffuse;
-uniform sampler2D sNormal;
-uniform sampler2D sGloss;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec3 vLightDirection;
+INPUT mediump vec3 vHalfVector;
+UNIFORM sampler2D sDiffuse;
+UNIFORM sampler2D sNormal;
+UNIFORM sampler2D sGloss;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
- vec4 texture = texture2D( sDiffuse, vTexCoord );
- vec3 normal = normalize( texture2D( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
- vec4 glossMap = texture2D( sGloss, vTexCoord );
+ vec4 tex = TEXTURE( sDiffuse, vTexCoord );
+ vec3 normal = normalize( TEXTURE( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
+ vec4 glossMap = TEXTURE( sGloss, vTexCoord );
float lightDiffuse = max( 0.0, dot( normal, normalize(vLightDirection) ) );
lightDiffuse = lightDiffuse * 0.5 + 0.5;
float shininess = pow (max (dot (normalize( vHalfVector ), normal), 0.0), 16.0);
- gl_FragColor = vec4( texture.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a);
+ gl_FragColor = vec4( tex.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, tex.a * uColor.a);
}
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-attribute highp vec3 aTangent;
-attribute highp vec3 aBiNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vLightDirection;
-varying mediump vec3 vHalfVector;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 uLightPosition;
+//@name model3d-view-nrmmap-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+INPUT highp vec3 aTangent;
+INPUT highp vec3 aBiNormal;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec3 vLightDirection;
+OUTPUT mediump vec3 vHalfVector;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump mat4 uModelView;
+ UNIFORM mediump mat3 uNormalMatrix;
+ UNIFORM mediump mat4 uObjectMatrix;
+ UNIFORM mediump vec3 uLightPosition;
+};
void main()
{
+//@name model3d-view-shader.frag
+
+//@version 100
+
precision mediump float;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
-uniform sampler2D sDiffuse;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec3 vIllumination;
+INPUT mediump float vSpecular;
+UNIFORM sampler2D sDiffuse;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
- vec4 texture = texture2D( sDiffuse, vTexCoord );
+ vec4 texture = TEXTURE( sDiffuse, vTexCoord );
gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb + vSpecular * 0.3, texture.a * uColor.a);
}
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-varying mediump vec2 vTexCoord;
-varying mediump vec3 vIllumination;
-varying mediump float vSpecular;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 uLightPosition;
+//@name model3d-view-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec3 vIllumination;
+OUTPUT mediump float vSpecular;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump mat4 uModelView;
+ UNIFORM mediump mat3 uNormalMatrix;
+ UNIFORM mediump mat4 uObjectMatrix;
+ UNIFORM mediump vec3 uLightPosition;
+};
void main()
{
+//@name model3d-view-simple-shader.frag
+
+//@version 100
+
precision mediump float;
-varying mediump vec3 vIllumination;
-uniform lowp vec4 uColor;
+INPUT mediump vec3 vIllumination;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-varying mediump vec3 vIllumination;
-uniform mediump vec3 uSize;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 uLightPosition;
+//@name model3d-view-simple-shader.vert
+
+//@version 100
+
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+OUTPUT mediump vec3 vIllumination;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump mat4 uModelView;
+ UNIFORM mediump mat3 uNormalMatrix;
+ UNIFORM mediump mat4 uObjectMatrix;
+ UNIFORM mediump vec3 uLightPosition;
+};
void main()
{
+//@name motion-blur-effect.frag
+
+//@version 100
+
precision mediump float;
-uniform sampler2D sTexture;
-uniform vec4 uColor;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM vec4 uColor;
-uniform vec2 uObjectFadeStart;
-uniform vec2 uObjectFadeEnd;
-uniform float uAlphaScale;
-uniform float uBlurTexCoordScale;
-uniform float uNumSamples;
-uniform float uRecipNumSamples;
-uniform float uRecipNumSamplesMinusOne;
+ UNIFORM vec2 uObjectFadeStart;
+ UNIFORM vec2 uObjectFadeEnd;
+ UNIFORM float uAlphaScale;
+ UNIFORM float uBlurTexCoordScale;
+ UNIFORM float uNumSamples;
+ UNIFORM float uRecipNumSamples;
+ UNIFORM float uRecipNumSamplesMinusOne;
+};
// inputs
-varying vec2 vModelSpaceCenterToPos;
-varying vec2 vScreenSpaceVelocityVector;
-varying float vSpeed;
-varying vec2 vTexCoord;
+INPUT vec2 vModelSpaceCenterToPos;
+INPUT vec2 vScreenSpaceVelocityVector;
+INPUT float vSpeed;
+INPUT vec2 vTexCoord;
void main()
{
vec2 velocity = vScreenSpaceVelocityVector * uBlurTexCoordScale;
// standard actor texel
- vec4 colActor = texture2D(sTexture, vTexCoord);
+ vec4 colActor = TEXTURE(sTexture, vTexCoord);
// blurred actor - gather texture samples from the actor texture in the direction of motion
vec4 col = colActor * uRecipNumSamples;
for(float i = 1.0; i < uNumSamples; i += 1.0)
{
float t = i * uRecipNumSamplesMinusOne;
- col += texture2D(sTexture, vTexCoord + (velocity * t)) * uRecipNumSamples;
+ col += TEXTURE(sTexture, vTexCoord + (velocity * t)) * uRecipNumSamples;
}
gl_FragColor = mix(colActor, col, vSpeed); // lerp blurred and non-blurred actor based on speed of motion
gl_FragColor.a = fadeToEdgesScale;//colActor.a * fadeToEdgesScale; // fade blurred actor to its edges based on speed of motion
+//@name motion-blur-effect.vert
+
+//@version 100
+
precision mediump float;
-attribute vec2 aPosition;
+INPUT vec2 aPosition;
+
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mat4 uMvpMatrix;
+ UNIFORM mat4 uModelView;
+ UNIFORM mat4 uViewMatrix;
+ UNIFORM mat4 uProjection;
+ UNIFORM vec3 uSize;
-uniform mat4 uMvpMatrix;
-uniform mat4 uModelView;
-uniform mat4 uViewMatrix;
-uniform mat4 uProjection;
-uniform vec3 uSize;
+ UNIFORM mat4 uModelLastFrame;
+ UNIFORM float uGeometryStretchFactor;
+ UNIFORM float uSpeedScalingFactor;
+};
-uniform mat4 uModelLastFrame;
float timeDelta = 0.0167;
-uniform float uGeometryStretchFactor;
-uniform float uSpeedScalingFactor;
// outputs
-varying vec2 vModelSpaceCenterToPos;
-varying vec2 vScreenSpaceVelocityVector;
-varying float vSpeed;
-varying vec2 vTexCoord;
+OUTPUT vec2 vModelSpaceCenterToPos;
+OUTPUT vec2 vScreenSpaceVelocityVector;
+OUTPUT float vSpeed;
+OUTPUT vec2 vTexCoord;
void main()
{
+//@name motion-stretch-effect.frag
+
+//@version 100
+
precision mediump float;
-uniform sampler2D sTexture;
-uniform vec4 uColor;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM vec4 uColor;
-uniform vec2 uObjectFadeStart;
-uniform vec2 uObjectFadeEnd;
-uniform float uAlphaScale;
+ UNIFORM vec2 uObjectFadeStart;//@blah
+ UNIFORM vec2 uObjectFadeEnd;//@input
+ UNIFORM float uAlphaScale;//@output
+};
// inputs
-varying vec2 vModelSpaceCenterToPos;
-varying vec2 vScreenSpaceVelocityVector;
-varying float vSpeed;
-varying vec2 vTexCoord;
+INPUT vec2 vModelSpaceCenterToPos;//@version
+INPUT vec2 vScreenSpaceVelocityVector; //@Notjhing
+INPUT float vSpeed;
+INPUT vec2 vTexCoord;
void main()
{
fadeToEdgesScale = mix(1.0, fadeToEdgesScale, vSpeed); // fade proportional to speed, so opaque when at rest
// standard actor texel
- vec4 colActor = texture2D(sTexture, vTexCoord);
+ vec4 colActor = TEXTURE(sTexture, vTexCoord);
gl_FragColor = colActor;
gl_FragColor.a *= fadeToEdgesScale; // fade actor to its edges based on speed of motion
gl_FragColor *= uColor;
+//@name motion-stretch-effect.vert
+
+//@version 100
+
precision mediump float;
-attribute vec2 aPosition;
+INPUT vec2 aPosition;//Stuff, things
+
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mat4 uMvpMatrix;
+ UNIFORM mat4 uModelView;
+ UNIFORM mat4 uViewMatrix;
+ UNIFORM mat4 uProjection;
+ UNIFORM vec3 uSize;
+
+ UNIFORM mat4 uModelLastFrame;
-uniform mat4 uMvpMatrix;
-uniform mat4 uModelView;
-uniform mat4 uViewMatrix;
-uniform mat4 uProjection;
-uniform vec3 uSize;
+ UNIFORM float uGeometryStretchFactor;
+ UNIFORM float uSpeedScalingFactor;
+};
-uniform mat4 uModelLastFrame;
float timeDelta = 0.0167;
-uniform float uGeometryStretchFactor;
-uniform float uSpeedScalingFactor;
// outputs
-varying vec2 vModelSpaceCenterToPos;
-varying vec2 vScreenSpaceVelocityVector;
-varying float vSpeed;
-varying vec2 vTexCoord;
+OUTPUT vec2 vModelSpaceCenterToPos;
+OUTPUT vec2 vScreenSpaceVelocityVector;
+OUTPUT float vSpeed;
+OUTPUT vec2 vTexCoord;
void main()
{
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vMaskTexCoord;
-
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform highp vec2 uFixed[3];
-uniform highp vec2 uStretchTotal;
-
-//Visual size and offset
-uniform highp vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
-uniform highp vec2 extraSize;
+//@name npatch-visual-3x3-shader.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec2 vMaskTexCoord;
+
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+ UNIFORM highp vec2 uFixed[3];
+ UNIFORM highp vec2 uStretchTotal;
+ //Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+ UNIFORM highp vec2 extraSize;
+};
void main()
{
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vMaskTexCoord;
-uniform sampler2D sTexture;
-uniform sampler2D sMask;
-uniform lowp vec4 uColor;
-uniform lowp float premultipliedAlpha;
-uniform mediump float auxiliaryImageAlpha;
+//@name npatch-visual-mask-shader.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec2 vMaskTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM sampler2D sMask;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM lowp float premultipliedAlpha;
+ UNIFORM mediump float auxiliaryImageAlpha;
+};
void main()
{
// where mask is translucent, less of background should be shown.
// auxiliaryImageAlpha controls how much of mask is visible
- mediump vec4 color = texture2D(sTexture, vTexCoord);
- mediump vec4 mask = texture2D(sMask, vMaskTexCoord);
+ mediump vec4 color = TEXTURE(sTexture, vTexCoord);
+ mediump vec4 mask = TEXTURE(sMask, vMaskTexCoord);
mediump float maskAlpha = mask.a * auxiliaryImageAlpha;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
+//@name npatch-visual-shader.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
}
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-varying mediump vec2 vMaskTexCoord;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-uniform highp vec2 uNinePatchFactorsX[FACTOR_SIZE_X];
-uniform highp vec2 uNinePatchFactorsY[FACTOR_SIZE_Y];
-
-// Visual size and offset
-uniform highp vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
-uniform highp vec2 extraSize;
+//@name npatch-visual-shader.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec2 vMaskTexCoord;
+
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+ UNIFORM highp vec2 uNinePatchFactorsX[FACTOR_SIZE_X];
+ UNIFORM highp vec2 uNinePatchFactorsY[FACTOR_SIZE_Y];
+ // Visual size and offset
+ UNIFORM highp vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+ UNIFORM highp vec2 extraSize;
+};
void main()
{
+//@name page-turn-book-spine-effect.frag
+
+//@version 100
+
precision mediump float;
-varying mediump vec2 vTexCoord;
-uniform vec3 uSize;
-uniform vec2 uSpineShadowParameter;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM vec2 uSpineShadowParameter;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+UNIFORM vec3 uSize;
+};
void main()
{
if( gl_FrontFacing ) // display front side
{
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
}
else // display back side, flip the image horizontally by changing the x component of the texture coordinate
{
- gl_FragColor = texture2D( sTexture, vec2( 1.0 - vTexCoord.x, vTexCoord.y ) ) * uColor;
+ gl_FragColor = TEXTURE( sTexture, vec2( 1.0 - vTexCoord.x, vTexCoord.y ) ) * uColor;
}
// display book spine, a stripe of shadowed texture
float pixelPos = vTexCoord.x * uSize.x;
+//@name page-turn-book-spine-effect.vert
+
+//@version 100
+
precision mediump float;
-attribute mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
-uniform vec3 uSize;
-uniform float uTextureWidth;
-varying vec2 vTexCoord;
+INPUT mediump vec2 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM float uTextureWidth;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+UNIFORM vec3 uSize;
+};
+
+OUTPUT vec2 vTexCoord;
void main()
{
+//@name page-turn-effect.frag
+
+//@version 100
+
precision mediump float;
-varying mediump vec2 vTexCoord;
+INPUT mediump vec2 vTexCoord;
+
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM vec2 uSpineShadowParameter;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+ UNIFORM vec3 uSize;
+};
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
-uniform vec3 uSize;
-uniform vec2 uSpineShadowParameter;
-varying vec3 vNormal;
-varying vec4 vPosition;
+INPUT vec3 vNormal;
+INPUT vec4 vPosition;
void main()
{
// display page content
vec4 texel;
// display back image of the page, flip the texture
- if( dot(vPosition.xyz, normal) > 0.0 ) texel = texture2D( sTexture, vec2( 1.0 - vTexCoord.x, vTexCoord.y ) );
+ if( dot(vPosition.xyz, normal) > 0.0 ) texel = TEXTURE( sTexture, vec2( 1.0 - vTexCoord.x, vTexCoord.y ) );
// display front image of the page
- else texel = texture2D( sTexture, vTexCoord );
+ else texel = TEXTURE( sTexture, vTexCoord );
// display book spine, a stripe of shadowed texture
float pixelPos = vTexCoord.x * uSize.x;
+//@name page-turn-effect.vert
+
+//@version 100
+
/*
* The common parameters for all the vertices, calculate in CPU then pass into the shader as uniforms
*
precision mediump float;
-attribute mediump vec2 aPosition;
+INPUT mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uModelView;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump mat3 uNormalMatrix;
+ UNIFORM mediump mat4 uModelView;
-uniform mat4 uCommonParameters;
+ UNIFORM mat4 uCommonParameters;
-uniform vec3 uSize;
-uniform float uIsTurningBack;
-uniform float uTextureWidth;
-varying vec3 vNormal;
-varying vec4 vPosition;
-varying mediump vec2 vTexCoord;
+ UNIFORM float uIsTurningBack;
+ UNIFORM float uTextureWidth;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+ UNIFORM vec3 uSize;
+};
+
+OUTPUT vec3 vNormal;
+OUTPUT vec4 vPosition;
+OUTPUT mediump vec2 vTexCoord;
void main()
{
}
vNormal = uNormalMatrix * normal;
gl_Position = uMvpMatrix * position;
- // varying parameters for fragment shader
+
+ // out parameters for fragment shader
vTexCoord = aPosition + vec2(0.5);
vTexCoord.x /= uTextureWidth;
vPosition = uModelView * position;
+//@name primitive-visual-shader.frag
+
+//@version 100
+
//Very simple fragment shader that merely applies the vertex shading to the color at each fragment.
precision mediump float;
-varying mediump vec3 vIllumination;
-uniform lowp vec4 uColor;
+INPUT mediump vec3 vIllumination;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
+//@name primitive-visual-shader.vert
+
+//@version 100
+
//A simple shader that applies diffuse lighting to a mono-coloured object.
-attribute highp vec3 aPosition;
-attribute highp vec2 aTexCoord;
-attribute highp vec3 aNormal;
-varying mediump vec3 vIllumination;
-uniform mediump vec3 uSize;
-uniform mediump vec3 uObjectDimensions;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelView;
-uniform mediump mat4 uViewMatrix;
-uniform mediump mat3 uNormalMatrix;
-uniform mediump mat4 uObjectMatrix;
-uniform mediump vec3 lightPosition;
-uniform mediump vec2 uStageOffset;
+INPUT highp vec3 aPosition;
+INPUT highp vec2 aTexCoord;
+INPUT highp vec3 aNormal;
+OUTPUT mediump vec3 vIllumination;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump vec3 uSize;
+ UNIFORM mediump vec3 uObjectDimensions;
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump mat4 uModelView;
+ UNIFORM mediump mat4 uViewMatrix;
+ UNIFORM mediump mat3 uNormalMatrix;
+ UNIFORM mediump mat4 uObjectMatrix;
+ UNIFORM mediump vec3 lightPosition;
+ UNIFORM mediump vec2 uStageOffset;
//Visual size and offset
-uniform mediump vec2 offset;
-uniform mediump vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+ UNIFORM mediump vec2 offset;
+ UNIFORM mediump vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+};
vec4 ComputeVertexPosition()
{
+//@name render-effect.frag
+
+//@version 100
+
precision highp float;
-varying highp vec2 vTexCoord;
-varying highp vec2 vOptRectSize;
-varying highp vec4 vCornerRadius;
+INPUT highp vec2 vTexCoord;
+INPUT highp vec2 vOptRectSize;
+INPUT highp vec4 vCornerRadius;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM highp vec4 uCornerSquareness;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+ UNIFORM highp vec3 uSize;
+};
-uniform lowp vec4 uColor;
-uniform highp vec3 uSize;
-uniform highp vec4 uCornerSquareness;
-uniform sampler2D sTexture;
+UNIFORM sampler2D sTexture;
highp float nrand(const in vec2 uv)
{
void main()
{
- gl_FragColor = texture2D(sTexture, vTexCoord) * uColor;
+ gl_FragColor = TEXTURE(sTexture, vTexCoord) * uColor;
gl_FragColor.rgb = applyDithering(gl_FragColor.rgb);
highp vec2 location = (vTexCoord.xy - vec2(0.5)) * uSize.xy;
+//@name render-effect.vert
+
+//@version 100
+
precision highp float;
-attribute highp vec2 aPosition;
+INPUT highp vec2 aPosition;
-varying highp vec2 vTexCoord;
-varying highp vec2 vOptRectSize;
-varying highp vec4 vCornerRadius; //output
+OUTPUT highp vec2 vTexCoord;
+OUTPUT highp vec2 vOptRectSize;
+OUTPUT highp vec4 vCornerRadius; //output
-uniform highp mat4 uMvpMatrix;
-uniform highp vec4 uCornerRadius; //input
-uniform lowp float uCornerRadiusPolicy;
-uniform highp vec3 uSize;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec4 uCornerRadius;//input
+ UNIFORM lowp float uCornerRadiusPolicy;
+};
+
+UNIFORM_BLOCK SharedBlock
+{
+UNIFORM highp vec3 uSize;
+};
void main()
{
-varying mediump vec2 vTexCoord;
-uniform lowp vec4 uShadowColor;
-uniform sampler2D sTexture;
+//@name shadow-view-render-shader.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uShadowColor;
+};
+UNIFORM sampler2D sTexture;
void main()
{
lowp float alpha;
- alpha = texture2D(sTexture, vec2(vTexCoord.x, vTexCoord.y)).a;
+ alpha = TEXTURE(sTexture, vec2(vTexCoord.x, vTexCoord.y)).a;
gl_FragColor = vec4(uShadowColor.rgb, uShadowColor.a * alpha);
}
\ No newline at end of file
-attribute mediump vec2 aPosition;
-uniform mediump mat4 uMvpMatrix;
-uniform mediump mat4 uModelMatrix;
-uniform vec3 uSize;
-varying vec2 vTexCoord;
+//@name shadow-view-render-shader.vert
-uniform mediump mat4 uLightCameraProjectionMatrix;
-uniform mediump mat4 uLightCameraViewMatrix;
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT vec2 vTexCoord;
+
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump mat4 uMvpMatrix;
+ UNIFORM mediump mat4 uModelMatrix;
+ UNIFORM vec3 uSize;
+ UNIFORM mediump mat4 uLightCameraProjectionMatrix;
+ UNIFORM mediump mat4 uLightCameraViewMatrix;
+};
void main()
{
+//@name spread-filter-shader.frag
+
+//@version 100
+
precision highp float;
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform int uSpread;
-uniform vec2 uTexScale;
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM int uSpread;
+ UNIFORM vec2 uTexScale;
+};
void main()
{
- vec4 color = texture2D( sTexture, vTexCoord);
+ vec4 color = TEXTURE( sTexture, vTexCoord);
for( int i = 1; i <= uSpread; ++i )
{
vec2 offset = uTexScale * float(i);
- color = max( texture2D( sTexture, vTexCoord + offset), color );
- color = max( texture2D( sTexture, vTexCoord - offset), color );
+ color = max( TEXTURE( sTexture, vTexCoord + offset), color );
+ color = max( TEXTURE( sTexture, vTexCoord - offset), color );
}
gl_FragColor = color;
}
\ No newline at end of file
-varying mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
-uniform lowp float uAlpha;
+//@name super-blur-view.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM lowp float uAlpha;
+};
void main()
{
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
gl_FragColor.a *= uAlpha;
}
-uniform lowp vec4 uColor;
-uniform lowp vec4 textColorAnimatable;
-uniform sampler2D sTexture;
-varying mediump vec2 vTexCoord;
-varying mediump vec4 vColor;
+//@name text-atlas-l8-shader.frag
+
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM lowp vec4 textColorAnimatable;
+};
+UNIFORM sampler2D sTexture;
+INPUT mediump vec2 vTexCoord;
+INPUT mediump vec4 vColor;
void main()
{
- mediump vec4 color = texture2D( sTexture, vTexCoord );
+ mediump vec4 color = TEXTURE( sTexture, vTexCoord );
gl_FragColor = vec4( vColor.rgb * uColor.rgb * textColorAnimatable.rgb, uColor.a * vColor.a * textColorAnimatable.a * color.r );
}
-uniform lowp vec4 uColor;
-uniform lowp vec4 textColorAnimatable;
-uniform sampler2D sTexture;
-varying mediump vec2 vTexCoord;
+//@name text-atlas-rgba-shader.frag
+
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+ UNIFORM lowp vec4 textColorAnimatable;
+};
+UNIFORM sampler2D sTexture;
+INPUT mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * textColorAnimatable;
+ gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor * textColorAnimatable;
}
-attribute highp vec2 aPosition;
-attribute mediump vec2 aTexCoord;
-attribute mediump vec4 aColor;
-uniform mediump vec2 uOffset;
-uniform highp mat4 uMvpMatrix;
-varying mediump vec2 vTexCoord;
-varying mediump vec4 vColor;
+//@name text-atlas-shader.vert
+
+//@version 100
+
+INPUT highp vec2 aPosition;
+INPUT mediump vec2 aTexCoord;
+INPUT mediump vec4 aColor;
+
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM mediump vec2 uOffset;
+ UNIFORM highp mat4 uMvpMatrix;
+};
+OUTPUT mediump vec2 vTexCoord;
+OUTPUT mediump vec4 vColor;
void main()
{
-varying mediump vec4 vColor;
-uniform lowp vec4 uColor;
+//@name text-controller-background-shader.frag
+
+//@version 100
+
+INPUT mediump vec4 vColor;
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
-attribute mediump vec2 aPosition;
-attribute mediump vec4 aColor;
-varying mediump vec4 vColor;
-uniform highp mat4 uMvpMatrix;
+//@name text-controller-background-shader.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+INPUT mediump vec4 aColor;
+OUTPUT mediump vec4 vColor;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+};
void main()
{
-uniform lowp vec4 uColor;
+//@name text-decorator-shader.frag
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
gl_FragColor = uColor;
-attribute mediump vec2 aPosition;
-uniform highp mat4 uMvpMatrix;
+//@name text-decorator-shader.vert
+//@version 100
+
+INPUT mediump vec2 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+};
void main()
{
mediump vec4 position = vec4( aPosition, 0.0, 1.0 );
-varying highp vec2 vTexCoord;
-uniform sampler2D sTexture;
-uniform lowp vec4 uColor;
+//@name text-scroller-shader.frag
+
+//@version 100
+
+INPUT highp vec2 vTexCoord;
+UNIFORM sampler2D sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
if ( vTexCoord.y > 1.0 )
discard;
- mediump vec4 textTexture = texture2D( sTexture, vTexCoord );
+ mediump vec4 textTexture = TEXTURE( sTexture, vTexCoord );
gl_FragColor = textTexture * uColor;
}
-attribute mediump vec2 aPosition;
-varying highp vec2 vTexCoord;
-uniform highp vec3 uSize;
-uniform highp float uDelta;
-uniform mediump vec2 uTextureSize;
-uniform highp float uGap;
-uniform mediump float uHorizontalAlign;
-uniform mediump float uVerticalAlign;
+//@name text-scroller-shader.vert
-uniform highp mat4 uMvpMatrix;
+//@version 100
-//Visual size and offset
-uniform mediump vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+INPUT mediump vec2 aPosition;
+OUTPUT highp vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp vec3 uSize;
+ UNIFORM highp float uDelta;
+ UNIFORM mediump vec2 uTextureSize;
+ UNIFORM highp float uGap;
+ UNIFORM mediump float uHorizontalAlign;
+ UNIFORM mediump float uVerticalAlign;
+ UNIFORM highp mat4 uMvpMatrix;
+
+ //Visual size and offset
+ UNIFORM mediump vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+};
void main()
{
highp vec2 visualSize = mix(size * uSize.xy, size, offsetSizeMode.zw);
+//@name text-visual-shader.frag
+
+//@version 100
+
INPUT mediump vec2 vTexCoord;
-uniform sampler2D sTexture;
+UNIFORM sampler2D sTexture;
#ifdef IS_REQUIRED_STYLE
-uniform sampler2D sStyle;
+UNIFORM sampler2D sStyle;
#endif
#ifdef IS_REQUIRED_OVERLAY
-uniform sampler2D sOverlayStyle;
+UNIFORM sampler2D sOverlayStyle;
#endif
+
#ifdef IS_REQUIRED_MULTI_COLOR
#elif defined(IS_REQUIRED_EMOJI)
// Single color with emoji.
-uniform sampler2D sMask;
-uniform lowp float uHasMultipleTextColors;
+UNIFORM sampler2D sMask;
#endif
-uniform lowp vec4 uTextColorAnimatable;
-uniform lowp vec4 uColor;
+UNIFORM_BLOCK FragBlock
+{
+ #ifdef IS_REQUIRED_MULTI_COLOR
+ #elif defined(IS_REQUIRED_EMOJI)
+ // Single color with emoji.
+ UNIFORM lowp float uHasMultipleTextColors;
+ #endif
+ UNIFORM lowp vec4 uTextColorAnimatable;
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
#ifdef IS_REQUIRED_STYLE
#endif
// Draw the text as overlay above the style
- OUT_COLOR = uColor * (
+ gl_FragColor = uColor * (
#ifdef IS_REQUIRED_OVERLAY
(
#endif
-INPUT mediump vec2 aPosition;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+//@name text-visual-shader.vert
+
+//@version 100
+INPUT mediump vec2 aPosition;
OUTPUT mediump vec2 vTexCoord;
-//Visual size and offset
-uniform mediump vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+
+ //Visual size and offset
+ UNIFORM mediump vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+};
vec4 ComputeVertexPosition()
{
-uniform lowp vec4 uColor;
-varying mediump vec2 vTexCoord;
-uniform samplerExternalOES sTexture;
+//@name video-view-texture.frag
+
+//@version 100
+
+INPUT mediump vec2 vTexCoord;
+UNIFORM samplerExternalOES sTexture;
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
- gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
}
-attribute mediump vec2 aPosition;
-varying mediump vec2 vTexCoord;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
-varying mediump vec2 sTexCoordRect;
+//@name video-view-texture.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+OUTPUT mediump vec2 vTexCoord;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+};
+OUTPUT mediump vec2 sTexCoordRect;
void main()
{
+//@name video-view.frag
+
+//@version 100
+
void main()
{
gl_FragColor = vec4(0.0);
-attribute mediump vec2 aPosition;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+//@name video-view.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
+};
void main()
{
-uniform lowp vec4 uColor;
+//@name wireframe-visual-shader.frag
+
+//@version 100
+
+UNIFORM_BLOCK FragBlock
+{
+ UNIFORM lowp vec4 uColor;
+};
void main()
{
-attribute mediump vec2 aPosition;
-uniform highp mat4 uMvpMatrix;
-uniform highp vec3 uSize;
+//@name wireframe-visual-shader.vert
+
+//@version 100
+
+INPUT mediump vec2 aPosition;
+UNIFORM_BLOCK VertBlock
+{
+ UNIFORM highp mat4 uMvpMatrix;
+ UNIFORM highp vec3 uSize;
//Visual size and offset
-uniform mediump vec2 offset;
-uniform highp vec2 size;
-uniform mediump vec4 offsetSizeMode;
-uniform mediump vec2 origin;
-uniform mediump vec2 anchorPoint;
+ UNIFORM mediump vec2 offset;
+ UNIFORM highp vec2 size;
+ UNIFORM mediump vec4 offsetSizeMode;
+ UNIFORM mediump vec2 origin;
+ UNIFORM mediump vec2 anchorPoint;
+};
vec4 ComputeVertexPosition()
{
projects / platform / core / uifw / dali-toolkit.git / commitdiff