-//@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;
-#endif
+uniform sampler2D sAlbedoAlpha;
+uniform float uBaseColorTextureTransformAvailable;
+uniform mat3 uBaseColorTextureTransform;
+#endif // BASECOLOR_TEX
#ifdef METALLIC_ROUGHNESS_TEX
-UNIFORM sampler2D sMetalRoughness;
-#endif
+uniform sampler2D sMetalRoughness;
+uniform float uMetalRoughnessTextureTransformAvailable;
+uniform mat3 uMetalRoughnessTextureTransform;
+#endif // METALLIC_ROUGHNESS_TEX
#ifdef NORMAL_TEX
-UNIFORM sampler2D sNormal;
-#endif
-#else
-UNIFORM sampler2D sAlbedoMetal;
-UNIFORM sampler2D sNormalRoughness;
+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;
#endif
+
+
#ifdef OCCLUSION
-UNIFORM sampler2D sOcclusion;
+uniform sampler2D sOcclusion;
+uniform float uOcclusionTextureTransformAvailable;
+uniform mat3 uOcclusionTextureTransform;
+uniform float uOcclusionStrength;
#endif
#ifdef EMISSIVE_TEXTURE
-UNIFORM sampler2D sEmissive;
+uniform sampler2D sEmissive;
+uniform float uEmissiveTextureTransformAvailable;
+uniform mat3 uEmissiveTextureTransform;
#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 uIsShadowReceiving;
+uniform lowp int uIsShadowEnabled;
+uniform sampler2D sShadowMap;
+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 float uIblIntensity;
- UNIFORM float uMaxLOD;
+uniform sampler2D sbrdfLUT;
+uniform samplerCube sDiffuseEnvSampler;
+uniform samplerCube sSpecularEnvSampler;
+uniform float uIblIntensity;
+uniform mediump vec3 uYDirection;
+uniform float uMaxLOD;
// For Alpha Mode.
- 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;
-};
-
+uniform lowp float uOpaque;
+uniform lowp float uMask;
+uniform lowp float uAlphaThreshold;
// TODO: Multiple texture coordinate will be supported.
INPUT mediump vec2 vUV;
-INPUT highp mat3 vTBN;
+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;
- gl_FragColor = vec4(pow(color, vec3(1.0 / 2.2)), baseColor.a) * uColor;
+ OUT_COLOR = 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;
-#endif
-
-UNIFORM_BLOCK VertBlock0
-{
-#ifdef MORPH
+uniform highp sampler2D sBlendShapeGeometry;
#ifdef SL_VERSION_LOW
- UNIFORM int uBlendShapeGeometryWidth;
- UNIFORM int uBlendShapeGeometryHeight;
+uniform int uBlendShapeGeometryWidth;
+uniform int uBlendShapeGeometryHeight;
#endif
#endif
- UNIFORM highp mat4 uViewMatrix;
- UNIFORM highp mat3 uNormalMatrix;
- UNIFORM highp mat4 uModelMatrix;
- UNIFORM highp mat4 uProjection;
+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;
#ifdef SKINNING
#ifdef SL_VERSION_LOW
- #define MAX_BONES 80
- UNIFORM highp mat4 uBone[MAX_BONES];
+#define MAX_BONES 80
+uniform highp mat4 uBone[MAX_BONES];
+#else
+#define MAX_BONES 256
+layout(std140) uniform Bones
+{
+ 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 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
+uniform lowp int uIsShadowEnabled;
+uniform highp mat4 uShadowLightViewProjectionMatrix;
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_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+uniform lowp vec4 uColor;
FLAT INPUT float vColor;
void main()
{
vec3 rgb = vec3(fract(vColor), fract(vColor * 0.00390625), fract(vColor * 0.00390625 * 0.00390625));
- gl_FragColor = vec4(rgb, 1.) * uColor;
+ OUT_COLOR = vec4(rgb, 1.) * uColor;
}
\ No newline at end of file
-//@version 100
precision mediump float;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM mat4 uMvpMatrix;
-};
+uniform mat4 uMvpMatrix;
INPUT vec3 aPosition;
INPUT float aColor;
FLAT OUTPUT float vColor;
-//@version 100
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColorFactor;// Color from material
- UNIFORM lowp float uMask;
- UNIFORM lowp float uAlphaThreshold;
- UNIFORM int uIsShadowCasting;
-};
+uniform lowp vec4 uColorFactor; // Color from material
+uniform lowp float uMask;
+uniform lowp float uAlphaThreshold;
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;
-#endif
-
-#ifdef SKINNING
-#ifndef SL_VERSION_LOW
-#define MAX_BONES 256
-UNIFORM_BLOCK Bones
-{
- UNIFORM mat4 uBone[MAX_BONES];
-};
+uniform highp sampler2D sBlendShapeGeometry;
+#ifdef SL_VERSION_LOW
+uniform int uBlendShapeGeometryWidth;
+uniform int uBlendShapeGeometryHeight;
#endif
#endif
OUTPUT mediump vec2 vUV;
OUTPUT lowp vec4 vColor;
-UNIFORM_BLOCK VertBlock
-{
-#ifdef MORPH
-#ifdef SL_VERSION_LOW
- UNIFORM int uBlendShapeGeometryWidth;
- UNIFORM int uBlendShapeGeometryHeight;
-#endif
-#endif
-
- UNIFORM highp mat4 uViewMatrix;
- UNIFORM highp mat4 uModelMatrix;
- UNIFORM highp mat4 uProjection;
+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];
+uniform mat4 uBone[MAX_BONES];
+#else
+#define MAX_BONES 256
+layout(std140) uniform Bones
+{
+ 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_BLOCK FragBlock
-{
- UNIFORM vec4 uColor;
- UNIFORM float uIntensity;
-};
+uniform vec4 uColor;
+uniform float uIntensity;
-INPUT vec3 vTexCoord;
+varying vec3 vTexCoord;
// Take the sample direction as interpolated from the cube's local position,
// and use this direction vector and the spherical to cartesian coordinate
// Flip the texture UVs vertically
vec2 uvFlippped = vec2(uv.x, 1.0 - uv.y);
- vec4 texColor = TEXTURE( uSkyBoxEquirectangularTexture, uvFlippped ) * uIntensity;
+ vec4 texColor = texture2D( uSkyBoxEquirectangularTexture, uvFlippped ) * uIntensity;
gl_FragColor = texColor * uColor;
}
-//@version 100
-
-UNIFORM samplerCube uSkyBoxTexture;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
- UNIFORM mediump float uIntensity;
-};
-
-INPUT mediump vec3 vTexCoord;
+uniform samplerCube uSkyBoxTexture;
+uniform lowp vec4 uColor;
+uniform mediump float uIntensity;
+varying mediump vec3 vTexCoord;
void main()
{
- mediump vec4 texColor = TEXTURE_CUBE(uSkyBoxTexture, vTexCoord) * uIntensity;
+ mediump vec4 texColor = textureCube(uSkyBoxTexture, vTexCoord) * uIntensity;
gl_FragColor = texColor * uColor;
}
\ No newline at end of file
-//@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;
+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;
void main()
{
-//@version 100
-
-INPUT mediump vec2 vTexCoord;
-
-UNIFORM sampler2D sTexture;
-
-UNIFORM_BLOCK FragBlock
-{
-UNIFORM lowp vec4 uColor;
-};
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform lowp vec4 uColor;
void main()
{
-//@name animated-gradient-visual-shader.frag
-
-//@version 100
-
precision mediump float;
-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;
+uniform mediump vec4 start_color;
+uniform mediump vec4 end_color;
+uniform mediump float gradient_offset;
+
+varying mediump vec2 vTexCoord;
+varying mediump vec2 vStart;
+varying mediump vec2 vEnd;
float get_position(vec2 x, vec2 s, vec2 e)
{
-//@name animated-gradient-visual-shader.vert
+attribute mediump vec2 aPosition;
+uniform highp mat4 uMvpMatrix;
+uniform highp vec3 uSize;
-//@version 100
+uniform mediump vec2 start_point;
+uniform mediump vec2 end_point;
+uniform mediump vec2 rotate_center;
+uniform mediump float rotate_angle;
-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;
+varying mediump vec2 vTexCoord;
+varying mediump vec2 vStart;
+varying mediump vec2 vEnd;
vec2 rotate(vec2 x, vec2 c, float a)
{
}
//Visual size and offset
-UNIFORM_BLOCK VisualBlock
-{
- 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 arc-visual-butt-cap-shader.frag
-
-//@version 100
-
INPUT mediump vec2 vPosition;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM lowp vec4 uColor;
- UNIFORM mediump float thickness;
- UNIFORM mediump float radius;
- UNIFORM mediump float startAngle;
- UNIFORM mediump float sweepAngle;
-};
+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()
{
- gl_FragColor = uColor;
- gl_FragColor.a *= GetOpacity();
+ OUT_COLOR = uColor;
+ OUT_COLOR.a *= GetOpacity();
}
-//@name arc-visual-round-cap-shader.frag
-
-//@version 100
-
INPUT mediump vec2 vPosition;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
- UNIFORM mediump float thickness;
- UNIFORM mediump float radius;
- UNIFORM mediump float startAngle;
- UNIFORM mediump float sweepAngle;
-};
+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()
{
- gl_FragColor = uColor;
- gl_FragColor.a *= GetOpacity();
+ OUT_COLOR = uColor;
+ OUT_COLOR.a *= GetOpacity();
}
\ No newline at end of file
-//@name arc-visual-shader.vert
-
-//@version 100
-
INPUT mediump vec2 aPosition;
OUTPUT mediump vec2 vPosition;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM highp mat4 uMvpMatrix;
- UNIFORM highp vec3 uSize;
+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;
-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;
-};
+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;
vec4 ChangeSaturation(vec4 col, float sat)
{
{
mediump vec4 image;
mediump vec4 bloom;
- image = TEXTURE(sTexture, vTexCoord);
- bloom = TEXTURE(sEffect, vTexCoord);
+ image = texture2D(sTexture, vTexCoord);
+ bloom = texture2D(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
-//@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;
-};
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform lowp vec4 uColor;
+uniform mediump float uBloomThreshold;
+uniform mediump float uRecipOneMinusBloomThreshold;
void main()
{
mediump vec4 col;
- col = TEXTURE(sTexture, vTexCoord);
+ col = texture2D(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
-//@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];
-};
+varying highp vec2 vTexCoord;
+uniform sampler2D sTexture;
+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 += (TEXTURE(sTexture, vTexCoord + uSampleOffsets[i]) + TEXTURE(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
+ col += (texture2D(sTexture, vTexCoord + uSampleOffsets[i]) + texture2D(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
}
gl_FragColor = col;
}
-//@name blur-two-images-shader.frag
-
-//@version 100
-
precision highp float;
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM float uBlurStrength;
-};
-
-UNIFORM sampler2D sTexture;
-UNIFORM sampler2D sEffect;
-INPUT mediump vec2 vTexCoord;
+uniform float uBlurStrength;
+uniform sampler2D sTexture;
+uniform sampler2D sEffect;
+varying mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uBlurStrength
- + TEXTURE( sEffect, vTexCoord )*(1.0-uBlurStrength);
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uBlurStrength
+ + texture2D( sEffect, vTexCoord )*(1.0-uBlurStrength);
}
\ No newline at end of file
-//@name blur-two-pass-shader.frag
-
-//@version 100
-
precision highp float;
-INPUT mediump vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM vec2 uSampleOffsets[NUM_SAMPLES];
- UNIFORM float uSampleWeights[NUM_SAMPLES];
-};
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+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 += TEXTURE( sTexture, vTexCoord + uSampleOffsets[i] ) * uSampleWeights[i];
+ color += texture2D( 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_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
- UNIFORM lowp vec4 borderColor;
- UNIFORM mediump float borderSize;
-};
+uniform lowp vec4 uColor;
+uniform lowp vec4 borderColor;
+uniform mediump float borderSize;
void main()
{
- gl_FragColor = borderColor * uColor;
- gl_FragColor.a *= smoothstep(0.0, 1.5, vAlpha) * smoothstep( borderSize + 1.5, borderSize, vAlpha );
+ OUT_COLOR = borderColor * uColor;
+ OUT_COLOR.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_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;
-};
+uniform highp mat4 uMvpMatrix;
+uniform highp vec3 uSize;
+uniform mediump float borderSize;
void main()
{
-//@name border-visual-shader.frag
-
-//@version 100
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
- UNIFORM lowp vec4 borderColor;
-};
+uniform lowp vec4 uColor;
+uniform lowp vec4 borderColor;
void main()
{
- gl_FragColor = borderColor * uColor;
+ OUT_COLOR = borderColor * uColor;
}
\ No newline at end of file
-//@name border-visual-shader.vert
-
-//@version 100
-
INPUT mediump vec2 aPosition;
INPUT mediump vec2 aDrift;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM highp mat4 uMvpMatrix;
- UNIFORM highp vec3 uSize;
- UNIFORM mediump float borderSize;
+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_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+uniform lowp vec4 uColor;
void main()
{
-//@name bouncing-effect-mesh-shader.vert
-
-//@version 100
-
// Modify the vertex position according to the bounce coefficient
-INPUT mediump vec3 aPosition1;
-INPUT mediump vec3 aPosition2;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM mediump vec3 uSize;
- UNIFORM mediump float uBounceCoefficient;
-};
+attribute mediump vec3 aPosition1;
+attribute mediump vec3 aPosition2;
+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_BLOCK FragBlock
-{
- UNIFORM vec3 uHSVDelta;
- UNIFORM float uIgnoreAlpha;
-};
-
-INPUT mediump vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
+uniform vec3 uHSVDelta;
+uniform float uIgnoreAlpha;
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
float rand(vec2 co)
{
void main()
{
- vec4 color = TEXTURE(sTexture, vTexCoord);
+ vec4 color = texture2D(sTexture, vTexCoord);
vec3 hsvColor = rgb2hsv( color.rgb );
// modify the hsv Value
hsvColor += uHSVDelta * rand(vTexCoord);
-//@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;
-};
+varying mediump vec2 vTexCoord;
+uniform lowp vec4 uColor;
+uniform sampler2D sBackground;
+uniform sampler2D sBubbleShape;
+varying mediump float vPercentage;
+varying mediump vec2 vEffectTexCoord;
void main()
{
// Get the emit pisition color, and Mix with the actor color
- mediump vec4 fragColor = TEXTURE(sBackground, vEffectTexCoord)*uColor;
+ mediump vec4 fragColor = texture2D(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*= TEXTURE(sBubbleShape, vTexCoord).a * ( 2.1 - max( vPercentage*2.1, 1.4 ) );
+ fragColor.a*= texture2D(sBubbleShape, vTexCoord).a * ( 2.1 - max( vPercentage*2.1, 1.4 ) );
gl_FragColor = fragColor;
}
\ No newline at end of file
-//@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;
+attribute mediump float aIndex;
+attribute mediump vec2 aPosition;
+attribute highp vec2 aTexCoord;
+varying mediump vec2 vTexCoord;
+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;
-};
-OUTPUT float vPercentage;
-OUTPUT vec2 vEffectTexCoord;
+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;
void main()
{
-//@name bubble-emitter.frag
-
-//@version 100
-
precision highp float;
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM vec3 uHSVDelta;
-};
-
-INPUT mediump vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
+uniform vec3 uHSVDelta;
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
float rand(vec2 co)
{
void main()
{
- vec4 color = TEXTURE(sTexture, vTexCoord);
+ vec4 color = texture2D(sTexture, vTexCoord);
vec3 hsvColor = rgb2hsv( color.rgb );
// modify the hsv Value
hsvColor += uHSVDelta * rand(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;
+attribute mediump vec2 aPosition;
+attribute mediump vec2 aTexCoord;
+uniform mediump vec3 uSize;
+uniform mediump mat4 uMvpMatrix;
+varying mediump vec2 vTexCoord;
void main()
{
-//@name canvas-view.frag
-
-//@version 100
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
-
-INPUT mediump vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
+uniform lowp vec4 uColor;
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
void main()
{
- gl_FragColor = TEXTURE(sTexture, vTexCoord) * uColor;
+ gl_FragColor = texture2D(sTexture, vTexCoord) * uColor;
}
-//@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;
-};
+attribute mediump vec2 aPosition;
+varying mediump vec2 vTexCoord;
+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;
#endif
#endif
-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;
+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;
#endif
#ifdef IS_REQUIRED_SQUIRCLE_CORNER
- UNIFORM highp vec4 cornerSquareness;
+uniform highp vec4 cornerSquareness;
#endif
-};
-
-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;
+#if defined(IS_REQUIRED_CUTOUT)
+uniform highp vec3 uSize;
+uniform lowp int uCutoutWithCornerRadius;
#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)
{
- gl_FragColor = targetColor;
+ OUT_COLOR = targetColor;
}
else
{
calculatePotential();
setupMinMaxPotential(tempBorderlineWidth);
- gl_FragColor = targetColor;
+ OUT_COLOR = targetColor;
mediump float opacity = calculateBlurOpacity();
- gl_FragColor *= opacity;
+ OUT_COLOR *= 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.
- gl_FragColor = targetColor;
+ OUT_COLOR = targetColor;
}
else
#endif
#endif
#endif
- gl_FragColor = targetColor;
+ OUT_COLOR = targetColor;
#ifdef IS_REQUIRED_ROUNDED_CORNER
mediump float opacity = calculateCornerOpacity();
- gl_FragColor *= opacity;
+ OUT_COLOR *= opacity;
#endif
}
#endif
#endif
#ifdef IS_REQUIRED_CUTOUT
- gl_FragColor *= discardOpacity;
+ OUT_COLOR *= 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;
#endif
#endif
-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
-
- //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 mat4 uMvpMatrix;
+uniform highp vec3 uSize;
-#ifdef IS_REQUIRED_ROUNDED_CORNER
- UNIFORM highp vec4 cornerRadius;
- UNIFORM mediump float cornerRadiusPolicy;
+#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
- 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 lowp vec4 borderlineColor;
+uniform highp float borderlineWidth;
+uniform highp float borderlineOffset;
#endif
-};
-
+#ifdef IS_REQUIRED_ROUNDED_CORNER
+uniform highp vec4 cornerRadius;
+uniform mediump float cornerRadiusPolicy;
+#endif
+uniform highp vec2 extraSize;
vec4 ComputeVertexPosition()
{
-//@name control-renderers.frag
-
-//@version 100
-
precision highp float;
-INPUT highp vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
-UNIFORM_BLOCK FragColor
-{
- UNIFORM vec4 uColor;
-};
+varying highp vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform vec4 uColor;
+
void main()
{
- gl_FragColor = TEXTURE(sTexture, vTexCoord);
+ gl_FragColor = texture2D(sTexture, vTexCoord);
gl_FragColor *= uColor;
}
-//@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;
-};
+attribute highp vec2 aPosition;
+varying highp vec2 vTexCoord;
+uniform highp mat4 uMvpMatrix;
+uniform highp vec3 uSize;
+
void main()
{
highp vec4 vertexPosition = vec4(aPosition * uSize.xy, 0.0, 1.0);
-//@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;
-};
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform lowp vec4 uColor;
+uniform lowp vec4 uSamplerRect;
void main()
{
- gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
}
-//@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;
-};
+attribute mediump vec2 aPosition;
+varying mediump vec2 vTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump vec4 uTextureRect;
void main()
{
-//@name dissolve-effect.frag
+varying float vPercentage;
+varying mediump vec2 vTexCoord;
-//@version 100
-
-INPUT float vPercentage;
-INPUT mediump vec2 vTexCoord;
-
-UNIFORM sampler2D sTexture;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+uniform sampler2D sTexture;
+uniform lowp vec4 uColor;
+uniform vec4 uTextureRect;
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 = TEXTURE(sTexture, lookupCoord) * uColor;
+ gl_FragColor = texture2D(sTexture, lookupCoord) * uColor;
gl_FragColor.a *= 1.0 - vPercentage;
}
\ No newline at end of file
-//@name dissolve-effect.vert
+attribute mediump vec2 aPosition;
-//@version 100
+uniform mediump mat4 uMvpMatrix;
+uniform vec3 uSize;
+uniform vec4 uTextureRect;
-INPUT mediump vec2 aPosition;
+uniform float uPercentage;
+uniform vec3 uSaddleParam;
+uniform vec2 uTranslation;
+uniform vec2 uRotation;
+uniform float uToNext;
-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;
+varying float vPercentage;
+varying vec2 vTexCoord;
void main()
{
-//@name distance-field-effect.frag
+varying mediump vec2 vTexCoord;
-//@version 100
+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;
-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;
+uniform sampler2D sTexture;
+uniform lowp vec4 uColor;
void main()
{
// sample distance field
mediump float smoothing = 0.5;
- mediump float distance = TEXTURE(sTexture, vTexCoord).a;
+ mediump float distance = texture2D(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 = TEXTURE(sTexture, vTexCoord - uShadowOffset).a;
+ mediump float shadowDistance = texture2D(sTexture, vTexCoord - uShadowOffset).a;
mediump float inText = alphaFactor;
mediump float inShadow = smoothstep(smoothing - smoothWidth, smoothing + smoothWidth, shadowDistance);
-//@name effects-view.frag
-
-//@version 100
-
-INPUT mediump vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 effectColor;
-};
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform lowp vec4 effectColor;
void main()
{
gl_FragColor = effectColor;
- gl_FragColor.a *= TEXTURE( sTexture, vTexCoord).a;
+ gl_FragColor.a *= texture2D( sTexture, vTexCoord).a;
}
-//@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;
-};
+attribute mediump vec2 aPosition;
+varying mediump vec2 vTexCoord;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+uniform mediump vec3 effectOffset;
void main()
{
-//@name emboss-filter-composite-shader.frag
-
-//@version 100
-
-INPUT mediump vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uEffectColor;
-};
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform lowp vec4 uEffectColor;
void main()
{
gl_FragColor = uEffectColor;
- gl_FragColor.a *= TEXTURE( sTexture, vTexCoord).a;
+ gl_FragColor.a *= texture2D( sTexture, vTexCoord).a;
}
\ No newline at end of file
-//@name emboss-filter-shader.frag
-
-//@version 100
-
precision highp float;
-INPUT mediump vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM vec2 uTexScale;
- UNIFORM vec3 uCoefficient;
-};
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform vec2 uTexScale;
+uniform vec3 uCoefficient;
void main()
{
- 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) );
+ 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) );
gl_FragColor = color;
}
\ No newline at end of file
-//@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];
-};
+varying highp vec2 vTexCoord;
+uniform sampler2D sTexture;
+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 += (TEXTURE(sTexture, vTexCoord + uSampleOffsets[i]) + TEXTURE(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
+ col += (texture2D(sTexture, vTexCoord + uSampleOffsets[i]) + texture2D(sTexture, vTexCoord - uSampleOffsets[i])) * uSampleWeights[i];
}
gl_FragColor = col;
}
-//@name gl-view.frag
-
-//@version 100
-INPUT mediump vec2 vTexCoord;
-UNIFORM samplerExternalOES sTexture;
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+uniform lowp vec4 uColor;
+varying mediump vec2 vTexCoord;
+uniform samplerExternalOES sTexture;
void main()
{
- gl_FragColor = TEXTURE(sTexture, vTexCoord) * uColor;
+ gl_FragColor = texture2D(sTexture, vTexCoord) * uColor;
}
\ No newline at end of file
-//@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;
+attribute mediump vec2 aPosition;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump vec3 uSize;
+varying mediump vec2 vTexCoord;
void main()
{
#define TEXTURE_BASECOLOR
-UNIFORM sampler2D uBaseColorSampler;
-
-UNIFORM_BLOCK FragBlockBaseColor
-{
- UNIFORM int uBaseColorTexCoordIndex;
-};
+uniform sampler2D uBaseColorSampler;
+uniform int uBaseColorTexCoordIndex;
#define TEXTURE_EMIT
-UNIFORM sampler2D uEmissiveSampler;
-UNIFORM_BLOCK FragBlockEmissive
-{
- UNIFORM int uEmissiveTexCoordIndex;
- UNIFORM vec3 uEmissiveFactor;
-};
+uniform sampler2D uEmissiveSampler;
+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_BLOCK FragBlockIBL
-{
- UNIFORM vec4 uScaleIBLAmbient;
- UNIFORM highp float uMipmapLevel;
-};
+uniform sampler2D ubrdfLUT;
+uniform samplerCube uDiffuseEnvSampler;
+uniform samplerCube uSpecularEnvSampler;
+uniform vec4 uScaleIBLAmbient;
+uniform highp float uMipmapLevel;
#define TEXTURE_METALLICROUGHNESS
-UNIFORM sampler2D uMetallicRoughnessSampler;
-
-UNIFORM_BLOCK FragBlockMetRough
-{
- UNIFORM int uMetallicRoughnessTexCoordIndex;
-};
+uniform sampler2D uMetallicRoughnessSampler;
+uniform int uMetallicRoughnessTexCoordIndex;
#define TEXTURE_NORMAL
-UNIFORM sampler2D uNormalSampler;
-UNIFORM_BLOCK FragBlockNormal
-{
- UNIFORM float uNormalScale;
- UNIFORM int uNormalTexCoordIndex;
-};
+uniform sampler2D uNormalSampler;
+uniform float uNormalScale;
+uniform int uNormalTexCoordIndex;
#define TEXTURE_OCCLUSION
-UNIFORM sampler2D uOcclusionSampler;
-UNIFORM_BLOCK FragBlockOcclusion
-{
- UNIFORM int uOcclusionTexCoordIndex;
- UNIFORM float uOcclusionStrength;
-};
+uniform sampler2D uOcclusionSampler;
+uniform int uOcclusionTexCoordIndex;
+uniform float uOcclusionStrength;
-//@name gltf-physically-based-shader.frag
+uniform lowp vec3 uLightColor;
+uniform lowp vec4 uBaseColorFactor;
+uniform lowp vec2 uMetallicRoughnessFactors;
+uniform lowp float alphaCutoff;
+uniform lowp float uAlphaMode;
+uniform lowp float uHasLightSource;
-//@version 100
+in lowp vec2 vUV[2];
+in lowp mat3 vTBN;
+in lowp vec4 vColor;
+in highp vec3 vLightDirection;
+in highp vec3 vPositionToCamera;
-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;
+out vec4 FragColor;
struct PBRInfo
{
lowp float perceptualRoughness = uMetallicRoughnessFactors.y;
// Roughness is stored in the 'g' channel, metallic is stored in the 'b' channel.
- // This layOUTPUT intentionally reserves the 'r' channel for (optional) occlusion map data
+ // This layout intentionally reserves the 'r' channel for (optional) occlusion map data
#ifdef TEXTURE_METALLICROUGHNESS
lowp vec4 metrou = texture(uMetallicRoughnessSampler, vUV[uMetallicRoughnessTexCoordIndex]);
metallic = metrou.b * metallic;
-//@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;
+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;
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;
-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;
+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;
#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 TEXTURE (_tex, pos);
+ return texture2D (_tex, pos);
}
-//@name glyphy-shader-main.frag
+uniform float u_contrast;
+uniform float u_gamma_adjust;
+uniform float u_outline_thickness;
+uniform float u_outline;
+uniform float u_boldness;
-//@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;
+varying vec4 v_glyph;
#define SQRT2_2 0.70711 /* 1 / sqrt(2.) */
#define SQRT2 1.41421
-//@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;
+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;
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;
#endif
#endif
-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;
-};
+// scale factor to fit start and end position of gradient.
+uniform mediump float uTextureCoordinateScaleFactor;
+uniform sampler2D sTexture; // sampler1D?
+uniform lowp vec4 uColor;
#ifdef IS_REQUIRED_BORDERLINE
-UNIFORM_BLOCK SharedBlock
-{
- UNIFORM highp float borderlineWidth;
- UNIFORM highp float borderlineOffset;
- UNIFORM lowp vec4 borderlineColor;
- UNIFORM lowp vec4 uActorColor;
-};
+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)
{
- gl_FragColor = textureColor;
+ OUT_COLOR = textureColor;
}
else
{
if(gFragmentPosition.x + gFragmentPosition.y < -(gRadius + vAliasMargin) * 2.0)
{
// Do nothing.
- gl_FragColor = textureColor;
+ OUT_COLOR = textureColor;
}
else
#endif
#ifdef IS_REQUIRED_BORDERLINE
textureColor = convertBorderlineColor(textureColor);
#endif
- gl_FragColor = textureColor;
+ OUT_COLOR = textureColor;
#ifdef IS_REQUIRED_ROUNDED_CORNER
mediump float opacity = calculateCornerOpacity();
- gl_FragColor *= opacity;
+ OUT_COLOR *= 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)
#endif
#endif
-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;
-#endif
+uniform highp mat4 uMvpMatrix;
+uniform highp vec3 uSize;
+uniform mediump mat3 uAlignmentMatrix;
- // 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;
+#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;
#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_BLOCK SharedBlock
-{
- UNIFORM highp float borderlineWidth;
- UNIFORM highp float borderlineOffset;
- UNIFORM lowp vec4 borderlineColor;
- UNIFORM lowp vec4 uActorColor;
-};
+uniform highp float borderlineWidth;
+uniform highp float borderlineOffset;
+#endif
+#ifdef IS_REQUIRED_ROUNDED_CORNER
+uniform highp vec4 cornerRadius;
+uniform mediump float cornerRadiusPolicy;
#endif
-
vec4 ComputeVertexPosition()
{
-//@name image-region-effect.vert
+attribute mediump vec2 aPosition;
-//@version 100
+uniform mediump mat4 uMvpMatrix;
+uniform vec3 uSize;
+uniform vec4 uTextureRect;
-INPUT mediump vec2 aPosition;
+varying vec2 vTexCoord;
-OUTPUT vec2 vTexCoord;
-
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM mediump vec2 uTopLeft;
- UNIFORM mediump vec2 uBottomRight;
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM vec3 uSize;
- UNIFORM vec4 uTextureRect;
-};
+uniform mediump vec2 uTopLeft;
+uniform mediump vec2 uBottomRight;
void main()
{
-//@name image-visual-shader.frag
-
-//@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;
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 sampler2D sMaskTexture;
+uniform lowp float uYFlipMaskTexture;
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 lowp vec4 borderlineColor;
- UNIFORM lowp vec4 uActorColor;
+uniform highp float borderlineWidth;
+uniform highp float borderlineOffset;
+uniform lowp vec4 borderlineColor;
+uniform lowp vec4 uActorColor;
#endif
#ifdef IS_REQUIRED_SQUIRCLE_CORNER
- UNIFORM highp vec4 cornerSquareness;
-#endif
-};
-
-#ifdef IS_REQUIRED_BORDERLINE
-UNIFORM_BLOCK Borderline
-{
- UNIFORM highp float borderlineWidth;
- UNIFORM highp float borderlineOffset;
-};
+uniform highp vec4 cornerSquareness;
#endif
#ifdef ATLAS_CUSTOM_WARP
// skip most potential calculate for performance
if(abs(vPosition.x) < vOptRectSize.x && abs(vPosition.y) < vOptRectSize.y)
{
- gl_FragColor = textureColor;
+ OUT_COLOR = textureColor;
}
else
#endif
if(gFragmentPosition.x + gFragmentPosition.y < -(gRadius + vAliasMargin) * 2.0)
{
// Do nothing.
- gl_FragColor = textureColor;
+ OUT_COLOR = textureColor;
}
else
#endif
#ifdef IS_REQUIRED_BORDERLINE
textureColor = convertBorderlineColor(textureColor);
#endif
- gl_FragColor = textureColor;
+ OUT_COLOR = textureColor;
#ifdef IS_REQUIRED_ROUNDED_CORNER
mediump float opacity = calculateCornerOpacity();
- gl_FragColor.a *= opacity;
- gl_FragColor.rgb *= mix(1.0, opacity, premultipliedAlpha);
+ OUT_COLOR.a *= opacity;
+ OUT_COLOR.rgb *= mix(1.0, opacity, premultipliedAlpha);
#endif
}
#endif
#ifdef IS_REQUIRED_DEBUG_VISUAL_SHADER
- gl_FragColor.rgb = ApplyDebugMixColor(gl_FragColor);
+ OUT_COLOR.rgb = ApplyDebugMixColor(OUT_COLOR);
#endif
}
-//@name image-visual-shader.vert
-
-//@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)
#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_BLOCK VertBlock
-{
- UNIFORM highp mat4 uMvpMatrix;
- UNIFORM highp vec3 uSize;
- UNIFORM highp vec4 pixelArea;
+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;
-
+//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
#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
- 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;
-};
+OUTPUT mediump vec2 vMaskTexCoord;
+uniform lowp float cropToMask;
+uniform mediump vec2 maskTextureRatio;
#endif
+uniform highp vec2 extraSize;
vec4 ComputeVertexPosition()
{
-//@name mesh-visual-normal-map-shader.frag
-
-//@version 100
-
precision mediump float;
-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;
-};
+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;
void main()
{
- vec4 tex = TEXTURE( sDiffuse, vTexCoord );
- vec3 normal = normalize( TEXTURE( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
- vec4 glossMap = TEXTURE( sGloss, vTexCoord );
+ vec4 texture = texture2D( sDiffuse, vTexCoord );
+ vec3 normal = normalize( texture2D( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
+ vec4 glossMap = texture2D( 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( tex.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, tex.a * uColor.a );
+ gl_FragColor = vec4( texture.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a );
}
-//@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;
+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;
//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;
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec3 vIllumination;
-INPUT mediump float vSpecular;
-UNIFORM sampler2D sDiffuse;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+varying mediump vec2 vTexCoord;
+varying mediump vec3 vIllumination;
+varying mediump float vSpecular;
+uniform sampler2D sDiffuse;
+uniform lowp vec4 uColor;
void main()
{
- vec4 tex = TEXTURE( sDiffuse, vTexCoord );
- gl_FragColor = vec4( vIllumination.rgb * tex.rgb * uColor.rgb + vSpecular * 0.3, tex.a * uColor.a );
+ vec4 texture = texture2D( sDiffuse, vTexCoord );
+ gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb + vSpecular * 0.3, texture.a * uColor.a );
}
-//@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;
+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;
//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;
-INPUT mediump vec3 vIllumination;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+varying mediump vec3 vIllumination;
+uniform lowp vec4 uColor;
void main()
{
-//@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;
+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;
//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;
-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;
-};
+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;
void main()
{
- vec4 tex = TEXTURE( sDiffuse, vTexCoord );
- vec3 normal = normalize( TEXTURE( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
- vec4 glossMap = TEXTURE( sGloss, vTexCoord );
+ vec4 texture = texture2D( sDiffuse, vTexCoord );
+ vec3 normal = normalize( texture2D( sNormal, vTexCoord ).xyz * 2.0 - 1.0 );
+ vec4 glossMap = texture2D( 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( tex.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, tex.a * uColor.a);
+ gl_FragColor = vec4( texture.rgb * uColor.rgb * lightDiffuse + shininess * glossMap.rgb, texture.a * uColor.a);
}
-//@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;
-};
+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;
void main()
{
-//@name model3d-view-shader.frag
-
-//@version 100
-
precision mediump float;
-INPUT mediump vec2 vTexCoord;
-INPUT mediump vec3 vIllumination;
-INPUT mediump float vSpecular;
-UNIFORM sampler2D sDiffuse;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+varying mediump vec2 vTexCoord;
+varying mediump vec3 vIllumination;
+varying mediump float vSpecular;
+uniform sampler2D sDiffuse;
+uniform lowp vec4 uColor;
void main()
{
- vec4 texture = TEXTURE( sDiffuse, vTexCoord );
+ vec4 texture = texture2D( sDiffuse, vTexCoord );
gl_FragColor = vec4( vIllumination.rgb * texture.rgb * uColor.rgb + vSpecular * 0.3, texture.a * uColor.a);
}
-//@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;
-};
+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;
void main()
{
-//@name model3d-view-simple-shader.frag
-
-//@version 100
-
precision mediump float;
-INPUT mediump vec3 vIllumination;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+varying mediump vec3 vIllumination;
+uniform lowp vec4 uColor;
void main()
{
-//@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;
-};
+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;
void main()
{
-//@name motion-blur-effect.frag
-
-//@version 100
-
precision mediump float;
-UNIFORM sampler2D sTexture;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM vec4 uColor;
+uniform sampler2D sTexture;
+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
-INPUT vec2 vModelSpaceCenterToPos;
-INPUT vec2 vScreenSpaceVelocityVector;
-INPUT float vSpeed;
-INPUT vec2 vTexCoord;
+varying vec2 vModelSpaceCenterToPos;
+varying vec2 vScreenSpaceVelocityVector;
+varying float vSpeed;
+varying vec2 vTexCoord;
void main()
{
vec2 velocity = vScreenSpaceVelocityVector * uBlurTexCoordScale;
// standard actor texel
- vec4 colActor = TEXTURE(sTexture, vTexCoord);
+ vec4 colActor = texture2D(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 += TEXTURE(sTexture, vTexCoord + (velocity * t)) * uRecipNumSamples;
+ col += texture2D(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;
-INPUT vec2 aPosition;
-
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM mat4 uMvpMatrix;
- UNIFORM mat4 uModelView;
- UNIFORM mat4 uViewMatrix;
- UNIFORM mat4 uProjection;
- UNIFORM vec3 uSize;
+attribute vec2 aPosition;
- UNIFORM mat4 uModelLastFrame;
- UNIFORM float uGeometryStretchFactor;
- UNIFORM float uSpeedScalingFactor;
-};
+uniform mat4 uMvpMatrix;
+uniform mat4 uModelView;
+uniform mat4 uViewMatrix;
+uniform mat4 uProjection;
+uniform vec3 uSize;
+uniform mat4 uModelLastFrame;
float timeDelta = 0.0167;
+uniform float uGeometryStretchFactor;
+uniform float uSpeedScalingFactor;
// outputs
-OUTPUT vec2 vModelSpaceCenterToPos;
-OUTPUT vec2 vScreenSpaceVelocityVector;
-OUTPUT float vSpeed;
-OUTPUT vec2 vTexCoord;
+varying vec2 vModelSpaceCenterToPos;
+varying vec2 vScreenSpaceVelocityVector;
+varying float vSpeed;
+varying vec2 vTexCoord;
void main()
{
-//@name motion-stretch-effect.frag
-
-//@version 100
-
precision mediump float;
-UNIFORM sampler2D sTexture;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM vec4 uColor;
+uniform sampler2D sTexture;
+uniform vec4 uColor;
- UNIFORM vec2 uObjectFadeStart;
- UNIFORM vec2 uObjectFadeEnd;
- UNIFORM float uAlphaScale; // Global alpha scale
-};
+uniform vec2 uObjectFadeStart;
+uniform vec2 uObjectFadeEnd;
+uniform float uAlphaScale;
// inputs
-INPUT vec2 vModelSpaceCenterToPos; // 2d, ignoring z
-INPUT vec2 vScreenSpaceVelocityVector;
-INPUT float vSpeed;
-INPUT vec2 vTexCoord;
+varying vec2 vModelSpaceCenterToPos;
+varying vec2 vScreenSpaceVelocityVector;
+varying float vSpeed;
+varying vec2 vTexCoord;
void main()
{
fadeToEdgesScale = mix(1.0, fadeToEdgesScale, vSpeed); // fade proportional to speed, so opaque when at rest
// standard actor texel
- vec4 colActor = TEXTURE(sTexture, vTexCoord);
+ vec4 colActor = texture2D(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;
-INPUT vec2 aPosition; // Use position to calculate uvs
-
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM mat4 uMvpMatrix;
- UNIFORM mat4 uModelView;
- UNIFORM mat4 uViewMatrix;
- UNIFORM mat4 uProjection;
- UNIFORM vec3 uSize;
-
- UNIFORM mat4 uModelLastFrame;
+attribute vec2 aPosition;
- UNIFORM float uGeometryStretchFactor;
- UNIFORM float uSpeedScalingFactor;
-};
+uniform mat4 uMvpMatrix;
+uniform mat4 uModelView;
+uniform mat4 uViewMatrix;
+uniform mat4 uProjection;
+uniform vec3 uSize;
+uniform mat4 uModelLastFrame;
float timeDelta = 0.0167;
+uniform float uGeometryStretchFactor;
+uniform float uSpeedScalingFactor;
// outputs
-OUTPUT vec2 vModelSpaceCenterToPos; // 2d, ignoring z
-OUTPUT vec2 vScreenSpaceVelocityVector;
-OUTPUT float vSpeed;
-OUTPUT vec2 vTexCoord;
+varying vec2 vModelSpaceCenterToPos;
+varying vec2 vScreenSpaceVelocityVector;
+varying float vSpeed;
+varying vec2 vTexCoord;
void main()
{
-//@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;
-};
+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;
void main()
{
-//@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;
-};
+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;
void main()
{
// where mask is translucent, less of background should be shown.
// auxiliaryImageAlpha controls how much of mask is visible
- mediump vec4 color = TEXTURE(sTexture, vTexCoord);
- mediump vec4 mask = TEXTURE(sMask, vMaskTexCoord);
+ mediump vec4 color = texture2D(sTexture, vTexCoord);
+ mediump vec4 mask = texture2D(sMask, vMaskTexCoord);
mediump float maskAlpha = mask.a * auxiliaryImageAlpha;
-//@name npatch-visual-shader.frag
-
-//@version 100
-
-INPUT mediump vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform lowp vec4 uColor;
void main()
{
- gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
}
-//@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;
-};
+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;
void main()
{
-//@name page-turn-book-spine-effect.frag
-
-//@version 100
-
precision mediump float;
-INPUT mediump vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
- UNIFORM vec2 uSpineShadowParameter;
-};
-
-UNIFORM_BLOCK SharedBlock
-{
-UNIFORM vec3 uSize;
-};
+varying mediump vec2 vTexCoord;
+uniform vec3 uSize;
+uniform vec2 uSpineShadowParameter;
+uniform sampler2D sTexture;
+uniform lowp vec4 uColor;
void main()
{
if( gl_FrontFacing ) // display front side
{
- gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
}
else // display back side, flip the image horizontally by changing the x component of the texture coordinate
{
- gl_FragColor = TEXTURE( sTexture, vec2( 1.0 - vTexCoord.x, vTexCoord.y ) ) * uColor;
+ gl_FragColor = texture2D( 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;
-INPUT mediump vec2 aPosition;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM float uTextureWidth;
-};
-
-UNIFORM_BLOCK SharedBlock
-{
-UNIFORM vec3 uSize;
-};
-
-OUTPUT vec2 vTexCoord;
+attribute mediump vec2 aPosition;
+uniform mediump mat4 uMvpMatrix;
+uniform vec3 uSize;
+uniform float uTextureWidth;
+varying vec2 vTexCoord;
void main()
{
-//@name page-turn-effect.frag
-
-//@version 100
-
precision mediump float;
-INPUT mediump vec2 vTexCoord;
-
-UNIFORM sampler2D sTexture;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
- UNIFORM vec2 uSpineShadowParameter;
-};
-
-UNIFORM_BLOCK SharedBlock
-{
- UNIFORM vec3 uSize;
-};
+varying mediump vec2 vTexCoord;
-INPUT vec3 vNormal;
-INPUT vec4 vPosition;
+uniform sampler2D sTexture;
+uniform lowp vec4 uColor;
+uniform vec3 uSize;
+uniform vec2 uSpineShadowParameter;
+varying vec3 vNormal;
+varying 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 = TEXTURE( sTexture, vec2( 1.0 - vTexCoord.x, vTexCoord.y ) );
+ if( dot(vPosition.xyz, normal) > 0.0 ) texel = texture2D( sTexture, vec2( 1.0 - vTexCoord.x, vTexCoord.y ) );
// display front image of the page
- else texel = TEXTURE( sTexture, vTexCoord );
+ else texel = texture2D( 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;
-INPUT mediump vec2 aPosition;
+attribute mediump vec2 aPosition;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM mediump mat4 uMvpMatrix;
- UNIFORM mediump mat3 uNormalMatrix;
- UNIFORM mediump mat4 uModelView;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump mat3 uNormalMatrix;
+uniform mediump mat4 uModelView;
- UNIFORM mat4 uCommonParameters;
+uniform mat4 uCommonParameters;
- UNIFORM float uIsTurningBack;
- UNIFORM float uTextureWidth;
-};
-
-UNIFORM_BLOCK SharedBlock
-{
- UNIFORM vec3 uSize;
-};
-
-OUTPUT vec3 vNormal;
-OUTPUT vec4 vPosition;
-OUTPUT mediump vec2 vTexCoord;
+uniform vec3 uSize;
+uniform float uIsTurningBack;
+uniform float uTextureWidth;
+varying vec3 vNormal;
+varying vec4 vPosition;
+varying mediump vec2 vTexCoord;
void main()
{
}
vNormal = uNormalMatrix * normal;
gl_Position = uMvpMatrix * position;
-
- // out parameters for fragment shader
+ // varying 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;
-INPUT mediump vec3 vIllumination;
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+varying mediump vec3 vIllumination;
+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.
-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;
+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;
//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;
-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;
-};
+varying highp vec2 vTexCoord;
+varying highp vec2 vOptRectSize;
+varying highp vec4 vCornerRadius;
-UNIFORM sampler2D sTexture;
+uniform lowp vec4 uColor;
+uniform highp vec3 uSize;
+uniform highp vec4 uCornerSquareness;
+uniform sampler2D sTexture;
highp float nrand(const in vec2 uv)
{
void main()
{
- gl_FragColor = TEXTURE(sTexture, vTexCoord) * uColor;
+ gl_FragColor = texture2D(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;
-INPUT highp vec2 aPosition;
+attribute highp vec2 aPosition;
-OUTPUT highp vec2 vTexCoord;
-OUTPUT highp vec2 vOptRectSize;
-OUTPUT highp vec4 vCornerRadius; //output
+varying highp vec2 vTexCoord;
+varying highp vec2 vOptRectSize;
+varying highp vec4 vCornerRadius; //output
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM highp mat4 uMvpMatrix;
- UNIFORM highp vec4 uCornerRadius;//input
- UNIFORM lowp float uCornerRadiusPolicy;
-};
-
-UNIFORM_BLOCK SharedBlock
-{
-UNIFORM highp vec3 uSize;
-};
+uniform highp mat4 uMvpMatrix;
+uniform highp vec4 uCornerRadius; //input
+uniform lowp float uCornerRadiusPolicy;
+uniform highp vec3 uSize;
void main()
{
-//@name shadow-view-render-shader.frag
-
-//@version 100
-
-INPUT mediump vec2 vTexCoord;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uShadowColor;
-};
-UNIFORM sampler2D sTexture;
+varying mediump vec2 vTexCoord;
+uniform lowp vec4 uShadowColor;
+uniform sampler2D sTexture;
void main()
{
lowp float alpha;
- alpha = TEXTURE(sTexture, vec2(vTexCoord.x, vTexCoord.y)).a;
+ alpha = texture2D(sTexture, vec2(vTexCoord.x, vTexCoord.y)).a;
gl_FragColor = vec4(uShadowColor.rgb, uShadowColor.a * alpha);
}
\ No newline at end of file
-//@name shadow-view-render-shader.vert
+attribute mediump vec2 aPosition;
+uniform mediump mat4 uMvpMatrix;
+uniform mediump mat4 uModelMatrix;
+uniform vec3 uSize;
+varying vec2 vTexCoord;
-//@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;
-};
+uniform mediump mat4 uLightCameraProjectionMatrix;
+uniform mediump mat4 uLightCameraViewMatrix;
void main()
{
-//@name spread-filter-shader.frag
-
-//@version 100
-
precision highp float;
-INPUT mediump vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM int uSpread;
- UNIFORM vec2 uTexScale;
-};
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform int uSpread;
+uniform vec2 uTexScale;
void main()
{
- vec4 color = TEXTURE( sTexture, vTexCoord);
+ vec4 color = texture2D( sTexture, vTexCoord);
for( int i = 1; i <= uSpread; ++i )
{
vec2 offset = uTexScale * float(i);
- color = max( TEXTURE( sTexture, vTexCoord + offset), color );
- color = max( TEXTURE( sTexture, vTexCoord - offset), color );
+ color = max( texture2D( sTexture, vTexCoord + offset), color );
+ color = max( texture2D( sTexture, vTexCoord - offset), color );
}
gl_FragColor = color;
}
\ No newline at end of file
-//@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;
-};
+varying mediump vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform lowp vec4 uColor;
+uniform lowp float uAlpha;
void main()
{
- gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
gl_FragColor.a *= uAlpha;
}
-//@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;
+uniform lowp vec4 uColor;
+uniform lowp vec4 textColorAnimatable;
+uniform sampler2D sTexture;
+varying mediump vec2 vTexCoord;
+varying mediump vec4 vColor;
void main()
{
- mediump vec4 color = TEXTURE( sTexture, vTexCoord );
+ mediump vec4 color = texture2D( sTexture, vTexCoord );
gl_FragColor = vec4( vColor.rgb * uColor.rgb * textColorAnimatable.rgb, uColor.a * vColor.a * textColorAnimatable.a * color.r );
}
-//@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;
+uniform lowp vec4 uColor;
+uniform lowp vec4 textColorAnimatable;
+uniform sampler2D sTexture;
+varying mediump vec2 vTexCoord;
void main()
{
- gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor * textColorAnimatable;
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor * textColorAnimatable;
}
-//@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;
+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;
void main()
{
-//@name text-controller-background-shader.frag
-
-//@version 100
-
-INPUT mediump vec4 vColor;
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+varying mediump vec4 vColor;
+uniform lowp vec4 uColor;
void main()
{
-//@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;
-};
+attribute mediump vec2 aPosition;
+attribute mediump vec4 aColor;
+varying mediump vec4 vColor;
+uniform highp mat4 uMvpMatrix;
void main()
{
-//@name text-decorator-shader.frag
+uniform lowp vec4 uColor;
-//@version 100
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
void main()
{
gl_FragColor = uColor;
-//@name text-decorator-shader.vert
+attribute mediump vec2 aPosition;
+uniform highp mat4 uMvpMatrix;
-//@version 100
-
-INPUT mediump vec2 aPosition;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM highp mat4 uMvpMatrix;
-};
void main()
{
mediump vec4 position = vec4( aPosition, 0.0, 1.0 );
-//@name text-scroller-shader.frag
-
-//@version 100
-
-INPUT highp vec2 vTexCoord;
-UNIFORM sampler2D sTexture;
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+varying highp vec2 vTexCoord;
+uniform sampler2D sTexture;
+uniform lowp vec4 uColor;
void main()
{
if ( vTexCoord.y > 1.0 )
discard;
- mediump vec4 textTexture = TEXTURE( sTexture, vTexCoord );
+ mediump vec4 textTexture = texture2D( sTexture, vTexCoord );
gl_FragColor = textTexture * uColor;
}
-//@name text-scroller-shader.vert
+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;
-//@version 100
+uniform highp mat4 uMvpMatrix;
-INPUT mediump vec2 aPosition;
-OUTPUT highp 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 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 sampler2D sMask;
+uniform lowp float uHasMultipleTextColors;
#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
- gl_FragColor = uColor * (
+ OUT_COLOR = uColor * (
#ifdef IS_REQUIRED_OVERLAY
(
#endif
-//@name text-visual-shader.vert
-
-//@version 100
-
INPUT mediump vec2 aPosition;
-OUTPUT mediump vec2 vTexCoord;
+uniform highp mat4 uMvpMatrix;
+uniform highp vec3 uSize;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM highp mat4 uMvpMatrix;
- UNIFORM highp vec3 uSize;
+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;
-};
+//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()
{
-//@name video-view-texture.frag
-
-//@version 100
-
-INPUT mediump vec2 vTexCoord;
-UNIFORM samplerExternalOES sTexture;
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+uniform lowp vec4 uColor;
+varying mediump vec2 vTexCoord;
+uniform samplerExternalOES sTexture;
void main()
{
- gl_FragColor = TEXTURE( sTexture, vTexCoord ) * uColor;
+ gl_FragColor = texture2D( sTexture, vTexCoord ) * uColor;
}
-//@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;
+attribute mediump vec2 aPosition;
+varying mediump vec2 vTexCoord;
+uniform highp mat4 uMvpMatrix;
+uniform highp vec3 uSize;
+varying mediump vec2 sTexCoordRect;
void main()
{
-//@name video-view.frag
-
-//@version 100
-
void main()
{
gl_FragColor = vec4(0.0);
-//@name video-view.vert
-
-//@version 100
-
-INPUT mediump vec2 aPosition;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM highp mat4 uMvpMatrix;
- UNIFORM highp vec3 uSize;
-};
+attribute mediump vec2 aPosition;
+uniform highp mat4 uMvpMatrix;
+uniform highp vec3 uSize;
void main()
{
-//@name wireframe-visual-shader.frag
-
-//@version 100
-
-UNIFORM_BLOCK FragBlock
-{
- UNIFORM lowp vec4 uColor;
-};
+uniform lowp vec4 uColor;
void main()
{
-//@name wireframe-visual-shader.vert
-
-//@version 100
-
-INPUT mediump vec2 aPosition;
-UNIFORM_BLOCK VertBlock
-{
- UNIFORM highp mat4 uMvpMatrix;
- UNIFORM highp vec3 uSize;
+attribute mediump vec2 aPosition;
+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()
{
/*
- * Copyright (c) 2024 Samsung Electronics Co., Ltd.
+ * Copyright (c) 2023 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* - ParticleSystem buffer is being updated every frame
*/
std::string vertexShaderCode = streamAttributesStr + std::string(
- "//@version 100\n\
- INPUT mediump vec2 aPosition;\n\
+
+ "INPUT mediump vec2 aPosition;\n\
INPUT mediump vec2 aTexCoords;\n\
\n\
- UNIFORM_BLOCK VertBlock \n\
- {\n\
- UNIFORM mediump mat4 uMvpMatrix;\n\
- UNIFORM mediump vec3 uSize;\n\
- UNIFORM lowp vec4 uColor;\n\
- };\n\
- OUTPUT mediump vec2 vTexCoord;\n\
+ uniform mediump mat4 uMvpMatrix;\n\
+ uniform mediump vec3 uSize;\n\
+ uniform lowp vec4 uColor;\n\
+ \
+ OUTPUT mediump vec2 vTexCoord;\n\
OUTPUT mediump vec4 vColor;\n\
\n\
void main()\n\
}\n");
std::string fragmentShaderCode =
- {"//@version 100\n\
- INPUT mediump vec2 vTexCoord;\n\
- INPUT mediump vec4 vColor;\n\
- UNIFORM sampler2D sTexture;\n\
- \n\
- void main()\n\
- {\n\
- lowp vec4 col = TEXTURE(sTexture, vTexCoord) * vColor;\n\
- if(col.a < 0.1) { discard; }\
- gl_FragColor = col;\n\
- }\n"};
+ {
+ "INPUT mediump vec2 vTexCoord;\n\
+ INPUT mediump vec4 vColor;\n\
+ uniform sampler2D sTexture;\n\
+ \n\
+ void main()\n\
+ {\n\
+ lowp vec4 col = TEXTURE(sTexture, vTexCoord) * vColor;\n\
+ if(col.a < 0.1) { discard; }\
+ fragColor = col;\n\
+ }\n"};
mShader = Shader::New(Dali::Shader::GetVertexShaderPrefix() + vertexShaderCode, Dali::Shader::GetFragmentShaderPrefix() + fragmentShaderCode);
mGeometry = Geometry::New();
projects / platform / core / uifw / dali-toolkit.git / commitdiff