From c675e15a92bb7025c59d746cf11c3e800ad03441 Mon Sep 17 00:00:00 2001 From: halx99 Date: Sat, 22 Jul 2023 23:59:17 +0800 Subject: [PATCH] Migrate cpp_tests shaders --- tests/cpp-tests/Source/shaders/Normal.frag | 39 ++++++ tests/cpp-tests/Source/shaders/OutLine.frag | 15 +++ tests/cpp-tests/Source/shaders/OutLine.vert | 18 +++ .../Source/shaders/SkinnedOutline.vert | 79 +++++++++++ .../cpp-tests/Source/shaders/VertexColor.frag | 12 ++ .../cpp-tests/Source/shaders/VertexColor.vert | 16 +++ .../Source/shaders/color_normal_tex.frag | 117 +++++++++++++++++ tests/cpp-tests/Source/shaders/color_tex.frag | 17 +++ tests/cpp-tests/Source/shaders/cube_map.frag | 17 +++ tests/cpp-tests/Source/shaders/cube_map.vert | 24 ++++ tests/cpp-tests/Source/shaders/cylinder.frag | 21 +++ tests/cpp-tests/Source/shaders/cylinder.vert | 16 +++ .../Source/shaders/example_3D_PositionTex.fsh | 18 +++ .../Source/shaders/example_3D_PositionTex.vsh | 17 +++ .../Source/shaders/example_Bloom.fsh | 59 +++++++++ .../cpp-tests/Source/shaders/example_Blur.fsh | 53 ++++++++ .../Source/shaders/example_Blur_winrt.fsh | 43 ++++++ .../Source/shaders/example_CelShading.fsh | 70 ++++++++++ .../Source/shaders/example_ColorBars.fsh | 46 +++++++ .../Source/shaders/example_ColorBars.vsh | 19 +++ .../Source/shaders/example_EdgeDetection.fsh | 47 +++++++ .../Source/shaders/example_Flower.fsh | 49 +++++++ .../Source/shaders/example_GreyScale.fsh | 17 +++ .../Source/shaders/example_Heart.fsh | 45 +++++++ .../shaders/example_HorizontalColor.fsh | 39 ++++++ .../Source/shaders/example_Julia.fsh | 41 ++++++ .../Source/shaders/example_LensFlare.fsh | 109 ++++++++++++++++ .../Source/shaders/example_Mandelbrot.fsh | 53 ++++++++ .../Source/shaders/example_Monjori.fsh | 47 +++++++ .../Source/shaders/example_MultiTexture.fsh | 24 ++++ .../Source/shaders/example_MultiTexture.vsh | 20 +++ .../Source/shaders/example_Noisy.fsh | 39 ++++++ .../Source/shaders/example_Normal.fsh | 15 +++ .../Source/shaders/example_Outline.fsh | 44 +++++++ .../Source/shaders/example_Plasma.fsh | 34 +++++ .../Source/shaders/example_Sepia.fsh | 21 +++ .../Source/shaders/example_Simple.vsh | 19 +++ .../Source/shaders/example_Twist.fsh | 39 ++++++ tests/cpp-tests/Source/shaders/fog.frag | 20 +++ tests/cpp-tests/Source/shaders/fog.vert | 35 +++++ .../Source/shaders/position_normal_tex.vert | 64 +++++++++ .../Source/shaders/position_skin_tex.vert | 74 +++++++++++ .../Source/shaders/position_tex.vert | 18 +++ .../Source/shaders/shadertoy_FireBall.fsh | 71 ++++++++++ .../Source/shaders/shadertoy_Glow.fsh | 123 ++++++++++++++++++ .../Source/shaders/shadertoy_LensFlare.fsh | 115 ++++++++++++++++ .../Source/shaders/simple_shadow.frag | 26 ++++ .../Source/shaders/simple_shadow.vert | 19 +++ tests/cpp-tests/Source/shaders/toon.frag | 29 +++++ tests/cpp-tests/Source/shaders/toon.vert | 20 +++ 50 files changed, 2032 insertions(+) create mode 100644 tests/cpp-tests/Source/shaders/Normal.frag create mode 100644 tests/cpp-tests/Source/shaders/OutLine.frag create mode 100644 tests/cpp-tests/Source/shaders/OutLine.vert create mode 100644 tests/cpp-tests/Source/shaders/SkinnedOutline.vert create mode 100644 tests/cpp-tests/Source/shaders/VertexColor.frag create mode 100644 tests/cpp-tests/Source/shaders/VertexColor.vert create mode 100644 tests/cpp-tests/Source/shaders/color_normal_tex.frag create mode 100644 tests/cpp-tests/Source/shaders/color_tex.frag create mode 100644 tests/cpp-tests/Source/shaders/cube_map.frag create mode 100644 tests/cpp-tests/Source/shaders/cube_map.vert create mode 100644 tests/cpp-tests/Source/shaders/cylinder.frag create mode 100644 tests/cpp-tests/Source/shaders/cylinder.vert create mode 100644 tests/cpp-tests/Source/shaders/example_3D_PositionTex.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_3D_PositionTex.vsh create mode 100644 tests/cpp-tests/Source/shaders/example_Bloom.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Blur.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Blur_winrt.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_CelShading.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_ColorBars.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_ColorBars.vsh create mode 100644 tests/cpp-tests/Source/shaders/example_EdgeDetection.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Flower.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_GreyScale.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Heart.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_HorizontalColor.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Julia.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_LensFlare.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Mandelbrot.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Monjori.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_MultiTexture.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_MultiTexture.vsh create mode 100644 tests/cpp-tests/Source/shaders/example_Noisy.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Normal.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Outline.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Plasma.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Sepia.fsh create mode 100644 tests/cpp-tests/Source/shaders/example_Simple.vsh create mode 100644 tests/cpp-tests/Source/shaders/example_Twist.fsh create mode 100644 tests/cpp-tests/Source/shaders/fog.frag create mode 100644 tests/cpp-tests/Source/shaders/fog.vert create mode 100644 tests/cpp-tests/Source/shaders/position_normal_tex.vert create mode 100644 tests/cpp-tests/Source/shaders/position_skin_tex.vert create mode 100644 tests/cpp-tests/Source/shaders/position_tex.vert create mode 100644 tests/cpp-tests/Source/shaders/shadertoy_FireBall.fsh create mode 100644 tests/cpp-tests/Source/shaders/shadertoy_Glow.fsh create mode 100644 tests/cpp-tests/Source/shaders/shadertoy_LensFlare.fsh create mode 100644 tests/cpp-tests/Source/shaders/simple_shadow.frag create mode 100644 tests/cpp-tests/Source/shaders/simple_shadow.vert create mode 100644 tests/cpp-tests/Source/shaders/toon.frag create mode 100644 tests/cpp-tests/Source/shaders/toon.vert diff --git a/tests/cpp-tests/Source/shaders/Normal.frag b/tests/cpp-tests/Source/shaders/Normal.frag new file mode 100644 index 0000000000..77fb2ce54c --- /dev/null +++ b/tests/cpp-tests/Source/shaders/Normal.frag @@ -0,0 +1,39 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; +layout(binding = 0) uniform sampler2D u_normalMap; + +layout(binding = 1) uniform sampler2D u_tex0; + +layout(std140, binding = 0) uniform fs_ub { + float u_kBump; + vec4 u_lightPosInLocalSpace; + vec2 u_contentSize; + vec3 u_diffuseL; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + vec4 texColor=texture(u_tex0, v_texCoord); + vec3 normal=texture(u_normalMap, v_texCoord).rgb; + normal=normal*2.0-1.0; + normal.y=-normal.y; + if(u_kBump!=1.0) + { + //if the vertex.z mult kBump, then the normal.z should div kBump and re-normalize + normal=vec3(normal.x,normal.y,normal.z/u_kBump); + normal=normalize(normal); + } + vec4 curPixelPosInLocalSpace=vec4(v_texCoord.x*u_contentSize.x,(1.0-v_texCoord.y)*u_contentSize.y,0.0,1.0); + vec4 lightDir=normalize(curPixelPosInLocalSpace-u_lightPosInLocalSpace); + vec3 posToLight=-lightDir.xyz; + float normDotPosToLight=max(0.0,dot(normal,posToLight)); + vec4 diffuse=vec4(normDotPosToLight*u_diffuseL,1.0); + vec4 ambient=vec4(0.5,0.5,0.5,1); + FragColor=texColor*vec4(vec3(diffuse+ambient),diffuse.a); +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/OutLine.frag b/tests/cpp-tests/Source/shaders/OutLine.frag new file mode 100644 index 0000000000..87b61bc9f6 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/OutLine.frag @@ -0,0 +1,15 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(std140, binding = 0) uniform fs_ub { + vec3 OutLineColor; + vec4 u_color; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + FragColor = vec4(OutLineColor,1.0) * u_color; +} diff --git a/tests/cpp-tests/Source/shaders/OutLine.vert b/tests/cpp-tests/Source/shaders/OutLine.vert new file mode 100644 index 0000000000..6d2e4e1b7f --- /dev/null +++ b/tests/cpp-tests/Source/shaders/OutLine.vert @@ -0,0 +1,18 @@ +#version 310 es +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec3 a_normal; + +layout(std140, binding = 0) uniform vs_ub { + float OutlineWidth; + mat4 u_MVPMatrix; +}; + +void main(void) +{ + vec4 pos = u_MVPMatrix * a_position; + vec4 normalproj = u_MVPMatrix * vec4(a_normal, 0); + normalproj = normalize(normalproj); + pos.xy += normalproj.xy * (OutlineWidth * (pos.z * 0.5 + 0.5)); + + gl_Position = pos; +} diff --git a/tests/cpp-tests/Source/shaders/SkinnedOutline.vert b/tests/cpp-tests/Source/shaders/SkinnedOutline.vert new file mode 100644 index 0000000000..2e4a9c0b11 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/SkinnedOutline.vert @@ -0,0 +1,79 @@ +#version 310 es +layout(location = 0) in vec3 a_position; +layout(location = 1) in vec3 a_normal; +layout(location = 2) in vec4 a_blendWeight; +layout(location = 3) in vec4 a_blendIndex; + + +const int SKINNING_JOINT_COUNT = 60; +// Uniforms + +// Varyings +layout(location = 0) out vec2 TextureCoordOut; + +layout(std140, binding = 0) uniform vs_ub { + float OutlineWidth; + vec4 u_matrixPalette[SKINNING_JOINT_COUNT * 3]; + mat4 u_MVPMatrix; +}; + +vec4 SkinnedVec3(vec4 vec) +{ + float blendWeight = a_blendWeight[0]; + + int matrixIndex = int (a_blendIndex[0]) * 3; + vec4 matrixPalette1 = u_matrixPalette[matrixIndex] * blendWeight; + vec4 matrixPalette2 = u_matrixPalette[matrixIndex + 1] * blendWeight; + vec4 matrixPalette3 = u_matrixPalette[matrixIndex + 2] * blendWeight; + + + blendWeight = a_blendWeight[1]; + if (blendWeight > 0.0) + { + matrixIndex = int(a_blendIndex[1]) * 3; + matrixPalette1 += u_matrixPalette[matrixIndex] * blendWeight; + matrixPalette2 += u_matrixPalette[matrixIndex + 1] * blendWeight; + matrixPalette3 += u_matrixPalette[matrixIndex + 2] * blendWeight; + } + + + blendWeight = a_blendWeight[2]; + if (blendWeight > 0.0) + { + matrixIndex = int(a_blendIndex[2]) * 3; + matrixPalette1 += u_matrixPalette[matrixIndex] * blendWeight; + matrixPalette2 += u_matrixPalette[matrixIndex + 1] * blendWeight; + matrixPalette3 += u_matrixPalette[matrixIndex + 2] * blendWeight; + } + + + blendWeight = a_blendWeight[3]; + if (blendWeight > 0.0) + { + matrixIndex = int(a_blendIndex[3]) * 3; + matrixPalette1 += u_matrixPalette[matrixIndex] * blendWeight; + matrixPalette2 += u_matrixPalette[matrixIndex + 1] * blendWeight; + matrixPalette3 += u_matrixPalette[matrixIndex + 2] * blendWeight; + } + + + vec4 _skinnedPosition; + vec4 postion = vec; + _skinnedPosition.x = dot(postion, matrixPalette1); + _skinnedPosition.y = dot(postion, matrixPalette2); + _skinnedPosition.z = dot(postion, matrixPalette3); + _skinnedPosition.w = postion.w; + + return _skinnedPosition; +} + +void main() +{ + vec4 pos = u_MVPMatrix * SkinnedVec3(vec4(a_position,1.0)); + + vec4 normalproj = u_MVPMatrix * vec4(SkinnedVec3(vec4(a_normal,0.0)).xyz, 0); + normalproj = normalize(normalproj); + pos.xy += normalproj.xy * (OutlineWidth * (pos.z * 0.5 + 0.5)); + + gl_Position = pos; +} diff --git a/tests/cpp-tests/Source/shaders/VertexColor.frag b/tests/cpp-tests/Source/shaders/VertexColor.frag new file mode 100644 index 0000000000..888937fb29 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/VertexColor.frag @@ -0,0 +1,12 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec4 v_fragmentColor; + +layout(location = 0) out vec4 FragColor; + +void main() +{ + FragColor = v_fragmentColor; +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/VertexColor.vert b/tests/cpp-tests/Source/shaders/VertexColor.vert new file mode 100644 index 0000000000..848926a667 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/VertexColor.vert @@ -0,0 +1,16 @@ +#version 310 es +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec4 a_color; + +layout(location = 0) out vec4 v_fragmentColor; + + +layout(std140, binding = 0) uniform vs_ub { + mat4 u_MVPMatrix; +}; + +void main() +{ + gl_Position = u_MVPMatrix * a_position; + v_fragmentColor = a_color; +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/color_normal_tex.frag b/tests/cpp-tests/Source/shaders/color_normal_tex.frag new file mode 100644 index 0000000000..79dc996daa --- /dev/null +++ b/tests/cpp-tests/Source/shaders/color_normal_tex.frag @@ -0,0 +1,117 @@ +#version 310 es +precision highp float; +precision highp int; + +#define MAX_DIRECTIONAL_LIGHT_NUM 1 + +#define MAX_POINT_LIGHT_NUM 1 + +#define MAX_SPOT_LIGHT_NUM 1 + +#if (MAX_DIRECTIONAL_LIGHT_NUM > 0) +#endif +#if (MAX_POINT_LIGHT_NUM > 0) +#endif +#if (MAX_SPOT_LIGHT_NUM > 0) +#endif + + +layout(location = 0) in vec2 TextureCoordOut; +#if MAX_POINT_LIGHT_NUM +layout(location = 1) in vec3 v_vertexToPointLightDirection[MAX_POINT_LIGHT_NUM]; +#if MAX_SPOT_LIGHT_NUM +layout(location = 2) in vec3 v_vertexToSpotLightDirection[MAX_SPOT_LIGHT_NUM]; +#endif +#if ((MAX_DIRECTIONAL_LIGHT_NUM > 0) || (MAX_POINT_LIGHT_NUM > 0) || (MAX_SPOT_LIGHT_NUM > 0)) +layout(location = 3) in vec3 v_normal; +#endif + +#endif + +layout(binding = 0) uniform sampler2D u_sampler0; + +layout(std140, binding = 0) uniform fs_ub { +#if (MAX_DIRECTIONAL_LIGHT_NUM > 0) + vec3 u_DirLightSourceColor[MAX_DIRECTIONAL_LIGHT_NUM]; + vec3 u_DirLightSourceDirection[MAX_DIRECTIONAL_LIGHT_NUM]; +#endif +#if (MAX_POINT_LIGHT_NUM > 0) + vec3 u_PointLightSourceColor[MAX_POINT_LIGHT_NUM]; + float u_PointLightSourceRangeInverse[MAX_POINT_LIGHT_NUM]; +#endif +#if (MAX_SPOT_LIGHT_NUM > 0) + vec3 u_SpotLightSourceColor[MAX_SPOT_LIGHT_NUM]; + vec3 u_SpotLightSourceDirection[MAX_SPOT_LIGHT_NUM]; + float u_SpotLightSourceInnerAngleCos[MAX_SPOT_LIGHT_NUM]; + float u_SpotLightSourceOuterAngleCos[MAX_SPOT_LIGHT_NUM]; + float u_SpotLightSourceRangeInverse[MAX_SPOT_LIGHT_NUM]; +#endif + vec3 u_AmbientLightSourceColor; + vec4 u_color; +}; + +vec3 computeLighting(vec3 normalVector, vec3 lightDirection, vec3 lightColor, float attenuation) +{ + float diffuse = max(dot(normalVector, lightDirection), 0.0); + vec3 diffuseColor = lightColor * diffuse * attenuation; + + return diffuseColor; +} + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ +#if ((MAX_DIRECTIONAL_LIGHT_NUM > 0) || (MAX_POINT_LIGHT_NUM > 0) || (MAX_SPOT_LIGHT_NUM > 0)) + vec3 normal = normalize(v_normal); +#endif + + vec4 combinedColor = vec4(u_AmbientLightSourceColor, 1.0); + + // Directional light contribution +#if (MAX_DIRECTIONAL_LIGHT_NUM > 0) + for (int i = 0; i < MAX_DIRECTIONAL_LIGHT_NUM; ++i) + { + vec3 lightDirection = normalize(u_DirLightSourceDirection[i] * 2.0); + combinedColor.xyz += computeLighting(normal, -lightDirection, u_DirLightSourceColor[i], 1.0); + } +#endif + + // Point light contribution +#if (MAX_POINT_LIGHT_NUM > 0) + for (int i = 0; i < MAX_POINT_LIGHT_NUM; ++i) + { + vec3 ldir = v_vertexToPointLightDirection[i] * u_PointLightSourceRangeInverse[i]; + float attenuation = clamp(1.0 - dot(ldir, ldir), 0.0, 1.0); + combinedColor.xyz += computeLighting(normal, normalize(v_vertexToPointLightDirection[i]), u_PointLightSourceColor[i], attenuation); + } +#endif + + // Spot light contribution +#if (MAX_SPOT_LIGHT_NUM > 0) + for (int i = 0; i < MAX_SPOT_LIGHT_NUM; ++i) + { + // Compute range attenuation + vec3 ldir = v_vertexToSpotLightDirection[i] * u_SpotLightSourceRangeInverse[i]; + float attenuation = clamp(1.0 - dot(ldir, ldir), 0.0, 1.0); + vec3 vertexToSpotLightDirection = normalize(v_vertexToSpotLightDirection[i]); + + vec3 spotLightDirection = normalize(u_SpotLightSourceDirection[i] * 2.0); + + // "-lightDirection" is used because light direction points in opposite direction to spot direction. + float spotCurrentAngleCos = dot(spotLightDirection, -vertexToSpotLightDirection); + + // Apply spot attenuation + attenuation *= smoothstep(u_SpotLightSourceOuterAngleCos[i], u_SpotLightSourceInnerAngleCos[i], spotCurrentAngleCos); + attenuation = clamp(attenuation, 0.0, 1.0); + combinedColor.xyz += computeLighting(normal, vertexToSpotLightDirection, u_SpotLightSourceColor[i], attenuation); + } +#endif + +#if ((MAX_DIRECTIONAL_LIGHT_NUM > 0) || (MAX_POINT_LIGHT_NUM > 0) || (MAX_SPOT_LIGHT_NUM > 0)) + FragColor = texture(u_sampler0, TextureCoordOut) * u_color * combinedColor; +#else + FragColor = texture(u_sampler0, TextureCoordOut) * u_color; +#endif + +} diff --git a/tests/cpp-tests/Source/shaders/color_tex.frag b/tests/cpp-tests/Source/shaders/color_tex.frag new file mode 100644 index 0000000000..58174e7a49 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/color_tex.frag @@ -0,0 +1,17 @@ +#version 310 es +precision highp float; +precision highp int; +layout(location = 0) in vec2 TextureCoordOut; +layout(binding = 0) uniform sampler2D u_sampler0; + +layout(std140, binding = 0) uniform fs_ub { + vec4 u_color; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + FragColor = texture(u_sampler0, TextureCoordOut) * u_color; +} + diff --git a/tests/cpp-tests/Source/shaders/cube_map.frag b/tests/cpp-tests/Source/shaders/cube_map.frag new file mode 100644 index 0000000000..50a555db3b --- /dev/null +++ b/tests/cpp-tests/Source/shaders/cube_map.frag @@ -0,0 +1,17 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec3 v_reflect; +layout(binding = 0) uniform samplerCube u_cubeTex; + +layout(std140, binding = 0) uniform fs_ub { + vec4 u_color; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + FragColor = texture(u_cubeTex, v_reflect) * u_color; +} diff --git a/tests/cpp-tests/Source/shaders/cube_map.vert b/tests/cpp-tests/Source/shaders/cube_map.vert new file mode 100644 index 0000000000..85e2137e50 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/cube_map.vert @@ -0,0 +1,24 @@ +#version 310 es +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec3 a_normal; + +layout(location = 0) out vec3 v_reflect; +//uniforms + +layout(std140, binding = 0) uniform vs_ub { + mat4 u_MVPMatrix; + mat4 u_MVMatrix; + mat3 u_NormalMatrix; +}; + +void main(void) +{ + gl_Position = u_MVPMatrix * a_position; + + // compute reflect + vec4 positionWorldViewSpace = u_MVMatrix * a_position; + vec3 vEyeVertex = normalize(positionWorldViewSpace.xyz); + + vec3 v_normalVector = u_NormalMatrix * a_normal; + v_reflect = normalize(reflect(-vEyeVertex, v_normalVector)); +} diff --git a/tests/cpp-tests/Source/shaders/cylinder.frag b/tests/cpp-tests/Source/shaders/cylinder.frag new file mode 100644 index 0000000000..661ae09dd5 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/cylinder.frag @@ -0,0 +1,21 @@ +#version 310 es +precision highp float; +precision highp int; +layout(location = 0) in vec2 v_texture_coord; + +layout(binding = 0) uniform sampler2D u_sampler0; +layout(binding = 1) uniform sampler2D u_sampler1; +layout(std140, binding = 0) uniform fs_ub { + vec4 u_color; + float offset; + float duration; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + vec4 color = duration*vec4(0,0.8,0.4,1.0); + //blend two texture + FragColor = u_color*texture(u_sampler0, vec2(v_texture_coord.x- 2.0 * offset,v_texture_coord.y)) * vec4(0.3,0.3,0.3,1)+texture(u_sampler1,vec2(v_texture_coord.x-offset,v_texture_coord.y)).r*color; +} diff --git a/tests/cpp-tests/Source/shaders/cylinder.vert b/tests/cpp-tests/Source/shaders/cylinder.vert new file mode 100644 index 0000000000..9ea65dc5ad --- /dev/null +++ b/tests/cpp-tests/Source/shaders/cylinder.vert @@ -0,0 +1,16 @@ +#version 310 es +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec2 a_texCoord; +layout(location = 0) out vec2 v_texture_coord; + +layout(std140, binding = 0) uniform vs_ub { + float offset; + mat4 u_MVPMatrix; +}; + +void main(void) +{ + gl_Position = u_MVPMatrix * a_position; + v_texture_coord = a_texCoord; + v_texture_coord.y = (1.0 - v_texture_coord.y); +} diff --git a/tests/cpp-tests/Source/shaders/example_3D_PositionTex.fsh b/tests/cpp-tests/Source/shaders/example_3D_PositionTex.fsh new file mode 100644 index 0000000000..30b4cc61a0 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_3D_PositionTex.fsh @@ -0,0 +1,18 @@ +#version 310 es +precision highp float; +precision highp int; +layout(location = 0) in vec2 TextureCoordOut; + +layout(binding = 0) uniform sampler2D u_tex0; + +layout(std140, binding = 0) uniform fs_ub { + vec4 u_color; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + FragColor = texture(u_tex0, TextureCoordOut) * u_color; +} + diff --git a/tests/cpp-tests/Source/shaders/example_3D_PositionTex.vsh b/tests/cpp-tests/Source/shaders/example_3D_PositionTex.vsh new file mode 100644 index 0000000000..24550dbfe4 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_3D_PositionTex.vsh @@ -0,0 +1,17 @@ +#version 310 es +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec2 a_texCoord; + +layout(location = 0) out vec2 TextureCoordOut; + + +layout(std140, binding = 0) uniform vs_ub { + mat4 u_MVPMatrix; +}; + +void main(void) +{ + gl_Position = u_MVPMatrix * a_position; + TextureCoordOut = a_texCoord; + TextureCoordOut.y = 1.0 - TextureCoordOut.y; +} diff --git a/tests/cpp-tests/Source/shaders/example_Bloom.fsh b/tests/cpp-tests/Source/shaders/example_Bloom.fsh new file mode 100644 index 0000000000..bfe3b60534 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Bloom.fsh @@ -0,0 +1,59 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; + +layout(binding = 0) uniform sampler2D u_tex0; + +const float blurSize = 1.0/512.0; +const float intensity = 0.35; +layout(std140, binding = 0) uniform fs_ub { + vec2 resolution; +}; + +layout(location = 0) out vec4 FragColor; + +void main() +{ + vec4 sum = vec4(0); + vec2 texcoord = v_texCoord.xy; + int j; + int i; + + //thank you! http://www.gamerendering.com/2008/10/11/gaussian-blur-filter-shader/ for the + //blur tutorial + // blur in y (vertical) + // take nine samples, with the distance blurSize between them + sum += texture(u_tex0, vec2(texcoord.x - 4.0*blurSize, texcoord.y)) * 0.05; + sum += texture(u_tex0, vec2(texcoord.x - 3.0*blurSize, texcoord.y)) * 0.09; + sum += texture(u_tex0, vec2(texcoord.x - 2.0*blurSize, texcoord.y)) * 0.12; + sum += texture(u_tex0, vec2(texcoord.x - blurSize, texcoord.y)) * 0.15; + sum += texture(u_tex0, vec2(texcoord.x, texcoord.y)) * 0.16; + sum += texture(u_tex0, vec2(texcoord.x + blurSize, texcoord.y)) * 0.15; + sum += texture(u_tex0, vec2(texcoord.x + 2.0*blurSize, texcoord.y)) * 0.12; + sum += texture(u_tex0, vec2(texcoord.x + 3.0*blurSize, texcoord.y)) * 0.09; + sum += texture(u_tex0, vec2(texcoord.x + 4.0*blurSize, texcoord.y)) * 0.05; + + // blur in y (vertical) + // take nine samples, with the distance blurSize between them + sum += texture(u_tex0, vec2(texcoord.x, texcoord.y - 4.0*blurSize)) * 0.05; + sum += texture(u_tex0, vec2(texcoord.x, texcoord.y - 3.0*blurSize)) * 0.09; + sum += texture(u_tex0, vec2(texcoord.x, texcoord.y - 2.0*blurSize)) * 0.12; + sum += texture(u_tex0, vec2(texcoord.x, texcoord.y - blurSize)) * 0.15; + sum += texture(u_tex0, vec2(texcoord.x, texcoord.y)) * 0.16; + sum += texture(u_tex0, vec2(texcoord.x, texcoord.y + blurSize)) * 0.15; + sum += texture(u_tex0, vec2(texcoord.x, texcoord.y + 2.0*blurSize)) * 0.12; + sum += texture(u_tex0, vec2(texcoord.x, texcoord.y + 3.0*blurSize)) * 0.09; + sum += texture(u_tex0, vec2(texcoord.x, texcoord.y + 4.0*blurSize)) * 0.05; + + //increase blur with intensity! + FragColor = sum*intensity + texture(u_tex0, texcoord); + return; + /*if(sin(iGlobalTime) > 0.0) + FragColor = sum * sin(iGlobalTime)+ texture(iChannel0, texcoord); + else + FragColor = sum * -sin(iGlobalTime)+ texture(iChannel0, texcoord); + */ +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/example_Blur.fsh b/tests/cpp-tests/Source/shaders/example_Blur.fsh new file mode 100644 index 0000000000..77cad33b5b --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Blur.fsh @@ -0,0 +1,53 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; + + +layout(binding = 0) uniform sampler2D u_tex0; + +layout(std140, binding = 0) uniform fs_ub { + vec2 resolution; + float blurRadius; + float sampleNum; +}; + +vec4 blur(vec2); + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + vec4 col = blur(v_texCoord); //* v_fragmentColor.rgb; + FragColor = vec4(col) * v_fragmentColor; +} + +vec4 blur(vec2 p) +{ + if (blurRadius > 0.0 && sampleNum > 1.0) + { + vec4 col = vec4(0); + vec2 unit = 1.0 / resolution.xy; + + float r = blurRadius; + float sampleStep = r / sampleNum; + + float count = 0.0; + + for(float x = -r; x < r; x += sampleStep) + { + for(float y = -r; y < r; y += sampleStep) + { + float weight = (r - abs(x)) * (r - abs(y)); + col += texture(u_tex0, p + vec2(x * unit.x, y * unit.y)) * weight; + count += weight; + } + } + + return col / count; + } + + return texture(u_tex0, p); +} diff --git a/tests/cpp-tests/Source/shaders/example_Blur_winrt.fsh b/tests/cpp-tests/Source/shaders/example_Blur_winrt.fsh new file mode 100644 index 0000000000..ac861246d9 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Blur_winrt.fsh @@ -0,0 +1,43 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; + + +layout(binding = 0) uniform sampler2D u_tex0; + +layout(std140, binding = 0) uniform fs_ub { + vec2 resolution; +}; + +vec4 blur(vec2); + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + vec4 col = blur(v_texCoord); //* v_fragmentColor.rgb; + FragColor = vec4(col) * v_fragmentColor; +} + +vec4 blur(vec2 p) +{ + vec4 col = vec4(0); + vec2 unit = 1.0 / resolution.xy; + + float count = 0.0; + + for(float x = -4.0; x <= 4.0; x += 2.0) + { + for(float y = -4.0; y <= 4.0; y += 2.0) + { + float weight = (4.0 - abs(x)) * (4.0 - abs(y)); + col += texture(u_tex0, p + vec2(x * unit.x, y * unit.y)) * weight; + count += weight; + } + } + + return col / count; +} diff --git a/tests/cpp-tests/Source/shaders/example_CelShading.fsh b/tests/cpp-tests/Source/shaders/example_CelShading.fsh new file mode 100644 index 0000000000..96559fabf3 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_CelShading.fsh @@ -0,0 +1,70 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; + + +layout(binding = 0) uniform sampler2D u_tex0; + +#define FILTER_SIZE 3 +#define COLOR_LEVELS 7.0 +#define EDGE_FILTER_SIZE 3 +#define EDGE_THRESHOLD 0.05 + +layout(std140, binding = 0) uniform fs_ub { + vec2 resolution; +}; + +vec4 edgeFilter(in int px, in int py) +{ + vec4 color = vec4(0.0); + + for (int y = -EDGE_FILTER_SIZE; y <= EDGE_FILTER_SIZE; ++y) + { + for (int x = -EDGE_FILTER_SIZE; x <= EDGE_FILTER_SIZE; ++x) + { + color += texture(u_tex0, v_texCoord + vec2(px + x, py + y) / resolution.xy); + } + } + + color /= float((2 * EDGE_FILTER_SIZE + 1) * (2 * EDGE_FILTER_SIZE + 1)); + + return color; +} + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + // Shade + vec4 color = vec4(0.0); + + for (int y = -FILTER_SIZE; y <= FILTER_SIZE; ++y) + { + for (int x = -FILTER_SIZE; x <= FILTER_SIZE; ++x) + { + color += texture(u_tex0, v_texCoord + vec2(x, y) / resolution.xy); + } + } + + color /= float((2 * FILTER_SIZE + 1) * (2 * FILTER_SIZE + 1)); + + for (int c = 0; c < 3; ++c) + { + color[c] = floor(COLOR_LEVELS * color[c]) / COLOR_LEVELS; + } + + // Highlight edges + vec4 sum = abs(edgeFilter(0, 1) - edgeFilter(0, -1)); + sum += abs(edgeFilter(1, 0) - edgeFilter(-1, 0)); + sum /= 2.0; + + if (length(sum) > EDGE_THRESHOLD) + { + color.rgb = vec3(0.0); + } + + FragColor = color; +} diff --git a/tests/cpp-tests/Source/shaders/example_ColorBars.fsh b/tests/cpp-tests/Source/shaders/example_ColorBars.fsh new file mode 100644 index 0000000000..876c2b7745 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_ColorBars.fsh @@ -0,0 +1,46 @@ +#version 310 es +precision highp float; +precision highp int; +// http://www.cocos2d-iphone.org + + +layout(location = 0) in vec2 v_texCoord; +layout(binding = 0) uniform sampler2D u_tex0; + +vec4 getColorByCoord(int y){ + if(y < 5){ + if(y == 0){ + return vec4(1,0,0,1); + } else if(y == 1){ + return vec4(0,1,0,1); + } else if(y == 2){ + return vec4(0,0,1,1); + } else if(y == 3){ + return vec4(0,1,1,1); + } else{ + return vec4(1,0,1,1); + } + } else { + if(y == 5){ + return vec4(1,1,0,1); + } else if(y == 6){ + return vec4(1,1,1,1); + } else if(y == 7){ + return vec4(1,0.5,0,1); + } else if(y == 8){ + return vec4(1,0.5,0.5,1); + }else { + return vec4(0.5,0.5,1,1); + } + } +} + +layout(location = 0) out vec4 FragColor; + +void main(void) { + // inline to prevent "float" loss and keep using lowp + //int y = int( mod(( (gl_FragCoord.y+gl_FragCoord.x)*mod(AX_Time[0],5.0)) / 10.0, 10.0 ) ); + //int y = int( mod( AX_Time[3] + (gl_FragCoord.y + gl_FragCoord.x) / 10.0, 10.0 ) ); + int y = int( mod(gl_FragCoord.y / 10.0, 10.0 ) ); + FragColor = getColorByCoord(y) * texture(u_tex0, v_texCoord); +} diff --git a/tests/cpp-tests/Source/shaders/example_ColorBars.vsh b/tests/cpp-tests/Source/shaders/example_ColorBars.vsh new file mode 100644 index 0000000000..a65016e300 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_ColorBars.vsh @@ -0,0 +1,19 @@ +#version 310 es +// http://www.cocos2d-iphone.org + +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec2 a_texCoord; + +layout(location = 0) out vec2 v_texCoord; + + +layout(std140, binding = 0) uniform vs_ub { + mat4 u_PMatrix; +}; + +void main() +{ + gl_Position = u_PMatrix * a_position; + v_texCoord = a_texCoord; +} + diff --git a/tests/cpp-tests/Source/shaders/example_EdgeDetection.fsh b/tests/cpp-tests/Source/shaders/example_EdgeDetection.fsh new file mode 100644 index 0000000000..9e38e05504 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_EdgeDetection.fsh @@ -0,0 +1,47 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; + +layout(binding = 0) uniform sampler2D u_tex0; + +layout(std140, binding = 0) uniform fs_ub { + vec2 resolution; +}; + +float lookup(vec2 p, float dx, float dy) +{ + vec2 uv = p.xy + vec2(dx , dy ) / resolution.xy; + vec4 c = texture(u_tex0, uv.xy); + return 0.2126*c.r + 0.7152*c.g + 0.0722*c.b; +} + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + vec2 p = v_texCoord.xy; + // simple sobel edge detection + float gx = 0.0; + gx += -1.0 * lookup(p, -1.0, -1.0); + gx += -2.0 * lookup(p, -1.0, 0.0); + gx += -1.0 * lookup(p, -1.0, 1.0); + gx += 1.0 * lookup(p, 1.0, -1.0); + gx += 2.0 * lookup(p, 1.0, 0.0); + gx += 1.0 * lookup(p, 1.0, 1.0); + + float gy = 0.0; + gy += -1.0 * lookup(p, -1.0, -1.0); + gy += -2.0 * lookup(p, 0.0, -1.0); + gy += -1.0 * lookup(p, 1.0, -1.0); + gy += 1.0 * lookup(p, -1.0, 1.0); + gy += 2.0 * lookup(p, 0.0, 1.0); + gy += 1.0 * lookup(p, 1.0, 1.0); + + float g = gx*gx + gy*gy; + + FragColor.xyz = vec3(1.-g); + FragColor.w = 1.; +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/example_Flower.fsh b/tests/cpp-tests/Source/shaders/example_Flower.fsh new file mode 100644 index 0000000000..f0ce8fe919 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Flower.fsh @@ -0,0 +1,49 @@ +#version 310 es +precision highp float; +precision highp int; +// Shader from http://www.iquilezles.org/apps/shadertoy/ + + + +layout(std140, binding = 0) uniform fs_ub { + vec2 center; + vec2 resolution; + vec2 u_screenSize; + vec4 u_Time; +}; + +//float u( float x ) { return 0.5+0.5*sign(x); } +float u( float x ) { return (x>0.0)?1.0:0.0; } +//float u( float x ) { return abs(x)/x; } + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + float time = u_Time[1]; +#ifdef METAL + vec2 fragCoord = vec2(gl_FragCoord.x, u_screenSize.y - gl_FragCoord.y); +#else + vec2 fragCoord = gl_FragCoord.xy; +#endif + vec2 p = 2.0 * (fragCoord - center.xy) / resolution.xy; + + float a = atan(p.x,p.y); + float r = length(p)*.75; + + float w = cos(3.1415927*time-r*2.0); + float h = 0.5+0.5*cos(12.0*a-w*7.0+r*8.0); + float d = 0.25+0.75*pow(h,1.0*r)*(0.7+0.3*w); + + float rd = 1.0-r/d; + float col = 0.0; + if(rd > 0.0) + col = u( d-r ) * sqrt(rd)*r*2.5; + col *= 1.25+0.25*cos((12.0*a-w*7.0+r*8.0)/2.0); + col *= 1.0 - 0.35*(0.5+0.5*sin(r*30.0))*(0.5+0.5*cos(12.0*a-w*7.0+r*8.0)); + FragColor = vec4( + col, + col-h*0.5+r*.2 + 0.35*h*(1.0-r), + col-h*r + 0.1*h*(1.0-r), + 1.0); +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/example_GreyScale.fsh b/tests/cpp-tests/Source/shaders/example_GreyScale.fsh new file mode 100644 index 0000000000..9506f14b4d --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_GreyScale.fsh @@ -0,0 +1,17 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; + +layout(binding = 0) uniform sampler2D u_tex0; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + vec4 c = texture(u_tex0, v_texCoord); + FragColor.xyz = vec3(0.2126*c.r + 0.7152*c.g + 0.0722*c.b); + FragColor.w = c.w; +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/example_Heart.fsh b/tests/cpp-tests/Source/shaders/example_Heart.fsh new file mode 100644 index 0000000000..5746b20667 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Heart.fsh @@ -0,0 +1,45 @@ +#version 310 es +precision highp float; +precision highp int; +// Shader from http://www.iquilezles.org/apps/shadertoy/ + + + +layout(std140, binding = 0) uniform fs_ub { + vec2 center; + vec2 resolution; + vec2 u_screenSize; + vec4 u_Time; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + float time = u_Time[1]; +#ifdef METAL + vec2 fragCoord = vec2(gl_FragCoord.x, u_screenSize.y - gl_FragCoord.y); +#else + vec2 fragCoord = gl_FragCoord.xy; +#endif + vec2 p = 2.0 * (fragCoord - center.xy) / resolution.xy; + + // animate + float tt = mod(time,2.0)/2.0; + float ss = pow(tt,.2)*0.5 + 0.5; + ss -= ss*0.2*sin(tt*6.2831*5.0)*exp(-tt*6.0); + p *= vec2(0.5,1.5) + ss*vec2(0.5,-0.5); + + + float a = atan(p.x,p.y)/3.141593; + float r = length(p); + + // shape + float h = abs(a); + float d = (13.0*h - 22.0*h*h + 10.0*h*h*h)/(6.0-5.0*h); + + // color + float f = step(r,d) * pow(1.0-r/d,0.25); + + FragColor = vec4(f,0.0,0.0,1.0); +} diff --git a/tests/cpp-tests/Source/shaders/example_HorizontalColor.fsh b/tests/cpp-tests/Source/shaders/example_HorizontalColor.fsh new file mode 100644 index 0000000000..860c88860e --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_HorizontalColor.fsh @@ -0,0 +1,39 @@ +#version 310 es +precision highp float; +precision highp int; +// http://www.cocos2d-iphone.org + + +layout(location = 0) in vec2 v_texCoord; + +layout(binding = 0) uniform sampler2D u_tex0; + +layout(std140, binding = 0) uniform fs_ub { + vec2 u_screenSize; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + vec4 optColor; +#ifdef METAL + float fragCoordY = u_screenSize.y - gl_FragCoord.y; +#else + float fragCoordY = gl_FragCoord.y; +#endif + int y = int( mod(fragCoordY / 3.0, 10.0 ) ); + if(y == 0) optColor = vec4(1,0,0,1); + else if(y == 1) optColor = vec4(0,1,0,1); + else if(y == 2) optColor = vec4(0,0,1,1); + else if(y == 3) optColor = vec4(0,1,1,1); + else if(y == 4) optColor = vec4(1,0,1,1); + else if(y == 5) optColor = vec4(1,1,0,1); + else if(y == 6) optColor = vec4(1,1,1,1); + else if(y == 7) optColor = vec4(1,0.5,0,1); + else if(y == 8) optColor = vec4(1,0.5,0.5,1); + else if(y == 9) optColor = vec4(0.5,0.5,1,1); + + // inline to prevent "float" loss and keep using lowp + FragColor = optColor * texture(u_tex0, v_texCoord); +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/example_Julia.fsh b/tests/cpp-tests/Source/shaders/example_Julia.fsh new file mode 100644 index 0000000000..eada82021f --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Julia.fsh @@ -0,0 +1,41 @@ +#version 310 es +precision highp float; +precision highp int; +// Shader from http://www.iquilezles.org/apps/shadertoy/ + + + +layout(std140, binding = 0) uniform fs_ub { + vec2 center; + vec2 resolution; + vec2 u_screenSize; + vec4 u_Time; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + float time = u_Time[1]; +#ifdef METAL + vec2 fragCoord = vec2(gl_FragCoord.x, u_screenSize.y - gl_FragCoord.y); +#else + vec2 fragCoord = gl_FragCoord.xy; +#endif + vec2 p = 2.0 * (fragCoord - center.xy) / resolution.xy; + vec2 cc = vec2( cos(.25*time), sin(.25*time*1.423) ); + + float dmin = 1000.0; + vec2 z = p*vec2(1.33,1.0); + for( int i=0; i<64; i++ ) + { + z = cc + vec2( z.x*z.x - z.y*z.y, 2.0*z.x*z.y ); + float m2 = dot(z,z); + if( m2>100.0 ) break; + dmin=min(dmin,m2); + } + + float color = sqrt(sqrt(dmin))*0.7; + FragColor = vec4(color,color,color,1.0); +} + diff --git a/tests/cpp-tests/Source/shaders/example_LensFlare.fsh b/tests/cpp-tests/Source/shaders/example_LensFlare.fsh new file mode 100644 index 0000000000..2cf5f572d0 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_LensFlare.fsh @@ -0,0 +1,109 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; + + + +layout(binding = 0) uniform sampler2D u_tex0; + +/*by musk License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. + + Trying to get some interesting looking lens flares. + + 13/08/13: + published + + muuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuusk!*/ + +layout(std140, binding = 0) uniform fs_ub { + vec2 resolution; + vec2 textureResolution; + vec4 u_Time; +}; + +float noise(float t) +{ + return texture(u_tex0,vec2(t,.0)/textureResolution.xy).x; +} +float noise(vec2 t) +{ + return texture(u_tex0,t/textureResolution.xy).x; +} + +vec3 lensflare(vec2 uv,vec2 pos) +{ + vec2 main = uv-pos; + vec2 uvd = uv*(length(uv)); + + float ang = atan(main.x,main.y); + float dist=length(main); dist = pow(dist,.1); + float n = noise(vec2(ang*16.0,dist*32.0)); + + float f0 = 1.0/(length(uv-pos)*16.0+1.0); + + f0 = f0+f0*(sin(noise((pos.x+pos.y)*2.2+ang*4.0+5.954)*16.0)*.1+dist*.1+.8); + + float f1 = max(0.01-pow(length(uv+1.2*pos),1.9),.0)*7.0; + + float f2 = max(1.0/(1.0+32.0*pow(length(uvd+0.8*pos),2.0)),.0)*00.25; + float f22 = max(1.0/(1.0+32.0*pow(length(uvd+0.85*pos),2.0)),.0)*00.23; + float f23 = max(1.0/(1.0+32.0*pow(length(uvd+0.9*pos),2.0)),.0)*00.21; + + vec2 uvx = mix(uv,uvd,-0.5); + + float f4 = max(0.01-pow(length(uvx+0.4*pos),2.4),.0)*6.0; + float f42 = max(0.01-pow(length(uvx+0.45*pos),2.4),.0)*5.0; + float f43 = max(0.01-pow(length(uvx+0.5*pos),2.4),.0)*3.0; + + uvx = mix(uv,uvd,-.4); + + float f5 = max(0.01-pow(length(uvx+0.2*pos),5.5),.0)*2.0; + float f52 = max(0.01-pow(length(uvx+0.4*pos),5.5),.0)*2.0; + float f53 = max(0.01-pow(length(uvx+0.6*pos),5.5),.0)*2.0; + + uvx = mix(uv,uvd,-0.5); + + float f6 = max(0.01-pow(length(uvx-0.3*pos),1.6),.0)*6.0; + float f62 = max(0.01-pow(length(uvx-0.325*pos),1.6),.0)*3.0; + float f63 = max(0.01-pow(length(uvx-0.35*pos),1.6),.0)*5.0; + + vec3 c = vec3(.0); + + c.r+=f2+f4+f5+f6; c.g+=f22+f42+f52+f62; c.b+=f23+f43+f53+f63; + c = c*1.3 - vec3(length(uvd)*.05); + c+=vec3(f0); + + return c; +} + +vec3 cc(vec3 color, float factor,float factor2) // color modifier +{ + float w = color.x+color.y+color.z; + return mix(color,vec3(w)*factor,w*factor2); +} + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + vec2 uv = v_texCoord - 0.5; + uv.x *= resolution.x/resolution.y; //fix aspect ratio +// vec3 mouse = vec3(iMouse.xy/iResolution.xy - 0.5,iMouse.z-.5); +// mouse.x *= iResolution.x/iResolution.y; //fix aspect ratio +// if (iMouse.z<.5) +// { +// +// } + vec3 mouse; + mouse.z = 0.5; + mouse.x=sin(u_Time[1])*.5; + mouse.y=sin(u_Time[1]*.913)*.5; + + vec3 color = vec3(1.4,1.2,1.0)*lensflare(uv,mouse.xy); + color -= noise(v_texCoord * resolution)*.015; + color = cc(color,.5,.1); + FragColor = vec4(color,1.0); +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/example_Mandelbrot.fsh b/tests/cpp-tests/Source/shaders/example_Mandelbrot.fsh new file mode 100644 index 0000000000..0bc17f5b6f --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Mandelbrot.fsh @@ -0,0 +1,53 @@ +#version 310 es +precision highp float; +precision highp int; +// Shader from http://www.iquilezles.org/apps/shadertoy/ + + + +layout(std140, binding = 0) uniform fs_ub { + vec2 center; + vec2 resolution; + vec2 u_screenSize; + vec4 u_Time; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ +#ifdef METAL + vec2 fragCoord = vec2(gl_FragCoord.x, u_screenSize.y - gl_FragCoord.y); +#else + vec2 fragCoord = gl_FragCoord.xy; +#endif + vec2 p = 2.0 * (fragCoord - center.xy) / resolution.xy; + p.x *= resolution.x/resolution.y; + + float zoo = .62+.38*sin(.1*u_Time[1]); + float coa = cos( 0.1*(1.0-zoo)*u_Time[1] ); + float sia = sin( 0.1*(1.0-zoo)*u_Time[1] ); + zoo = pow( zoo,8.0); + vec2 xy = vec2( p.x*coa-p.y*sia, p.x*sia+p.y*coa); + vec2 cc = vec2(-.745,.186) + xy*zoo; + + vec2 z = vec2(0.0); + vec2 z2 = z*z; + float m2; + float co = 0.0; + + for( int i=0; i<256; i++ ) + { + z = cc + vec2( z.x*z.x - z.y*z.y, 2.0*z.x*z.y ); + m2 = dot(z,z); + if( m2>1024.0 ) break; + co += 1.0; + } + co = co + 1.0 - log2(.5*log2(m2)); + + co = sqrt(co/256.0); + FragColor = vec4( .5+.5*cos(6.2831*co+0.0), + .5+.5*cos(6.2831*co+0.4), + .5+.5*cos(6.2831*co+0.7), + 1.0 ); +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/example_Monjori.fsh b/tests/cpp-tests/Source/shaders/example_Monjori.fsh new file mode 100644 index 0000000000..f445a03f0d --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Monjori.fsh @@ -0,0 +1,47 @@ +#version 310 es +precision highp float; +precision highp int; +// Shader from http://www.iquilezles.org/apps/shadertoy/ + + + +layout(std140, binding = 0) uniform fs_ub { + vec2 center; + vec2 resolution; + vec4 u_Time; + vec2 u_screenSize; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ +#ifdef METAL + vec2 fragCoord = vec2(gl_FragCoord.x, u_screenSize.y - gl_FragCoord.y); +#else + vec2 fragCoord = gl_FragCoord.xy; +#endif + vec2 p = 2.0 * (fragCoord - center.xy) / resolution.xy; + float a = u_Time[1]*40.0; + float d,e,f,g=1.0/40.0,h,i,r,q; + e=400.0*(p.x*0.5+0.5); + f=400.0*(p.y*0.5+0.5); + i=200.0+sin(e*g+a/150.0)*20.0; + d=200.0+cos(f*g/2.0)*18.0+cos(e*g)*7.0; + r=sqrt(pow(i-e,2.0)+pow(d-f,2.0)); + q=f/r; + e=(r*cos(q))-a/2.0;f=(r*sin(q))-a/2.0; + d=sin(e*g)*176.0+sin(e*g)*164.0+r; + h=((f+d)+a/2.0)*g; + i=cos(h+r*p.x/1.3)*(e+e+a)+cos(q*g*6.0)*(r+h/3.0); + h=sin(f*g)*144.0-sin(e*g)*212.0*p.x; + h=(h+(f-e)*q+sin(r-(a+h)/7.0)*10.0+i/4.0)*g; + i+=cos(h*2.3*sin(a/350.0-q))*184.0*sin(q-(r*4.3+a/12.0)*g)+tan(r*g+h)*184.0*cos(r*g+h); + i=mod(i/5.6,256.0)/64.0; + if(i<0.0) i+=4.0; + if(i>=2.0) i=4.0-i; + d=r/350.0; + d+=sin(d*d*8.0)*0.52; + f=(sin(a*g)+1.0)/2.0; + FragColor=vec4(vec3(f*i/1.6,i/2.0+d/13.0,i)*d*p.x+vec3(i/1.3+d/8.0,i/2.0+d/18.0,i)*d*(1.0-p.x),1.0); +} diff --git a/tests/cpp-tests/Source/shaders/example_MultiTexture.fsh b/tests/cpp-tests/Source/shaders/example_MultiTexture.fsh new file mode 100644 index 0000000000..eadcb37df3 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_MultiTexture.fsh @@ -0,0 +1,24 @@ +#version 310 es +precision highp float; +precision highp int; + + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; + +layout(binding = 0) uniform sampler2D u_tex0; +layout(binding = 1) uniform sampler2D u_tex1; + + +layout(std140, binding = 0) uniform fs_ub { + float u_interpolate; +}; + +layout(location = 0) out vec4 FragColor; + +void main() { + vec4 color1 = texture(u_tex0, v_texCoord); + vec4 color2 = texture(u_tex1, v_texCoord); + FragColor = v_fragmentColor * mix( color1, color2, u_interpolate); +} + diff --git a/tests/cpp-tests/Source/shaders/example_MultiTexture.vsh b/tests/cpp-tests/Source/shaders/example_MultiTexture.vsh new file mode 100644 index 0000000000..a880ee72fe --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_MultiTexture.vsh @@ -0,0 +1,20 @@ +#version 310 es + +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec2 a_texCoord; +layout(location = 2) in vec4 a_color; + +layout(location = 0) out vec4 v_fragmentColor; +layout(location = 1) out vec2 v_texCoord; + + +layout(std140, binding = 0) uniform vs_ub { + mat4 u_MVPMatrix; +}; + +void main() +{ + gl_Position = u_MVPMatrix * a_position; + v_fragmentColor = a_color; + v_texCoord = a_texCoord; +} diff --git a/tests/cpp-tests/Source/shaders/example_Noisy.fsh b/tests/cpp-tests/Source/shaders/example_Noisy.fsh new file mode 100644 index 0000000000..552a363ffb --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Noisy.fsh @@ -0,0 +1,39 @@ +#version 310 es +precision highp float; +precision highp int; +// Shader taken from: http://webglsamples.googlecode.com/hg/electricflower/electricflower.html + + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; + +layout(binding = 0) uniform sampler2D u_tex0; + +const float intensity = 0.05; +layout(std140, binding = 0) uniform fs_ub { + vec2 resolution; + vec4 u_Time; + vec2 u_screenSize; +}; + +vec3 noise(vec2 uv) +{ + vec2 p = abs(sin(uv * 13.0 + uv.x * u_Time[1] * sin(uv.y))); + + return vec3(sin (0.2 * u_Time[1] + sin(p * 0.5) * u_Time[1] / cos(50.0)) * 10.0,0.3+0.5 * abs(sin(u_Time[1] * tan(5.0)))); + +} + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ +#ifdef METAL + vec2 fragCoord = vec2(gl_FragCoord.x, u_screenSize.y - gl_FragCoord.y); +#else + vec2 fragCoord = gl_FragCoord.xy; +#endif + FragColor.xyz = intensity * noise(fragCoord / sin(resolution.xy * u_Time[1] * 0.01)) + (1. - intensity) * + texture(u_tex0,v_texCoord.xy).xyz; + FragColor.w = 1.; +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/example_Normal.fsh b/tests/cpp-tests/Source/shaders/example_Normal.fsh new file mode 100644 index 0000000000..e40d027ccb --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Normal.fsh @@ -0,0 +1,15 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; + +layout(binding = 0) uniform sampler2D u_tex0; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + FragColor = texture(u_tex0, v_texCoord); +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/example_Outline.fsh b/tests/cpp-tests/Source/shaders/example_Outline.fsh new file mode 100644 index 0000000000..7185c35e16 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Outline.fsh @@ -0,0 +1,44 @@ +#version 310 es +precision highp float; +precision highp int; +/* + Created by guanghui on 4/8/14. +http://www.idevgames.com/forums/thread-3010.html +*/ + +layout(location = 0) in vec2 v_texCoord; +layout(location = 1) in vec4 v_fragmentColor; + + +layout(binding = 0) uniform sampler2D u_tex0; + +layout(std140, binding = 0) uniform fs_ub { + vec3 u_outlineColor; + float u_threshold; + float u_radius; +}; + +layout(location = 0) out vec4 FragColor; + +void main() +{ + float radius = u_radius; + vec4 accum = vec4(0.0); + vec4 normal = vec4(0.0); + + normal = texture(u_tex0, vec2(v_texCoord.x, v_texCoord.y)); + + accum += texture(u_tex0, vec2(v_texCoord.x - radius, v_texCoord.y - radius)); + accum += texture(u_tex0, vec2(v_texCoord.x + radius, v_texCoord.y - radius)); + accum += texture(u_tex0, vec2(v_texCoord.x + radius, v_texCoord.y + radius)); + accum += texture(u_tex0, vec2(v_texCoord.x - radius, v_texCoord.y + radius)); + + accum *= u_threshold; + accum.rgb = u_outlineColor * accum.a; + accum.a = 1.0; + + normal = ( accum * (1.0 - normal.a)) + (normal * normal.a); + + FragColor = v_fragmentColor * normal; +} + diff --git a/tests/cpp-tests/Source/shaders/example_Plasma.fsh b/tests/cpp-tests/Source/shaders/example_Plasma.fsh new file mode 100644 index 0000000000..dc08d40594 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Plasma.fsh @@ -0,0 +1,34 @@ +#version 310 es +precision highp float; +precision highp int; +// Shader from http://www.iquilezles.org/apps/shadertoy/ + + + +layout(std140, binding = 0) uniform fs_ub { + vec2 center; + vec2 resolution; + vec2 u_screenSize; + vec4 u_Time; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ +#ifdef METAL + float fragCoordY = u_screenSize.y - gl_FragCoord.y; +#else + float fragCoordY = gl_FragCoord.y; +#endif + float time = u_Time[1]; + float x = gl_FragCoord.x - (center.x - resolution.x / 2.0); + float y = fragCoordY - (center.y - resolution.y / 2.0); + float mov0 = x+y+cos(sin(time)*2.)*100.+sin(x/100.)*1000.; + float mov1 = y / resolution.y / 0.2 + time; + float mov2 = x / resolution.x / 0.2; + float c1 = abs(sin(mov1+time)/2.+mov2/2.-mov1-mov2+time); + float c2 = abs(sin(c1+sin(mov0/1000.+time)+sin(y/40.+time)+sin((x+y)/100.)*3.)); + float c3 = abs(sin(c2+cos(mov1+mov2+c2)+cos(mov2)+sin(x/1000.))); + FragColor = vec4( c1,c2,c3,1.0); +} diff --git a/tests/cpp-tests/Source/shaders/example_Sepia.fsh b/tests/cpp-tests/Source/shaders/example_Sepia.fsh new file mode 100644 index 0000000000..a30725b297 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Sepia.fsh @@ -0,0 +1,21 @@ +#version 310 es +precision highp float; +precision highp int; + +layout(location = 0) in vec4 v_fragmentColor; +layout(location = 1) in vec2 v_texCoord; + +layout(binding = 0) uniform sampler2D u_tex0; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + vec4 c = texture(u_tex0, v_texCoord); + vec4 final = c; + final.r = (c.r * 0.393) + (c.g * 0.769) + (c.b * 0.189); + final.g = (c.r * 0.349) + (c.g * 0.686) + (c.b * 0.168); + final.b = (c.r * 0.272) + (c.g * 0.534) + (c.b * 0.131); + + FragColor = final; +} \ No newline at end of file diff --git a/tests/cpp-tests/Source/shaders/example_Simple.vsh b/tests/cpp-tests/Source/shaders/example_Simple.vsh new file mode 100644 index 0000000000..250f37f483 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Simple.vsh @@ -0,0 +1,19 @@ +#version 310 es +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec2 a_texCoord; +layout(location = 2) in vec4 a_color; + +layout(location = 0) out vec4 v_fragmentColor; +layout(location = 1) out vec2 v_texCoord; + + +layout(std140, binding = 0) uniform vs_ub { + mat4 u_MVPMatrix; +}; + +void main() +{ + gl_Position = u_MVPMatrix * a_position; + v_fragmentColor = a_color; + v_texCoord = a_texCoord; +} diff --git a/tests/cpp-tests/Source/shaders/example_Twist.fsh b/tests/cpp-tests/Source/shaders/example_Twist.fsh new file mode 100644 index 0000000000..df7cf36f59 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/example_Twist.fsh @@ -0,0 +1,39 @@ +#version 310 es +precision highp float; +precision highp int; +// Shader from here: http://www.iquilezles.org/ + + +layout(binding = 0) uniform sampler2D tex0; +layout(binding = 1) uniform sampler2D tex1; + +layout(std140, binding = 0) uniform fs_ub { + vec2 resolution; + vec2 u_screenSize; + vec4 u_Time; + vec4 u_CosTime; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ +#ifdef METAL + vec2 fragCoord = vec2(gl_FragCoord.x, u_screenSize.y - gl_FragCoord.y); +#else + vec2 fragCoord = gl_FragCoord.xy; +#endif + float time = u_Time[1]; + vec2 p = -1.0 + 2.0 * fragCoord / resolution.xy; + vec2 uv; + + float a = atan(p.y,p.x); + float r = sqrt(dot(p,p)); + + uv.x = r - u_Time[2]; + uv.y = sin(a*10.0 + 2.0)*u_CosTime[0]; + + vec3 col = (.5+.5*uv.y)*texture(tex0,uv).xyz; + + FragColor = vec4(col,1.0); +} diff --git a/tests/cpp-tests/Source/shaders/fog.frag b/tests/cpp-tests/Source/shaders/fog.frag new file mode 100644 index 0000000000..fab66664ea --- /dev/null +++ b/tests/cpp-tests/Source/shaders/fog.frag @@ -0,0 +1,20 @@ +#version 310 es +precision highp float; +precision highp int; +layout(location = 0) in vec2 v_texture_coord; +layout(location = 1) in float v_fogFactor; + + +layout(binding = 0) uniform sampler2D u_tex0; + +layout(std140, binding = 0) uniform fs_ub { + vec4 u_fogColor; +}; + +layout(location = 0) out vec4 FragColor; + +void main (void) +{ + vec4 finalColor = texture(u_tex0, v_texture_coord); + FragColor = mix(u_fogColor, finalColor, v_fogFactor ); //out put finalColor +} diff --git a/tests/cpp-tests/Source/shaders/fog.vert b/tests/cpp-tests/Source/shaders/fog.vert new file mode 100644 index 0000000000..0bec84d4ab --- /dev/null +++ b/tests/cpp-tests/Source/shaders/fog.vert @@ -0,0 +1,35 @@ +#version 310 es +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec2 a_texCoord; +layout(location = 0) out float v_fogFactor; //weight for fog +layout(location = 1) out vec2 v_texture_coord; + + + +layout(std140, binding = 0) uniform vs_ub { + float u_fogDensity;// For exp and exp2 equation + float u_fogStart; // This is only for linear fog + float u_fogEnd; // This is only for linear fog + int u_fogEquation; // 0 = linear, 1 = exp, 2 = exp2 + mat4 u_MVPMatrix; +}; + +void main(void) +{ + gl_Position = u_MVPMatrix * a_position; + v_texture_coord = a_texCoord; + + float fogFragCoord = abs(gl_Position.z); //get fog distance + + + if(u_fogEquation == 0) + v_fogFactor = (u_fogEnd-fogFragCoord )/(u_fogEnd-u_fogStart); //linear fog + else if(u_fogEquation == 1) + v_fogFactor = exp(-u_fogDensity*fogFragCoord ); //exp fog + else if(u_fogEquation == 2) + v_fogFactor = exp(-pow(u_fogDensity*fogFragCoord , 2.0)); //exp2 fog + + + v_fogFactor = clamp(v_fogFactor, 0.0, 1.0); //clamp 0 to 1 + +} diff --git a/tests/cpp-tests/Source/shaders/position_normal_tex.vert b/tests/cpp-tests/Source/shaders/position_normal_tex.vert new file mode 100644 index 0000000000..ccabc0d76f --- /dev/null +++ b/tests/cpp-tests/Source/shaders/position_normal_tex.vert @@ -0,0 +1,64 @@ +#version 310 es + +#define MAX_POINT_LIGHT_NUM 1 +#define MAX_SPOT_LIGHT_NUM 1 +#define MAX_DIRECTIONAL_LIGHT_NUM 1 + +#if (MAX_POINT_LIGHT_NUM > 0) +#endif +#if (MAX_SPOT_LIGHT_NUM > 0) +#endif + +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec2 a_texCoord; +layout(location = 2) in vec3 a_normal; +layout(location = 0) out vec2 TextureCoordOut; + +#if MAX_POINT_LIGHT_NUM +layout(location = 1) out vec3 v_vertexToPointLightDirection[MAX_POINT_LIGHT_NUM]; +#endif +#if MAX_SPOT_LIGHT_NUM +layout(location = 2) out vec3 v_vertexToSpotLightDirection[MAX_SPOT_LIGHT_NUM]; +#endif +#if ((MAX_DIRECTIONAL_LIGHT_NUM > 0) || (MAX_POINT_LIGHT_NUM > 0) || (MAX_SPOT_LIGHT_NUM > 0)) +layout(location = 3) out vec3 v_normal; +#endif + +layout(std140, binding = 0) uniform vs_ub { +#if (MAX_POINT_LIGHT_NUM > 0) + vec3 u_PointLightSourcePosition[MAX_POINT_LIGHT_NUM]; +#endif +#if (MAX_SPOT_LIGHT_NUM > 0) + vec3 u_SpotLightSourcePosition[MAX_SPOT_LIGHT_NUM]; +#endif + mat4 u_MVMatrix; + mat4 u_PMatrix; + mat3 u_NormalMatrix; +}; + +void main(void) +{ + vec4 ePosition = u_MVMatrix * a_position; +#if (MAX_POINT_LIGHT_NUM > 0) + for (int i = 0; i < MAX_POINT_LIGHT_NUM; ++i) + { + v_vertexToPointLightDirection[i] = u_PointLightSourcePosition[i].xyz - ePosition.xyz; + } +#endif + +#if (MAX_SPOT_LIGHT_NUM > 0) + for (int i = 0; i < MAX_SPOT_LIGHT_NUM; ++i) + { + v_vertexToSpotLightDirection[i] = u_SpotLightSourcePosition[i] - ePosition.xyz; + } +#endif + +#if ((MAX_DIRECTIONAL_LIGHT_NUM > 0) || (MAX_POINT_LIGHT_NUM > 0) || (MAX_SPOT_LIGHT_NUM > 0)) + v_normal = u_NormalMatrix * a_normal; +#endif + + TextureCoordOut = a_texCoord; + TextureCoordOut.y = 1.0 - TextureCoordOut.y; + gl_Position = u_PMatrix * ePosition; +} + diff --git a/tests/cpp-tests/Source/shaders/position_skin_tex.vert b/tests/cpp-tests/Source/shaders/position_skin_tex.vert new file mode 100644 index 0000000000..546a8730b3 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/position_skin_tex.vert @@ -0,0 +1,74 @@ +#version 310 es +layout(location = 0) in vec3 a_position; + +layout(location = 1) in vec4 a_blendWeight; +layout(location = 2) in vec4 a_blendIndex; + +layout(location = 3) in vec2 a_texCoord; + +const int SKINNING_JOINT_COUNT = 60; +// Uniforms + +// Varyings +layout(location = 0) out vec2 TextureCoordOut; + +layout(std140, binding = 0) uniform vs_ub { + vec4 u_matrixPalette[SKINNING_JOINT_COUNT * 3]; + mat4 u_MVPMatrix; +}; + +vec4 getPosition() +{ + float blendWeight = a_blendWeight[0]; + + int matrixIndex = int (a_blendIndex[0]) * 3; + vec4 matrixPalette1 = u_matrixPalette[matrixIndex] * blendWeight; + vec4 matrixPalette2 = u_matrixPalette[matrixIndex + 1] * blendWeight; + vec4 matrixPalette3 = u_matrixPalette[matrixIndex + 2] * blendWeight; + + + blendWeight = a_blendWeight[1]; + if (blendWeight > 0.0) + { + matrixIndex = int(a_blendIndex[1]) * 3; + matrixPalette1 += u_matrixPalette[matrixIndex] * blendWeight; + matrixPalette2 += u_matrixPalette[matrixIndex + 1] * blendWeight; + matrixPalette3 += u_matrixPalette[matrixIndex + 2] * blendWeight; + + blendWeight = a_blendWeight[2]; + if (blendWeight > 0.0) + { + matrixIndex = int(a_blendIndex[2]) * 3; + matrixPalette1 += u_matrixPalette[matrixIndex] * blendWeight; + matrixPalette2 += u_matrixPalette[matrixIndex + 1] * blendWeight; + matrixPalette3 += u_matrixPalette[matrixIndex + 2] * blendWeight; + + blendWeight = a_blendWeight[3]; + if (blendWeight > 0.0) + { + matrixIndex = int(a_blendIndex[3]) * 3; + matrixPalette1 += u_matrixPalette[matrixIndex] * blendWeight; + matrixPalette2 += u_matrixPalette[matrixIndex + 1] * blendWeight; + matrixPalette3 += u_matrixPalette[matrixIndex + 2] * blendWeight; + } + } + } + + vec4 _skinnedPosition; + vec4 postion = vec4(a_position, 1.0); + _skinnedPosition.x = dot(postion, matrixPalette1); + _skinnedPosition.y = dot(postion, matrixPalette2); + _skinnedPosition.z = dot(postion, matrixPalette3); + _skinnedPosition.w = postion.w; + + return _skinnedPosition; +} + +void main() +{ + vec4 position = getPosition(); + gl_Position = u_MVPMatrix * position; + + TextureCoordOut = a_texCoord; + TextureCoordOut.y = 1.0 - TextureCoordOut.y; +} diff --git a/tests/cpp-tests/Source/shaders/position_tex.vert b/tests/cpp-tests/Source/shaders/position_tex.vert new file mode 100644 index 0000000000..bb333381f6 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/position_tex.vert @@ -0,0 +1,18 @@ +#version 310 es + + +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec2 a_texCoord; + +layout(location = 0) out vec2 TextureCoordOut; + +layout(std140, binding = 0) uniform vs_ub { + mat4 u_MVPMatrix; +}; + +void main(void) +{ + gl_Position = u_MVPMatrix * a_position; + TextureCoordOut = a_texCoord; + TextureCoordOut.y = 1.0 - TextureCoordOut.y; +} diff --git a/tests/cpp-tests/Source/shaders/shadertoy_FireBall.fsh b/tests/cpp-tests/Source/shaders/shadertoy_FireBall.fsh new file mode 100644 index 0000000000..63aded6ccf --- /dev/null +++ b/tests/cpp-tests/Source/shaders/shadertoy_FireBall.fsh @@ -0,0 +1,71 @@ +#version 310 es +precision highp float; +precision highp int; + + +//vec2 iCenter = center; +//uniform float iChannelTime[4]; // channel playback time (in seconds) +//uniform vec3 iChannelResolution[4]; // channel resolution (in pixels) +vec4 iMouse = vec4(0,0,0,0); // mouse pixel coords. xy: current (if MLB down), + + + +layout(std140, binding = 0) uniform fs_ub { + vec2 center; + vec2 resolution; + vec2 u_screenSize; + vec4 u_Time; +}; + +float snoise(vec3 uv, float res) +{ + const vec3 s = vec3(1e0, 1e2, 1e4); + + uv *= res; + + vec3 uv0 = floor(mod(uv, res))*s; + vec3 uv1 = floor(mod(uv+vec3(1.), res))*s; + + vec3 f = fract(uv); f = f*f*(3.0-2.0*f); + + vec4 v = vec4(uv0.x+uv0.y+uv0.z, uv1.x+uv0.y+uv0.z, + uv0.x+uv1.y+uv0.z, uv1.x+uv1.y+uv0.z); + + vec4 r = fract(sin(v*1e-3)*1e5); + float r0 = mix(mix(r.x, r.y, f.x), mix(r.z, r.w, f.x), f.y); + + r = fract(sin((v + uv1.z - uv0.z)*1e-3)*1e5); + float r1 = mix(mix(r.x, r.y, f.x), mix(r.z, r.w, f.x), f.y); + + return mix(r0, r1, f.z)*2.-1.; +} + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ +#ifdef METAL + vec2 fragCoord = vec2(gl_FragCoord.x, u_screenSize.y - gl_FragCoord.y); +#else + vec2 fragCoord = gl_FragCoord.xy; +#endif + vec2 iResolution = resolution; // viewport resolution (in pixels) + float iGlobalTime = u_Time[1]; // shader playback time (in seconds) + + //vec2 p = -.5 + fragCoord.xy / iResolution.xy; + + vec2 p = (fragCoord.xy - center.xy) / iResolution.xy; + p.x *= iResolution.x/iResolution.y; + + float color = 3.0 - (3.*length(2.*p)); + + vec3 coord = vec3(atan(p.x,p.y)/6.2832+.5, length(p)*.4, .5); + + for(int i = 1; i <= 3; i++) + { + float power = pow(2.0, float(i)); + color += (1.5 / power) * snoise(coord + vec3(0.,-iGlobalTime*.05, iGlobalTime*.01), power*16.); + } + FragColor = vec4( color, pow(max(color,0.),2.)*0.4, pow(max(color,0.),3.)*0.15 , 1.0); +} + diff --git a/tests/cpp-tests/Source/shaders/shadertoy_Glow.fsh b/tests/cpp-tests/Source/shaders/shadertoy_Glow.fsh new file mode 100644 index 0000000000..f1a4ef82b2 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/shadertoy_Glow.fsh @@ -0,0 +1,123 @@ +#version 310 es +precision highp float; +precision highp int; + + +//uniform float iChannelTime[4]; // channel playback time (in seconds) +//uniform vec3 iChannelResolution[4]; // channel resolution (in pixels) +vec4 iMouse = vec4(0,0,0,0); // mouse pixel coords. xy: current (if MLB down), zw: click +layout(binding = 0) //uniform sampler2D iChannel0; // input channel. XX = 2D/Cube + + + +layout(std140, binding = 0) uniform fs_ub { + vec2 center; + vec2 resolution; + vec2 u_screenSize; + vec4 u_Time; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ +#ifdef METAL + vec2 fragCoord = vec2(gl_FragCoord.x, u_screenSize.y - gl_FragCoord.y); +#else + vec2 fragCoord = gl_FragCoord.xy; +#endif + vec2 iResolution = resolution; // viewport resolution (in pixels) + float iGlobalTime = u_Time[1]; // shader playback time (in seconds) + + float pointRadius = 0.06; + float linkSize = 0.04; + float noiseStrength = 0.08; // range: 0-1 + + float minDimension = min(iResolution.x, iResolution.y); + vec2 bounds = vec2(iResolution.x / minDimension, iResolution.y / minDimension); + //vec2 uv = fragCoord.xy / minDimension; + vec2 uv = (2. * fragCoord.xy - center.xy) / iResolution.xy; + + vec3 pointR = vec3(0.0, 0.0, 1.0); + vec3 pointG = vec3(0.0, 0.0, 1.0); + vec3 pointB = vec3(0.0, 0.0, 1.0); + + // Make the points orbit round the origin in 3 dimensions. + // Coefficients are arbitrary to give different behaviours. + // The Z coordinate should always be >0.0, as it's used directly to + // multiply the radius to give the impression of depth. + pointR.x += 0.32 * sin(1.32 * iGlobalTime); + pointR.y += 0.3 * sin(1.03 * iGlobalTime); + pointR.z += 0.4 * sin(1.32 * iGlobalTime); + + pointG.x += 0.31 * sin(0.92 * iGlobalTime); + pointG.y += 0.29 * sin(0.99 * iGlobalTime); + pointG.z += 0.38 * sin(1.24 * iGlobalTime); + + pointB.x += 0.33 * sin(1.245 * iGlobalTime); + pointB.y += 0.3 * sin(1.41 * iGlobalTime); + pointB.z += 0.41 * sin(1.11 * iGlobalTime); + + // Centre the points in the display + vec2 midUV = vec2(bounds.x * 0.5, bounds.y * 0.5); + pointR.xy += midUV; + pointG.xy += midUV; + pointB.xy += midUV; + + // Calculate the vectors from the current fragment to the coloured points + vec2 vecToR = pointR.xy - uv; + vec2 vecToG = pointG.xy - uv; + vec2 vecToB = pointB.xy - uv; + + vec2 dirToR = normalize(vecToR.xy); + vec2 dirToG = normalize(vecToG.xy); + vec2 dirToB = normalize(vecToB.xy); + + float distToR = length(vecToR); + float distToG = length(vecToG); + float distToB = length(vecToB); + + // Calculate the dot product between vectors from the current fragment to each pair + // of adjacent coloured points. This helps us determine how close the current fragment + // is to a link between points. + float dotRG = dot(dirToR, dirToG); + float dotGB = dot(dirToG, dirToB); + float dotBR = dot(dirToB, dirToR); + + // Start with a bright coloured dot around each point + FragColor.x = 1.0 - smoothstep(distToR, 0.0, pointRadius * pointR.z); + FragColor.y = 1.0 - smoothstep(distToG, 0.0, pointRadius * pointG.z); + FragColor.z = 1.0 - smoothstep(distToB, 0.0, pointRadius * pointB.z); + FragColor.w = 1.0; + + // We want to show a coloured link between adjacent points. + // Determine the strength of each link at the current fragment. + // This tends towards 1.0 as the vectors to each point tend towards opposite directions. + float linkStrengthRG = 1.0 - smoothstep(dotRG, -1.01, -1.0 + (linkSize * pointR.z * pointG.z)); + float linkStrengthGB = 1.0 - smoothstep(dotGB, -1.01, -1.0 + (linkSize * pointG.z * pointB.z)); + float linkStrengthBR = 1.0 - smoothstep(dotBR, -1.01, -1.0 + (linkSize * pointB.z * pointR.z)); + + // If the current fragment is in a link, we need to know how much the + // linked points contribute of their colour. + float sumDistRG = distToR + distToG; + float sumDistGB = distToG + distToB; + float sumDistBR = distToB + distToR; + + float contribRonRG = 1.0 - (distToR / sumDistRG); + float contribRonBR = 1.0 - (distToR / sumDistBR); + + float contribGonRG = 1.0 - (distToG / sumDistRG); + float contribGonGB = 1.0 - (distToG / sumDistGB); + + float contribBonGB = 1.0 - (distToB / sumDistGB); + float contribBonBR = 1.0 - (distToB / sumDistBR); + + // Additively blend the link colours into the fragment. + FragColor.x += (linkStrengthRG * contribRonRG) + (linkStrengthBR * contribRonBR); + FragColor.y += (linkStrengthGB * contribGonGB) + (linkStrengthRG * contribGonRG); + FragColor.z += (linkStrengthBR * contribBonBR) + (linkStrengthGB * contribBonGB); + + // Use an underlying texture to provide some noise + float noiseMin = 1.0 - noiseStrength; + FragColor.xyz *= (1.0 - noiseStrength) + (noiseStrength * 0.); +} diff --git a/tests/cpp-tests/Source/shaders/shadertoy_LensFlare.fsh b/tests/cpp-tests/Source/shaders/shadertoy_LensFlare.fsh new file mode 100644 index 0000000000..dec78f09b0 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/shadertoy_LensFlare.fsh @@ -0,0 +1,115 @@ +#version 310 es +precision highp float; +precision highp int; + +//uniform float iChannelTime[4]; // channel playback time (in seconds) +//uniform vec3 iChannelResolution[4]; // channel resolution (in pixels) +vec4 iMouse = vec4(0,0,0,0); // mouse pixel coords. xy: current (if MLB down), zw: click +layout(binding = 0) //uniform sampler2D iChannel0; // input channel. XX = 2D/Cube + +/*by musk License Creative Commons Attribution-NonCommercial-ShareAlike 3.0 Unported License. + + Trying to get some interesting looking lens flares. + + 13/08/13: + published + + muuuuuuuuuuuuuuuuuuuuuuuuuuuuuuuusk!*/ + + +layout(std140, binding = 0) uniform fs_ub { + vec2 center; + vec2 resolution; + vec2 u_screenSize; + vec4 u_Time; +}; + +float noise(float t) +{ + return 0.; +} +float noise(vec2 t) +{ + return 0.; +} + +vec3 lensflare(vec2 uv,vec2 pos) +{ + vec2 main = uv-pos; + vec2 uvd = uv*(length(uv)); + + float ang = atan(main.x,main.y); + float dist=length(main); dist = pow(dist,.1); + float n = noise(vec2(ang*16.0,dist*32.0)); + + float f0 = 1.0/(length(uv-pos)*16.0+1.0); + + f0 = f0+f0*(sin(noise((pos.x+pos.y)*2.2+ang*4.0+5.954)*16.0)*.1+dist*.1+.8); + + float f1 = max(0.01-pow(length(uv+1.2*pos),1.9),.0)*7.0; + + float f2 = max(1.0/(1.0+32.0*pow(length(uvd+0.8*pos),2.0)),.0)*00.25; + float f22 = max(1.0/(1.0+32.0*pow(length(uvd+0.85*pos),2.0)),.0)*00.23; + float f23 = max(1.0/(1.0+32.0*pow(length(uvd+0.9*pos),2.0)),.0)*00.21; + + vec2 uvx = mix(uv,uvd,-0.5); + + float f4 = max(0.01-pow(length(uvx+0.4*pos),2.4),.0)*6.0; + float f42 = max(0.01-pow(length(uvx+0.45*pos),2.4),.0)*5.0; + float f43 = max(0.01-pow(length(uvx+0.5*pos),2.4),.0)*3.0; + + uvx = mix(uv,uvd,-.4); + + float f5 = max(0.01-pow(length(uvx+0.2*pos),5.5),.0)*2.0; + float f52 = max(0.01-pow(length(uvx+0.4*pos),5.5),.0)*2.0; + float f53 = max(0.01-pow(length(uvx+0.6*pos),5.5),.0)*2.0; + + uvx = mix(uv,uvd,-0.5); + + float f6 = max(0.01-pow(length(uvx-0.3*pos),1.6),.0)*6.0; + float f62 = max(0.01-pow(length(uvx-0.325*pos),1.6),.0)*3.0; + float f63 = max(0.01-pow(length(uvx-0.35*pos),1.6),.0)*5.0; + + vec3 c = vec3(.0); + + c.r+=f2+f4+f5+f6; c.g+=f22+f42+f52+f62; c.b+=f23+f43+f53+f63; + c = c*1.3 - vec3(length(uvd)*.05); + c+=vec3(f0); + + return c; +} + +vec3 cc(vec3 color, float factor,float factor2) // color modifier +{ + float w = color.x+color.y+color.z; + return mix(color,vec3(w)*factor,w*factor2); +} + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ +#ifdef METAL + vec2 fragCoord = vec2(gl_FragCoord.x, u_screenSize.y - gl_FragCoord.y); +#else + vec2 fragCoord = gl_FragCoord.xy; +#endif + vec2 iResolution = resolution; // viewport resolution (in pixels) + float iGlobalTime = u_Time[1]; // shader playback time (in seconds) + + //vec2 uv = gl_FragCoord.xy / iResolution.xy - 0.5; + vec2 uv = (fragCoord.xy - center.xy) / iResolution.xy; + uv.x *= iResolution.x/iResolution.y; //fix aspect ratio + vec3 mouse = vec3(iMouse.xy/iResolution.xy - 0.5,iMouse.z-.5); + mouse.x *= iResolution.x/iResolution.y; //fix aspect ratio + if (iMouse.z<.5) + { + mouse.x=sin(iGlobalTime)*.5; + mouse.y=sin(iGlobalTime*.913)*.5; + } + + vec3 color = vec3(1.4,1.2,1.0)*lensflare(uv,mouse.xy); + color -= noise(fragCoord.xy)*.015; + color = cc(color,.5,.1); + FragColor = vec4(color,1.0); +} diff --git a/tests/cpp-tests/Source/shaders/simple_shadow.frag b/tests/cpp-tests/Source/shaders/simple_shadow.frag new file mode 100644 index 0000000000..0fa587997b --- /dev/null +++ b/tests/cpp-tests/Source/shaders/simple_shadow.frag @@ -0,0 +1,26 @@ +#version 310 es +precision highp float; +precision highp int; +layout(location = 0) in vec2 v_texture_coord; +layout(location = 1) in vec4 v_position; +layout(binding = 0) uniform sampler2D u_sampler0; +layout(binding = 1) uniform sampler2D u_sampler1; +layout(std140, binding = 0) uniform fs_ub { + vec3 u_target_pos; + vec4 u_color; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + + float Radius = 4.0;//project range + vec3 UVector = vec3(1.0, 0.0, 0.0)/(2.0 * Radius); + vec3 VVector = vec3(0.0, 0.0, -1.0)/(-2.0 * Radius); + vec2 coord; + coord.x = dot(v_position.xyz - u_target_pos, UVector) + 0.5; + coord.y = dot(v_position.xyz - u_target_pos, VVector) + 0.5; + + FragColor = u_color*texture(u_sampler0,v_texture_coord)*texture(u_sampler1,coord); +} diff --git a/tests/cpp-tests/Source/shaders/simple_shadow.vert b/tests/cpp-tests/Source/shaders/simple_shadow.vert new file mode 100644 index 0000000000..dc6f431ce9 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/simple_shadow.vert @@ -0,0 +1,19 @@ +#version 310 es +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec2 a_texCoord; +layout(location = 0) out vec2 v_texture_coord; +layout(location = 1) out vec4 v_position; + + +layout(std140, binding = 0) uniform vs_ub { + mat4 u_model_matrix; + mat4 u_MVPMatrix; +}; + +void main(void) +{ + gl_Position = u_MVPMatrix * a_position; + v_texture_coord = a_texCoord; + v_texture_coord.y = (1.0 - v_texture_coord.y); + v_position = u_model_matrix * a_position; +} diff --git a/tests/cpp-tests/Source/shaders/toon.frag b/tests/cpp-tests/Source/shaders/toon.frag new file mode 100644 index 0000000000..bc6d08516c --- /dev/null +++ b/tests/cpp-tests/Source/shaders/toon.frag @@ -0,0 +1,29 @@ +#version 310 es +precision highp float; +precision highp int; +layout(location = 0) in vec2 v_texture_coord; +layout(binding = 0) uniform sampler2D u_sampler0; +layout(location = 1) in vec3 v_normal; +layout(std140, binding = 0) uniform fs_ub { + vec4 u_color; +}; + +layout(location = 0) out vec4 FragColor; + +void main(void) +{ + vec3 light_direction = vec3(1,-1,-1); + light_direction = normalize(light_direction); + vec3 light_color = vec3(1,1,1); + vec3 normal = normalize(v_normal); + float diffuse_factor = dot(normal,-light_direction); + vec4 diffuse_color = texture(u_sampler0,v_texture_coord); + + if (diffuse_factor > 0.95) diffuse_factor=1.0; + else if (diffuse_factor > 0.75) diffuse_factor = 0.8; + else if (diffuse_factor > 0.50) diffuse_factor = 0.6; + else diffuse_factor = 0.4; + + light_color = light_color * diffuse_factor; + FragColor = vec4(light_color,1.0) * diffuse_color * u_color; +} diff --git a/tests/cpp-tests/Source/shaders/toon.vert b/tests/cpp-tests/Source/shaders/toon.vert new file mode 100644 index 0000000000..f8ec9a6b18 --- /dev/null +++ b/tests/cpp-tests/Source/shaders/toon.vert @@ -0,0 +1,20 @@ +#version 310 es +layout(location = 0) in vec4 a_position; +layout(location = 1) in vec2 a_texCoord; +layout(location = 2) in vec3 a_normal; +layout(location = 0) out vec2 v_texture_coord; +layout(location = 1) out vec3 v_normal; + + +layout(std140, binding = 0) uniform vs_ub { + mat4 u_MVPMatrix; + mat3 u_NormalMatrix; +}; + +void main(void) +{ + gl_Position = u_MVPMatrix * a_position; + v_texture_coord = a_texCoord; + v_texture_coord.y = (1.0 - v_texture_coord.y); + v_normal = u_NormalMatrix *a_normal; +}