All Larabie Fonts in this file are free to use for personal and/or commercial purposes. No payment is necessary to use these fonts for personal or commercial use. For Software Products who want to include Larabie Fonts see the License Agreement below. You can add this font to a website but do not combine fonts into a single archive or alter them in any way.
All Larabie Fonts are free for commercial use but a sample of your product would be gratefully appreciated so I can see how the font looks in use. Contact www.larabiefonts.com/donation.html for mailing information.
Some Larabie Fonts have enhanced and expanded families available for sale at www.typodermic.com.
If you'd like to make a voluntary donation to Larabie Fonts for the use of the free fonts in any amount please go to www.larabiefonts.com/donation.html
I accept CDs, magazines, t-shirts, a sample of your merchandise or anything featuring Larabie Fonts. Please remember to list your item as a ‘gift’ on the customs form or I will have to pay import duties and taxes on the item. Mailing information is provided at the link above.
Font installation help is available at www.larabiefonts.com/help.html
The SOFTWARE PRODUCT is protected by copyright laws and International copyright treaties, as well as other intellectual property laws and treaties. The SOFTWARE PRODUCT is licensed, not sold.
- Installation and Use. You may install and use an unlimited number of copies of the SOFTWARE PRODUCT. You may copy and distribute unlimited copies of the SOFTWARE PRODUCT as you receive them, in any medium, provided that you publish on each copy an appropriate copyright notice. Keep intact all the notices that refer to this License and give any other recipients of the fonts a copy of this License along with the fonts.
- You may modify your copy or copies of the SOFTWARE PRODUCT or any portion of it, provided that you also meet all of these rules:
a) Do not alter in any way alphanumeric characters (A-Z, a-z, 1-9) contained in the font. An exception is converting between formats, here is allowed the nominal distortion that occurs during conversion from second order to third order quadratic curves (TrueType to Postscript) and vice versa.
b) Extra characters may be added; here it is allowed to use curves (shapes) from alphanumeric characters in fonts under same license.
c) It is allowed to modify and remove analpahbetics (punctuation, special characters, ligatures and symbols).
d) The original font name must be retained but can be augmented. (ie. a Font named Blue Highway can be renamed Blue Highway Cyrillic or Blue Highway ANSI, etc.)
e) Character mapping may be altered.
f) If the kerning information is altered or discarded it must be stated in the user notes or documentation.
g) All modifications must be released under this license.
LIMITED WARRANTY NO WARRANTIES. Larabie Fonts expressly disclaims any warranty for the SOFTWARE PRODUCT. The SOFTWARE PRODUCT and any related documentation is provided "as is" without warranty of any kind, either express or implied, including, without limitation, the implied warranties or merchantability, fitness for a particular purpose, or non-infringement. The entire risk arising out of use or performance of the SOFTWARE PRODUCT remains with you.NO LIABILITY FOR CONSEQUENTIAL DAMAGES. In no event shall Larabie Fonts be liable for any damages whatsoever (including, without limitation, damages for loss of business profits, business interruption, loss of business information, or any other pecuniary loss) arising out of the use of or inability to use this product, even if Larabie Fonts has been advised of the possibility of such damages.
Should you have any questions concerning this document, or if you desire to contact Larabie Fonts for any reason, please email www.larabiefonts.com/email.html.
+ diff --git a/res/dist/media/fonts/sample.fontdef b/res/dist/media/fonts/sample.fontdef new file mode 100644 index 00000000000..462defc5f14 --- /dev/null +++ b/res/dist/media/fonts/sample.fontdef @@ -0,0 +1,11 @@ +StarWars +{ + // Now this one I agree with ;) + // A Star Wars font :) + type truetype + source solo5.ttf + size 16 + resolution 96 +} + + diff --git a/res/dist/media/fonts/solo5.ttf b/res/dist/media/fonts/solo5.ttf new file mode 100644 index 00000000000..c723496ee5f Binary files /dev/null and b/res/dist/media/fonts/solo5.ttf differ diff --git a/res/dist/media/materials/programs/ASCIIFP.cg b/res/dist/media/materials/programs/ASCIIFP.cg new file mode 100644 index 00000000000..9f4357e3874 --- /dev/null +++ b/res/dist/media/materials/programs/ASCIIFP.cg @@ -0,0 +1,32 @@ +sampler2D RT : register(s0); +sampler3D pattern : register(s1); + +float4 ASCII_ps( float4 pos : POSITION, + float2 TexCoord : TEXCOORD0, + uniform float2 numTiles, + uniform float2 iNumTiles, + uniform float2 iNumTiles2, + uniform float4 lum, + uniform float charBias) : COLOR +{ + float3 local; + + //sample RT + local.xy = fmod(TexCoord, iNumTiles); + float2 middle = TexCoord - local.xy; + local.xy = local.xy * numTiles; + + //iNumTiles2 = iNumTiles / 2 + middle = middle + iNumTiles2; + float4 c = tex2D(RT, middle ); + + //multiply luminance by charbias , beacause not all slices of the ascii + //volume texture are used + local.z = dot(c , lum)*charBias; + + //fix to brighten the dark pixels with small characters + //c *= lerp(2.0,1.0, local.z); + + c *= tex3D(pattern,local); + return c; +} \ No newline at end of file diff --git a/res/dist/media/materials/programs/ASCIIFP.glsles b/res/dist/media/materials/programs/ASCIIFP.glsles new file mode 100644 index 00000000000..7af11ab39b3 --- /dev/null +++ b/res/dist/media/materials/programs/ASCIIFP.glsles @@ -0,0 +1,31 @@ +sampler RT : register(s0); +sampler pattern : register(s1); + +float4 ASCII_ps( float2 TexCoord : TEXCOORD0, + uniform float2 numTiles, + uniform float2 iNumTiles, + uniform float2 iNumTiles2, + uniform float4 lum, + uniform float charBias) : COLOR +{ + float3 local; + + //sample RT + local.xy = fmod(TexCoord, iNumTiles); + float2 middle = TexCoord - local.xy; + local.xy = local.xy * numTiles; + + //iNumTiles2 = iNumTiles / 2 + middle = middle + iNumTiles2; + float4 c = tex2D(RT, middle ); + + //multiply luminance by charbias , because not all slices of the ascii + //volume texture are used + local.z = dot(c , lum)*charBias; + + //fix to brighten the dark pixels with small characters + //c *= mix(2.0,1.0, local.z); + + c *= tex3D(pattern,local); + return c; +} \ No newline at end of file diff --git a/res/dist/media/materials/programs/AmbientOneTexture.glsl b/res/dist/media/materials/programs/AmbientOneTexture.glsl new file mode 100644 index 00000000000..66b4bcd3d3a --- /dev/null +++ b/res/dist/media/materials/programs/AmbientOneTexture.glsl @@ -0,0 +1,13 @@ +uniform vec4 ambient; + +/* + Basic ambient lighting vertex program +*/ +void main() +{ + gl_Position = ftransform(); + gl_TexCoord[0] = gl_MultiTexCoord0; + gl_FrontColor = ambient; +} + + diff --git a/res/dist/media/materials/programs/AmbientOneTexture.glsles b/res/dist/media/materials/programs/AmbientOneTexture.glsles new file mode 100644 index 00000000000..1345ab072ee --- /dev/null +++ b/res/dist/media/materials/programs/AmbientOneTexture.glsles @@ -0,0 +1,20 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform vec4 ambient; +uniform mat4 worldViewProj; + +attribute vec4 position; + +varying vec4 colour; + +/* + Basic ambient lighting vertex program for GLSL ES +*/ +void main() +{ + gl_Position = worldViewProj * position; + colour = ambient; +} diff --git a/res/dist/media/materials/programs/AmbientOneTextureWithUV.glsles b/res/dist/media/materials/programs/AmbientOneTextureWithUV.glsles new file mode 100644 index 00000000000..c9994fea07f --- /dev/null +++ b/res/dist/media/materials/programs/AmbientOneTextureWithUV.glsles @@ -0,0 +1,23 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform vec4 ambient; +uniform mat4 worldViewProj; + +attribute vec4 position; +attribute vec4 uv0; + +varying vec4 colour; +varying vec4 ambientUV; + +/* + Basic ambient lighting vertex program for GLSL ES +*/ +void main() +{ + gl_Position = worldViewProj * position; + colour = ambient; + ambientUV = uv0; +} diff --git a/res/dist/media/materials/programs/Bloom2_ps20.glsl b/res/dist/media/materials/programs/Bloom2_ps20.glsl new file mode 100644 index 00000000000..9443e66e136 --- /dev/null +++ b/res/dist/media/materials/programs/Bloom2_ps20.glsl @@ -0,0 +1,27 @@ +//------------------------------- +//Bloom_ps20.glsl +// Blends using weights the blurred image with the sharp one +// Params: +// OriginalImageWeight +// BlurWeight +//------------------------------- + +uniform sampler2D RT; +uniform sampler2D Blur1; + +uniform float OriginalImageWeight; +uniform float BlurWeight; + +void main() +{ + vec4 sharp; + vec4 blur; + + vec2 texCoord = vec2( gl_TexCoord[0] ); + + sharp = texture2D( RT, texCoord); + blur = texture2D( Blur1, texCoord); + + gl_FragColor = ( (blur * BlurWeight) + (sharp * OriginalImageWeight) ); + //gl_FragColor = vec4(0); +} diff --git a/res/dist/media/materials/programs/Bloom2_ps20.glsles b/res/dist/media/materials/programs/Bloom2_ps20.glsles new file mode 100644 index 00000000000..5dfdead7eaf --- /dev/null +++ b/res/dist/media/materials/programs/Bloom2_ps20.glsles @@ -0,0 +1,30 @@ +#version 100 +precision mediump int; +precision mediump float; + +//------------------------------- +// Bloom_ps20.glsles +// Blends using weights the blurred image with the sharp one +// Params: +// OriginalImageWeight +// BlurWeight +//------------------------------- + +uniform sampler2D RT; +uniform sampler2D Blur1; + +uniform float OriginalImageWeight; +uniform float BlurWeight; +varying vec2 texCoord; + +void main() +{ + vec4 sharp; + vec4 blur; + + sharp = texture2D( RT, texCoord); + blur = texture2D( Blur1, texCoord); + + gl_FragColor = ( (blur * BlurWeight) + (sharp * OriginalImageWeight) ); + //gl_FragColor = vec4(0); +} diff --git a/res/dist/media/materials/programs/Bloom2_ps20.hlsl b/res/dist/media/materials/programs/Bloom2_ps20.hlsl new file mode 100644 index 00000000000..a33674df9f6 --- /dev/null +++ b/res/dist/media/materials/programs/Bloom2_ps20.hlsl @@ -0,0 +1,58 @@ +//--------------------------------------------- +// Bloom + + +float4 main(float2 texCoord: TEXCOORD0, + uniform sampler RT: register(s0), + uniform sampler Blur1: register(s1), + uniform float OriginalImageWeight, + uniform float BlurWeight + ) : COLOR { + + + float4 sharp = tex2D(RT, texCoord); + float4 blur = tex2D(Blur1, texCoord); + + //return blur*0.5+sharp*0.5; + return blur*BlurWeight+sharp*OriginalImageWeight; + //return blur; + + //return ( sharp + blur * 1.8 ) / 2; + +// return (sharp*3/6 + (blur*4/6))*float4(1.5, 1.5, 1.5, 1);; + +// float4 color = lerp( sharp, blur, 0.4f ); + +// return color; + + +/* + return ( sharp + blur * 1.8 ) / 2 + + luminance(blur) * + float4( 0.5, 0.5, 0.5, 0) + + luminance(sharp) * + float4( 0.3, 0.3, 0.3, 0); +*/ +/* + return ( sharp + blur * 0.9) / 2 + + luminance(blur) * float4(0.1, 0.15, 0.7, 0); +*/ + +/* + return ( sharp + blur * 0.9) / 2 + + luminance(blur) * float4(0.1, 0.15, 0.7, 0); +*/ + +// float4 retColor = luminance( sharp ) + +// luminance( blur ) + blur / 2; +// return retColor; +} + + + + + + + + + diff --git a/res/dist/media/materials/programs/Bloom_ps20.hlsl b/res/dist/media/materials/programs/Bloom_ps20.hlsl new file mode 100644 index 00000000000..15aa068c34b --- /dev/null +++ b/res/dist/media/materials/programs/Bloom_ps20.hlsl @@ -0,0 +1,52 @@ +sampler Blur1: register(s1); +sampler RT: register(s0); + + +float luminance(float3 c) +{ + return dot( c, float3(0.3, 0.59, 0.11) ); +} + +float4 main(float2 texCoord: TEXCOORD0) : COLOR { + float4 sharp = tex2D(RT, texCoord); + float4 blur = tex2D(Blur1, texCoord); + + + + return ( sharp + blur * 1.8 ) / 2; + +// float4 color = lerp( sharp, blur, 0.4f ); + +// return color; + + +/* + return ( sharp + blur * 1.8 ) / 2 + + luminance(blur) * + float4( 0.5, 0.5, 0.5, 0) + + luminance(sharp) * + float4( 0.3, 0.3, 0.3, 0); +*/ +/* + return ( sharp + blur * 0.9) / 2 + + luminance(blur) * float4(0.1, 0.15, 0.7, 0); +*/ + +/* + return ( sharp + blur * 0.9) / 2 + + luminance(blur) * float4(0.1, 0.15, 0.7, 0); +*/ + +// float4 retColor = luminance( sharp ) + +// luminance( blur ) + blur / 2; +// return retColor; +} + + + + + + + + + diff --git a/res/dist/media/materials/programs/Bloom_vs11.hlsl b/res/dist/media/materials/programs/Bloom_vs11.hlsl new file mode 100644 index 00000000000..b6e49a3e053 --- /dev/null +++ b/res/dist/media/materials/programs/Bloom_vs11.hlsl @@ -0,0 +1,21 @@ + +struct VS_OUTPUT { + float4 Pos: POSITION; + float2 texCoord: TEXCOORD0; +}; + +VS_OUTPUT main(float4 Pos: POSITION){ + VS_OUTPUT Out; + + // Clean up inaccuracies + Pos.xy = sign(Pos.xy); + + Out.Pos = float4(Pos.xy, 0, 1); + // Image-space + Out.texCoord.x = 0.5 * (1 + Pos.x); + Out.texCoord.y = 0.5 * (1 - Pos.y); + + return Out; +} + + diff --git a/res/dist/media/materials/programs/Blur0_ps20.hlsl b/res/dist/media/materials/programs/Blur0_ps20.hlsl new file mode 100644 index 00000000000..5790dce51d8 --- /dev/null +++ b/res/dist/media/materials/programs/Blur0_ps20.hlsl @@ -0,0 +1,31 @@ +sampler RT: register(s0); +// Simple blur filter + +float4 main(float2 texCoord: TEXCOORD0) : COLOR { + + float2 samples[12] = { + -0.326212, -0.405805, + -0.840144, -0.073580, + -0.695914, 0.457137, + -0.203345, 0.620716, + 0.962340, -0.194983, + 0.473434, -0.480026, + 0.519456, 0.767022, + 0.185461, -0.893124, + 0.507431, 0.064425, + 0.896420, 0.412458, + -0.321940, -0.932615, + -0.791559, -0.597705, + }; + + float4 sum = tex2D(RT, texCoord); + for (int i = 0; i < 12; i++){ + sum += tex2D(RT, texCoord + 0.025 * samples[i]); + } + return sum / 13; + +} + + + + diff --git a/res/dist/media/materials/programs/Blur0_vs.glsl b/res/dist/media/materials/programs/Blur0_vs.glsl new file mode 100644 index 00000000000..24212edd037 --- /dev/null +++ b/res/dist/media/materials/programs/Blur0_vs.glsl @@ -0,0 +1,15 @@ +varying vec2 texCoord[5]; + +void main() +{ + vec2 inPos = sign(gl_Vertex.xy); + gl_Position = vec4(inPos.xy, 0.0, 1.0); + + texCoord[0] = (vec2(inPos.x, -inPos.y) + 1.0)/2.0; + + const float size = 0.01; + texCoord[1] = texCoord[0] + vec2(1.0, 0.0)*size; + texCoord[2] = texCoord[0] + vec2(2.0, 0.0)*size; + texCoord[3] = texCoord[0] + vec2(-1.0, 0.0)*size; + texCoord[4] = texCoord[0] + vec2(-2.0, 0.0)*size; +} diff --git a/res/dist/media/materials/programs/Blur0_vs.glsles b/res/dist/media/materials/programs/Blur0_vs.glsles new file mode 100644 index 00000000000..b30795a0141 --- /dev/null +++ b/res/dist/media/materials/programs/Blur0_vs.glsles @@ -0,0 +1,22 @@ +#version 100 + +precision mediump int; +precision mediump float; + +varying vec2 texCoord[5]; + +attribute vec4 vertex; + +void main() +{ + vec2 inPos = sign(vertex.xy); + gl_Position = vec4(inPos.xy, 0.0, 1.0); + + texCoord[0] = (vec2(inPos.x, -inPos.y) + 1.0)/2.0; + + const float size = 0.01; + texCoord[1] = texCoord[0] + vec2(1.0, 0.0)*size; + texCoord[2] = texCoord[0] + vec2(2.0, 0.0)*size; + texCoord[3] = texCoord[0] + vec2(-1.0, 0.0)*size; + texCoord[4] = texCoord[0] + vec2(-2.0, 0.0)*size; +} diff --git a/res/dist/media/materials/programs/Blur0_vs11.hlsl b/res/dist/media/materials/programs/Blur0_vs11.hlsl new file mode 100644 index 00000000000..3979eae9fba --- /dev/null +++ b/res/dist/media/materials/programs/Blur0_vs11.hlsl @@ -0,0 +1,22 @@ +struct VS_OUTPUT { + float4 Pos: POSITION; + float2 texCoord: TEXCOORD0; +}; + +VS_OUTPUT main(float4 Pos: POSITION){ + VS_OUTPUT Out; + + // Clean up inaccuracies + Pos.xy = sign(Pos.xy); + + Out.Pos = float4(Pos.xy, 0, 1); + // Image-space + Out.texCoord.x = 0.5 * (1 + Pos.x); + Out.texCoord.y = 0.5 * (1 - Pos.y); + + return Out; +} + + + + diff --git a/res/dist/media/materials/programs/Blur1_ps20.hlsl b/res/dist/media/materials/programs/Blur1_ps20.hlsl new file mode 100644 index 00000000000..95e754b24fc --- /dev/null +++ b/res/dist/media/materials/programs/Blur1_ps20.hlsl @@ -0,0 +1,28 @@ +sampler Blur0: register(s0); +// Simple blur filter + +float4 main(float2 texCoord: TEXCOORD0) : COLOR { + + float2 samples[12] = { + -0.326212, -0.405805, + -0.840144, -0.073580, + -0.695914, 0.457137, + -0.203345, 0.620716, + 0.962340, -0.194983, + 0.473434, -0.480026, + 0.519456, 0.767022, + 0.185461, -0.893124, + 0.507431, 0.064425, + 0.896420, 0.412458, + -0.321940, -0.932615, + -0.791559, -0.597705, + }; + + float4 sum = tex2D(Blur0, texCoord); + for (int i = 0; i < 12; i++){ + sum += tex2D(Blur0, texCoord + 0.025 * samples[i]); + } + return sum / 13; + +} + diff --git a/res/dist/media/materials/programs/Blur1_vs.glsl b/res/dist/media/materials/programs/Blur1_vs.glsl new file mode 100644 index 00000000000..dd20151971d --- /dev/null +++ b/res/dist/media/materials/programs/Blur1_vs.glsl @@ -0,0 +1,15 @@ +varying vec2 texCoord[5]; + +void main() +{ + vec2 inPos = sign(gl_Vertex.xy); + gl_Position = vec4(inPos.xy, 0.0, 1.0); + + texCoord[0] = (vec2(inPos.x, -inPos.y) + 1.0)/2.0; + + const float size = 0.01; + texCoord[1] = texCoord[0] + vec2(0.0, 1.0)*size; + texCoord[2] = texCoord[0] + vec2(0.0, 2.0)*size; + texCoord[3] = texCoord[0] + vec2(0.0, -1.0)*size; + texCoord[4] = texCoord[0] + vec2(0.0, -2.0)*size; +} diff --git a/res/dist/media/materials/programs/Blur1_vs.glsles b/res/dist/media/materials/programs/Blur1_vs.glsles new file mode 100644 index 00000000000..05d99684d33 --- /dev/null +++ b/res/dist/media/materials/programs/Blur1_vs.glsles @@ -0,0 +1,22 @@ +#version 100 + +precision mediump int; +precision mediump float; + +varying vec2 texCoord; + +attribute vec4 vertex; + +void main() +{ + vec2 inPos = sign(vertex.xy); + gl_Position = vec4(inPos.xy, 0.0, 1.0); + + texCoord = (vec2(inPos.x, -inPos.y) + 1.0)/2.0; + +/* const float size = 0.01; + texCoord[1] = texCoord[0] + vec2(0.0, 1.0)*size; + texCoord[2] = texCoord[0] + vec2(0.0, 2.0)*size; + texCoord[3] = texCoord[0] + vec2(0.0, -1.0)*size; + texCoord[4] = texCoord[0] + vec2(0.0, -2.0)*size; +*/} diff --git a/res/dist/media/materials/programs/Blur1_vs11.hlsl b/res/dist/media/materials/programs/Blur1_vs11.hlsl new file mode 100644 index 00000000000..49b316f169c --- /dev/null +++ b/res/dist/media/materials/programs/Blur1_vs11.hlsl @@ -0,0 +1,19 @@ +struct VS_OUTPUT { + float4 Pos: POSITION; + float2 texCoord: TEXCOORD0; +}; + +VS_OUTPUT main(float4 Pos: POSITION){ + VS_OUTPUT Out; + + // Clean up inaccuracies + Pos.xy = sign(Pos.xy); + + Out.Pos = float4(Pos.xy, 0, 1); + // Image-space + Out.texCoord.x = 0.5 * (1 + Pos.x); + Out.texCoord.y = 0.5 * (1 - Pos.y); + + return Out; +} + diff --git a/res/dist/media/materials/programs/BlurH_ps20.glsl b/res/dist/media/materials/programs/BlurH_ps20.glsl new file mode 100644 index 00000000000..59a8f514d16 --- /dev/null +++ b/res/dist/media/materials/programs/BlurH_ps20.glsl @@ -0,0 +1,56 @@ +//------------------------------- +//BlurH_ps20.glsl +// Horizontal Gaussian-Blur pass +//------------------------------- + +uniform sampler2D Blur0; +vec2 pos[11] = +{ + vec2( -5, 0), + vec2( -4, 0), + vec2( -3, 0), + vec2( -2, 0), + vec2( -1, 0), + vec2( 0, 0), + vec2( 1, 0), + vec2( 2, 0), + vec2( 3, 0), + vec2( 4, 0), + vec2( 5, 0) +}; + +//We use the Normal-gauss distribution formula +//f(x) being the formula, we used f(0.5)-f(-0.5); f(1.5)-f(0.5)... +float samples[11] = +{//stddev=2.0 +0.01222447, +0.02783468, +0.06559061, +0.12097757, +0.17466632, + +0.19741265, + +0.17466632, +0.12097757, +0.06559061, +0.02783468, +0.01222447 +}; + +void main() +{ + vec4 retVal; + + vec4 sum; + vec2 texcoord = vec2( gl_TexCoord[0] ); + int i = 0; + + sum = vec4( 0 ); + for( i=0;i < 11; i++ ) + { + sum += texture2D( Blur0, texcoord + (pos[i] * 0.0100000) ) * samples[i]; + } + + gl_FragColor = sum; +} diff --git a/res/dist/media/materials/programs/BlurH_ps20.glsles b/res/dist/media/materials/programs/BlurH_ps20.glsles new file mode 100644 index 00000000000..534559f8a5b --- /dev/null +++ b/res/dist/media/materials/programs/BlurH_ps20.glsles @@ -0,0 +1,58 @@ +#version 100 +precision mediump int; +precision mediump float; + +//------------------------------- +//BlurH_ps20.glsles +// Horizontal Gaussian-Blur pass +//------------------------------- + +uniform sampler2D Blur0; +varying vec2 texCoord; + +vec2 pos[11]; +//We use the Normal-gauss distribution formula +//f(x) being the formula, we used f(0.5)-f(-0.5); f(1.5)-f(0.5)... +float samples[11]; + +void main() +{ + pos[0] = vec2(-5.0, 0.0); + pos[1] = vec2(-4.0, 0.0); + pos[2] = vec2(-3.0, 0.0); + pos[3] = vec2(-2.0, 0.0); + pos[4] = vec2(-1.0, 0.0); + pos[5] = vec2(0.0, 0.0); + pos[6] = vec2(1.0, 0.0); + pos[7] = vec2(2.0, 0.0); + pos[8] = vec2(3.0, 0.0); + pos[9] = vec2(4.0, 0.0); + pos[10] = vec2(5.0, 0.0); + + //We use the Normal-gauss distribution formula + //f(x) being the formula, we used f(0.5)-f(-0.5); f(1.5)-f(0.5)... + //stddev=2.0 + samples[0] = 0.01222447; + samples[1] = 0.02783468; + samples[2] = 0.06559061; + samples[3] = 0.12097757; + samples[4] = 0.17466632; + samples[5] = 0.19741265; + samples[6] = 0.17466632; + samples[7] = 0.12097757; + samples[8] = 0.06559061; + samples[9] = 0.02783468; + samples[10] = 0.01222447; + + vec4 retVal; + vec4 sum; + int i = 0; + + sum = vec4( 0 ); + for( i = 0;i < 11; i++ ) + { + sum += texture2D( Blur0, texCoord + (pos[i] * 0.0100000) ) * samples[i]; + } + + gl_FragColor = sum; +} diff --git a/res/dist/media/materials/programs/BlurH_ps20.hlsl b/res/dist/media/materials/programs/BlurH_ps20.hlsl new file mode 100644 index 00000000000..ab7388c5185 --- /dev/null +++ b/res/dist/media/materials/programs/BlurH_ps20.hlsl @@ -0,0 +1,51 @@ +//------------------------------- +//BlurH_ps20.hlsl +// Horizontal Gaussian-Blur pass +//------------------------------- + +sampler Blur0: register(s0); +// Simple blur filter + +//We use the Normal-gauss distribution formula +//f(x) being the formula, we used f(0.5)-f(-0.5); f(1.5)-f(0.5)... +static const float samples[11] = +{//stddev=2.0 +0.01222447, +0.02783468, +0.06559061, +0.12097757, +0.17466632, + +0.19741265, + +0.17466632, +0.12097757, +0.06559061, +0.02783468, +0.01222447 +}; + +static const float2 pos[11] = +{ +-5, 0, +-4, 0, +-3, 0, +-2, 0, +-1, 0, + 0, 0, + 1, 0, + 2, 0, + 3, 0, + 4, 0, + 5, 0, +}; + +float4 main(float2 texCoord: TEXCOORD0) : COLOR +{ + float4 sum = 0; + for (int i = 0; i < 11; i++) + { + sum += tex2D(Blur0, texCoord + pos[i]*0.01) * samples[i]; + } + return sum; +} diff --git a/res/dist/media/materials/programs/BlurV_ps20.glsl b/res/dist/media/materials/programs/BlurV_ps20.glsl new file mode 100644 index 00000000000..3448e1de1fc --- /dev/null +++ b/res/dist/media/materials/programs/BlurV_ps20.glsl @@ -0,0 +1,60 @@ +// Note, this won't work on ATI which is why it's not used +// the issue is with the array initializers +// no card supports GL_3DL_array_objects but it does work on nvidia, not on ATI +//#extension GL_3DL_array_objects : enable + +//------------------------------- +//BlurV_ps20.glsl +// Vertical Gaussian-Blur pass +//------------------------------- + +uniform sampler2D Blur0; +vec2 pos[11] = vec2[11]( + vec2(0.0, -5.0), + vec2(0.0, -4.0), + vec2(0.0, -3.0), + vec2(0.0, -2.0), + vec2(0.0, -1.0), + vec2(0.0, 0.0), + vec2(0.0, 1.0), + vec2(0.0, 2.0), + vec2(0.0, 3.0), + vec2(0.0, 4.0), + vec2(0.0, 5.0) +); + +//We use the Normal-gauss distribution formula +//f(x) being the formula, we used f(0.5)-f(-0.5); f(1.5)-f(0.5)... +float samples[11] = float[11] +(//stddev=2.0 +0.01222447, +0.02783468, +0.06559061, +0.12097757, +0.17466632, + +0.19741265, + +0.17466632, +0.12097757, +0.06559061, +0.02783468, +0.01222447 +); + +void main() +{ + vec4 retVal; + + vec4 sum; + vec2 texcoord = vec2(gl_TexCoord[0]); + int i = 0; + + sum = vec4( 0 ); + for( ;i < 11; i++ ) + { + sum += texture2D( Blur0, texcoord + (pos[i] * 0.0100000) ) * samples[i]; + } + + gl_FragColor = sum; +} diff --git a/res/dist/media/materials/programs/BlurV_ps20.glsles b/res/dist/media/materials/programs/BlurV_ps20.glsles new file mode 100644 index 00000000000..bc9f39c8dec --- /dev/null +++ b/res/dist/media/materials/programs/BlurV_ps20.glsles @@ -0,0 +1,63 @@ +#version 100 +precision mediump int; +precision mediump float; + +// Note, this won't work on ATI which is why it's not used +// the issue is with the array initializers +// no card supports GL_3DL_array_objects but it does work on nvidia, not on ATI +//#extension GL_3DL_array_objects : enable + +//------------------------------- +//BlurV_ps20.glsles +// Vertical Gaussian-Blur pass +//------------------------------- + +uniform sampler2D Blur0; +varying vec2 texCoord; + +vec2 pos[11]; +//We use the Normal-gauss distribution formula +//f(x) being the formula, we used f(0.5)-f(-0.5); f(1.5)-f(0.5)... +float samples[11]; + +void main() +{ + pos[0] = vec2(0.0, -5.0); + pos[1] = vec2(0.0, -4.0); + pos[2] = vec2(0.0, -3.0); + pos[3] = vec2(0.0, -2.0); + pos[4] = vec2(0.0, -1.0); + pos[5] = vec2(0.0, 0.0); + pos[6] = vec2(0.0, 1.0); + pos[7] = vec2(0.0, 2.0); + pos[8] = vec2(0.0, 3.0); + pos[9] = vec2(0.0, 4.0); + pos[10] = vec2(0.0, 5.0); + + //We use the Normal-gauss distribution formula + //f(x) being the formula, we used f(0.5)-f(-0.5); f(1.5)-f(0.5)... + //stddev=2.0 + samples[0] = 0.01222447; + samples[1] = 0.02783468; + samples[2] = 0.06559061; + samples[3] = 0.12097757; + samples[4] = 0.17466632; + samples[5] = 0.19741265; + samples[6] = 0.17466632; + samples[7] = 0.12097757; + samples[8] = 0.06559061; + samples[9] = 0.02783468; + samples[10] = 0.01222447; + + vec4 retVal; + vec4 sum; + int i = 0; + + sum = vec4( 0 ); + for( ;i < 11; i++ ) + { + sum += texture2D( Blur0, texCoord + (pos[i] * 0.0100000) ) * samples[i]; + } + + gl_FragColor = sum; +} diff --git a/res/dist/media/materials/programs/BlurV_ps20.hlsl b/res/dist/media/materials/programs/BlurV_ps20.hlsl new file mode 100644 index 00000000000..c5becdc350f --- /dev/null +++ b/res/dist/media/materials/programs/BlurV_ps20.hlsl @@ -0,0 +1,51 @@ +//------------------------------- +//BlurV_ps20.hlsl +// Vertical Gaussian-Blur pass +//------------------------------- + +sampler Blur0: register(s0); +// Simple blur filter + +//We use the Normal-gauss distribution formula +//f(x) being the formula, we used f(0.5)-f(-0.5); f(1.5)-f(0.5)... +static const float samples[11] = +{//stddev=2.0 +0.01222447, +0.02783468, +0.06559061, +0.12097757, +0.17466632, + +0.19741265, + +0.17466632, +0.12097757, +0.06559061, +0.02783468, +0.01222447 +}; + +static const float2 pos[11] = +{ +0, -5, +0, -4, +0, -3, +0, -2, +0, -1, +0, 0, +0, 1, +0, 2, +0, 3, +0, 4, +0, 5 +}; + +float4 main(float2 texCoord: TEXCOORD0) : COLOR +{ + float4 sum = 0; + for (int i = 0; i < 11; i++) + { + sum += tex2D(Blur0, texCoord + pos[i]*0.01) * samples[i]; + } + return sum; +} diff --git a/res/dist/media/materials/programs/Blur_ps.glsl b/res/dist/media/materials/programs/Blur_ps.glsl new file mode 100644 index 00000000000..d6bb1939c8e --- /dev/null +++ b/res/dist/media/materials/programs/Blur_ps.glsl @@ -0,0 +1,14 @@ +uniform sampler2D tex0; + +varying vec2 texCoord[5]; + +void main() +{ + vec4 sum = texture2D(tex0, texCoord[0]) + + texture2D(tex0, texCoord[1]) + + texture2D(tex0, texCoord[2]) + + texture2D(tex0, texCoord[3]) + + texture2D(tex0, texCoord[4]); + gl_FragColor = sum / 5.0; +} + diff --git a/res/dist/media/materials/programs/Blur_ps.glsles b/res/dist/media/materials/programs/Blur_ps.glsles new file mode 100644 index 00000000000..bbde137469d --- /dev/null +++ b/res/dist/media/materials/programs/Blur_ps.glsles @@ -0,0 +1,18 @@ +#version 100 +precision mediump int; +precision mediump float; + +uniform sampler2D tex0; + +varying vec2 texCoord[5]; + +void main() +{ + vec4 sum = texture2D(tex0, texCoord[0]) + + texture2D(tex0, texCoord[1]) + + texture2D(tex0, texCoord[2]) + + texture2D(tex0, texCoord[3]) + + texture2D(tex0, texCoord[4]); + gl_FragColor = sum / 5.0; +} + diff --git a/res/dist/media/materials/programs/Blur_vs.glsl b/res/dist/media/materials/programs/Blur_vs.glsl new file mode 100644 index 00000000000..e64f9d31e99 --- /dev/null +++ b/res/dist/media/materials/programs/Blur_vs.glsl @@ -0,0 +1,14 @@ +void main() +{ + vec2 inPos = sign(gl_Vertex.xy); + gl_Position = vec4(inPos.xy, 0.0, 1.0); + + vec2 uv = (vec2(inPos.x, -inPos.y) + 1.0)*0.5; + gl_TexCoord[0] = vec4( uv, 0, 0 ); + + const float size = 0.01; + gl_TexCoord[1] = vec4( uv + vec2(0.0, 1.0)*size, 0, 0); + gl_TexCoord[2] = vec4( uv + vec2(0.0, 2.0)*size, 0, 0); + gl_TexCoord[3] = vec4( uv + vec2(0.0, -1.0)*size, 0, 0); + gl_TexCoord[4] = vec4( uv + vec2(0.0, -2.0)*size, 0, 0); +} diff --git a/res/dist/media/materials/programs/Blur_vs.glsles b/res/dist/media/materials/programs/Blur_vs.glsles new file mode 100644 index 00000000000..a32d54a8d12 --- /dev/null +++ b/res/dist/media/materials/programs/Blur_vs.glsles @@ -0,0 +1,24 @@ +#version 100 + +precision mediump int; +precision mediump float; + +varying vec2 texCoord; + +attribute vec4 vertex; + +void main() +{ + vec2 inPos = sign(vertex.xy); + gl_Position = vec4(inPos.xy, 0.0, 1.0); + + vec2 uv = (vec2(inPos.x, -inPos.y) + 1.0)*0.5; + texCoord = uv; + /* + const float size = 0.01; + texCoord[1] = uv + vec2(0.0, 1.0)*size; + texCoord[2] = uv + vec2(0.0, 2.0)*size; + texCoord[3] = uv + vec2(0.0, -1.0)*size; + texCoord[4] = uv + vec2(0.0, -2.0)*size; + */ +} diff --git a/res/dist/media/materials/programs/Blur_vs11.hlsl b/res/dist/media/materials/programs/Blur_vs11.hlsl new file mode 100644 index 00000000000..49b316f169c --- /dev/null +++ b/res/dist/media/materials/programs/Blur_vs11.hlsl @@ -0,0 +1,19 @@ +struct VS_OUTPUT { + float4 Pos: POSITION; + float2 texCoord: TEXCOORD0; +}; + +VS_OUTPUT main(float4 Pos: POSITION){ + VS_OUTPUT Out; + + // Clean up inaccuracies + Pos.xy = sign(Pos.xy); + + Out.Pos = float4(Pos.xy, 0, 1); + // Image-space + Out.texCoord.x = 0.5 * (1 + Pos.x); + Out.texCoord.y = 0.5 * (1 - Pos.y); + + return Out; +} + diff --git a/res/dist/media/materials/programs/BrightBloom2_ps20.glsl b/res/dist/media/materials/programs/BrightBloom2_ps20.glsl new file mode 100644 index 00000000000..4a3b9ab021d --- /dev/null +++ b/res/dist/media/materials/programs/BrightBloom2_ps20.glsl @@ -0,0 +1,29 @@ +//------------------------------- +//BrightBloom_ps20.glsl +// High-pass filter for obtaining lumminance +// We use an aproximation formula that is pretty fast: +// f(x) = ( -3 * ( x - 1 )^2 + 1 ) * 2 +// Color += Grayscale( f(Color) ) + 0.6 +// +// Special thanks to ATI for their great HLSL2GLSL utility +// http://sourceforge.net/projects/hlsl2glsl +//------------------------------- + +uniform sampler2D RT; + +void main() +{ + vec4 tex; + vec4 bright4; + float bright; + + vec2 texCoord = vec2( gl_TexCoord[0] ); + + tex = texture2D( RT, texCoord); + tex -= 1.00000; + bright4 = -6.00000 * tex * tex + 2.00000; + bright = dot( bright4, vec4( 0.333333, 0.333333, 0.333333, 0.000000) ); + tex += (bright + 0.600000); + + gl_FragColor = tex; +} diff --git a/res/dist/media/materials/programs/BrightBloom2_ps20.glsles b/res/dist/media/materials/programs/BrightBloom2_ps20.glsles new file mode 100644 index 00000000000..3dc06925a21 --- /dev/null +++ b/res/dist/media/materials/programs/BrightBloom2_ps20.glsles @@ -0,0 +1,32 @@ +#version 100 +precision mediump int; +precision mediump float; + +//------------------------------- +//BrightBloom_ps20.glsles +// High-pass filter for obtaining luminance +// We use an approximation formula that is pretty fast: +// f(x) = ( -3 * ( x - 1 )^2 + 1 ) * 2 +// Color += Grayscale( f(Color) ) + 0.6 +// +// Special thanks to ATI for their great HLSL2GLSL utility +// http://sourceforge.net/projects/hlsl2glsl +//------------------------------- + +uniform sampler2D RT; +varying vec2 uv; + +void main() +{ + vec4 tex; + vec4 bright4; + float bright; + + tex = texture2D(RT, uv); + tex -= 1.00000; + bright4 = -6.00000 * tex * tex + 2.00000; + bright = dot( bright4, vec4( 0.333333, 0.333333, 0.333333, 0.000000) ); + tex += (bright + 0.600000); + + gl_FragColor = tex; +} diff --git a/res/dist/media/materials/programs/BrightBloom2_ps20.hlsl b/res/dist/media/materials/programs/BrightBloom2_ps20.hlsl new file mode 100644 index 00000000000..81c7bf53b53 --- /dev/null +++ b/res/dist/media/materials/programs/BrightBloom2_ps20.hlsl @@ -0,0 +1,20 @@ +//------------------------------- +//BrightBloom_ps20.hlsl +// High-pass filter for obtaining lumminance +// We use an aproximation formula that is pretty fast: +// f(x) = ( -3 * ( x - 1 )^2 + 1 ) * 2 +// Color += f(Color) +//------------------------------- + +float4 main(float2 texCoord: TEXCOORD0, + uniform sampler RT: register(s0) + ) : COLOR { + float4 tex = tex2D(RT, texCoord); + + tex -= 1; + float4 bright4= -6 * tex * tex + 2; //float4 bright4= ( -3 * tex * tex + 1 ) * 2; + float bright = dot( bright4, float4( 0.333333, 0.333333, 0.333333, 0) ); + tex += bright + 0.6; + + return tex; +} diff --git a/res/dist/media/materials/programs/ColdCasterFp.glsles b/res/dist/media/materials/programs/ColdCasterFp.glsles new file mode 100644 index 00000000000..9ba88ef2111 --- /dev/null +++ b/res/dist/media/materials/programs/ColdCasterFp.glsles @@ -0,0 +1,11 @@ +#version 100 + +precision mediump int; +precision mediump float; + +varying vec2 NDotV; + +void main() +{ + gl_FragColor = vec4(NDotV.x / 2.0); +} diff --git a/res/dist/media/materials/programs/ColdCasterVp.glsles b/res/dist/media/materials/programs/ColdCasterVp.glsles new file mode 100644 index 00000000000..571759710db --- /dev/null +++ b/res/dist/media/materials/programs/ColdCasterVp.glsles @@ -0,0 +1,18 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform mat4 worldViewProj; +uniform vec3 eyePosition; +attribute vec4 position; +attribute vec4 normal; +varying vec2 NDotV; + +void main() +{ + vec4 eyeDir = vec4(eyePosition - position.xyz, 0.0); + eyeDir = normalize(eyeDir); + gl_Position = worldViewProj * position; + NDotV = vec2(clamp( dot( normal, eyeDir ), 0.0, 1.0 )); +} diff --git a/res/dist/media/materials/programs/Combine_fp.cg b/res/dist/media/materials/programs/Combine_fp.cg new file mode 100644 index 00000000000..6ad9c7b7d64 --- /dev/null +++ b/res/dist/media/materials/programs/Combine_fp.cg @@ -0,0 +1,15 @@ +float4 Combine_fp +( + in float2 texCoord: TEXCOORD0, + + uniform sampler RT : register(s0), + uniform sampler Sum : register(s1), + + uniform float blur +) : COLOR +{ + float4 render = tex2D(RT, texCoord); + float4 sum = tex2D(Sum, texCoord); + + return lerp(render, sum, blur); +} diff --git a/res/dist/media/materials/programs/Combine_fp.glsles b/res/dist/media/materials/programs/Combine_fp.glsles new file mode 100644 index 00000000000..95c86ea1512 --- /dev/null +++ b/res/dist/media/materials/programs/Combine_fp.glsles @@ -0,0 +1,17 @@ +#version 100 +precision mediump int; +precision mediump float; + +uniform sampler2D RT; +uniform sampler2D Sum; +uniform float blur; + +varying vec2 uv; + +void main() +{ + vec4 render = texture2D(RT, uv); + vec4 sum = texture2D(Sum, uv); + + gl_FragColor = mix(render, sum, blur); +} diff --git a/res/dist/media/materials/programs/Common.cg b/res/dist/media/materials/programs/Common.cg new file mode 100644 index 00000000000..45a903d012c --- /dev/null +++ b/res/dist/media/materials/programs/Common.cg @@ -0,0 +1,81 @@ +struct outPixel +{ + float4 colour : COLOR0; +}; + +// General functions + +// Expand a range-compressed vector +half4 expand(half4 v) +{ + return v * 2 - 1; +} +half3 expand(half3 v) +{ + return v * 2 - 1; +} +half2 expand(half2 v) +{ + return v * 2 - 1; +} +half1 expand(half1 v) +{ + return v * 2 - 1; +} + +// Returns light direction from light position and vertex position +half3 getLightDirection(float4 lightPosition, float4 position) +{ + // calculate tangent space light vector + // Get object space light direction + // Non-normalised since we'll do that in the fragment program anyway + return lightPosition.xyz - (position.xyz * lightPosition.w); +} + +// Returns eye direction from eye position and vertex position +half3 getEyeDirection(float3 eyePosition, float4 position) +{ + return eyePosition - position.xyz; +} + +// Returns a Tangent Binormal Normal matrix +half3x3 getTBNMatrix(float3 tangent, float3 normal) +{ + // Calculate the binormal (NB we assume both normal and tangent are + // already normalised) + // NB looks like nvidia cross params are BACKWARDS to what you'd expect + // this equates to NxT, not TxN + float3 binormal = cross(tangent, normal); + + // Form a rotation matrix out of the vectors + return half3x3(tangent, binormal, normal); +} + +// Returns expanded normal vector from texture map +half3 getNormalMapVector(sampler2D normalMap, float2 uv) +{ + // get bump map vector, again expand from range-compressed + return expand(tex2D(normalMap, uv).xyz); +} + +// Returns displacement vector from normalmaps alpha channel +half getDisplacement(sampler2D normalMap, float2 uv, half scale, half bias) +{ + // get the height using the tex coords + half height = tex2D(normalMap, uv).a; + + // calculate displacement + return (height * scale) + bias; +} + +// Returns a specular component from normal vector, specular colour and specular power +half3 getSpecularComponent(float3 normal, float3 halfAngle, float3 specularcolour, float specularPower) +{ + return pow(saturate(dot(normal, halfAngle)), specularPower) * specularcolour; +} + +// Returns a per-pixel lighted component from normal vector, lightdir and colour +half3 getLightingComponent(float3 normal, float3 lightDir, float3 colour) +{ + return saturate(dot(normal, lightDir)) * colour; +} diff --git a/res/dist/media/materials/programs/DOF_ps.cg b/res/dist/media/materials/programs/DOF_ps.cg new file mode 100644 index 00000000000..ecf8ce06f22 --- /dev/null +++ b/res/dist/media/materials/programs/DOF_ps.cg @@ -0,0 +1,47 @@ +// Simple blur filter + +const float2 samples[8] = { + {-1, 1}, + {-1, 0}, + {-1, -1}, + {0, -1}, + {1, -1}, + {1, 0}, + {1, 1}, + {0, 1} +}; + +float4 blur( + + in float2 texCoord: TEXCOORD0, + uniform float sampleDistance: register(c0), + uniform sampler Blur0: register(s0) + +) : COLOR +{ + float4 sum = tex2D(Blur0, texCoord); + for (int i = 0; i < 8; ++i){ + sum += tex2D(Blur0, texCoord + sampleDistance * samples[i]); + } + return sum / 9; +} + + + +float4 blend +( + in float2 texCoord: TEXCOORD0, + + uniform sampler Blur0 : register(s0), + uniform sampler Blur1 : register(s1), + + uniform float focus: register(c0), + uniform float range: register(c1) +) : COLOR +{ + float4 sharp = tex2D(Blur0, texCoord); + float4 blur = tex2D(Blur1, texCoord); + + // alpha channel of sharp RT has depth info + return lerp(sharp, blur, saturate(range * abs(focus - sharp.a))); +} diff --git a/res/dist/media/materials/programs/DOF_ps.glsles b/res/dist/media/materials/programs/DOF_ps.glsles new file mode 100644 index 00000000000..833d955b151 --- /dev/null +++ b/res/dist/media/materials/programs/DOF_ps.glsles @@ -0,0 +1,94 @@ +// Simple blur filter + +const float2 samples[8] = { + {-1, 1}, + {-1, 0}, + {-1, -1}, + {0, -1}, + {1, -1}, + {1, 0}, + {1, 1}, + {0, 1} +}; + +float4 blur( + + in float2 texCoord: TEXCOORD0, + uniform float sampleDistance: register(c0), + uniform sampler Blur0: register(s0) + +) : COLOR +{ + float4 sum = tex2D(Blur0, texCoord); + for (int i = 0; i < 8; ++i){ + sum += tex2D(Blur0, texCoord + sampleDistance * samples[i]); + } + return sum / 9; +} + + + +float4 blend +( + in float2 texCoord: TEXCOORD0, + + uniform sampler Blur0 : register(s0), + uniform sampler Blur1 : register(s1), + + uniform float focus: register(c0), + uniform float range: register(c1) +) : COLOR +{ + float4 sharp = tex2D(Blur0, texCoord); + float4 blur = tex2D(Blur1, texCoord); + + // alpha channel of sharp RT has depth info + return mix(sharp, blur, saturate(range * abs(focus - sharp.a))); +} +// Simple blur filter + +const float2 samples[8] = { + {-1, 1}, + {-1, 0}, + {-1, -1}, + {0, -1}, + {1, -1}, + {1, 0}, + {1, 1}, + {0, 1} +}; + +float4 blur( + + in float2 texCoord: TEXCOORD0, + uniform float sampleDistance: register(c0), + uniform sampler Blur0: register(s0) + +) : COLOR +{ + float4 sum = tex2D(Blur0, texCoord); + for (int i = 0; i < 8; ++i){ + sum += tex2D(Blur0, texCoord + sampleDistance * samples[i]); + } + return sum / 9; +} + + + +float4 blend +( + in float2 texCoord: TEXCOORD0, + + uniform sampler Blur0 : register(s0), + uniform sampler Blur1 : register(s1), + + uniform float focus: register(c0), + uniform float range: register(c1) +) : COLOR +{ + float4 sharp = tex2D(Blur0, texCoord); + float4 blur = tex2D(Blur1, texCoord); + + // alpha channel of sharp RT has depth info + return mix(sharp, blur, saturate(range * abs(focus - sharp.a))); +} diff --git a/res/dist/media/materials/programs/DepthShadowmap.hlsl b/res/dist/media/materials/programs/DepthShadowmap.hlsl new file mode 100644 index 00000000000..f79134346d0 --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmap.hlsl @@ -0,0 +1,309 @@ +/* This file implements standard programs for depth shadow mapping. + These particular ones are suitable for additive lighting models, and + include 3 techniques to reduce depth fighting on self-shadowed surfaces, + constant bias, gradient (slope-scale) bias, and a fuzzy shadow map comparison*/ + + +// Shadow caster vertex program. +void casterVP( + float4 position : POSITION, + out float4 outPos : POSITION, + out float2 outDepth : TEXCOORD0, + + uniform float4x4 worldViewProj, + uniform float4 texelOffsets, + uniform float4 depthRange + ) +{ + outPos = mul(worldViewProj, position); + + // fix pixel / texel alignment + outPos.xy += texelOffsets.zw * outPos.w; + // linear depth storage + // offset / scale range output +#if LINEAR_RANGE + outDepth.x = (outPos.z - depthRange.x) * depthRange.w; +#else + outDepth.x = outPos.z; +#endif + outDepth.y = outPos.w; +} + + +// Shadow caster fragment program for high-precision single-channel textures +void casterFP( + float2 depth : TEXCOORD0, + out float4 result : COLOR) + +{ +#if LINEAR_RANGE + float finalDepth = depth.x; +#else + float finalDepth = depth.x / depth.y; +#endif + // just smear across all components + // therefore this one needs high individual channel precision + result = float4(finalDepth, finalDepth, finalDepth, 1); +} + + + +void receiverVP( + float4 position : POSITION, + float4 normal : NORMAL, + + out float4 outPos : POSITION, + out float4 outColour : COLOR, + out float4 outShadowUV : TEXCOORD0, + + uniform float4x4 world, + uniform float4x4 worldIT, + uniform float4x4 worldViewProj, + uniform float4x4 texViewProj, + uniform float4 lightPosition, + uniform float4 lightColour, + uniform float4 shadowDepthRange + ) +{ + float4 worldPos = mul(world, position); + outPos = mul(worldViewProj, position); + + float3 worldNorm = mul(worldIT, normal).xyz; + + // calculate lighting (simple vertex lighting) + float3 lightDir = normalize( + lightPosition.xyz - (worldPos.xyz * lightPosition.w)); + + outColour = lightColour * max(dot(lightDir, worldNorm), 0.0); + + // calculate shadow map coords + outShadowUV = mul(texViewProj, worldPos); +#if LINEAR_RANGE + // adjust by fixed depth bias, rescale into range + outShadowUV.z = (outShadowUV.z - shadowDepthRange.x) * shadowDepthRange.w; +#endif + + + + +} + +void receiverFP( + float4 position : POSITION, + float4 shadowUV : TEXCOORD0, + float4 vertexColour : COLOR, + + uniform sampler2D shadowMap : register(s0), + uniform float inverseShadowmapSize, + uniform float fixedDepthBias, + uniform float gradientClamp, + uniform float gradientScaleBias, + uniform float shadowFuzzyWidth, + + out float4 result : COLOR) +{ + // point on shadowmap +#if LINEAR_RANGE + shadowUV.xy = shadowUV.xy / shadowUV.w; +#else + shadowUV = shadowUV / shadowUV.w; +#endif + float centerdepth = tex2D(shadowMap, shadowUV.xy).x; + + // gradient calculation + float pixeloffset = inverseShadowmapSize; + float4 depths = float4( + tex2D(shadowMap, shadowUV.xy + float2(-pixeloffset, 0)).x, + tex2D(shadowMap, shadowUV.xy + float2(+pixeloffset, 0)).x, + tex2D(shadowMap, shadowUV.xy + float2(0, -pixeloffset)).x, + tex2D(shadowMap, shadowUV.xy + float2(0, +pixeloffset)).x); + + float2 differences = abs( depths.yw - depths.xz ); + float gradient = min(gradientClamp, max(differences.x, differences.y)); + float gradientFactor = gradient * gradientScaleBias; + + // visibility function + float depthAdjust = gradientFactor + (fixedDepthBias * centerdepth); + float finalCenterDepth = centerdepth + depthAdjust; + + // shadowUV.z contains lightspace position of current object + +#if FUZZY_TEST + // fuzzy test - introduces some ghosting in result and doesn't appear to be needed? + //float visibility = saturate(1 + delta_z / (gradient * shadowFuzzyWidth)); + float visibility = saturate(1 + (finalCenterDepth - shadowUV.z) * shadowFuzzyWidth * shadowUV.w); + + result = vertexColour * visibility; +#else + // hard test +#if PCF + // use depths from prev, calculate diff + depths += depthAdjust.xxxx; + float final = (finalCenterDepth > shadowUV.z) ? 1.0f : 0.0f; + final += (depths.x > shadowUV.z) ? 1.0f : 0.0f; + final += (depths.y > shadowUV.z) ? 1.0f : 0.0f; + final += (depths.z > shadowUV.z) ? 1.0f : 0.0f; + final += (depths.w > shadowUV.z) ? 1.0f : 0.0f; + + final *= 0.2f; + + result = float4(vertexColour.xyz * final, 1); + +#else + result = (finalCenterDepth > shadowUV.z) ? vertexColour : float4(0,0,0,1); +#endif + +#endif + + + +} + + + + +// Expand a range-compressed vector +float3 expand(float3 v) +{ + return (v - 0.5) * 2; +} + + +/* Normal mapping plus depth shadowmapping receiver programs +*/ +void normalMapShadowReceiverVp(float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 tangent : TANGENT0, + + // outputs + out float4 outPos : POSITION, + out float4 outShadowUV : TEXCOORD0, + out float2 oUv : TEXCOORD1, + out float3 oTSLightDir : TEXCOORD2, + // parameters + uniform float4 lightPosition, // object space + uniform float4x4 world, + uniform float4x4 worldViewProj, + uniform float4x4 texViewProj) +{ + float4 worldPos = mul(world, position); + outPos = mul(worldViewProj, position); + + // calculate shadow map coords + outShadowUV = mul(texViewProj, worldPos); +#if LINEAR_RANGE + // adjust by fixed depth bias, rescale into range + outShadowUV.z = (outShadowUV.z - shadowDepthRange.x) * shadowDepthRange.w; +#endif + + // pass the main uvs straight through unchanged + oUv = uv; + + // calculate tangent space light vector + // Get object space light direction + // Non-normalised since we'll do that in the fragment program anyway + float3 lightDir = lightPosition.xyz - (position * lightPosition.w); + + // Calculate the binormal (NB we assume both normal and tangent are + // already normalised) + // NB looks like nvidia cross params are BACKWARDS to what you'd expect + // this equates to NxT, not TxN + float3 binormal = cross(tangent, normal); + + // Form a rotation matrix out of the vectors + float3x3 rotation = float3x3(tangent, binormal, normal); + + // Transform the light vector according to this matrix + oTSLightDir = mul(rotation, lightDir); + + +} + + +void normalMapShadowReceiverFp( + float4 shadowUV : TEXCOORD0, + float2 uv : TEXCOORD1, + float3 TSlightDir : TEXCOORD2, + + out float4 result : COLOR, + + uniform float4 lightColour, + uniform float inverseShadowmapSize, + uniform float fixedDepthBias, + uniform float gradientClamp, + uniform float gradientScaleBias, + uniform float shadowFuzzyWidth, + + uniform sampler2D shadowMap : register(s0), + uniform sampler2D normalMap : register(s1), + uniform samplerCUBE normalCubeMap : register(s2)) +{ + + // retrieve normalised light vector, expand from range-compressed + float3 lightVec = expand(texCUBE(normalCubeMap, TSlightDir).xyz); + + // get bump map vector, again expand from range-compressed + float3 bumpVec = expand(tex2D(normalMap, uv).xyz); + + // Calculate dot product + float4 vertexColour = lightColour * dot(bumpVec, lightVec); + + + // point on shadowmap +#if LINEAR_RANGE + shadowUV.xy = shadowUV.xy / shadowUV.w; +#else + shadowUV = shadowUV / shadowUV.w; +#endif + float centerdepth = tex2D(shadowMap, shadowUV.xy).x; + + // gradient calculation + float pixeloffset = inverseShadowmapSize; + float4 depths = float4( + tex2D(shadowMap, shadowUV.xy + float2(-pixeloffset, 0)).x, + tex2D(shadowMap, shadowUV.xy + float2(+pixeloffset, 0)).x, + tex2D(shadowMap, shadowUV.xy + float2(0, -pixeloffset)).x, + tex2D(shadowMap, shadowUV.xy + float2(0, +pixeloffset)).x); + + float2 differences = abs( depths.yw - depths.xz ); + float gradient = min(gradientClamp, max(differences.x, differences.y)); + float gradientFactor = gradient * gradientScaleBias; + + // visibility function + float depthAdjust = gradientFactor + (fixedDepthBias * centerdepth); + float finalCenterDepth = centerdepth + depthAdjust; + + // shadowUV.z contains lightspace position of current object + +#if FUZZY_TEST + // fuzzy test - introduces some ghosting in result and doesn't appear to be needed? + //float visibility = saturate(1 + delta_z / (gradient * shadowFuzzyWidth)); + float visibility = saturate(1 + (finalCenterDepth - shadowUV.z) * shadowFuzzyWidth * shadowUV.w); + + result = vertexColour * visibility; +#else + // hard test +#if PCF + // use depths from prev, calculate diff + depths += depthAdjust.xxxx; + float final = (finalCenterDepth > shadowUV.z) ? 1.0f : 0.0f; + final += (depths.x > shadowUV.z) ? 1.0f : 0.0f; + final += (depths.y > shadowUV.z) ? 1.0f : 0.0f; + final += (depths.z > shadowUV.z) ? 1.0f : 0.0f; + final += (depths.w > shadowUV.z) ? 1.0f : 0.0f; + + final *= 0.2f; + + result = float4(vertexColour.xyz * final, 1); + +#else + result = (finalCenterDepth > shadowUV.z) ? vertexColour : float4(0,0,0,1); +#endif + +#endif + + + +} + diff --git a/res/dist/media/materials/programs/DepthShadowmapCasterFp.glsl b/res/dist/media/materials/programs/DepthShadowmapCasterFp.glsl new file mode 100644 index 00000000000..1e32d262647 --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapCasterFp.glsl @@ -0,0 +1,16 @@ + +varying vec2 depth; + +void main() +{ +#if LINEAR_RANGE + float finalDepth = depth.x; +#else + float finalDepth = depth.x / depth.y; +#endif + // just smear across all components + // therefore this one needs high individual channel precision + gl_FragColor = vec4(finalDepth, finalDepth, finalDepth, 1); + +} + diff --git a/res/dist/media/materials/programs/DepthShadowmapCasterFp.glsles b/res/dist/media/materials/programs/DepthShadowmapCasterFp.glsles new file mode 100644 index 00000000000..827305b5483 --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapCasterFp.glsles @@ -0,0 +1,19 @@ +#version 100 + +precision mediump int; +precision mediump float; + +varying vec2 depth; + +void main() +{ +#if LINEAR_RANGE + float finalDepth = depth.x; +#else + float finalDepth = depth.x / depth.y; +#endif + // just smear across all components + // therefore this one needs high individual channel precision + gl_FragColor = vec4(finalDepth, finalDepth, finalDepth, 1.0); + +} diff --git a/res/dist/media/materials/programs/DepthShadowmapCasterVp.glsl b/res/dist/media/materials/programs/DepthShadowmapCasterVp.glsl new file mode 100644 index 00000000000..2f19c7599c2 --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapCasterVp.glsl @@ -0,0 +1,24 @@ +uniform mat4 worldViewProj; +uniform vec4 texelOffsets; +uniform vec4 depthRange; + +varying vec2 depth; + +void main() +{ + gl_Position = ftransform(); + + // fix pixel / texel alignment + gl_Position.xy += texelOffsets.zw * gl_Position.w; + // linear depth storage + // offset / scale range output +#if LINEAR_RANGE + depth.x = (gl_Position.z - depthRange.x) * depthRange.w; +#else + depth.x = gl_Position.z; +#endif + depth.y = gl_Position.w; + + +} + diff --git a/res/dist/media/materials/programs/DepthShadowmapCasterVp.glsles b/res/dist/media/materials/programs/DepthShadowmapCasterVp.glsles new file mode 100644 index 00000000000..a347c4d1ea7 --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapCasterVp.glsles @@ -0,0 +1,27 @@ +#version 100 +precision mediump int; +precision mediump float; + +uniform mat4 worldViewProj; +uniform vec4 texelOffsets; +uniform vec4 depthRange; + +varying vec2 depth; + +attribute vec4 position; + +void main() +{ + gl_Position = position * worldViewProj; + + // fix pixel / texel alignment + gl_Position.xy += texelOffsets.zw * gl_Position.w; + // linear depth storage + // offset / scale range output +#if LINEAR_RANGE + depth.x = (gl_Position.z - depthRange.x) * depthRange.w; +#else + depth.x = gl_Position.z; +#endif + depth.y = gl_Position.w; +} diff --git a/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverFp.glsl b/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverFp.glsl new file mode 100644 index 00000000000..2c45a54534d --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverFp.glsl @@ -0,0 +1,84 @@ +uniform float inverseShadowmapSize; +uniform float fixedDepthBias; +uniform float gradientClamp; +uniform float gradientScaleBias; +uniform float shadowFuzzyWidth; +uniform vec4 lightColour; + +uniform sampler2D shadowMap; +uniform sampler2D normalMap; + +varying vec3 tangentLightDir; + + +// Expand a range-compressed vector +vec3 expand(vec3 v) +{ + return (v - 0.5) * 2.0; +} + +void main() +{ + + // get the new normal and diffuse values + vec3 normal = normalize(expand(texture2D(normalMap, gl_TexCoord[1].xy).xyz)); + + vec4 vertexColour = clamp(dot(normal, tangentLightDir),0.0,1.0) * lightColour; + + + vec4 shadowUV = gl_TexCoord[0]; + // point on shadowmap +#if LINEAR_RANGE + shadowUV.xy = shadowUV.xy / shadowUV.w; +#else + shadowUV = shadowUV / shadowUV.w; +#endif + float centerdepth = texture2D(shadowMap, shadowUV.xy).x; + + // gradient calculation + float pixeloffset = inverseShadowmapSize; + vec4 depths = vec4( + texture2D(shadowMap, shadowUV.xy + vec2(-pixeloffset, 0)).x, + texture2D(shadowMap, shadowUV.xy + vec2(+pixeloffset, 0)).x, + texture2D(shadowMap, shadowUV.xy + vec2(0, -pixeloffset)).x, + texture2D(shadowMap, shadowUV.xy + vec2(0, +pixeloffset)).x); + + vec2 differences = abs( depths.yw - depths.xz ); + float gradient = min(gradientClamp, max(differences.x, differences.y)); + float gradientFactor = gradient * gradientScaleBias; + + // visibility function + float depthAdjust = gradientFactor + (fixedDepthBias * centerdepth); + float finalCenterDepth = centerdepth + depthAdjust; + + // shadowUV.z contains lightspace position of current object + +#if FUZZY_TEST + // fuzzy test - introduces some ghosting in result and doesn't appear to be needed? + //float visibility = saturate(1 + delta_z / (gradient * shadowFuzzyWidth)); + float visibility = saturate(1 + (finalCenterDepth - shadowUV.z) * shadowFuzzyWidth * shadowUV.w); + + gl_FragColor = vertexColour * visibility; +#else + // hard test +#if PCF + // use depths from prev, calculate diff + depths += depthAdjust; + float final = (finalCenterDepth > shadowUV.z) ? 1.0 : 0.0; + final += (depths.x > shadowUV.z) ? 1.0 : 0.0; + final += (depths.y > shadowUV.z) ? 1.0 : 0.0; + final += (depths.z > shadowUV.z) ? 1.0 : 0.0; + final += (depths.w > shadowUV.z) ? 1.0 : 0.0; + + final *= 0.2; + + gl_FragColor = vec4(vertexColour.xyz * final, 1); + +#else + gl_FragColor = (finalCenterDepth > shadowUV.z) ? vertexColour : vec4(0,0,0,1); +#endif + +#endif + +} + diff --git a/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverFp.glsles b/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverFp.glsles new file mode 100644 index 00000000000..15eca58ebe0 --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverFp.glsles @@ -0,0 +1,86 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform float inverseShadowmapSize; +uniform float fixedDepthBias; +uniform float gradientClamp; +uniform float gradientScaleBias; +uniform float shadowFuzzyWidth; +uniform vec4 lightColour; + +uniform sampler2D shadowMap; +uniform sampler2D normalMap; + +varying vec3 tangentLightDir; +varying vec4 vUv0; +varying vec4 vUv1; + +// Expand a range-compressed vector +vec3 expand(vec3 v) +{ + return (v - 0.5) * 2.0; +} + +void main() +{ + + // get the new normal and diffuse values + vec3 normal = normalize(expand(texture2D(normalMap, vUv1.xy).xyz)); + vec4 vertexColour = clamp(dot(normal, tangentLightDir), 0.0, 1.0) * lightColour; + vec4 shadowUV = vUv0; + // point on shadowmap +#if LINEAR_RANGE + shadowUV.xy = shadowUV.xy / shadowUV.w; +#else + shadowUV = shadowUV / shadowUV.w; +#endif + float centerdepth = texture2D(shadowMap, shadowUV.xy).x; + + // gradient calculation + float pixeloffset = inverseShadowmapSize; + vec4 depths = vec4( + texture2D(shadowMap, shadowUV.xy + vec2(-pixeloffset, 0.0)).x, + texture2D(shadowMap, shadowUV.xy + vec2(+pixeloffset, 0.0)).x, + texture2D(shadowMap, shadowUV.xy + vec2(0.0, -pixeloffset)).x, + texture2D(shadowMap, shadowUV.xy + vec2(0.0, +pixeloffset)).x); + + vec2 differences = abs( depths.yw - depths.xz ); + float gradient = min(gradientClamp, max(differences.x, differences.y)); + float gradientFactor = gradient * gradientScaleBias; + + // visibility function + float depthAdjust = gradientFactor + (fixedDepthBias * centerdepth); + float finalCenterDepth = centerdepth + depthAdjust; + + // shadowUV.z contains lightspace position of current object + +#if FUZZY_TEST + // fuzzy test - introduces some ghosting in result and doesn't appear to be needed? + //float visibility = saturate(1 + delta_z / (gradient * shadowFuzzyWidth)); + float visibility = saturate(1.0 + (finalCenterDepth - shadowUV.z) * shadowFuzzyWidth * shadowUV.w); + + gl_FragColor = vertexColour * visibility; +#else + // hard test +#if PCF + // use depths from prev, calculate diff + depths += depthAdjust; + float final = (finalCenterDepth > shadowUV.z) ? 1.0 : 0.0; + final += (depths.x > shadowUV.z) ? 1.0 : 0.0; + final += (depths.y > shadowUV.z) ? 1.0 : 0.0; + final += (depths.z > shadowUV.z) ? 1.0 : 0.0; + final += (depths.w > shadowUV.z) ? 1.0 : 0.0; + + final *= 0.2; + + gl_FragColor = vec4(vertexColour.xyz * final, 1.0); + +#else + gl_FragColor = (finalCenterDepth > shadowUV.z) ? vertexColour : vec4(0.0, 0.0, 0.0, 1.0); +#endif + +#endif + +} diff --git a/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverVp.glsl b/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverVp.glsl new file mode 100644 index 00000000000..66762f3ea89 --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverVp.glsl @@ -0,0 +1,42 @@ +attribute vec3 tangent; + +uniform mat4 world; +uniform mat4 worldViewProj; +uniform mat4 texViewProj; +uniform vec4 lightPosition; // object space +uniform vec4 shadowDepthRange; + +varying vec3 tangentLightDir; + + +void main() +{ + gl_Position = ftransform(); + + vec4 worldPos = world * gl_Vertex; + + // Get object space light direction + vec3 lightDir = normalize(lightPosition.xyz - (gl_Vertex.xyz * lightPosition.w)); + + // calculate shadow map coords + gl_TexCoord[0] = texViewProj * worldPos; +#if LINEAR_RANGE + // adjust by fixed depth bias, rescale into range + gl_TexCoord[0].z = (gl_TexCoord[0].z - shadowDepthRange.x) * shadowDepthRange.w; +#endif + + // pass the main uvs straight through unchanged + gl_TexCoord[1] = gl_MultiTexCoord0; + + // Calculate the binormal (NB we assume both normal and tangent are + // already normalised) + vec3 binormal = cross(gl_Normal, tangent); + + // Form a rotation matrix out of the vectors + mat3 rotation = mat3(tangent, binormal, gl_Normal); + + // Transform the light vector according to this matrix + tangentLightDir = normalize(rotation * lightDir); + +} + diff --git a/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverVp.glsles b/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverVp.glsles new file mode 100644 index 00000000000..6b7274872ee --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapNormalMapReceiverVp.glsles @@ -0,0 +1,51 @@ +#version 100 +precision mediump int; +precision mediump float; + +attribute vec3 tangent; +attribute vec4 position; +attribute vec3 normal; + +uniform mat4 world; +uniform mat4 worldViewProj; +uniform mat4 texViewProj; +uniform vec4 lightPosition; // object space +uniform vec4 shadowDepthRange; + +varying vec3 tangentLightDir; +varying vec4 vUv0; +varying vec4 vUv1; + +attribute vec4 uv0; +attribute vec4 uv1; + +void main() +{ + gl_Position = position * worldViewProj; + + vec4 worldPos = world * position; + + // Get object space light direction + vec3 lightDir = normalize(lightPosition.xyz - (position.xyz * lightPosition.w)); + + // calculate shadow map coords + vUv0 = texViewProj * worldPos; +#if LINEAR_RANGE + // adjust by fixed depth bias, rescale into range + vUv0.z = (uv0.z - shadowDepthRange.x) * shadowDepthRange.w; +#endif + + vUv1 = uv1; + + // Calculate the binormal (NB we assume both normal and tangent are + // already normalised) + vec3 binormal = cross(normal, tangent); + + // Form a rotation matrix out of the vectors, column major for glsl es + mat3 rotation = mat3(vec3(tangent[0], binormal[0], normal[0]), + vec3(tangent[1], binormal[1], normal[1]), + vec3(tangent[2], binormal[2], normal[2])); + + // Transform the light vector according to this matrix + tangentLightDir = normalize(rotation * lightDir); +} diff --git a/res/dist/media/materials/programs/DepthShadowmapReceiverFp.glsl b/res/dist/media/materials/programs/DepthShadowmapReceiverFp.glsl new file mode 100644 index 00000000000..04ebeaadb9b --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapReceiverFp.glsl @@ -0,0 +1,66 @@ +uniform float inverseShadowmapSize; +uniform float fixedDepthBias; +uniform float gradientClamp; +uniform float gradientScaleBias; +uniform float shadowFuzzyWidth; + +uniform sampler2D shadowMap; + +void main() +{ + vec4 shadowUV = gl_TexCoord[0]; + // point on shadowmap +#if LINEAR_RANGE + shadowUV.xy = shadowUV.xy / shadowUV.w; +#else + shadowUV = shadowUV / shadowUV.w; +#endif + float centerdepth = texture2D(shadowMap, shadowUV.xy).x; + + // gradient calculation + float pixeloffset = inverseShadowmapSize; + vec4 depths = vec4( + texture2D(shadowMap, shadowUV.xy + vec2(-pixeloffset, 0)).x, + texture2D(shadowMap, shadowUV.xy + vec2(+pixeloffset, 0)).x, + texture2D(shadowMap, shadowUV.xy + vec2(0, -pixeloffset)).x, + texture2D(shadowMap, shadowUV.xy + vec2(0, +pixeloffset)).x); + + vec2 differences = abs( depths.yw - depths.xz ); + float gradient = min(gradientClamp, max(differences.x, differences.y)); + float gradientFactor = gradient * gradientScaleBias; + + // visibility function + float depthAdjust = gradientFactor + (fixedDepthBias * centerdepth); + float finalCenterDepth = centerdepth + depthAdjust; + + // shadowUV.z contains lightspace position of current object + +#if FUZZY_TEST + // fuzzy test - introduces some ghosting in result and doesn't appear to be needed? + //float visibility = saturate(1 + delta_z / (gradient * shadowFuzzyWidth)); + float visibility = saturate(1 + (finalCenterDepth - shadowUV.z) * shadowFuzzyWidth * shadowUV.w); + + gl_FragColor = vertexColour * visibility; +#else + // hard test +#if PCF + // use depths from prev, calculate diff + depths += depthAdjust; + float final = (finalCenterDepth > shadowUV.z) ? 1.0 : 0.0; + final += (depths.x > shadowUV.z) ? 1.0 : 0.0; + final += (depths.y > shadowUV.z) ? 1.0 : 0.0; + final += (depths.z > shadowUV.z) ? 1.0 : 0.0; + final += (depths.w > shadowUV.z) ? 1.0 : 0.0; + + final *= 0.2; + + gl_FragColor = vec4(gl_Color.xyz * final, 1); + +#else + gl_FragColor = (finalCenterDepth > shadowUV.z) ? gl_Color : vec4(0,0,0,1); +#endif + +#endif + +} + diff --git a/res/dist/media/materials/programs/DepthShadowmapReceiverFp.glsles b/res/dist/media/materials/programs/DepthShadowmapReceiverFp.glsles new file mode 100644 index 00000000000..62d3dfaaf17 --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapReceiverFp.glsles @@ -0,0 +1,67 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform float inverseShadowmapSize; +uniform float fixedDepthBias; +uniform float gradientClamp; +uniform float gradientScaleBias; +uniform float shadowFuzzyWidth; +uniform sampler2D shadowMap; + +varying vec4 shadowUV; +varying vec4 vColor; +varying vec4 oColour; + +void main() +{ + // point on shadowmap + float centerdepth = texture2D(shadowMap, shadowUV.xy).x; + + // gradient calculation + float pixeloffset = inverseShadowmapSize; + vec4 depths = vec4( + texture2D(shadowMap, shadowUV.xy + vec2(-pixeloffset, 0.0)).x, + texture2D(shadowMap, shadowUV.xy + vec2(+pixeloffset, 0.0)).x, + texture2D(shadowMap, shadowUV.xy + vec2(0.0, -pixeloffset)).x, + texture2D(shadowMap, shadowUV.xy + vec2(0.0, +pixeloffset)).x); + + vec2 differences = abs( depths.yw - depths.xz ); + float gradient = min(gradientClamp, max(differences.x, differences.y)); + float gradientFactor = gradient * gradientScaleBias; + + // visibility function + float depthAdjust = gradientFactor + (fixedDepthBias * centerdepth); + float finalCenterDepth = centerdepth + depthAdjust; + + // shadowUV.z contains lightspace position of current object + +#if FUZZY_TEST + // Fuzzy test - introduces some ghosting in result and doesn't appear to be needed? + //float visibility = saturate(1 + delta_z / (gradient * shadowFuzzyWidth)); + float visibility = saturate(1.0 + (finalCenterDepth - shadowUV.z) * shadowFuzzyWidth * shadowUV.w); + + gl_FragColor = vertexColour * visibility; +#else + // Hard test +#if PCF + // Use depths from prev, calculate diff + depths += depthAdjust; + float final = (finalCenterDepth > shadowUV.z) ? 1.0 : 0.0; + final += (depths.x > shadowUV.z) ? 1.0 : 0.0; + final += (depths.y > shadowUV.z) ? 1.0 : 0.0; + final += (depths.z > shadowUV.z) ? 1.0 : 0.0; + final += (depths.w > shadowUV.z) ? 1.0 : 0.0; + + final *= 0.2; + + gl_FragColor = vec4(oColour.xyz * final, 1.0); + +#else + gl_FragColor = (finalCenterDepth > shadowUV.z) ? oColour : vec4(0.0, 0.0, 0.0, 1.0); +#endif + +#endif + +} diff --git a/res/dist/media/materials/programs/DepthShadowmapReceiverVp.glsl b/res/dist/media/materials/programs/DepthShadowmapReceiverVp.glsl new file mode 100644 index 00000000000..85c32e6a1e1 --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapReceiverVp.glsl @@ -0,0 +1,32 @@ +uniform mat4 world; +uniform mat4 worldIT; +uniform mat4 worldViewProj; +uniform mat4 texViewProj; +uniform vec4 lightPosition; +uniform vec4 lightColour; +uniform vec4 shadowDepthRange; + + +void main() +{ + gl_Position = ftransform(); + + vec4 worldPos = world * gl_Vertex; + + vec3 worldNorm = (worldIT * vec4(gl_Normal, 1)).xyz; + + // calculate lighting (simple vertex lighting) + vec3 lightDir = normalize( + lightPosition.xyz - (worldPos.xyz * lightPosition.w)); + + gl_FrontColor = lightColour * max(dot(lightDir, worldNorm), 0.0); + + // calculate shadow map coords + gl_TexCoord[0] = texViewProj * worldPos; +#if LINEAR_RANGE + // adjust by fixed depth bias, rescale into range + gl_TexCoord[0].z = (gl_TexCoord[0].z - shadowDepthRange.x) * shadowDepthRange.w; +#endif + +} + diff --git a/res/dist/media/materials/programs/DepthShadowmapReceiverVp.glsles b/res/dist/media/materials/programs/DepthShadowmapReceiverVp.glsles new file mode 100644 index 00000000000..f07ca6fb958 --- /dev/null +++ b/res/dist/media/materials/programs/DepthShadowmapReceiverVp.glsles @@ -0,0 +1,42 @@ +#version 100 +precision mediump int; +precision mediump float; + +uniform mat4 world; +uniform mat4 worldIT; +uniform mat4 worldViewProj; +uniform mat4 texViewProj; +uniform vec4 lightPosition; +uniform vec4 lightColour; +uniform vec4 shadowDepthRange; + +attribute vec4 position; +attribute vec3 normal; +attribute vec4 ambient; + +varying vec4 shadowUV; +varying vec4 vColor; +varying vec4 oColour; + +void main() +{ + gl_Position = position * worldViewProj; + oColour = ambient; + vec4 worldPos = world * position; + vec3 worldNorm = (worldIT * vec4(normal, 1.0)).xyz; + + // Calculate lighting (simple vertex lighting) + vec3 lightDir = normalize(lightPosition.xyz - (worldPos.xyz * lightPosition.w)); + + vColor = lightColour * max(dot(lightDir, worldNorm), 0.0); + + // Calculate shadow map coords + shadowUV = texViewProj * worldPos; +#if LINEAR_RANGE + // Adjust by fixed depth bias, rescale into range + shadowUV.z = (shadowUV.z - shadowDepthRange.x) * shadowDepthRange.w; + shadowUV.xy = shadowUV.xy / shadowUV.w; +#else + shadowUV = shadowUV / shadowUV.w; +#endif +} diff --git a/res/dist/media/materials/programs/DiffuseOneTexture.glsles b/res/dist/media/materials/programs/DiffuseOneTexture.glsles new file mode 100644 index 00000000000..bc6c155eeda --- /dev/null +++ b/res/dist/media/materials/programs/DiffuseOneTexture.glsles @@ -0,0 +1,17 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform sampler2D texMap; + +varying vec4 colour; +varying vec4 uv; + +/* + Basic fragment program using texture and diffuse colour. +*/ +void main() +{ + gl_FragColor = texture2D(texMap, uv.xy) * colour; +} diff --git a/res/dist/media/materials/programs/DitherFP.cg b/res/dist/media/materials/programs/DitherFP.cg new file mode 100644 index 00000000000..e6500d176ba --- /dev/null +++ b/res/dist/media/materials/programs/DitherFP.cg @@ -0,0 +1,18 @@ +sampler2D RT : register(s0); +sampler2D pattern : register(s1); + +half4 Dither_ps(float4 pos : POSITION, float2 TexCoord : TEXCOORD0) : COLOR +{ + half c = dot(tex2D(RT, TexCoord),half4(0.30,0.11,0.59,0.00)); + half n = tex2D(pattern, TexCoord).a*2 - 1.0; + c += n; + if (c > 0.5) + { + c = 0.0; + } + else + { + c = 1.0; + } + return half4(c,c,c,1.0); +} \ No newline at end of file diff --git a/res/dist/media/materials/programs/DitherFP.glsles b/res/dist/media/materials/programs/DitherFP.glsles new file mode 100644 index 00000000000..bc9788421ec --- /dev/null +++ b/res/dist/media/materials/programs/DitherFP.glsles @@ -0,0 +1,25 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform sampler2D RT; +uniform sampler2D pattern; +varying vec2 uv0; +varying vec2 uv1; + +void main() +{ + float c = dot(texture2D(RT, uv0), vec4(0.30, 0.11, 0.59, 0.00)); + float n = texture2D(pattern, uv0).a*2.0 - 1.0; + c += n; + if (c > 0.5) + { + c = 0.0; + } + else + { + c = 1.0; + } + gl_FragColor = vec4(c,c,c,1.0); +} \ No newline at end of file diff --git a/res/dist/media/materials/programs/DualQuaternion.cg b/res/dist/media/materials/programs/DualQuaternion.cg new file mode 100644 index 00000000000..f468a97d39c --- /dev/null +++ b/res/dist/media/materials/programs/DualQuaternion.cg @@ -0,0 +1,159 @@ +#include "DualQuaternion_Common.cg" + +//Dual quaternion skinning with per-vertex antipodality handling (this is the most robust, but not the most efficient way): +void dualQuaternionHardwareSkinningTwoWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float2x4 worldDualQuaternion2x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient, + uniform float4 diffuse) +{ + float2x4 blendDQ = blendTwoWeightsAntipod(blendWgt, blendIdx, worldDualQuaternion2x4Array); + + float len = length(blendDQ[0]); + blendDQ /= len; + + float3 blendPosition = calculateBlendPosition(position.xyz, blendDQ); + + //No need to normalize, the magnitude of the normal is preserved because only rotation is performed + float3 blendNormal = calculateBlendNormal(normal, blendDQ); + + oPosition = mul(viewProjectionMatrix, float4(blendPosition, 1.0)); + + // Lighting - support point and directional + float3 lightDir0 = normalize(lightPos[0].xyz - (blendPosition.xyz * lightPos[0].w)); + float3 lightDir1 = normalize(lightPos[1].xyz - (blendPosition.xyz * lightPos[1].w)); + + oUv = uv; + + colour = diffuse * (ambient + (saturate(dot(lightDir0, blendNormal)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, blendNormal)) * lightDiffuseColour[1])); +} + + +//Shadow caster pass +void dualQuaternionHardwareSkinningTwoWeightsCaster_vp( + float4 position : POSITION, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float2x4 worldDualQuaternion2x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + float2x4 blendDQ = blendTwoWeightsAntipod(blendWgt, blendIdx, worldDualQuaternion2x4Array); + + float len = length(blendDQ[0]); + blendDQ /= len; + + float3 blendPosition = calculateBlendPosition(position.xyz, blendDQ); + + // view / projection + oPosition = mul(viewProjectionMatrix, float4(blendPosition, 1.0)); + + colour = ambient; +} + +//Two-phase skinning: dual quaternion skinning with scale and shear transformations +void dualQuaternionHardwareSkinningTwoWeightsTwoPhase_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float2x4 worldDualQuaternion2x4Array[24], + uniform float3x4 scaleM[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient, + uniform float4 diffuse) +{ + //First phase - applies scaling and shearing: + float3x4 blendS = blendWgt.x*scaleM[blendIdx.x]; + blendS += blendWgt.y*scaleM[blendIdx.y]; + + float3 pass1_position = mul(blendS, position); + float3x3 blendSrotAT = adjointTransposeMatrix(float3x3(blendS)); + float3 pass1_normal = normalize(mul(blendSrotAT, normal.xyz)); + + //Second phase + float2x4 blendDQ = blendTwoWeightsAntipod(blendWgt, blendIdx, worldDualQuaternion2x4Array); + + float len = length(blendDQ[0]); + blendDQ /= len; + + float3 blendPosition = calculateBlendPosition(pass1_position, blendDQ); + + //No need to normalize, the magnitude of the normal is preserved because only rotation is performed + float3 blendNormal = calculateBlendNormal(pass1_normal, blendDQ); + + oPosition = mul(viewProjectionMatrix, float4(blendPosition, 1.0)); + + // Lighting - support point and directional + float3 lightDir0 = normalize(lightPos[0].xyz - (blendPosition.xyz * lightPos[0].w)); + float3 lightDir1 = normalize(lightPos[1].xyz - (blendPosition.xyz * lightPos[1].w)); + + oUv = uv; + colour = diffuse * (ambient + (saturate(dot(lightDir0, blendNormal)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, blendNormal)) * lightDiffuseColour[1])); +} + +//Two-phase skinning shadow caster pass +void dualQuaternionHardwareSkinningTwoWeightsTwoPhaseCaster_vp( + float4 position : POSITION, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float2x4 worldDualQuaternion2x4Array[24], + uniform float3x4 scaleM[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + //First phase - applies scaling and shearing: + float3x4 blendS = blendWgt.x*scaleM[blendIdx.x]; + blendS += blendWgt.y*scaleM[blendIdx.y]; + + float3 pass1_position = mul(blendS, position); + + //Second phase + float2x4 blendDQ = blendTwoWeightsAntipod(blendWgt, blendIdx, worldDualQuaternion2x4Array); + + float len = length(blendDQ[0]); + blendDQ /= len; + + float3 blendPosition = calculateBlendPosition(pass1_position, blendDQ); + + // view / projection + oPosition = mul(viewProjectionMatrix, float4(blendPosition, 1.0)); + + colour = ambient; +} + diff --git a/res/dist/media/materials/programs/DualQuaternion.glsl b/res/dist/media/materials/programs/DualQuaternion.glsl new file mode 100644 index 00000000000..9d670a40d03 --- /dev/null +++ b/res/dist/media/materials/programs/DualQuaternion.glsl @@ -0,0 +1,42 @@ +#version 120 + +mat2x4 blendTwoWeightsAntipod(vec4 blendWgt, vec4 blendIdx, vec4 dualQuaternions[24]); +vec3 calculateBlendPosition(vec3 position, mat2x4 blendDQ); +vec3 calculateBlendNormal(vec3 normal, mat2x4 blendDQ); + +uniform vec4 worldDualQuaternion2x4Array[24]; +uniform mat4 viewProjectionMatrix; +uniform vec4 lightPos[2]; +uniform vec4 lightDiffuseColour[2]; +uniform vec4 ambient; + +attribute vec4 vertex; +attribute vec3 normal; +attribute vec4 blendIndices; +attribute vec4 blendWeights; +attribute vec4 uv0; + +void main() +{ + mat2x4 blendDQ = blendTwoWeightsAntipod(blendWeights, blendIndices, worldDualQuaternion2x4Array); + + float len = length(blendDQ[0]); + blendDQ /= len; + + vec3 blendPosition = calculateBlendPosition(vertex.xyz, blendDQ); + + //No need to normalize, the magnitude of the normal is preserved because only rotation is performed + vec3 blendNormal = calculateBlendNormal(normal, blendDQ); + + gl_Position = viewProjectionMatrix * vec4(blendPosition, 1.0); + + // Lighting - support point and directional + vec3 lightDir0 = normalize(lightPos[0].xyz - (blendPosition * lightPos[0].w)); + vec3 lightDir1 = normalize(lightPos[1].xyz - (blendPosition * lightPos[1].w)); + + gl_TexCoord[0] = uv0; + + gl_FrontColor = gl_FrontMaterial.diffuse * (ambient + (clamp(dot(lightDir0, blendNormal), 0.0, 1.0) * lightDiffuseColour[0]) + + (clamp(dot(lightDir1, blendNormal), 0.0, 1.0) * lightDiffuseColour[1])); +} + diff --git a/res/dist/media/materials/programs/DualQuaternion_Common.cg b/res/dist/media/materials/programs/DualQuaternion_Common.cg new file mode 100644 index 00000000000..038e12c57dc --- /dev/null +++ b/res/dist/media/materials/programs/DualQuaternion_Common.cg @@ -0,0 +1,85 @@ +//All of these functions are based on dqs.cg from http://isg.cs.tcd.ie/kavanl/dq/ +/* dqs.cg + + Dual quaternion skinning vertex shaders (no shading computations) + + Version 1.0.3, November 1st, 2007 + + Copyright (C) 2006-2007 University of Dublin, Trinity College, All Rights + Reserved + + This software is provided 'as-is', without any express or implied + warranty. In no event will the author(s) be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Author: Ladislav Kavan, kavanl@cs.tcd.ie + +*/ + +float2x4 blendTwoWeights(float4 blendWgt, float4 blendIdx, float2x4 dualQuaternions[24]) +{ + float2x4 blendDQ = blendWgt.x*dualQuaternions[blendIdx.x]; + blendDQ += blendWgt.y*dualQuaternions[blendIdx.y]; + + return blendDQ; +} + +float2x4 blendTwoWeightsAntipod(float4 blendWgt, float4 blendIdx, float2x4 dualQuaternions[24]) +{ + float2x4 dq0 = dualQuaternions[blendIdx.x]; + float2x4 dq1 = dualQuaternions[blendIdx.y]; + + //Accurate antipodality handling. For speed increase, remove the following line, + //though, the results will only be valid for rotations less than 180 degrees. + if (dot(dq0[0], dq1[0]) < 0.0) dq1 *= -1.0; + + float2x4 blendDQ = blendWgt.x*dq0; + blendDQ += blendWgt.y*dq1; + + return blendDQ; +} + +float3 calculateBlendPosition(float3 position, float2x4 blendDQ) +{ + float3 blendPosition = position + 2.0*cross(blendDQ[0].yzw, cross(blendDQ[0].yzw, position.xyz) + blendDQ[0].x*position); + float3 trans = 2.0*(blendDQ[0].x*blendDQ[1].yzw - blendDQ[1].x*blendDQ[0].yzw + cross(blendDQ[0].yzw, blendDQ[1].yzw)); + blendPosition += trans; + + return blendPosition; +} + +float3 calculateBlendNormal(float3 normal, float2x4 blendDQ) +{ + return normal + 2.0*cross(blendDQ[0].yzw, cross(blendDQ[0].yzw, normal) + blendDQ[0].x*normal); +} + +float3x3 adjointTransposeMatrix(float3x3 M) +{ + float3x3 atM; + atM._m00 = M._m22 * M._m11 - M._m12 * M._m21; + atM._m01 = M._m12 * M._m20 - M._m10 * M._m22; + atM._m02 = M._m10 * M._m21 - M._m20 * M._m11; + + atM._m10 = M._m02 * M._m21 - M._m22 * M._m01; + atM._m11 = M._m22 * M._m00 - M._m02 * M._m20; + atM._m12 = M._m20 * M._m01 - M._m00 * M._m21; + + atM._m20 = M._m12 * M._m01 - M._m02 * M._m11; + atM._m21 = M._m10 * M._m02 - M._m12 * M._m00; + atM._m22 = M._m00 * M._m11 - M._m10 * M._m01; + + return atM; +} + diff --git a/res/dist/media/materials/programs/DualQuaternion_Common.glsl b/res/dist/media/materials/programs/DualQuaternion_Common.glsl new file mode 100644 index 00000000000..7dc9b075410 --- /dev/null +++ b/res/dist/media/materials/programs/DualQuaternion_Common.glsl @@ -0,0 +1,70 @@ +#version 120 + +//All of these functions are based on dqs.cg from http://isg.cs.tcd.ie/kavanl/dq/ +/* dqs.cg + + Dual quaternion skinning vertex shaders (no shading computations) + + Version 1.0.3, November 1st, 2007 + + Copyright (C) 2006-2007 University of Dublin, Trinity College, All Rights + Reserved + + This software is provided 'as-is', without any express or implied + warranty. In no event will the author(s) be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. + + Author: Ladislav Kavan, kavanl@cs.tcd.ie + +*/ + +mat2x4 blendTwoWeights(vec4 blendWgt, vec4 blendIdx, vec4 dualQuaternions[24]) +{ + mat2x4 blendDQ = blendWgt.x*mat2x4(dualQuaternions[int(blendIdx.x) * 2], dualQuaternions[int(blendIdx.x) * 2 + 1]); + blendDQ += blendWgt.y*mat2x4(dualQuaternions[int(blendIdx.y) * 2], dualQuaternions[int(blendIdx.y) * 2 + 1]); + + return blendDQ; +} + +mat2x4 blendTwoWeightsAntipod(vec4 blendWgt, vec4 blendIdx, vec4 dualQuaternions[24]) +{ + mat2x4 dq0 = mat2x4(dualQuaternions[int(blendIdx.x) * 2], dualQuaternions[int(blendIdx.x) * 2 + 1]); + mat2x4 dq1 = mat2x4(dualQuaternions[int(blendIdx.y) * 2], dualQuaternions[int(blendIdx.y) * 2 + 1]); + + //Accurate antipodality handling. For speed increase, remove the following line, + //though, the results will only be valid for rotations less than 180 degrees. + if (dot(dq0[0], dq1[0]) < 0.0) dq1 *= -1.0; + + mat2x4 blendDQ = blendWgt.x*dq0; + blendDQ += blendWgt.y*dq1; + + return blendDQ; +} + +vec3 calculateBlendPosition(vec3 position, mat2x4 blendDQ) +{ + vec3 blendPosition = position + 2.0*cross(blendDQ[0].yzw, cross(blendDQ[0].yzw, position) + blendDQ[0].x*position); + vec3 trans = 2.0*(blendDQ[0].x*blendDQ[1].yzw - blendDQ[1].x*blendDQ[0].yzw + cross(blendDQ[0].yzw, blendDQ[1].yzw)); + blendPosition += trans; + + return blendPosition; +} + +vec3 calculateBlendNormal(vec3 normal, mat2x4 blendDQ) +{ + return normal + 2.0*cross(blendDQ[0].yzw, cross(blendDQ[0].yzw, normal) + blendDQ[0].x*normal); +} + + diff --git a/res/dist/media/materials/programs/DualQuaternion_ShadowCaster.glsl b/res/dist/media/materials/programs/DualQuaternion_ShadowCaster.glsl new file mode 100644 index 00000000000..6f726a1bb15 --- /dev/null +++ b/res/dist/media/materials/programs/DualQuaternion_ShadowCaster.glsl @@ -0,0 +1,29 @@ +#version 120 + +mat2x4 blendTwoWeightsAntipod(vec4 blendWgt, vec4 blendIdx, vec4 dualQuaternions[24]); +vec3 calculateBlendPosition(vec3 position, mat2x4 blendDQ); + +uniform vec4 worldDualQuaternion2x4Array[24]; +uniform mat4x4 viewProjectionMatrix; +uniform vec4 ambient; + +attribute vec4 vertex; +attribute vec4 blendIndices; +attribute vec4 blendWeights; + +//Shadow caster pass +void main() +{ + mat2x4 blendDQ = blendTwoWeightsAntipod(blendWeights, blendIndices, worldDualQuaternion2x4Array); + + float len = length(blendDQ[0]); + blendDQ /= len; + + vec3 blendPosition = calculateBlendPosition(vertex.xyz, blendDQ); + + // view / projection + gl_Position = viewProjectionMatrix * vec4(blendPosition, 1.0); + + gl_FrontColor = ambient; +} + diff --git a/res/dist/media/materials/programs/DualQuaternion_TwoPhase.glsl b/res/dist/media/materials/programs/DualQuaternion_TwoPhase.glsl new file mode 100644 index 00000000000..8fabafcd978 --- /dev/null +++ b/res/dist/media/materials/programs/DualQuaternion_TwoPhase.glsl @@ -0,0 +1,77 @@ +#version 120 + +mat2x4 blendTwoWeightsAntipod(vec4 blendWgt, vec4 blendIdx, vec4 dualQuaternions[24]); +vec3 calculateBlendPosition(vec3 position, mat2x4 blendDQ); +vec3 calculateBlendNormal(vec3 normal, mat2x4 blendDQ); + +mat3 adjointTransposeMatrix(mat3 M) +{ + mat3 atM; + atM[0][0] = M[2][2] * M[1][1] - M[2][1] * M[1][2]; + atM[1][0] = M[2][1] * M[0][2] - M[0][1] * M[2][2]; + atM[2][0] = M[0][1] * M[1][2] - M[0][2] * M[1][1]; + + atM[0][1] = M[2][0] * M[1][2] - M[2][2] * M[1][0]; + atM[1][1] = M[2][2] * M[0][0] - M[2][0] * M[0][2]; + atM[2][1] = M[0][2] * M[1][0] - M[0][0] * M[1][2]; + + atM[0][2] = M[2][1] * M[1][0] - M[2][0] * M[1][1]; + atM[1][2] = M[0][1] * M[2][0] - M[2][1] * M[0][0]; + atM[2][2] = M[0][0] * M[1][1] - M[0][1] * M[1][0]; + + return atM; +} + +uniform vec4 worldDualQuaternion2x4Array[24]; +uniform vec4 scaleM[72]; +uniform mat4 viewProjectionMatrix; +uniform vec4 lightPos[2]; +uniform vec4 lightDiffuseColour[2]; +uniform vec4 ambient; + +attribute vec4 vertex; +attribute vec3 normal; +attribute vec4 blendIndices; +attribute vec4 blendWeights; +attribute vec4 uv0; + +void main() +{ + //First phase - applies scaling and shearing: + int blendIndicesX = int(blendIndices.x) * 3; + int blendIndicesY = int(blendIndices.y) * 3; + + mat3x4 blendS = blendWeights.x*mat3x4(scaleM[blendIndicesX], + scaleM[blendIndicesX + 1], scaleM[blendIndicesX + 2]); + + blendS += blendWeights.y*mat3x4(scaleM[blendIndicesY], scaleM[blendIndicesY + 1], scaleM[blendIndicesY + 2]); + + mat4x3 blendF = transpose(blendS); + + vec3 pass1_position = blendF * vertex; + + mat3x3 blendSrotAT = adjointTransposeMatrix(mat3x3(blendF)); + vec3 pass1_normal = normalize(blendSrotAT * normal); + + //Second phase + mat2x4 blendDQ = blendTwoWeightsAntipod(blendWeights, blendIndices, worldDualQuaternion2x4Array); + + blendDQ /= length(blendDQ[0]); + + vec3 blendPosition = calculateBlendPosition(pass1_position, blendDQ); + + //No need to normalize, the magnitude of the normal is preserved because only rotation is performed + vec3 blendNormal = calculateBlendNormal(pass1_normal, blendDQ); + + gl_Position = viewProjectionMatrix * vec4(blendPosition, 1.0); + + // Lighting - support point and directional + vec3 lightDir0 = normalize(lightPos[0].xyz - (blendPosition * lightPos[0].w)); + vec3 lightDir1 = normalize(lightPos[1].xyz - (blendPosition * lightPos[1].w)); + + gl_TexCoord[0] = uv0; + + gl_FrontColor = gl_FrontMaterial.diffuse * (ambient + (clamp(dot(lightDir0, blendNormal), 0.0, 1.0) * lightDiffuseColour[0]) + + (clamp(dot(lightDir1, blendNormal), 0.0, 1.0) * lightDiffuseColour[1])); +} + diff --git a/res/dist/media/materials/programs/DualQuaternion_TwoPhaseShadowCaster.glsl b/res/dist/media/materials/programs/DualQuaternion_TwoPhaseShadowCaster.glsl new file mode 100644 index 00000000000..efe8f3cbf20 --- /dev/null +++ b/res/dist/media/materials/programs/DualQuaternion_TwoPhaseShadowCaster.glsl @@ -0,0 +1,41 @@ +#version 120 + +mat2x4 blendTwoWeightsAntipod(vec4 blendWgt, vec4 blendIdx, vec4 dualQuaternions[24]); +vec3 calculateBlendPosition(vec3 position, mat2x4 blendDQ); + +uniform vec4 worldDualQuaternion2x4Array[24]; +uniform vec4 scaleM[72]; +uniform mat4 viewProjectionMatrix; +uniform vec4 ambient; + +attribute vec4 vertex; +attribute vec4 blendIndices; +attribute vec4 blendWeights; + +void main() +{ + //First phase - applies scaling and shearing: + int blendIndicesX = int(blendIndices.x) * 3; + int blendIndicesY = int(blendIndices.y) * 3; + + mat3x4 blendS = blendWeights.x*mat3x4(scaleM[blendIndicesX], + scaleM[blendIndicesX + 1], scaleM[blendIndicesX + 2]); + + blendS += blendWeights.y*mat3x4(scaleM[blendIndicesY], scaleM[blendIndicesY + 1], scaleM[blendIndicesY + 2]); + + mat4x3 blendF = transpose(blendS); + + vec3 pass1_position = blendF * vertex; + + //Second phase + mat2x4 blendDQ = blendTwoWeightsAntipod(blendWeights, blendIndices, worldDualQuaternion2x4Array); + + blendDQ /= length(blendDQ[0]); + + vec3 blendPosition = calculateBlendPosition(pass1_position, blendDQ); + + gl_Position = viewProjectionMatrix * vec4(blendPosition, 1.0); + + gl_FrontColor = ambient; +} + diff --git a/res/dist/media/materials/programs/EmbossedFp.glsles b/res/dist/media/materials/programs/EmbossedFp.glsles new file mode 100644 index 00000000000..1c172c15e19 --- /dev/null +++ b/res/dist/media/materials/programs/EmbossedFp.glsles @@ -0,0 +1,18 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform sampler2D RT; +varying vec2 uv; + +void main() +{ + vec4 Color; + Color.a = 1.0; + Color.rgb = vec3(0.5); + Color -= texture2D( RT, uv - 0.001)*2.0; + Color += texture2D( RT, uv + 0.001)*2.0; + Color.rgb = vec3((Color.r+Color.g+Color.b)/3.0); + gl_FragColor = Color; +} diff --git a/res/dist/media/materials/programs/Example_Basic.cg b/res/dist/media/materials/programs/Example_Basic.cg new file mode 100644 index 00000000000..0c826c63e8e --- /dev/null +++ b/res/dist/media/materials/programs/Example_Basic.cg @@ -0,0 +1,400 @@ +/* + Basic ambient lighting vertex program +*/ +void ambientOneTexture_vp(float4 position : POSITION, + float2 uv : TEXCOORD0, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 ambient) +{ + oPosition = mul(worldViewProj, position); + oUv = uv; + colour = ambient; +} + +/* + Basic fragment program using texture and diffuse colour. +*/ +void diffuseOneTexture_fp(float4 position : POSITION, + float2 uv : TEXCOORD0, + float4 diffuse : COLOR, + out float4 colour : COLOR, + uniform sampler2D texMap : register(s0)) +{ + colour = tex2D(texMap,uv) * diffuse; +} + +/* + Single-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningOneWeight_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = mul((float3x3)worldMatrix3x4Array[blendIdx], normal); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +/* + Single-weight-per-vertex hardware skinning, shadow-caster pass +*/ +void hardwareSkinningOneWeightCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + colour = ambient; + +} + +/* + Two-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningTwoWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient, + uniform float4 diffuse) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 2; ++i) + { + norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = diffuse * (ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1])); + +} + +/* + Two-weight-per-vertex hardware skinning, shadow caster pass +*/ +void hardwareSkinningTwoWeightsCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + + colour = ambient; +} + + +/* + Four-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningFourWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 4; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 4; ++i) + { + float3x3 d = (float3x3)worldMatrix3x4Array[blendIdx[i]]; + norm += mul(d, normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +// hardware morph animation (no normals) +void hardwareMorphAnimation(float3 pos1 : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pos2 : TEXCOORD1, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos1 + anim_t.x*(pos2 - pos1), 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + +// hardware pose animation (no normals) +void hardwarePoseAnimation(float3 pos : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pose1 : TEXCOORD1, + float3 pose2 : TEXCOORD2, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos + anim_t.x*pose1 + anim_t.y*pose2, 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + +// hardware morph animation (with normals) +void hardwareMorphAnimationWithNormals(float3 pos1 : POSITION, + float3 normal1 : NORMAL, + float2 uv : TEXCOORD0, + float3 pos2 : TEXCOORD1, + float3 normal2 : TEXCOORD2, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 objSpaceLightPos, + uniform float4 ambient, + uniform float4 anim_t) +{ + // interpolate position + float4 posinterp = float4(pos1 + anim_t.x*(pos2 - pos1), 1.0f); + + // nlerp normal + float3 ninterp = normal1 + anim_t.x*(normal2 - normal1); + ninterp = normalize(ninterp); + + oPosition = mul(worldViewProj, posinterp); + oUv = uv; + + float3 lightDir = normalize( + objSpaceLightPos.xyz - (posinterp.xyz * objSpaceLightPos.w)); + + // Colour it red to make it easy to identify + float lit = saturate(dot(lightDir, ninterp)); + colour = float4((ambient.rgb + float3(lit,lit,lit)) * float3(1,0,0), 1); +} + +// hardware pose animation (with normals) +void hardwarePoseAnimationWithNormals(float3 pos : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pose1pos : TEXCOORD1, + float3 pose1norm : TEXCOORD2, + float3 pose2pos : TEXCOORD3, + float3 pose2norm : TEXCOORD4, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 objSpaceLightPos, + uniform float4 ambient, + uniform float4 anim_t) +{ + // interpolate + float4 posinterp = float4(pos + anim_t.x*pose1pos + anim_t.y*pose2pos, 1.0f); + + // nlerp normal + // First apply the pose normals (these are actual normals, not offsets) + float3 ninterp = anim_t.x*pose1norm + anim_t.y*pose2norm; + + // Now add back any influence of the original normal + // This depends on what the cumulative weighting left the normal at, if it's lacking or cancelled out + //float remainder = 1.0 - min(anim_t.x + anim_t.y, 1.0); + float remainder = 1.0 - min(length(ninterp), 1.0); + ninterp = ninterp + (normal * remainder); + ninterp = normalize(ninterp); + + oPosition = mul(worldViewProj, posinterp); + oUv = uv; + + float3 lightDir = normalize( + objSpaceLightPos.xyz - (posinterp.xyz * objSpaceLightPos.w)); + + // Colour it red to make it easy to identify + float lit = saturate(dot(lightDir, ninterp)); + colour = float4((ambient.rgb + float3(lit,lit,lit)) * float3(1,0,0), 1); +} + +void basicPassthroughTangent_v(float4 position : POSITION, + float3 tangent : TANGENT, + + out float4 oPosition : POSITION, + out float3 oTangent : TEXCOORD0, + + uniform float4x4 worldViewProj) +{ + oPosition = mul(worldViewProj, position); + oTangent = tangent; +} +void basicPassthroughNormal_v(float4 position : POSITION, + float3 normal : NORMAL, + + out float4 oPosition : POSITION, + out float3 oNormal : TEXCOORD0, + + uniform float4x4 worldViewProj) +{ + oPosition = mul(worldViewProj, position); + oNormal = normal; +} +// Basic fragment program to display UV +float4 showuv_p (float4 position : POSITION, float2 uv : TEXCOORD0) : COLOR +{ + // wrap values using frac + return float4(frac(uv.x), frac(uv.y), 0, 1); +} +// Basic fragment program to display 3d uv +float4 showuvdir3d_p (float4 position : POSITION, float3 uv : TEXCOORD0) : COLOR +{ + float3 n = normalize(uv); + return float4(n.x, n.y, n.z, 1); +} + + diff --git a/res/dist/media/materials/programs/Example_Basic.hlsl b/res/dist/media/materials/programs/Example_Basic.hlsl new file mode 100644 index 00000000000..b7a2f51a983 --- /dev/null +++ b/res/dist/media/materials/programs/Example_Basic.hlsl @@ -0,0 +1,273 @@ +/* + Basic ambient lighting vertex program +*/ +void ambientOneTexture_vp(float4 position : POSITION, + float2 uv : TEXCOORD0, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 ambient) +{ + oPosition = mul(worldViewProj, position); + oUv = uv; + colour = ambient; +} + +/* + Single-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningOneWeight_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = mul((float3x3)worldMatrix3x4Array[blendIdx], normal); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +/* + Single-weight-per-vertex hardware skinning, shadow-caster pass +*/ +void hardwareSkinningOneWeightCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + colour = ambient; + +} + +/* + Two-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningTwoWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 2; ++i) + { + norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +/* + Two-weight-per-vertex hardware skinning, shadow caster pass +*/ +void hardwareSkinningTwoWeightsCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + + colour = ambient; + + +} + + +/* + Four-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningFourWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 4; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 4; ++i) + { + norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +void hardwareMorphAnimation(float3 pos1 : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pos2 : TEXCOORD1, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos1 + anim_t.x*(pos2 - pos1), 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + +void hardwarePoseAnimation(float3 pos : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pose1 : TEXCOORD1, + float3 pose2 : TEXCOORD2, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos + anim_t.x*pose1 + anim_t.y*pose2, 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + diff --git a/res/dist/media/materials/programs/Example_BasicFp.glsles b/res/dist/media/materials/programs/Example_BasicFp.glsles new file mode 100644 index 00000000000..1502cb79eca --- /dev/null +++ b/res/dist/media/materials/programs/Example_BasicFp.glsles @@ -0,0 +1,620 @@ +/* + Basic ambient lighting vertex program +*/ +void ambientOneTexture_vp(float4 position : POSITION, + float2 uv : TEXCOORD0, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 ambient) +{ + oPosition = mul(worldViewProj, position); + oUv = uv; + colour = ambient; +} + +/* + Single-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningOneWeight_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = mul((float3x3)worldMatrix3x4Array[blendIdx], normal); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +/* + Single-weight-per-vertex hardware skinning, shadow-caster pass +*/ +void hardwareSkinningOneWeightCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + colour = ambient; + +} + +/* + Two-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningTwoWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 2; ++i) + { + norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = float4(0.5, 0.5, 0.5, 1) + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +/* + Two-weight-per-vertex hardware skinning, shadow caster pass +*/ +void hardwareSkinningTwoWeightsCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + + colour = ambient; + + +} + + +/* + Four-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningFourWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 4; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 4; ++i) + { + norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +void hardwareMorphAnimation(float3 pos1 : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pos2 : TEXCOORD1, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos1 + anim_t.x*(pos2 - pos1), 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + +void hardwarePoseAnimation(float3 pos : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pose1 : TEXCOORD1, + float3 pose2 : TEXCOORD2, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos + anim_t.x*pose1 + anim_t.y*pose2, 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + + +void basicPassthroughTangent_v(float4 position : POSITION, + float3 tangent : TANGENT, + + out float4 oPosition : POSITION, + out float3 oTangent : TEXCOORD0, + + uniform float4x4 worldViewProj) +{ + oPosition = mul(worldViewProj, position); + oTangent = tangent; +} +void basicPassthroughNormal_v(float4 position : POSITION, + float3 normal : NORMAL, + + out float4 oPosition : POSITION, + out float3 oNormal : TEXCOORD0, + + uniform float4x4 worldViewProj) +{ + oPosition = mul(worldViewProj, position); + oNormal = normal; +} +// Basic fragment program to display UV +float4 showuv_p (float2 uv : TEXCOORD0) : COLOR +{ + // wrap values using frac + return float4(frac(uv.x), frac(uv.y), 0, 1); +} +// Basic fragment program to display 3d uv +float4 showuvdir3d_p (float3 uv : TEXCOORD0) : COLOR +{ + float3 n = normalize(uv); + return float4(n.x, n.y, n.z, 1); +} + + +/* + Basic ambient lighting vertex program +*/ +void ambientOneTexture_vp(float4 position : POSITION, + float2 uv : TEXCOORD0, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 ambient) +{ + oPosition = mul(worldViewProj, position); + oUv = uv; + colour = ambient; +} + +/* + Single-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningOneWeight_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = mul((float3x3)worldMatrix3x4Array[blendIdx], normal); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +/* + Single-weight-per-vertex hardware skinning, shadow-caster pass +*/ +void hardwareSkinningOneWeightCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + colour = ambient; + +} + +/* + Two-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningTwoWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 2; ++i) + { + norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = float4(0.5, 0.5, 0.5, 1) + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +/* + Two-weight-per-vertex hardware skinning, shadow caster pass +*/ +void hardwareSkinningTwoWeightsCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + + colour = ambient; + + +} + + +/* + Four-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningFourWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 4; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 4; ++i) + { + norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +void hardwareMorphAnimation(float3 pos1 : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pos2 : TEXCOORD1, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos1 + anim_t.x*(pos2 - pos1), 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + +void hardwarePoseAnimation(float3 pos : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pose1 : TEXCOORD1, + float3 pose2 : TEXCOORD2, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos + anim_t.x*pose1 + anim_t.y*pose2, 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + + +void basicPassthroughTangent_v(float4 position : POSITION, + float3 tangent : TANGENT, + + out float4 oPosition : POSITION, + out float3 oTangent : TEXCOORD0, + + uniform float4x4 worldViewProj) +{ + oPosition = mul(worldViewProj, position); + oTangent = tangent; +} +void basicPassthroughNormal_v(float4 position : POSITION, + float3 normal : NORMAL, + + out float4 oPosition : POSITION, + out float3 oNormal : TEXCOORD0, + + uniform float4x4 worldViewProj) +{ + oPosition = mul(worldViewProj, position); + oNormal = normal; +} +// Basic fragment program to display UV +float4 showuv_p (float2 uv : TEXCOORD0) : COLOR +{ + // wrap values using frac + return float4(frac(uv.x), frac(uv.y), 0, 1); +} +// Basic fragment program to display 3d uv +float4 showuvdir3d_p (float3 uv : TEXCOORD0) : COLOR +{ + float3 n = normalize(uv); + return float4(n.x, n.y, n.z, 1); +} + + diff --git a/res/dist/media/materials/programs/Example_BasicVp.glsles b/res/dist/media/materials/programs/Example_BasicVp.glsles new file mode 100644 index 00000000000..1502cb79eca --- /dev/null +++ b/res/dist/media/materials/programs/Example_BasicVp.glsles @@ -0,0 +1,620 @@ +/* + Basic ambient lighting vertex program +*/ +void ambientOneTexture_vp(float4 position : POSITION, + float2 uv : TEXCOORD0, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 ambient) +{ + oPosition = mul(worldViewProj, position); + oUv = uv; + colour = ambient; +} + +/* + Single-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningOneWeight_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = mul((float3x3)worldMatrix3x4Array[blendIdx], normal); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +/* + Single-weight-per-vertex hardware skinning, shadow-caster pass +*/ +void hardwareSkinningOneWeightCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + colour = ambient; + +} + +/* + Two-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningTwoWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 2; ++i) + { + norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = float4(0.5, 0.5, 0.5, 1) + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +/* + Two-weight-per-vertex hardware skinning, shadow caster pass +*/ +void hardwareSkinningTwoWeightsCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + + colour = ambient; + + +} + + +/* + Four-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningFourWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 4; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 4; ++i) + { + norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +void hardwareMorphAnimation(float3 pos1 : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pos2 : TEXCOORD1, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos1 + anim_t.x*(pos2 - pos1), 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + +void hardwarePoseAnimation(float3 pos : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pose1 : TEXCOORD1, + float3 pose2 : TEXCOORD2, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos + anim_t.x*pose1 + anim_t.y*pose2, 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + + +void basicPassthroughTangent_v(float4 position : POSITION, + float3 tangent : TANGENT, + + out float4 oPosition : POSITION, + out float3 oTangent : TEXCOORD0, + + uniform float4x4 worldViewProj) +{ + oPosition = mul(worldViewProj, position); + oTangent = tangent; +} +void basicPassthroughNormal_v(float4 position : POSITION, + float3 normal : NORMAL, + + out float4 oPosition : POSITION, + out float3 oNormal : TEXCOORD0, + + uniform float4x4 worldViewProj) +{ + oPosition = mul(worldViewProj, position); + oNormal = normal; +} +// Basic fragment program to display UV +float4 showuv_p (float2 uv : TEXCOORD0) : COLOR +{ + // wrap values using frac + return float4(frac(uv.x), frac(uv.y), 0, 1); +} +// Basic fragment program to display 3d uv +float4 showuvdir3d_p (float3 uv : TEXCOORD0) : COLOR +{ + float3 n = normalize(uv); + return float4(n.x, n.y, n.z, 1); +} + + +/* + Basic ambient lighting vertex program +*/ +void ambientOneTexture_vp(float4 position : POSITION, + float2 uv : TEXCOORD0, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 ambient) +{ + oPosition = mul(worldViewProj, position); + oUv = uv; + colour = ambient; +} + +/* + Single-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningOneWeight_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = mul((float3x3)worldMatrix3x4Array[blendIdx], normal); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +/* + Single-weight-per-vertex hardware skinning, shadow-caster pass +*/ +void hardwareSkinningOneWeightCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float blendIdx : BLENDINDICES, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(mul(worldMatrix3x4Array[blendIdx], position).xyz, 1.0); + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + colour = ambient; + +} + +/* + Two-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningTwoWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 2; ++i) + { + norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = float4(0.5, 0.5, 0.5, 1) + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +/* + Two-weight-per-vertex hardware skinning, shadow caster pass +*/ +void hardwareSkinningTwoWeightsCaster_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 2; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + + + colour = ambient; + + +} + + +/* + Four-weight-per-vertex hardware skinning, 2 lights + The trouble with vertex programs is they're not general purpose, but + fixed function hardware skinning is very poorly supported +*/ +void hardwareSkinningFourWeights_vp( + float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 blendIdx : BLENDINDICES, + float4 blendWgt : BLENDWEIGHT, + + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + // Support up to 24 bones of float3x4 + // vs_1_1 only supports 96 params so more than this is not feasible + uniform float3x4 worldMatrix3x4Array[24], + uniform float4x4 viewProjectionMatrix, + uniform float4 lightPos[2], + uniform float4 lightDiffuseColour[2], + uniform float4 ambient) +{ + // transform by indexed matrix + float4 blendPos = float4(0,0,0,0); + int i; + for (i = 0; i < 4; ++i) + { + blendPos += float4(mul(worldMatrix3x4Array[blendIdx[i]], position).xyz, 1.0) * blendWgt[i]; + } + // view / projection + oPosition = mul(viewProjectionMatrix, blendPos); + // transform normal + float3 norm = float3(0,0,0); + for (i = 0; i < 4; ++i) + { + norm += mul((float3x3)worldMatrix3x4Array[blendIdx[i]], normal) * + blendWgt[i]; + } + norm = normalize(norm); + // Lighting - support point and directional + float3 lightDir0 = normalize( + lightPos[0].xyz - (blendPos.xyz * lightPos[0].w)); + float3 lightDir1 = normalize( + lightPos[1].xyz - (blendPos.xyz * lightPos[1].w)); + + + oUv = uv; + colour = ambient + + (saturate(dot(lightDir0, norm)) * lightDiffuseColour[0]) + + (saturate(dot(lightDir1, norm)) * lightDiffuseColour[1]); + +} + +void hardwareMorphAnimation(float3 pos1 : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pos2 : TEXCOORD1, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos1 + anim_t.x*(pos2 - pos1), 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + +void hardwarePoseAnimation(float3 pos : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 pose1 : TEXCOORD1, + float3 pose2 : TEXCOORD2, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 colour : COLOR, + + uniform float4x4 worldViewProj, + uniform float4 anim_t) +{ + // interpolate + float4 interp = float4(pos + anim_t.x*pose1 + anim_t.y*pose2, 1.0f); + + oPosition = mul(worldViewProj, interp); + oUv = uv; + colour = float4(1,0,0,1); +} + + +void basicPassthroughTangent_v(float4 position : POSITION, + float3 tangent : TANGENT, + + out float4 oPosition : POSITION, + out float3 oTangent : TEXCOORD0, + + uniform float4x4 worldViewProj) +{ + oPosition = mul(worldViewProj, position); + oTangent = tangent; +} +void basicPassthroughNormal_v(float4 position : POSITION, + float3 normal : NORMAL, + + out float4 oPosition : POSITION, + out float3 oNormal : TEXCOORD0, + + uniform float4x4 worldViewProj) +{ + oPosition = mul(worldViewProj, position); + oNormal = normal; +} +// Basic fragment program to display UV +float4 showuv_p (float2 uv : TEXCOORD0) : COLOR +{ + // wrap values using frac + return float4(frac(uv.x), frac(uv.y), 0, 1); +} +// Basic fragment program to display 3d uv +float4 showuvdir3d_p (float3 uv : TEXCOORD0) : COLOR +{ + float3 n = normalize(uv); + return float4(n.x, n.y, n.z, 1); +} + + diff --git a/res/dist/media/materials/programs/Example_BumpMapping.cg b/res/dist/media/materials/programs/Example_BumpMapping.cg new file mode 100644 index 00000000000..d87f58e74e7 --- /dev/null +++ b/res/dist/media/materials/programs/Example_BumpMapping.cg @@ -0,0 +1,235 @@ +// General functions + +// Expand a range-compressed vector +float3 expand(float3 v) +{ + return (v - 0.5) * 2; +} + + +/* Bump mapping vertex program + In this program, we want to calculate the tangent space light vector + on a per-vertex level which will get passed to the fragment program, + or to the fixed function dot3 operation, to produce the per-pixel + lighting effect. +*/ +void main_vp(float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float4 tangent : TANGENT, + // outputs + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float3 oTSLightDir : TEXCOORD1, + // parameters + uniform float4 lightPosition, // object space + uniform float4x4 worldViewProj) +{ + // calculate output position + oPosition = mul(worldViewProj, position); + + // pass the main uvs straight through unchanged + oUv = uv; + + // calculate tangent space light vector + // Get object space light direction + // Non-normalised since we'll do that in the fragment program anyway + float3 lightDir = lightPosition.xyz - (position * lightPosition.w); + + // Calculate the binormal (NB we assume both normal and tangent are + // already normalised) + // NB looks like nvidia cross params are BACKWARDS to what you'd expect + // this equates to NxT, not TxN + +#if TANGENTS_HAVE_PARITY + float3 binormal = cross(tangent.xyz, normal) * tangent.www; +#else + // fixed handedness + float3 binormal = cross(tangent.xyz, normal); +#endif + + // Form a rotation matrix out of the vectors + float3x3 rotation = float3x3(tangent.xyz, binormal, normal); + + // Transform the light vector according to this matrix + oTSLightDir = mul(rotation, lightDir); + + +} + +/* Bump mapping vertex program for shadow receiving + In this program, we want to calculate the tangent space light vector + on a per-vertex level which will get passed to the fragment program, + or to the fixed function dot3 operation, to produce the per-pixel + lighting effect. +*/ +void main_shadowreceiver_vp(float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 tangent : TANGENT, + + // outputs + out float4 oPosition : POSITION, + out float4 uvproj : TEXCOORD0, + out float2 oUv : TEXCOORD1, + out float3 oTSLightDir : TEXCOORD2, + + // parameters + uniform float4 lightPosition, // object space + uniform float4x4 worldViewProj, + uniform float4x4 worldMatrix, + uniform float4x4 texViewProj) +{ + // calculate output position + oPosition = mul(worldViewProj, position); + + // pass the main uvs straight through unchanged + oUv = uv; + + // calculate tangent space light vector + // Get object space light direction + // Non-normalised since we'll do that in the fragment program anyway + float3 lightDir = lightPosition.xyz - (position * lightPosition.w); + + // Calculate the binormal (NB we assume both normal and tangent are + // already normalised) + // NB looks like nvidia cross params are BACKWARDS to what you'd expect + // this equates to NxT, not TxN + float3 binormal = cross(tangent, normal); + + // Form a rotation matrix out of the vectors + float3x3 rotation = float3x3(tangent.xyz, binormal, normal); + + // Transform the light vector according to this matrix + oTSLightDir = mul(rotation, lightDir); + + // Projection + uvproj = mul(worldMatrix, position); + uvproj = mul(texViewProj, uvproj); + +} + + +void main_fp( float4 position : POSITION, + float2 uv : TEXCOORD0, + float3 TSlightDir : TEXCOORD1, + + out float4 colour : COLOR, + + uniform float4 lightDiffuse, + uniform sampler2D normalMap : register(s0)) +{ + // retrieve normalised light vector, expand from range-compressed + float3 lightVec = normalize(TSlightDir).xyz; + + // get bump map vector, again expand from range-compressed + float3 bumpVec = expand(tex2D(normalMap, uv).xyz); + + // Calculate dot product + colour = lightDiffuse * dot(bumpVec, lightVec); + +} + +void main_shadowreceiver_fp( float4 position : POSITION, + float4 uvproj : TEXCOORD0, + float2 uv : TEXCOORD1, + float3 TSlightDir : TEXCOORD2, + + out float4 colour : COLOR, + + uniform float4 lightDiffuse, + uniform sampler2D shadowMap : register(s0), + uniform sampler2D normalMap : register(s1)) +{ + + + // retrieve normalised light vector, expand from range-compressed + float3 lightVec = expand(normalize(TSlightDir).xyz); + + // get bump map vector, again expand from range-compressed + float3 bumpVec = expand(tex2D(normalMap, uv).xyz); + + // get shadow value + float3 shadow = tex2Dproj(shadowMap, uvproj).xyz; + + // Calculate dot product + colour = float4(shadow * lightDiffuse * dot(bumpVec, lightVec), 1.0f); + +} + +/* Vertex program which includes specular component */ +void specular_vp(float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + float3 tangent : TANGENT, + // outputs + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float3 oTSLightDir : TEXCOORD1, + out float3 oTSHalfAngle : TEXCOORD2, + // parameters + uniform float4 lightPosition, // object space + uniform float3 eyePosition, // object space + uniform float4x4 worldViewProj) +{ + // calculate output position + oPosition = mul(worldViewProj, position); + + // pass the main uvs straight through unchanged + oUv = uv; + + // calculate tangent space light vector + // Get object space light direction + float3 lightDir = normalize(lightPosition.xyz - (position * lightPosition.w)); + + // Calculate the binormal (NB we assume both normal and tangent are + // already normalised) + // NB looks like nvidia cross params are BACKWARDS to what you'd expect + // this equates to NxT, not TxN + float3 binormal = cross(tangent, normal); + + // Form a rotation matrix out of the vectors + float3x3 rotation = float3x3(tangent, binormal, normal); + + // Transform the light vector according to this matrix + oTSLightDir = mul(rotation, lightDir); + + // Calculate half-angle in tangent space + float3 eyeDir = normalize(eyePosition - position.xyz); + float3 halfAngle = normalize(eyeDir + lightDir); + oTSHalfAngle = mul(rotation, halfAngle); + + +} + +/* Fragment program which supports specular component */ +void specular_fp( float4 position : POSITION, + float2 uv : TEXCOORD0, + float3 TSlightDir : TEXCOORD1, + float3 TShalfAngle: TEXCOORD2, + + out float4 colour : COLOR, + + uniform float4 lightDiffuse, + uniform float4 lightSpecular, + uniform sampler2D normalMap : register(s0)) +{ + // retrieve normalised light vector + float3 lightVec = normalize(TSlightDir); + + // retrieve half angle and normalise + float3 halfAngle = normalize(TShalfAngle); + + // get bump map vector, again expand from range-compressed + float3 bumpVec = expand(tex2D(normalMap, uv).xyz); + + // Pre-raise the specular exponent to the eight power + float specFactor = pow(saturate(dot(bumpVec, halfAngle)), 4); + + + // Calculate dot product for diffuse + colour = (lightDiffuse * saturate(dot(bumpVec, lightVec))) + + (lightSpecular * specFactor); + +} + diff --git a/res/dist/media/materials/programs/Example_BumpMappingFp.glsles b/res/dist/media/materials/programs/Example_BumpMappingFp.glsles new file mode 100644 index 00000000000..e9f297184a6 --- /dev/null +++ b/res/dist/media/materials/programs/Example_BumpMappingFp.glsles @@ -0,0 +1,29 @@ +#version 100 +precision mediump int; +precision mediump float; + +uniform vec4 lightDiffuse; +uniform sampler2D normalMap; + +varying vec2 oUv0; +varying vec3 oTSLightDir; + +// General functions + +// Expand a range-compressed vector +vec3 expand(vec3 v) +{ + return (v - 0.5) * 2.0; +} + +void main() +{ + // Retrieve normalised light vector, expand from range-compressed + vec3 lightVec = normalize(oTSLightDir).xyz; + + // Get bump map vector, again expand from range-compressed + vec3 bumpVec = expand(texture2D(normalMap, oUv0).xyz); + + // Calculate dot product + gl_FragColor = lightDiffuse * dot(bumpVec, lightVec); +} diff --git a/res/dist/media/materials/programs/Example_BumpMappingShadowRcvFp.glsles b/res/dist/media/materials/programs/Example_BumpMappingShadowRcvFp.glsles new file mode 100644 index 00000000000..0b179e8b89f --- /dev/null +++ b/res/dist/media/materials/programs/Example_BumpMappingShadowRcvFp.glsles @@ -0,0 +1,34 @@ +#version 100 +precision mediump int; +precision mediump float; + +// General functions + +// Expand a range-compressed vector +vec3 expand(vec3 v) +{ + return (v - 0.5) * 2.0; +} + +uniform sampler2D shadowMap; +uniform sampler2D normalMap; +uniform vec4 lightDiffuse; + +varying vec4 uvproj; +varying vec4 oUv0; +varying vec3 oTSLightDir; + +void main() +{ + // retrieve normalised light vector, expand from range-compressed + vec3 lightVec = expand(normalize(oTSLightDir).xyz); + + // get bump map vector, again expand from range-compressed + vec3 bumpVec = expand(texture2D(normalMap, oUv0.xy).xyz); + + // get shadow value + vec3 shadow = texture2DProj(shadowMap, uvproj).xyz; + + // Calculate dot product + gl_FragColor = vec4(shadow * lightDiffuse.xyz * dot(bumpVec, lightVec), 1.0); +} diff --git a/res/dist/media/materials/programs/Example_BumpMappingShadowRcvVp.glsles b/res/dist/media/materials/programs/Example_BumpMappingShadowRcvVp.glsles new file mode 100644 index 00000000000..181993f0b7c --- /dev/null +++ b/res/dist/media/materials/programs/Example_BumpMappingShadowRcvVp.glsles @@ -0,0 +1,55 @@ +#version 100 +precision mediump int; +precision mediump float; + +/* Bump mapping vertex program for shadow receiving + In this program, we want to calculate the tangent space light vector + on a per-vertex level which will get passed to the fragment program, + or to the fixed function dot3 operation, to produce the per-pixel + lighting effect. +*/ + +// parameters +uniform vec4 lightPosition; // object space +uniform mat4 worldViewProj; +uniform mat4 worldMatrix; +uniform mat4 texViewProj; + +attribute vec4 vertex; +attribute vec3 normal; +attribute vec3 tangent; +attribute vec4 uv0; + +varying vec4 uvproj; +varying vec4 oUv0; +varying vec3 oTSLightDir; + +void main() +{ + // Calculate output position + gl_Position = worldViewProj * vertex; + + // Pass the main uvs straight through unchanged + oUv0 = uv0; + + // Calculate tangent space light vector + // Get object space light direction + // Non-normalised since we'll do that in the fragment program anyway + vec3 lightDir = lightPosition.xyz - (vertex * lightPosition.w).xyz; + + // Calculate the binormal (NB we assume both normal and tangent are + // already normalised) + vec3 binormal = cross(normal, tangent); + + // Form a rotation matrix out of the vectors, column major for glsl es + mat3 rotation = mat3(tangent,binormal,normal); +// mat3 rotation = mat3(vec3(tangent[0], binormal[0], normal[0]), +// vec3(tangent[1], binormal[1], normal[1]), +// vec3(tangent[2], binormal[2], normal[2])); + + // Transform the light vector according to this matrix + oTSLightDir = rotation * lightDir; + + // Projection + uvproj = texViewProj * (worldMatrix * vertex); +} diff --git a/res/dist/media/materials/programs/Example_BumpMappingSpecularFp.glsles b/res/dist/media/materials/programs/Example_BumpMappingSpecularFp.glsles new file mode 100644 index 00000000000..0ba5b3c4396 --- /dev/null +++ b/res/dist/media/materials/programs/Example_BumpMappingSpecularFp.glsles @@ -0,0 +1,41 @@ +#version 100 +precision mediump int; +precision mediump float; + +// General functions + +// Expand a range-compressed vector +vec3 expand(vec3 v) +{ + return (v - 0.5) * 2.0; +} + +uniform vec4 lightDiffuse; +uniform vec4 lightSpecular; +uniform sampler2D normalMap; + +varying vec4 oUv0; +varying vec3 oTSLightDir; +varying vec3 oTSHalfAngle; + +// NOTE: GLSL does not have the saturate function. But it is equivalent to clamp(val, 0.0, 1.0) + +/* Fragment program which supports specular component */ +void main() +{ + // retrieve normalised light vector + vec3 lightVec = normalize(oTSLightDir); + + // retrieve half angle and normalise + vec3 halfAngle = normalize(oTSHalfAngle); + + // get bump map vector, again expand from range-compressed + vec3 bumpVec = expand(texture2D(normalMap, oUv0.xy).xyz); + + // Pre-raise the specular exponent to the eight power + float specFactor = pow(clamp(dot(bumpVec, halfAngle), 0.0, 1.0), 4.0); + + // Calculate dot product for diffuse + gl_FragColor = (lightDiffuse * clamp(dot(bumpVec, lightVec), 0.0, 1.0)) + + (lightSpecular * specFactor); +} diff --git a/res/dist/media/materials/programs/Example_BumpMappingSpecularVp.glsles b/res/dist/media/materials/programs/Example_BumpMappingSpecularVp.glsles new file mode 100644 index 00000000000..6576660c3a2 --- /dev/null +++ b/res/dist/media/materials/programs/Example_BumpMappingSpecularVp.glsles @@ -0,0 +1,50 @@ +#version 100 +precision mediump int; +precision mediump float; + +// General functions +// parameters +uniform vec4 lightPosition; // object space +uniform vec3 eyePosition; // object space +uniform mat4 worldViewProj; + +attribute vec4 vertex; +attribute vec3 normal; +attribute vec3 tangent; +attribute vec4 uv0; + +varying vec4 oUv0; +varying vec3 oTSLightDir; +varying vec3 oTSHalfAngle; + +/* Vertex program which includes specular component */ +void main() +{ + // calculate output position + gl_Position = worldViewProj * vertex; + + // pass the main uvs straight through unchanged + oUv0 = uv0; + + // calculate tangent space light vector + // Get object space light direction + vec3 lightDir = normalize(lightPosition.xyz - (vertex * lightPosition.w).xyz); + + // Calculate the binormal (NB we assume both normal and tangent are + // already normalised) + vec3 binormal = cross(normal, tangent); + + // Form a rotation matrix out of the vectors + mat3 rotation = mat3(tangent,binormal,normal); +// mat3 rotation = mat3(vec3(tangent[0], binormal[0], normal[0]), +// vec3(tangent[1], binormal[1], normal[1]), +// vec3(tangent[2], binormal[2], normal[2])); + + // Transform the light vector according to this matrix + oTSLightDir = rotation * lightDir; + + // Calculate half-angle in tangent space + vec3 eyeDir = normalize(eyePosition - vertex.xyz); + vec3 halfAngle = normalize(eyeDir + lightDir); + oTSHalfAngle = rotation * halfAngle; +} diff --git a/res/dist/media/materials/programs/Example_BumpMappingVp.glsles b/res/dist/media/materials/programs/Example_BumpMappingVp.glsles new file mode 100644 index 00000000000..19d9e87f106 --- /dev/null +++ b/res/dist/media/materials/programs/Example_BumpMappingVp.glsles @@ -0,0 +1,50 @@ +#version 100 +precision mediump int; +precision mediump float; + +/* Bump mapping vertex program + In this program, we want to calculate the tangent space light vector + on a per-vertex level which will get passed to the fragment program, + or to the fixed function dot3 operation, to produce the per-pixel + lighting effect. +*/ +// parameters +uniform vec4 lightPosition; // object space +uniform mat4 worldViewProj; + +attribute vec4 vertex; +attribute vec3 normal; +attribute vec3 tangent; +attribute vec2 uv0; + +varying vec2 oUv0; +varying vec3 oTSLightDir; + +void main() +{ + // Calculate output position + gl_Position = worldViewProj * vertex; + + // Pass the main uvs straight through unchanged + oUv0 = uv0; + + // Calculate tangent space light vector + // Get object space light direction + // Non-normalised since we'll do that in the fragment program anyway + vec3 lightDir = lightPosition.xyz - (vertex * lightPosition.w).xyz; + + // Calculate the binormal (NB we assume both normal and tangent are + // already normalised) + + // Fixed handedness + vec3 binormal = cross(normal, tangent); + + // Form a rotation matrix out of the vectors, column major for glsl es + mat3 rotation = mat3(tangent,binormal,normal); +// mat3 rotation = mat3(vec3(tangent[0], binormal[0], normal[0]), +// vec3(tangent[1], binormal[1], normal[1]), +// vec3(tangent[2], binormal[2], normal[2])); + + // Transform the light vector according to this matrix + oTSLightDir = rotation * lightDir; +} diff --git a/res/dist/media/materials/programs/Example_CelShading.cg b/res/dist/media/materials/programs/Example_CelShading.cg new file mode 100644 index 00000000000..72ee749f7c7 --- /dev/null +++ b/res/dist/media/materials/programs/Example_CelShading.cg @@ -0,0 +1,64 @@ + +/* Cel shading vertex program for single-pass rendering + In this program, we want to calculate the diffuse and specular + ramp components, and the edge factor (for doing simple outlining) + For the outlining to look good, we need a pretty well curved model. +*/ +void main_vp(float4 position : POSITION, + float3 normal : NORMAL, + // outputs + out float4 oPosition : POSITION, + out float diffuse : TEXCOORD0, + out float specular : TEXCOORD1, + out float edge : TEXCOORD2, + // parameters + uniform float3 lightPosition, // object space + uniform float3 eyePosition, // object space + uniform float4 shininess, + uniform float4x4 worldViewProj) +{ + // calculate output position + oPosition = mul(worldViewProj, position); + + // calculate light vector + float3 N = normalize(normal); + float3 L = normalize(lightPosition - position.xyz); + + // Calculate diffuse component + diffuse = max(dot(N, L) , 0); + + // Calculate specular component + float3 E = normalize(eyePosition - position.xyz); + float3 H = normalize(L + E); + specular = pow(max(dot(N, H), 0), shininess); + // Mask off specular if diffuse is 0 + if (diffuse == 0) specular = 0; + + // Edge detection, dot eye and normal vectors + edge = max(dot(N, E), 0); +} + +void main_fp( float4 position : POSITION, + float diffuseIn : TEXCOORD0, + float specularIn : TEXCOORD1, + float edge : TEXCOORD2, + + out float4 colour : COLOR, + + uniform float4 diffuse, + uniform float4 specular, + + uniform sampler1D diffuseRamp, + uniform sampler1D specularRamp, + uniform sampler1D edgeRamp) +{ + // Step functions from textures + diffuseIn = tex1D(diffuseRamp, diffuseIn).x; + specularIn = tex1D(specularRamp, specularIn).x; + edge = tex1D(edgeRamp, edge).x; + + colour = edge * ((diffuse * diffuseIn) + + (specular * specularIn)); +} + + diff --git a/res/dist/media/materials/programs/Example_CelShadingFp.glsles b/res/dist/media/materials/programs/Example_CelShadingFp.glsles new file mode 100644 index 00000000000..db311e55acc --- /dev/null +++ b/res/dist/media/materials/programs/Example_CelShadingFp.glsles @@ -0,0 +1,25 @@ +#version 100 +precision mediump int; +precision mediump float; + +/* Cel shading fragment program for single-pass rendering */ +uniform vec4 diffuse; +uniform vec4 specular; +uniform sampler2D diffuseRamp; +uniform sampler2D specularRamp; +uniform sampler2D edgeRamp; + +varying float diffuseIn; +varying float specularIn; +varying float edge; + +void main() +{ + // Step functions from textures + vec4 diffuseStep = texture2D(diffuseRamp, vec2(diffuseIn)); + vec4 specularStep = texture2D(specularRamp, vec2(specularIn)); + vec4 edgeStep = texture2D(edgeRamp, vec2(edge)); + + gl_FragColor = edgeStep.x * ((diffuse * diffuseStep.x) + + (specular * specularStep.x)); +} diff --git a/res/dist/media/materials/programs/Example_CelShadingVp.glsles b/res/dist/media/materials/programs/Example_CelShadingVp.glsles new file mode 100644 index 00000000000..c37b738ec46 --- /dev/null +++ b/res/dist/media/materials/programs/Example_CelShadingVp.glsles @@ -0,0 +1,50 @@ +#version 100 +precision mediump int; +precision mediump float; + +/* Cel shading vertex program for single-pass rendering + In this program, we want to calculate the diffuse and specular + ramp components, and the edge factor (for doing simple outlining) + For the outlining to look good, we need a pretty well curved model. +*/ +// Parameters +attribute vec4 vertex; +attribute vec3 normal; + +uniform vec3 lightPosition; // object space +uniform vec3 eyePosition; // object space +uniform vec4 shininess; +uniform mat4 worldViewProj; + +varying float diffuseIn; +varying float specularIn; +varying float edge; + +void main() +{ + // calculate output position + gl_Position = worldViewProj * vertex; + + // calculate light vector + vec3 N = normalize(normal); + vec3 L = normalize(lightPosition - vertex.xyz); + vec3 E = normalize(eyePosition - vertex.xyz); + + // Calculate diffuse component + diffuseIn = max(dot(N, L) , 0.0); + + // Mask off specular if diffuse is 0 + if (diffuseIn == 0.0) + { + specularIn = 0.0; + } + else + { + // Calculate specular component + vec3 H = normalize(L + E); + specularIn = pow(max(dot(N, H), 0.0), shininess.x); + } + + // Edge detection, dot eye and normal vectors + edge = max(dot(N, E), 0.0); +} diff --git a/res/dist/media/materials/programs/Example_Fresnel.cg b/res/dist/media/materials/programs/Example_Fresnel.cg new file mode 100644 index 00000000000..d3eaabc76e7 --- /dev/null +++ b/res/dist/media/materials/programs/Example_Fresnel.cg @@ -0,0 +1,116 @@ +// Vertex program for fresnel reflections / refractions +void main_vp( + float4 pos : POSITION, + float4 normal : NORMAL, + float2 tex : TEXCOORD0, + + out float4 oPos : POSITION, + out float3 noiseCoord : TEXCOORD0, + out float4 projectionCoord : TEXCOORD1, + out float3 oEyeDir : TEXCOORD2, + out float3 oNormal : TEXCOORD3, + + uniform float4x4 worldViewProjMatrix, + uniform float3 eyePosition, // object space + uniform float timeVal, + uniform float scale, // the amount to scale the noise texture by + uniform float scroll, // the amount by which to scroll the noise + uniform float noise // the noise perturb as a factor of the time + ) +{ + oPos = mul(worldViewProjMatrix, pos); + // Projective texture coordinates, adjust for mapping + float4x4 scalemat = float4x4(0.5, 0, 0, 0.5, + 0,-0.5, 0, 0.5, + 0, 0, 0.5, 0.5, + 0, 0, 0, 1); + projectionCoord = mul(scalemat, oPos); + // Noise map coords + noiseCoord.xy = (tex + (timeVal * scroll)) * scale; + noiseCoord.z = noise * timeVal; + + oEyeDir = normalize(pos.xyz - eyePosition); + oNormal = normal.rgb; + +} + +// Fragment program for distorting a texture using a 3D noise texture +void main_fp( + float4 pos : POSITION, + float3 noiseCoord : TEXCOORD0, + float4 projectionCoord : TEXCOORD1, + float3 eyeDir : TEXCOORD2, + float3 normal : TEXCOORD3, + + out float4 col : COLOR, + + uniform float4 tintColour, + uniform float noiseScale, + uniform float fresnelBias, + uniform float fresnelScale, + uniform float fresnelPower, + uniform sampler2D noiseMap : register(s0), + uniform sampler2D reflectMap : register(s1), + uniform sampler2D refractMap : register(s2) + ) +{ + // Do the tex projection manually so we can distort _after_ + float2 final = projectionCoord.xy / projectionCoord.w; + + // Noise + float3 noiseNormal = (tex2D(noiseMap, (noiseCoord.xy / 5)).rgb - 0.5).rbg * noiseScale; + final += noiseNormal.xz; + + // Fresnel + //normal = normalize(normal + noiseNormal.xz); + float fresnel = fresnelBias + fresnelScale * pow(1 + dot(eyeDir, normal), fresnelPower); + + // Reflection / refraction + float4 reflectionColour = tex2D(reflectMap, final); + float4 refractionColour = tex2D(refractMap, final) + tintColour; + + // Final colour + col = lerp(refractionColour, reflectionColour, fresnel); + + +} + + +// Old version to match ATI PS 1.3 implementation +void main_vp_old( + float4 pos : POSITION, + float4 normal : NORMAL, + float2 tex : TEXCOORD0, + + out float4 oPos : POSITION, + out float fresnel : COLOR, + out float3 noiseCoord : TEXCOORD0, + out float4 projectionCoord : TEXCOORD1, + + uniform float4x4 worldViewProjMatrix, + uniform float3 eyePosition, // object space + uniform float fresnelBias, + uniform float fresnelScale, + uniform float fresnelPower, + uniform float timeVal, + uniform float scale, // the amount to scale the noise texture by + uniform float scroll, // the amount by which to scroll the noise + uniform float noise // the noise perturb as a factor of the time + ) +{ + oPos = mul(worldViewProjMatrix, pos); + // Projective texture coordinates, adjust for mapping + float4x4 scalemat = float4x4(0.5, 0, 0, 0.5, + 0,-0.5, 0, 0.5, + 0, 0, 0.5, 0.5, + 0, 0, 0, 1); + projectionCoord = mul(scalemat, oPos); + // Noise map coords + noiseCoord.xy = (tex + (timeVal * scroll)) * scale; + noiseCoord.z = noise * timeVal; + + // calc fresnel factor (reflection coefficient) + float3 eyeDir = normalize(pos.xyz - eyePosition); + fresnel = fresnelBias + fresnelScale * pow(1 + dot(eyeDir, normal), fresnelPower); + +} diff --git a/res/dist/media/materials/programs/Example_FresnelFp.glsles b/res/dist/media/materials/programs/Example_FresnelFp.glsles new file mode 100644 index 00000000000..4f58e7cd643 --- /dev/null +++ b/res/dist/media/materials/programs/Example_FresnelFp.glsles @@ -0,0 +1,40 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform vec4 tintColour; +uniform float noiseScale; +uniform float fresnelBias; +uniform float fresnelScale; +uniform float fresnelPower; +uniform sampler2D noiseMap; +uniform sampler2D reflectMap; +uniform sampler2D refractMap; + +varying vec3 noiseCoord; +varying vec4 projectionCoord; +varying vec3 eyeDir; +varying vec3 oNormal; + +// Fragment program for distorting a texture using a 3D noise texture +void main() +{ + // Do the tex projection manually so we can distort _after_ + vec2 final = projectionCoord.xy / projectionCoord.w; + + // Noise + vec3 noiseNormal = (texture2D(noiseMap, (noiseCoord.xy / 5.0)).rgb - 0.5).rbg * noiseScale; + final += noiseNormal.xz; + + // Fresnel + //normal = normalize(normal + noiseNormal.xz); + float fresnel = fresnelBias + fresnelScale * pow(1.0 + dot(eyeDir, oNormal), fresnelPower); + + // Reflection / refraction + vec4 reflectionColour = texture2D(reflectMap, final); + vec4 refractionColour = texture2D(refractMap, final) + tintColour; + + // Final colour + gl_FragColor = mix(refractionColour, reflectionColour, fresnel); +} diff --git a/res/dist/media/materials/programs/Example_FresnelPS.asm b/res/dist/media/materials/programs/Example_FresnelPS.asm new file mode 100644 index 00000000000..193881a7719 --- /dev/null +++ b/res/dist/media/materials/programs/Example_FresnelPS.asm @@ -0,0 +1,72 @@ +ps.1.4 + // conversion from Cg generated ARB_fragment_program to ps.1.4 by NFZ + // command line args: -profile arbfp1 -entry main_fp + // program main_fp + // c0 : distortionRange + // c1 : tintColour + // testure 0 : noiseMap + // texture 1 : reflectMap + // texture 2 : refractMap + // v0.x : fresnel + // t0.xyz : noiseCoord + // t1.xyw : projectionCoord + +def c2, 2, 1, 0, 0 + + // Cg: distort.x = tex3D(noiseMap, noiseCoord).x; + // arbfp1: TEX R0.x, fragment.texcoord[0], texture[0], 3D; + // sample noise map using noiseCoord in TEX unit 0 + +texld r0, t0.xyz + + // get projected texture coordinates from TEX coord 1 + // will be used in phase 2 + +texcrd r1.xy, t1_dw.xyw +mov r1.z, c2.y + + // Cg: distort.y = tex3D(noiseMap, noiseCoord + yoffset).x; + // arbfp1: ADD R1.xyz, fragment.texcoord[0], c1; + // arbfp1: TEX R1.x, R1, texture[0], 3D; + // arbfp1: MOV R0.y, R1.x; + + // Cg: distort = (distort * 2 - 1) * distortionRange; + // arbfp1: MAD R0.xy, R0, c0.x, -c0.y; + // arbfp1: MUL R0.xy, R0, u0.x; + // (distort * 2 - 1) same as 2*(distort -.5) so use _bx2 + + + // Cg: final = projectionCoord.xy / projectionCoord.w; + // Cg: final += distort; + // arbfp1: RCP R0.w, fragment.texcoord[1].w; + // arbfp1: MAD R0.xy, fragment.texcoord[1], R0.w, R0; + // final = (distort * projectionCoord.w) + projectionCoord.xy + // for ps.1.4 have to re-arrange things a bit to perturb projected texture coordinates + +mad r0.xyz, r0_bx2, c0.x, r1 + +phase + + // do dependent texture reads + // Cg: reflectionColour = tex2D(reflectMap, final); + // arbfp1: TEX R0, R0, texture[1], 2D; + // sampe reflectMap using dependent read : texunit 1 + +texld r1, r0.xyz + + // Cg: refractionColour = tex2D(refractMap, final) + tintColour; + // arbfp1: TEX R1, R0, texture[2], 2D; + // sample refractMap : texunit 2 + +texld r2, r0.xyz + + // adding tintColour that is in global c1 + // arbfp1: ADD R1, R1, u1; + +add r2, r2, c1 + + // Cg: col = lerp(refractionColour, reflectionColour, fresnel); + // arbfp1: ADD R0, R0, -R1; + // arbfp1: MAD result.color, fragment.color.primary.x, R0, R1; + +lrp r0, v0.x, r1, r2 diff --git a/res/dist/media/materials/programs/Example_FresnelVp.glsles b/res/dist/media/materials/programs/Example_FresnelVp.glsles new file mode 100644 index 00000000000..a9fc0c387ea --- /dev/null +++ b/res/dist/media/materials/programs/Example_FresnelVp.glsles @@ -0,0 +1,39 @@ +#version 100 + +precision mediump int; +precision mediump float; + +attribute vec4 uv0; +attribute vec4 position; +attribute vec3 normal; + +uniform mat4 worldViewProjMatrix; +uniform vec3 eyePosition; // object space +uniform float timeVal; +uniform float scale; // the amount to scale the noise texture by +uniform float scroll; // the amount by which to scroll the noise +uniform float noise; // the noise perturb as a factor of the time + +varying vec3 noiseCoord; +varying vec4 projectionCoord; +varying vec3 eyeDir; +varying vec3 oNormal; + +// Vertex program for fresnel reflections / refractions +void main() +{ + gl_Position = worldViewProjMatrix * position; + // Projective texture coordinates, adjust for mapping + mat4 scalemat = mat4(0.5, 0.0, 0.0, 0.0, + 0.0, -0.5, 0.0, 0.0, + 0.0, 0.0, 0.5, 0.0, + 0.5, 0.5, 0.5, 1.0); + projectionCoord = scalemat * gl_Position; + + // Noise map coords + noiseCoord.xy = (uv0.xy + (timeVal * scroll)) * scale; + noiseCoord.z = noise * timeVal; + + eyeDir = normalize(position.xyz - eyePosition); + oNormal = normal.rgb; +} diff --git a/res/dist/media/materials/programs/Example_Projection.cg b/res/dist/media/materials/programs/Example_Projection.cg new file mode 100644 index 00000000000..c43f59041bd --- /dev/null +++ b/res/dist/media/materials/programs/Example_Projection.cg @@ -0,0 +1,28 @@ + +void generalPurposeProjection_vp( + float4 pos : POSITION, + + out float4 oPos : POSITION, + out float4 texCoord : TEXCOORD0, + + uniform float4x4 worldViewProjMatrix, + uniform float4x4 worldMatrix, + uniform float4x4 texViewProjMatrix) +{ + oPos = mul(worldViewProjMatrix, pos); + // multiply position by world matrix, then by projective view/proj + float4 newpos = mul(worldMatrix, pos); + texCoord = mul(texViewProjMatrix, newpos); + +} + +void generalPurposeProjection_fp( + float4 texCoord : TEXCOORD0, + out float4 col : COLOR, + uniform sampler2D texMap) +{ + col = tex2Dproj(texMap, texCoord); + +} + + diff --git a/res/dist/media/materials/programs/Example_ProjectionFp.glsles b/res/dist/media/materials/programs/Example_ProjectionFp.glsles new file mode 100644 index 00000000000..20fd2bd22b7 --- /dev/null +++ b/res/dist/media/materials/programs/Example_ProjectionFp.glsles @@ -0,0 +1,56 @@ + +void generalPurposeProjection_vp( + float4 pos : POSITION, + + out float4 oPos : POSITION, + out float4 texCoord : TEXCOORD0, + + uniform float4x4 worldViewProjMatrix, + uniform float4x4 worldMatrix, + uniform float4x4 texViewProjMatrix) +{ + oPos = mul(worldViewProjMatrix, pos); + // multiply position by world matrix, then by projective view/proj + float4 newpos = mul(worldMatrix, pos); + texCoord = mul(texViewProjMatrix, newpos); + +} + +void generalPurposeProjection_fp( + float4 texCoord : TEXCOORD0, + out float4 col : COLOR, + uniform sampler2D texMap) +{ + col = tex2Dproj(texMap, texCoord); + +} + + + +void generalPurposeProjection_vp( + float4 pos : POSITION, + + out float4 oPos : POSITION, + out float4 texCoord : TEXCOORD0, + + uniform float4x4 worldViewProjMatrix, + uniform float4x4 worldMatrix, + uniform float4x4 texViewProjMatrix) +{ + oPos = mul(worldViewProjMatrix, pos); + // multiply position by world matrix, then by projective view/proj + float4 newpos = mul(worldMatrix, pos); + texCoord = mul(texViewProjMatrix, newpos); + +} + +void generalPurposeProjection_fp( + float4 texCoord : TEXCOORD0, + out float4 col : COLOR, + uniform sampler2D texMap) +{ + col = tex2Dproj(texMap, texCoord); + +} + + diff --git a/res/dist/media/materials/programs/Example_ProjectionVp.glsles b/res/dist/media/materials/programs/Example_ProjectionVp.glsles new file mode 100644 index 00000000000..095109475df --- /dev/null +++ b/res/dist/media/materials/programs/Example_ProjectionVp.glsles @@ -0,0 +1,26 @@ + +void generalPurposeProjection_vp( + float4 pos : POSITION, + + out float4 oPos : POSITION, + out float4 texCoord : TEXCOORD0, + + uniform float4x4 worldViewProjMatrix, + uniform float4x4 worldMatrix, + uniform float4x4 texViewProjMatrix) +{ + oPos = mul(worldViewProjMatrix, pos); + // multiply position by world matrix, then by projective view/proj + float4 newpos = mul(worldMatrix, pos); + texCoord = mul(texViewProjMatrix, newpos); +} + +void generalPurposeProjection_fp( + float4 texCoord : TEXCOORD0, + out float4 col : COLOR, + uniform sampler2D texMap) +{ + col = tex2Dproj(texMap, texCoord); +} + + diff --git a/res/dist/media/materials/programs/Example_TextureArrayPS.asm b/res/dist/media/materials/programs/Example_TextureArrayPS.asm new file mode 100644 index 00000000000..8134784a895 --- /dev/null +++ b/res/dist/media/materials/programs/Example_TextureArrayPS.asm @@ -0,0 +1,10 @@ +!!NVfp4.0 +TEMP texcoord, c0, c1, frac; +MOV texcoord, fragment.texcoord[0]; +FLR texcoord.z, texcoord; +TEX c0, texcoord, texture[0], ARRAY2D; +ADD texcoord.z, texcoord, { 0, 0, 1, 0 }; +TEX c1, texcoord, texture[0], ARRAY2D; +FRC frac.x, fragment.texcoord[0].z; +LRP result.color, frac.x, c1, c0; +END diff --git a/res/dist/media/materials/programs/Example_TextureArrayPS.glsl b/res/dist/media/materials/programs/Example_TextureArrayPS.glsl new file mode 100644 index 00000000000..13c92aea292 --- /dev/null +++ b/res/dist/media/materials/programs/Example_TextureArrayPS.glsl @@ -0,0 +1,17 @@ +#version 120 +#extension GL_EXT_texture_array : enable + +uniform sampler2DArray TextureArrayTex; +varying vec3 oUv; + +void main(void) +{ + vec3 texcoord; + texcoord = oUv; + texcoord.z = floor(texcoord.z); + vec4 c0 = texture2DArray(TextureArrayTex, texcoord); + texcoord.z += 1.0; + vec4 c1 = texture2DArray(TextureArrayTex, texcoord); + + gl_FragColor = mix(c0, c1, fract(oUv.z)); +} diff --git a/res/dist/media/materials/programs/Example_TextureArrayPS.hlsl4 b/res/dist/media/materials/programs/Example_TextureArrayPS.hlsl4 new file mode 100644 index 00000000000..faaff11b32b --- /dev/null +++ b/res/dist/media/materials/programs/Example_TextureArrayPS.hlsl4 @@ -0,0 +1,33 @@ + +Texture2DArray g_txTextures : TextureArray; + +//-------------------------------------------------------------------------------------- + +SamplerState g_samAniso +{ + Filter = ANISOTROPIC; + AddressU = Wrap; + AddressV = Wrap; +}; + +//-------------------------------------------------------------------------------------- + +struct VS_OUTPUT { + float4 Position : SV_Position; + float3 TextureUV : TEXCOORD0; +}; + +//-------------------------------------------------------------------------------------- + +float4 textureArray_p ( VS_OUTPUT In ) : SV_Target +{ + int numberOfTextures = 20; + float3 texcoord; + texcoord = In.TextureUV; + texcoord.z = floor(texcoord.z); + float4 c0 = g_txTextures.Sample(g_samAniso, texcoord); + texcoord.z += 1; + float4 c1 = g_txTextures.Sample(g_samAniso, texcoord); + + return lerp(c0, c1, frac(In.TextureUV.z)); +} diff --git a/res/dist/media/materials/programs/Example_TextureArrayVS.cg b/res/dist/media/materials/programs/Example_TextureArrayVS.cg new file mode 100644 index 00000000000..be020d71db7 --- /dev/null +++ b/res/dist/media/materials/programs/Example_TextureArrayVS.cg @@ -0,0 +1,14 @@ + + +void textureArray_v(float4 position : POSITION, + float3 uv : TEXCOORD0, + + out float4 oPosition : POSITION, + out float3 oUv : TEXCOORD0, + + uniform float4x4 worldViewProj) +{ + oPosition = mul(worldViewProj, position); + oUv = uv; +} + diff --git a/res/dist/media/materials/programs/Example_TextureArrayVS.glsl b/res/dist/media/materials/programs/Example_TextureArrayVS.glsl new file mode 100644 index 00000000000..864b1e57983 --- /dev/null +++ b/res/dist/media/materials/programs/Example_TextureArrayVS.glsl @@ -0,0 +1,11 @@ +#version 120 + +varying vec3 oUv; + +uniform mat4 worldViewProj; + +void main(void) +{ + gl_Position = worldViewProj * gl_Vertex; + oUv = gl_MultiTexCoord0.xyz; +} diff --git a/res/dist/media/materials/programs/GlassFP.cg b/res/dist/media/materials/programs/GlassFP.cg new file mode 100644 index 00000000000..efcf73c8ef7 --- /dev/null +++ b/res/dist/media/materials/programs/GlassFP.cg @@ -0,0 +1,9 @@ +sampler2D RT : register(s0); +sampler2D NormalMap : register(s1); + +float4 main_ps(float4 pos : POSITION, float2 iTexCoord : TEXCOORD0) : COLOR +{ + float4 normal = 2 * (tex2D(NormalMap, iTexCoord * 2.5) - 0.5); + + return tex2D(RT, iTexCoord + normal.xy * 0.05); +} diff --git a/res/dist/media/materials/programs/GlassFP.glsles b/res/dist/media/materials/programs/GlassFP.glsles new file mode 100644 index 00000000000..ac95084e9a3 --- /dev/null +++ b/res/dist/media/materials/programs/GlassFP.glsles @@ -0,0 +1,15 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform sampler2D RT; +uniform sampler2D NormalMap; +varying vec2 uv; + +void main() +{ + vec4 normal = 2.0 * (texture2D(NormalMap, uv * 2.5) - 0.5); + + gl_FragColor = texture2D(RT, uv + normal.xy * 0.05); +} diff --git a/res/dist/media/materials/programs/Grass.cg b/res/dist/media/materials/programs/Grass.cg new file mode 100644 index 00000000000..5072e891af5 --- /dev/null +++ b/res/dist/media/materials/programs/Grass.cg @@ -0,0 +1,283 @@ +////////////////////////////// MOVING GRASS +// Vertex program to wave some grass about +// Assumes UV texture coords of v==0 indicates the top of the grass +void grass_vp(float4 position : POSITION, + float3 normal : NORMAL, + float2 uv : TEXCOORD0, + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 oColour : COLOR, + + uniform float4x4 worldViewProj, + //uniform float4 camObjPos, + uniform float4 ambient, + uniform float4 objSpaceLight, + uniform float4 lightColour, + uniform float4 offset) +{ + float4 mypos = position; + //offset = float4(0.5, 0, 0, 0); + float4 factor = float4(1,1,1,1) - uv.yyyy; + mypos = mypos + offset * factor; + oPosition = mul(worldViewProj, mypos); + + oUv = uv; + // Color + // get vertex light direction (support directional and point) + float3 light = normalize(objSpaceLight.xyz - (mypos.xyz * objSpaceLight.w)); + // grass is just 2D quads, so if light passes underneath we need to invert the normal + // abs() will have the same effect + float diffuseFactor = abs(dot(normal.xyz, light)); + oColour = ambient + diffuseFactor * lightColour; + +} + +void grass_fp( float4 position : POSITION, + float2 uv : TEXCOORD0, + float4 colour : COLOR, + + out float4 oColour : COLOR, + + uniform sampler2D diffuseMap + ) +{ + float4 texColor = tex2D(diffuseMap, uv.xy); + oColour = float4(texColor.rgb * colour.rgb, texColor.a); + if(oColour.a < 0.58) + discard; +} + + +void grassTex_vp( + float4 position : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + //out float4 oNormal : NORMAL, + + uniform float4x4 worldViewProj, + + uniform float4 ambient, + uniform float4 objSpaceLight, + uniform float4 lightColour, + + uniform float4 offset) +{ + // Position + float4 mypos = position; + float4 factor = float4(1,1,1,1) - uv.yyyy; + mypos = mypos + offset * factor; + oPosition = mul(worldViewProj, mypos); + // Texture Coord + oUv.xy = uv.xy; +} + +/// grass_vp ambient +void grassAmbient_vp( + float4 position : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float4 oColour : COLOR, + //out float4 oNormal : NORMAL, + + //uniform float4 camObjPos, + uniform float4x4 worldViewProj, + uniform float4 ambient, + uniform float4 offset) +{ + // Position + float4 mypos = position; + float4 factor = float4(1,1,1,1) - uv.yyyy; + mypos = mypos + offset * factor; + oPosition = mul(worldViewProj, mypos); + // Texture Coord + oUv.xy = uv.xy; + /* + // Normal + // Make vec from vertex to camera + float4 EyeVec = camObjPos - mypos; + // Dot the v to eye and the normal to see if they point + // in the same direction or opposite + float aligned = dot(normal, EyeVec); // -1..1 + // If aligned is negative, we need to flip the normal + if (aligned < 0) + normal = -normal; + //oNormal = normal; + */ + // Color + oColour = ambient; +} + + +void grassAmbient_fp( + float4 position : POSITION, + float2 uv : TEXCOORD0, + float4 colour : COLOR, + + out float4 oColour : COLOR, + + uniform sampler2D diffuseMap + ) +{ + float4 texColor = tex2D(diffuseMap, uv.xy); + oColour = float4(colour.rgb, texColor.a); +} + +//////////////////////// GRASS SHADOW CASTER +// Shadow caster vertex program. +void grasscaster_vp(float4 position : POSITION, + float2 uv : TEXCOORD0, + + out float4 oPosition : POSITION, + out float2 oUv : TEXCOORD0, + out float2 oDepth : TEXCOORD1, + + uniform float4x4 worldViewProj, + uniform float4 offset, + uniform float4 texelOffsets) +{ + float4 mypos = position; + float4 factor = float4(1,1,1,1) - uv.yyyy; + mypos = mypos + offset * factor; + oPosition = mul(worldViewProj, mypos); + + // fix pixel / texel alignment + oPosition.xy += texelOffsets.zw * oPosition.w; + + oDepth.x = oPosition.z; + oDepth.y = oPosition.w; + + oUv = uv; + +} + + +void grasscaster_fp( + float4 position : POSITION, + float2 uv : TEXCOORD0, + float2 depth : TEXCOORD1, + + out float4 result : COLOR, + + uniform sampler2D diffuseMap + ) +{ + float alpha = tex2D(diffuseMap, uv).a; + if (alpha > 0.001) + { + result = float4(1.0f, 1.0f, 1.0f, 0.0f); + } + else + { + float finalDepth = depth.x / depth.y; + // just smear across all components + // therefore this one needs high individual channel precision + result = float4(finalDepth.xxx, 1.0f); + } +} + + +//////////////////////// GRASS SHADOW RECEIVER +void grassreceiver_vp( + float4 position : POSITION, + float4 normal : NORMAL, + float2 uv : TEXCOORD0, + + out float4 oPosition : POSITION, + out float4 oShadowUV : TEXCOORD0, + out float3 oUv : TEXCOORD1, + out float4 oColour : COLOR, + //out float4 oNormal : NORMAL, + + uniform float4x4 world, + uniform float4x4 worldViewProj, + uniform float4x4 texViewProj, + + uniform float4 camObjPos, + + uniform float4 objSpaceLight, + uniform float4 lightColour, + + uniform float4 offset) +{ + float4 mypos = position; + float4 factor = float4(1,1,1,1) - uv.yyyy; + mypos = mypos + offset * factor; + oPosition = mul(worldViewProj, mypos); + oUv.xy = uv.xy; + // Transform position to world space + float4 worldPos = mul(world, mypos); + // calculate shadow map coords + oShadowUV = mul(texViewProj, worldPos); + + // Make vec from vertex to camera + float4 EyeVec = camObjPos - mypos; + // Dot the v to eye and the normal to see if they point + // in the same direction or opposite + float alignedEye = dot(normal, EyeVec); // -1..1 + // If aligned is negative, we need to flip the normal + if (alignedEye < 0) + normal = -normal; + //oNormal = normal; + + // get vertex light direction (support directional and point) + float3 lightVec = normalize(objSpaceLight.xyz - (mypos.xyz * objSpaceLight.w)); + // Dot the v to light and the normal to see if they point + // in the same direction or opposite + float alignedLight = dot(normal.xyz, lightVec); // -1..1 + // If aligned is negative, shadowing/lighting is not possible. + oUv.z = (alignedLight < 0)? 0 : 1 ; + + float diffuseFactor = max(alignedLight, 0); + //oColour = diffuseFactor * lightColour; + oColour = lightColour; +} + + +void grassreceiver_fp( + float4 position : POSITION + , float4 shadowUV : TEXCOORD0 + , float3 uv : TEXCOORD1 + , float4 vertexLight : COLOR + + , out float4 oColour : COLOR + + , uniform sampler2D shadowMap : register(s0) + , uniform sampler2D diffuseMap : register(s1) + + //, uniform float inverseShadowmapSize + , uniform float fixedDepthBias + , uniform float gradientClamp + , uniform float gradientScaleBias + ) +{ + if (shadowUV.z > 0) + { + float4 diffuse = tex2D(diffuseMap, uv.xy); + if (diffuse.a > 0.001) + { + oColour = float4(0.0f, 0.0f, 0.0f, 0.0f); + } + else + { + // point on shadowmap (no gradient as cg1.4 compiler is unable to handle that complexity) + shadowUV = shadowUV / shadowUV.w; + float4 shadowDepths = tex2D(shadowMap, shadowUV.xy); + + float gradientFactor = gradientClamp * gradientScaleBias; + float depthAdjust = gradientFactor + fixedDepthBias * shadowDepths.x; + float centerdepth = shadowDepths.x + depthAdjust; + + oColour = (centerdepth > shadowUV.z) ? float4(vertexLight.rgb, diffuse.a) : float4(0, 0, 0, diffuse.a); + } + } + else + { + oColour = float4(0.0f, 0.0f, 0.0f, 0.0f); + } +} diff --git a/res/dist/media/materials/programs/GrassAmbientFp.glsles b/res/dist/media/materials/programs/GrassAmbientFp.glsles new file mode 100644 index 00000000000..204ff50850b --- /dev/null +++ b/res/dist/media/materials/programs/GrassAmbientFp.glsles @@ -0,0 +1,22 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform sampler2D diffuseMap; + +varying vec4 oUv0; +varying vec4 oColour; + +/// grass_vp ambient +void main() +{ + vec4 texColor = texture2D(diffuseMap, oUv0.xy); + // Do manual alpha rejection because it is not built into OpenGL ES 2 + if (texColor.a < 0.588) + { + discard; + } + + gl_FragColor = vec4(oColour.rgb, texColor.a); +} diff --git a/res/dist/media/materials/programs/GrassAmbientVp.glsles b/res/dist/media/materials/programs/GrassAmbientVp.glsles new file mode 100644 index 00000000000..7e0c85db3cc --- /dev/null +++ b/res/dist/media/materials/programs/GrassAmbientVp.glsles @@ -0,0 +1,41 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform mat4 worldViewProj; +uniform vec4 ambient; +uniform vec4 offset; + +attribute vec4 position; +attribute vec4 normal; +attribute vec4 uv0; + +varying vec4 oUv0; +varying vec4 oColour; + +/// grass_vp ambient +void main() +{ + // Position + vec4 mypos = position; + vec4 factor = vec4(1.0, 1.0, 1.0, 1.0) - uv0.yyyy; + mypos = mypos + offset * factor; + gl_Position = worldViewProj * mypos; + // Texture Coord + oUv0.xy = uv0.xy; + /* + // Normal + // Make vec from vertex to camera + vec4 EyeVec = camObjPos - mypos; + // Dot the v to eye and the normal to see if they point + // in the same direction or opposite + float aligned = dot(normal, EyeVec); // -1..1 + // If aligned is negative, we need to flip the normal + if (aligned < 0) + normal = -normal; + //oNormal = normal; + */ + // Color + oColour = ambient; +} diff --git a/res/dist/media/materials/programs/GrassCasterFp.glsles b/res/dist/media/materials/programs/GrassCasterFp.glsles new file mode 100644 index 00000000000..afbd62d9ddd --- /dev/null +++ b/res/dist/media/materials/programs/GrassCasterFp.glsles @@ -0,0 +1,33 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform sampler2D diffuseMap; + +varying vec4 oUv0; +varying vec2 oDepth; + +//////////////////////// GRASS SHADOW CASTER +void main() +{ + float alpha = texture2D(diffuseMap, oUv0.xy).a; + + // Do manual alpha rejection because it is not built into OpenGL ES 2 + if (alpha < 0.588) + { + discard; + } + + if (alpha > 0.001) + { + gl_FragColor = vec4(1.0, 1.0, 1.0, 0.0); + } + else + { + float finalDepth = oDepth.x / oDepth.y; + // just smear across all components + // therefore this one needs high individual channel precision + gl_FragColor = vec4(vec3(finalDepth), 1.0); + } +} diff --git a/res/dist/media/materials/programs/GrassCasterVp.glsles b/res/dist/media/materials/programs/GrassCasterVp.glsles new file mode 100644 index 00000000000..a2f3bb73761 --- /dev/null +++ b/res/dist/media/materials/programs/GrassCasterVp.glsles @@ -0,0 +1,32 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform mat4 worldViewProj; +uniform vec4 offset; +uniform vec4 texelOffsets; + +attribute vec4 position; +attribute vec4 uv0; + +varying vec4 oUv0; +varying vec2 oDepth; + +//////////////////////// GRASS SHADOW CASTER +// Shadow caster vertex program. +void main() +{ + vec4 mypos = position; + vec4 factor = vec4(1.0, 1.0, 1.0, 1.0) - uv0.yyyy; + mypos = mypos + offset * factor; + gl_Position = worldViewProj * mypos; + + // fix pixel / texel alignment + gl_Position.xy += texelOffsets.zw * gl_Position.w; + + oDepth.x = gl_Position.z; + oDepth.y = gl_Position.w; + + oUv0 = uv0; +} diff --git a/res/dist/media/materials/programs/GrassFp.glsles b/res/dist/media/materials/programs/GrassFp.glsles new file mode 100644 index 00000000000..064b0e73bca --- /dev/null +++ b/res/dist/media/materials/programs/GrassFp.glsles @@ -0,0 +1,25 @@ +#version 100 + +precision mediump int; +precision mediump float; + +////////////////////////////// MOVING GRASS +// Vertex program to wave some grass about +// Assumes UV texture coords of v==0 indicates the top of the grass +uniform sampler2D diffuseMap; + +varying vec4 oUv0; +varying vec4 oColour; + +void main() +{ + vec4 texColor = texture2D(diffuseMap, oUv0.xy); + + // Do manual alpha rejection because it is not built into OpenGL ES 2 + if (texColor.a < 0.588) + { + discard; + } + + gl_FragColor = vec4(texColor.rgb * oColour.rgb, texColor.a); +} diff --git a/res/dist/media/materials/programs/GrassReceiverFp.glsles b/res/dist/media/materials/programs/GrassReceiverFp.glsles new file mode 100644 index 00000000000..e1c5595e2a4 --- /dev/null +++ b/res/dist/media/materials/programs/GrassReceiverFp.glsles @@ -0,0 +1,47 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform float fixedDepthBias; +uniform float gradientClamp; +uniform float gradientScaleBias; +uniform sampler2D shadowMap; +uniform sampler2D diffuseMap; +uniform vec4 vertexLight; + +varying vec4 oUv0; +varying vec4 oShadowUV; + +//////////////////////// GRASS SHADOW RECEIVER +void main() +{ + if (oShadowUV.z > 0.0) + { + vec4 diffuse = texture2D(diffuseMap, oUv0.xy); + if (diffuse.a > 0.001) + { + // Do manual alpha rejection because it is not built into OpenGL ES 2 + if (diffuse.a < 0.588) + { + discard; + } + gl_FragColor = vec4(0.0); + } + else + { + vec4 normShadowUV = oShadowUV / oShadowUV.w; + vec4 shadowDepths = texture2D(shadowMap, normShadowUV.xy); + + float gradientFactor = gradientClamp * gradientScaleBias; + float depthAdjust = gradientFactor + fixedDepthBias * shadowDepths.x; + float centerdepth = shadowDepths.x + depthAdjust; + + gl_FragColor = (centerdepth > normShadowUV.z) ? vec4(vertexLight.rgb, diffuse.a) : vec4(0.0, 0.0, 0.0, diffuse.a); + } + } + else + { + gl_FragColor = vec4(0.0); + } +} diff --git a/res/dist/media/materials/programs/GrassReceiverVp.glsles b/res/dist/media/materials/programs/GrassReceiverVp.glsles new file mode 100644 index 00000000000..5b5d14d99db --- /dev/null +++ b/res/dist/media/materials/programs/GrassReceiverVp.glsles @@ -0,0 +1,57 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform mat4 world; +uniform mat4 worldViewProj; +uniform mat4 texViewProj; +uniform vec4 camObjPos; +uniform vec4 objSpaceLight; +uniform vec4 lightColour; +uniform vec4 offset; + +attribute vec4 position; +attribute vec4 normal; +attribute vec4 uv0; + +varying vec4 oShadowUV; +varying vec3 oUv0; +varying vec4 oColour; + +//////////////////////// GRASS SHADOW RECEIVER +void main() +{ + vec4 mypos = position; + vec4 factor = vec4(1.0, 1.0, 1.0, 1.0) - uv0.yyyy; + mypos = mypos + offset * factor; + gl_Position = worldViewProj * mypos; + oUv0.xy = uv0.xy; + // Transform position to world space + vec4 worldPos = world * mypos; + // calculate shadow map coords + oShadowUV = texViewProj * worldPos; + + // Make vec from vertex to camera + vec4 EyeVec = camObjPos - mypos; + // Dot the v to eye and the normal to see if they point + // in the same direction or opposite + float alignedEye = dot(normal, EyeVec); // -1..1 + // If aligned is negative, we need to flip the normal + vec4 myNormal = normal; + if (alignedEye < 0.0) + myNormal = -normal; + //oNormal = normal; + + // get vertex light direction (support directional and point) + vec3 lightVec = normalize(objSpaceLight.xyz - (mypos.xyz * objSpaceLight.w).xyz); + // Dot the v to light and the normal to see if they point + // in the same direction or opposite + float alignedLight = dot(myNormal.xyz, lightVec); // -1..1 + // If aligned is negative, shadowing/lighting is not possible. + oUv0.z = (alignedLight < 0.0) ? 0.0 : 1.0 ; + + float diffuseFactor = max(alignedLight, 0.0); + //oColour = diffuseFactor * lightColour; + oColour = lightColour; +} diff --git a/res/dist/media/materials/programs/GrassTexVp.glsles b/res/dist/media/materials/programs/GrassTexVp.glsles new file mode 100644 index 00000000000..63f453d9d5c --- /dev/null +++ b/res/dist/media/materials/programs/GrassTexVp.glsles @@ -0,0 +1,26 @@ +#version 100 + +precision mediump int; +precision mediump float; + +varying vec4 oUv0; + +attribute vec4 position; +attribute vec4 uv0; + +uniform mat4 worldViewProj; +uniform vec4 ambient; +uniform vec4 objSpaceLight; +uniform vec4 lightColour; +uniform vec4 offset; + +void main() +{ + // Position + vec4 mypos = position; + vec4 factor = vec4(1.0, 1.0, 1.0, 1.0) - uv0.yyyy; + mypos = mypos + offset * factor; + gl_Position = worldViewProj * mypos; + // Texture Coord + oUv0.xy = uv0.xy; +} diff --git a/res/dist/media/materials/programs/GrassVp.glsles b/res/dist/media/materials/programs/GrassVp.glsles new file mode 100644 index 00000000000..60b725632b1 --- /dev/null +++ b/res/dist/media/materials/programs/GrassVp.glsles @@ -0,0 +1,38 @@ +#version 100 + +precision mediump int; +precision mediump float; + +////////////////////////////// MOVING GRASS +// Vertex program to wave some grass about +// Assumes UV texture coords of v==0 indicates the top of the grass +uniform mat4 worldViewProj; +uniform vec4 camObjPos; +uniform vec4 ambient; +uniform vec4 objSpaceLight; +uniform vec4 lightColour; +uniform vec4 offset; + +attribute vec4 position; +attribute vec4 normal; +attribute vec4 uv0; + +varying vec4 oUv0; +varying vec4 oColour; + +void main() +{ + vec4 mypos = position; + vec4 factor = vec4(1.0, 1.0, 1.0, 1.0) - uv0.yyyy; + mypos = mypos + offset * factor; + gl_Position = worldViewProj * mypos; + + oUv0 = uv0; + // Color + // get vertex light direction (support directional and point) + vec3 light = normalize(objSpaceLight.xyz - (mypos.xyz * objSpaceLight.w).xyz); + // grass is just 2D quads, so if light passes underneath we need to invert the normal + // abs() will have the same effect + float diffuseFactor = abs(dot(normal.xyz, light)); + oColour = ambient + diffuseFactor * lightColour; +} diff --git a/res/dist/media/materials/programs/GrayScale.cg b/res/dist/media/materials/programs/GrayScale.cg new file mode 100644 index 00000000000..6a18a47fccb --- /dev/null +++ b/res/dist/media/materials/programs/GrayScale.cg @@ -0,0 +1,20 @@ +sampler2D RT : register(s0); + +float4 GrayScale_ps( float4 pos : POSITION, + float2 iTexCoord : TEXCOORD0) : COLOR +{ + float3 greyscale = dot(tex2D(RT, iTexCoord).rgb, float3(0.3, 0.59, 0.11)); + return float4(greyscale, 1.0); +} + +float4 Embossed_ps( float4 pos : POSITION, + float2 iTexCoord : TEXCOORD0) : COLOR +{ + float4 Color; + Color.a = 1.0f; + Color.rgb = 0.5f; + Color -= tex2D( RT, iTexCoord - 0.001)*2.0f; + Color += tex2D( RT, iTexCoord + 0.001)*2.0f; + Color.rgb = (Color.r+Color.g+Color.b)/3.0f; + return Color; +} diff --git a/res/dist/media/materials/programs/GrayScale.glsles b/res/dist/media/materials/programs/GrayScale.glsles new file mode 100644 index 00000000000..b5c3b85d668 --- /dev/null +++ b/res/dist/media/materials/programs/GrayScale.glsles @@ -0,0 +1,13 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform sampler2D RT; +varying vec2 uv; + +void main() +{ + vec3 greyscale = vec3(dot(texture2D(RT, uv).rgb, vec3(0.3, 0.59, 0.11))); + gl_FragColor = vec4(greyscale, 1.0); +} diff --git a/res/dist/media/materials/programs/HWBasicInstancing.cg b/res/dist/media/materials/programs/HWBasicInstancing.cg new file mode 100644 index 00000000000..d5e4fac895e --- /dev/null +++ b/res/dist/media/materials/programs/HWBasicInstancing.cg @@ -0,0 +1,69 @@ +//--------------------------------------------------------------------------- +//These materials/shaders are part of the NEW InstanceManager implementation +//Written by Matias N. Goldberg ("dark_sylinc") +//--------------------------------------------------------------------------- + +//--------------------------------------------- +//Vertex Shader Input +//--------------------------------------------- +struct VS_INPUT +{ + float4 Position : POSITION; + float3 Normal : NORMAL; + float3 Tangent : TANGENT; + float2 uv0 : TEXCOORD0; + + float4 mat14 : TEXCOORD1; + float4 mat24 : TEXCOORD2; + float4 mat34 : TEXCOORD3; +}; + +#include "InstancingVertexInterpolators.cg" + +//--------------------------------------------- +//Main Vertex Shader +//--------------------------------------------- +VS_OUTPUT main_vs( in VS_INPUT input, + uniform float4x4 viewProjMatrix + +#if defined( DEPTH_SHADOWCASTER ) || defined( DEPTH_SHADOWRECEIVER ) + , uniform float4 depthRange +#endif +#ifdef DEPTH_SHADOWRECEIVER + , uniform float4x4 texViewProjMatrix +#endif + ) +{ + VS_OUTPUT output; + + float3x4 worldMatrix; + worldMatrix[0] = input.mat14; + worldMatrix[1] = input.mat24; + worldMatrix[2] = input.mat34; + + float4 worldPos = float4( mul( worldMatrix, input.Position ).xyz, 1.0f ); + float3 worldNorm= mul( (float3x3)(worldMatrix), input.Normal ); + + //Transform the position + output.Position = mul( viewProjMatrix, worldPos ); + +#ifdef DEPTH_SHADOWCASTER + output.ps.unused = float3( 0 ); + output.ps.depth = (output.Position.z - depthRange.x + SHADOW_BIAS) * depthRange.w; +#else + output.ps.uv0 = input.uv0; + + //Pass Normal and position for Blinn Phong lighting + output.ps.Normal = normalize(worldNorm); + output.ps.vPos = worldPos.xyz; + + #ifdef DEPTH_SHADOWRECEIVER + // Calculate the position of vertex in light space to do shadows + output.ps.lightSpacePos = mul( texViewProjMatrix, worldPos ); + // make linear + output.ps.lightSpacePos.z = (output.ps.lightSpacePos.z - depthRange.x) * depthRange.w; + #endif +#endif + + return output; +} diff --git a/res/dist/media/materials/programs/HWBasicInstancing.vert b/res/dist/media/materials/programs/HWBasicInstancing.vert new file mode 100644 index 00000000000..e427e488331 --- /dev/null +++ b/res/dist/media/materials/programs/HWBasicInstancing.vert @@ -0,0 +1,69 @@ +//--------------------------------------------------------------------------- +//These materials/shaders are part of the NEW InstanceManager implementation +//Written by Matias N. Goldberg ("dark_sylinc") +//--------------------------------------------------------------------------- +#version 120 + +//Vertex input +attribute vec4 vertex; +attribute vec3 normal; +attribute vec4 uv0; +attribute vec4 uv1; +attribute vec4 uv2; +attribute vec4 uv3; +attribute vec3 tangent; + +//Parameters +uniform mat4 viewProjMatrix; + +#if (DEPTH_SHADOWCASTER || DEPTH_SHADOWRECEIVER) +uniform vec4 depthRange; +#endif + +#if DEPTH_SHADOWRECEIVER +uniform mat4 texViewProjMatrix; +#endif + +//Output +#if DEPTH_SHADOWCASTER + varying vec2 depth; +#else + varying vec2 _uv0; + varying vec3 oNormal; + varying vec3 oVPos; + #if DEPTH_SHADOWRECEIVER + varying vec4 oLightSpacePos; + #endif +#endif + +//--------------------------------------------- +//Main Vertex Shader +//--------------------------------------------- +void main(void) +{ + mat4 worldMatrix; + worldMatrix[0] = uv1; + worldMatrix[1] = uv2; + worldMatrix[2] = uv3; + worldMatrix[3] = vec4( 0, 0, 0, 1 ); + + vec4 worldPos = vertex * worldMatrix; + vec3 worldNorm = normal * mat3(worldMatrix); + + //Transform the position + gl_Position = viewProjMatrix * worldPos; + +#if DEPTH_SHADOWCASTER + depth.x = (gl_Position.z - depthRange.x) * depthRange.w; + depth.y = depthRange.w; +#else + _uv0 = uv0.xy; + oNormal = worldNorm; + oVPos = worldPos.xyz; + + #if DEPTH_SHADOWRECEIVER + oLightSpacePos = texViewProjMatrix * worldPos; + oLightSpacePos.z = (oLightSpacePos.z - depthRange.x) * depthRange.w; + #endif +#endif +} diff --git a/res/dist/media/materials/programs/HW_VTFInstancing.cg b/res/dist/media/materials/programs/HW_VTFInstancing.cg new file mode 100644 index 00000000000..e10352fe046 --- /dev/null +++ b/res/dist/media/materials/programs/HW_VTFInstancing.cg @@ -0,0 +1,124 @@ +//--------------------------------------------------------------------------- +//These materials/shaders are part of the NEW InstanceManager implementation +//Written by Matias N. Goldberg ("dark_sylinc") +//--------------------------------------------------------------------------- + +//--------------------------------------------- +//Vertex Shader Input +//--------------------------------------------- +struct VS_INPUT +{ + float4 Position : POSITION; + float3 Normal : NORMAL; + float3 Tangent : TANGENT; +#ifdef BONE_TWO_WEIGHTS + float4 weights : BLENDWEIGHT; +#endif + float2 uv0 : TEXCOORD0; + float4 m03 : TEXCOORD1; //m03.w is always 0 + + float2 mOffset : TEXCOORD2; + +#ifdef BONE_MATRIX_LUT + float4 worldMatrix0 : TEXCOORD3; + float4 worldMatrix1 : TEXCOORD4; + float4 worldMatrix2 : TEXCOORD5; +#endif +}; + +#include "InstancingVertexInterpolators.cg" +#ifdef ST_DUAL_QUATERNION +#include "DualQuaternion_Common.cg" +#endif + +//--------------------------------------------- +//Main Vertex Shader +//--------------------------------------------- +VS_OUTPUT main_vs( in VS_INPUT input, + uniform float4x4 viewProjMatrix, + +#ifdef DEPTH_SHADOWCASTER + uniform sampler2D matrixTexture : register(s0) +#else + uniform sampler2D matrixTexture : register(s2) +#endif + +#if defined( DEPTH_SHADOWCASTER ) || defined( DEPTH_SHADOWRECEIVER ) + , uniform float4 depthRange +#endif +#ifdef DEPTH_SHADOWRECEIVER + , uniform float4x4 texViewProjMatrix +#endif + ) +{ + VS_OUTPUT output; + float4 worldPos; + float3 worldNorm; + + +#ifdef ST_DUAL_QUATERNION + float2x4 blendDQ; + blendDQ[0] = tex2D( matrixTexture, float2(input.m03.x, 0.0) + input.mOffset ); + blendDQ[1] = tex2D( matrixTexture, float2(input.m03.y, 0.0) + input.mOffset ); +#ifdef BONE_TWO_WEIGHTS + float2x4 blendDQ2; + //Use the empty parts of m03, z and w, for the second dual quaternion + blendDQ2[0] = tex2D( matrixTexture, float2(input.m03.z, 0.0) + input.mOffset ); + blendDQ2[1] = tex2D( matrixTexture, float2(input.m03.w, 0.0) + input.mOffset ); + + //Accurate antipodality handling. For speed increase, remove the following line + if (dot(blendDQ[0], blendDQ2[0]) < 0.0) blendDQ2 *= -1.0; + + //Blend the dual quaternions based on the weights + blendDQ *= input.weights.x; + blendDQ += input.weights.y*blendDQ2; + //Normalize the resultant dual quaternion + blendDQ /= length(blendDQ[0]); +#endif + worldPos = float4(calculateBlendPosition(input.Position.xyz, blendDQ), 1.0); + worldNorm = calculateBlendNormal(input.Normal, blendDQ); +#else + float3x4 worldMatrix; + worldMatrix[0] = tex2D( matrixTexture, input.m03.xw + input.mOffset ); + worldMatrix[1] = tex2D( matrixTexture, input.m03.yw + input.mOffset ); + worldMatrix[2] = tex2D( matrixTexture, input.m03.zw + input.mOffset ); + + worldPos = float4( mul( worldMatrix, input.Position ).xyz, 1.0f ); + worldNorm= mul( (float3x3)(worldMatrix), input.Normal ); +#endif + +#ifdef BONE_MATRIX_LUT + float3x4 worldCompMatrix; + worldCompMatrix[0] = input.worldMatrix0; + worldCompMatrix[1] = input.worldMatrix1; + worldCompMatrix[2] = input.worldMatrix2; + + worldPos = float4( mul( worldCompMatrix, worldPos ).xyz, 1.0f ); + worldNorm = mul( (float3x3)(worldCompMatrix), worldNorm ); + +#endif + + + //Transform the position + output.Position = mul( viewProjMatrix, worldPos ); + +#ifdef DEPTH_SHADOWCASTER + output.ps.unused = float3( 0 ); + output.ps.depth = (output.Position.z - depthRange.x + SHADOW_BIAS) * depthRange.w; +#else + output.ps.uv0 = input.uv0; + + //Pass Normal and position for Blinn Phong lighting + output.ps.Normal = normalize(worldNorm); + output.ps.vPos = worldPos.xyz; + + #ifdef DEPTH_SHADOWRECEIVER + // Calculate the position of vertex in light space to do shadows + output.ps.lightSpacePos = mul( texViewProjMatrix, worldPos ); + // make linear + output.ps.lightSpacePos.z = (output.ps.lightSpacePos.z - depthRange.x) * depthRange.w; + #endif +#endif + + return output; +} diff --git a/res/dist/media/materials/programs/HW_VTFInstancing.vert b/res/dist/media/materials/programs/HW_VTFInstancing.vert new file mode 100644 index 00000000000..d53bcd05577 --- /dev/null +++ b/res/dist/media/materials/programs/HW_VTFInstancing.vert @@ -0,0 +1,131 @@ +//--------------------------------------------------------------------------- +//These materials/shaders are part of the NEW InstanceManager implementation +//Written by Matias N. Goldberg ("dark_sylinc") +//--------------------------------------------------------------------------- +#version 120 + +//Vertex input +attribute vec4 vertex; +attribute vec3 normal; + +#ifdef BONE_TWO_WEIGHTS + attribute vec4 blendWeights; +#endif + +attribute vec4 uv0; +attribute vec4 uv1; +attribute vec4 uv2; + +#if BONE_MATRIX_LUT + attribute vec4 uv3; + attribute vec4 uv4; + attribute vec4 uv5; +#endif + +attribute vec3 tangent; + +//Parameters +uniform mat4 viewProjMatrix; +uniform sampler2D matrixTexture; + +#if (DEPTH_SHADOWCASTER || DEPTH_SHADOWRECEIVER) +uniform vec4 depthRange; +#endif + +#if DEPTH_SHADOWRECEIVER +uniform mat4 texViewProjMatrix; +#endif + +//Output +#if DEPTH_SHADOWCASTER + varying vec2 depth; +#else + varying vec2 _uv0; + varying vec3 oNormal; + varying vec3 oVPos; + #if DEPTH_SHADOWRECEIVER + varying vec4 oLightSpacePos; + #endif +#endif + +vec3 calculateBlendPosition(vec3 position, mat2x4 blendDQ) +{ + vec3 blendPosition = position + 2.0*cross(blendDQ[0].yzw, cross(blendDQ[0].yzw, position) + blendDQ[0].x*position); + vec3 trans = 2.0*(blendDQ[0].x*blendDQ[1].yzw - blendDQ[1].x*blendDQ[0].yzw + cross(blendDQ[0].yzw, blendDQ[1].yzw)); + blendPosition += trans; + + return blendPosition; +} + +vec3 calculateBlendNormal(vec3 normal, mat2x4 blendDQ) +{ + return normal + 2.0*cross(blendDQ[0].yzw, cross(blendDQ[0].yzw, normal) + blendDQ[0].x*normal); +} + +//--------------------------------------------- +//Main Vertex Shader +//--------------------------------------------- +void main(void) +{ + vec4 worldPos; + vec3 worldNorm; + +#ifdef ST_DUAL_QUATERNION + mat2x4 blendDQ; + blendDQ[0] = texture2D( matrixTexture, vec2(uv1.x, 0.0) + uv2.xy ); + blendDQ[1] = texture2D( matrixTexture, vec2(uv1.y, 0.0) + uv2.xy ); +#ifdef BONE_TWO_WEIGHTS + mat2x4 blendDQ2; + blendDQ2[0] = texture2D( matrixTexture, vec2(uv1.z, 0.0) + uv2.xy ); + blendDQ2[1] = texture2D( matrixTexture, vec2(uv1.w, 0.0) + uv2.xy ); + + //Accurate antipodality handling. For speed increase, remove the following line + if (dot(blendDQ[0], blendDQ2[0]) < 0.0) blendDQ2 *= -1.0; + + //Blend the dual quaternions based on the weights + blendDQ *= blendWeights.x; + blendDQ += blendWeights.y*blendDQ2; + //Normalize the resultant dual quaternion + blendDQ /= length(blendDQ[0]); +#endif + worldPos = vec4(calculateBlendPosition(vertex.xyz, blendDQ), 1.0); + worldNorm = calculateBlendNormal(normal, blendDQ); +#else + mat4 worldMatrix; + worldMatrix[0] = texture2D( matrixTexture, uv1.xw + uv2.xy ); + worldMatrix[1] = texture2D( matrixTexture, uv1.yw + uv2.xy ); + worldMatrix[2] = texture2D( matrixTexture, uv1.zw + uv2.xy ); + worldMatrix[3] = vec4( 0, 0, 0, 1 ); + + worldPos = vertex * worldMatrix; + worldNorm = normal * mat3(worldMatrix); +#endif + +#if BONE_MATRIX_LUT + mat4 worldCompMatrix; + worldCompMatrix[0] = uv3; + worldCompMatrix[1] = uv4; + worldCompMatrix[2] = uv5; + worldCompMatrix[3] = vec4( 0, 0, 0, 1 ); + + worldPos = worldPos * worldCompMatrix; + worldNorm = worldNorm * mat3(worldCompMatrix); +#endif + + //Transform the position + gl_Position = viewProjMatrix * worldPos; + +#if DEPTH_SHADOWCASTER + depth.x = (gl_Position.z - depthRange.x) * depthRange.w; + depth.y = depthRange.w; +#else + _uv0 = uv0.xy; + oNormal = worldNorm; + oVPos = worldPos.xyz; + + #if DEPTH_SHADOWRECEIVER + oLightSpacePos = texViewProjMatrix * worldPos; + oLightSpacePos.z = (oLightSpacePos.z - depthRange.x) * depthRange.w; + #endif +#endif +} diff --git a/res/dist/media/materials/programs/HalftoneFP.cg b/res/dist/media/materials/programs/HalftoneFP.cg new file mode 100644 index 00000000000..19bb81e9e63 --- /dev/null +++ b/res/dist/media/materials/programs/HalftoneFP.cg @@ -0,0 +1,19 @@ +sampler2D RT : register(s0); +sampler3D pattern : register(s1); + +float4 Halftone_ps( float4 pos : POSITION, + float2 TexCoord : TEXCOORD0, + uniform float2 numTiles, + uniform float2 iNumTiles, + uniform float2 iNumTiles2, + uniform float4 lum) : COLOR +{ + float3 local; + local.xy = fmod(TexCoord, iNumTiles); + float2 middle = TexCoord - local.xy; + local.xy = local.xy * numTiles; + middle += iNumTiles2; + local.z = dot(tex2D(RT, middle ) , lum); + float4 c = tex3D(pattern,local).a; + return c; +} \ No newline at end of file diff --git a/res/dist/media/materials/programs/HalftoneFP.glsles b/res/dist/media/materials/programs/HalftoneFP.glsles new file mode 100644 index 00000000000..460f7f4e91e --- /dev/null +++ b/res/dist/media/materials/programs/HalftoneFP.glsles @@ -0,0 +1,24 @@ +#version 100 + +precision mediump int; +precision mediump float; + +sampler2D RT : register(s0); +sampler3D pattern : register(s1); + +float4 Halftone_ps( float4 pos : POSITION, + float2 TexCoord : TEXCOORD0, + uniform float2 numTiles, + uniform float2 iNumTiles, + uniform float2 iNumTiles2, + uniform float4 lum) : COLOR +{ + float3 local; + local.xy = fmod(TexCoord, iNumTiles); + float2 middle = TexCoord - local.xy; + local.xy = local.xy * numTiles; + middle += iNumTiles2; + local.z = dot(tex2D(RT, middle ) , lum); + float4 c = tex3D(pattern,local).a; + return c; +} \ No newline at end of file diff --git a/res/dist/media/materials/programs/HeatBlurFp.glsles b/res/dist/media/materials/programs/HeatBlurFp.glsles new file mode 100644 index 00000000000..831b633fec3 --- /dev/null +++ b/res/dist/media/materials/programs/HeatBlurFp.glsles @@ -0,0 +1,63 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform sampler2D Input; +uniform vec4 blurAmount; + +varying vec2 uv; + +void main() +{ + int i; + vec4 tmpOutColor; + float diffuseGlowFactor; + vec2 offsets[4]; +/* + // hazy blur + -1.8, -1.8, + -1.8, 1.8, + 1.8, -1.8, + 1.8, 1.8 +*/ +/* + // less-hazy blur + -1.0, 2.0, + -1.0, -1.0, + 1.0, -1.0, + 1.0, 1.0 +*/ +/* + -0.326212, -0.405805, + -0.840144, -0.073580, + -0.695914, 0.457137, + -0.203345, 0.620716 +*/ + + offsets[0] = vec2(-0.3, 0.4); + offsets[1] = vec2(-0.3, -0.4); + offsets[2] = vec2(0.3, -0.4); + offsets[3] = vec2(0.3, 0.4); + + tmpOutColor = texture2D( Input, uv ); // UV coords are in image space + + // calculate glow amount + diffuseGlowFactor = 0.0113 * (2.0 - max( tmpOutColor.r, tmpOutColor.g )); + + // basic blur filter + for (i = 0; i < 4; i++) { + tmpOutColor += texture2D( Input, uv + blurAmount.x * diffuseGlowFactor * offsets[i] ); + } + + tmpOutColor *= 0.25; + + // TIPS (old-skool strikes again!) + // Pay attention here! If you use the "out float4 outColor" directly + // in your steps while creating the output color (like you remove + // the "tmpOutColor" var and just use the "outColor" directly) + // your pixel-color output IS CHANGING EACH TIME YOU DO AN ASSIGNMENT TOO! + // A temporary variable, instead, acts like a per-pixel double buffer, and + // best of all, lead to better performance. + gl_FragColor = tmpOutColor; +} \ No newline at end of file diff --git a/res/dist/media/materials/programs/HeatBlurVp.glsles b/res/dist/media/materials/programs/HeatBlurVp.glsles new file mode 100644 index 00000000000..ae194a172ad --- /dev/null +++ b/res/dist/media/materials/programs/HeatBlurVp.glsles @@ -0,0 +1,16 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform vec4 position; +uniform float flipping; +varying vec2 uv; + +void main() +{ + vec4 inPos = position; + gl_Position = vec4(inPos.x, flipping * inPos.y, 0.0, 1.0); + inPos.xy = sign(inPos.xy); + uv = (vec2(inPos.x, -inPos.y) + 1.0)/2.0; +} diff --git a/res/dist/media/materials/programs/HeatCasterFp.glsles b/res/dist/media/materials/programs/HeatCasterFp.glsles new file mode 100644 index 00000000000..c1188974809 --- /dev/null +++ b/res/dist/media/materials/programs/HeatCasterFp.glsles @@ -0,0 +1,11 @@ +#version 100 + +precision mediump int; +precision mediump float; + +varying vec2 NDotV; + +void main() +{ + gl_FragColor = vec4(NDotV.x); +} diff --git a/res/dist/media/materials/programs/HeatCasterVp.glsles b/res/dist/media/materials/programs/HeatCasterVp.glsles new file mode 100644 index 00000000000..571759710db --- /dev/null +++ b/res/dist/media/materials/programs/HeatCasterVp.glsles @@ -0,0 +1,18 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform mat4 worldViewProj; +uniform vec3 eyePosition; +attribute vec4 position; +attribute vec4 normal; +varying vec2 NDotV; + +void main() +{ + vec4 eyeDir = vec4(eyePosition - position.xyz, 0.0); + eyeDir = normalize(eyeDir); + gl_Position = worldViewProj * position; + NDotV = vec2(clamp( dot( normal, eyeDir ), 0.0, 1.0 )); +} diff --git a/res/dist/media/materials/programs/HeatVision.cg b/res/dist/media/materials/programs/HeatVision.cg new file mode 100644 index 00000000000..86d5b8124a9 --- /dev/null +++ b/res/dist/media/materials/programs/HeatVision.cg @@ -0,0 +1,230 @@ +////////////////////////////////////////////// +// CASTER PASS // +// HEAT // +////////////////////////////////////////////// + +// vs_1_1 +void HeatCaster_vp( + // in + float4 vPos: POSITION, + float4 vNormal: NORMAL, + + // out + out float4 oPos: POSITION, + out float2 oNDotV: TEXCOORD0, + + // parameters + uniform float4x4 worldViewProj, + uniform float3 eyePosition // object space + ) +{ + float4 eyeDir = float4(eyePosition - vPos.xyz, 0); + eyeDir = normalize(eyeDir); + oPos = mul( worldViewProj, vPos ); + oNDotV = clamp( dot( vNormal, eyeDir ), 0, 1 ); +} + +// ps_2_0 +float4 HeatCaster_fp( + // input from vp + float2 iNDotV: TEXCOORD0 + ) : COLOR0 +{ + return iNDotV.x; +} + + +////////////////////////////////////////////// +// CASTER PASS // +// COLD // +////////////////////////////////////////////// + +// vs_1_1 +void ColdCaster_vp( + // in + float4 vPos: POSITION, + float4 vNormal: NORMAL, + + // out + out float4 oPos: POSITION, + out float2 oNDotV: TEXCOORD0, + + // parameters + uniform float4x4 worldViewProj, + uniform float3 eyePosition // object space + ) +{ + float4 eyeDir = float4(eyePosition - vPos.xyz, 0); + eyeDir = normalize(eyeDir); + oPos = mul( worldViewProj, vPos ); + oNDotV = clamp( dot( vNormal, eyeDir ), 0, 1 ); +} + +// ps_2_0 +float4 ColdCaster_fp( + // input from vp + float2 iNDotV: TEXCOORD0 + ) : COLOR0 +{ + return iNDotV.x / 2; +} + + +////////////////////////////////////////////// +// PASS 1 - Light to heat conversion // +////////////////////////////////////////////// + +// vs_1_1 +void LightToHeat_vp( + // in + float4 inPos: POSITION, + + uniform float flipping, + + // out + out float4 Pos: POSITION, + out float2 uv0: TEXCOORD0 + ) +{ + Pos = float4(inPos.x, flipping * inPos.y, 0.0f, 1.0f); + inPos.xy = sign(inPos.xy); + uv0 = (float2(inPos.x, -inPos.y) + 1.0f)/2.0f; +} + + +// ps_2_0 +void LightToHeat_fp( + // input from vp + float4 inDiffuse: COLOR0, + float2 inUV0: TEXCOORD0, + + // out + out float4 outColor: COLOR0, + + // params + uniform float4 random_fractions, + uniform float4 heatBiasScale, + uniform float4 depth_modulator, + + uniform sampler2D Input, // output of HeatVisionCaster_fp (NdotV) + uniform sampler2D NoiseMap, + uniform sampler2D HeatLookup + ) +{ + float depth, heat, interference; + + // Output constant color: + depth = tex2D( Input, inUV0 ); + depth *= (depth * depth_modulator); + + heat = (depth * heatBiasScale.y); + +// if (depth > 0) + { + interference = -0.5 + tex2D( NoiseMap, inUV0 + float2( random_fractions.x, random_fractions.y ) ); + interference *= interference; + interference *= 1 - heat; + heat += interference;//+ heatBiasScale.x; + } + +/* + heatBias isn't used for now + if (heat > 0) + heat += heatBiasScale.x; +*/ + + // Clamp UVs + heat = max( 0.005, min( 0.995, heat ) ); + outColor = tex2D( HeatLookup, float2( heat, 0.f ) ); +} + + +////////////////////////////////////////////// +// PASS 2 - add simple blur (final pass) // +////////////////////////////////////////////// + +// vs_1_1 +void Blur_vp( + // in + float4 inPos: POSITION, + + uniform float flipping, + + // out + out float4 Pos: POSITION, + out float2 uv0: TEXCOORD0 + ) +{ + Pos = float4(inPos.x, flipping * inPos.y, 0.0f, 1.0f); + inPos.xy = sign(inPos.xy); + uv0 = (float2(inPos.x, -inPos.y) + 1.0f)/2.0f; +} + +// ps_2_0 +void Blur_fp( + // input from vp + float4 inDiffuse: COLOR0, + float2 inUV0: TEXCOORD0, + + // out + out float4 outColor: COLOR0, + + // parameters + uniform sampler2D Input, // output of HeatVision_fp1 (HeatRenderTexture) + uniform float4 blurAmount + ) +{ + int i; + float4 tmpOutColor; + float diffuseGlowFactor; + const float2 offsets[4] = + { +/* + // hazy blur + -1.8, -1.8, + -1.8, 1.8, + 1.8, -1.8, + 1.8, 1.8 +*/ +/* + // less-hazy blur + -1.0, 2.0, + -1.0, -1.0, + 1.0, -1.0, + 1.0, 1.0 +*/ +/* + -0.326212, -0.405805, + -0.840144, -0.073580, + -0.695914, 0.457137, + -0.203345, 0.620716 +*/ + + -0.3, 0.4, + -0.3, -0.4, + 0.3, -0.4, + 0.3, 0.4 + + }; + + tmpOutColor = tex2D( Input, inUV0 ); // UV coords are in image space + + // calculate glow amount + diffuseGlowFactor = 0.0113f * (2.0 - max( tmpOutColor.r, tmpOutColor.g )); + + // basic blur filter + for (i = 0; i < 4; i++) { + tmpOutColor += tex2D( Input, inUV0 + blurAmount.x * diffuseGlowFactor * offsets[i] ); + } + + tmpOutColor *= 0.25; + + // TIPS (old-skool strikes again!) + // Pay attention here! If you use the "out float4 outColor" directly + // in your steps while creating the output color (like you remove + // the "tmpOutColor" var and just use the "outColor" directly) + // your pixel-color output IS CHANGING EACH TIME YOU DO AN ASSIGNMENT TOO! + // A temporary variable, instead, acts like a per-pixel double buffer, and + // best of all, lead to better performance. + outColor = tmpOutColor; +} \ No newline at end of file diff --git a/res/dist/media/materials/programs/Instancing.frag b/res/dist/media/materials/programs/Instancing.frag new file mode 100644 index 00000000000..cf064dacffa --- /dev/null +++ b/res/dist/media/materials/programs/Instancing.frag @@ -0,0 +1,66 @@ +//--------------------------------------------------------------------------- +//These materials/shaders are part of the NEW InstanceManager implementation +//Written by Matias N. Goldberg ("dark_sylinc") +//--------------------------------------------------------------------------- + +uniform sampler2D diffuseMap; + +uniform vec4 lightPosition; +uniform vec3 cameraPosition; +uniform vec3 lightAmbient; +uniform vec3 lightDiffuse; +uniform vec3 lightSpecular; +uniform vec4 lightAttenuation; +uniform float lightGloss; + +#if DEPTH_SHADOWRECEIVER +uniform float invShadowMapSize; +uniform sampler2DShadow shadowMap; + +//declare external function +//vec4 calcDepthShadow(in vec4 inColour, in float lum); +float calcDepthShadow(sampler2DShadow shadowMap, vec4 uv, float invShadowMapSize); +#endif + +varying vec2 _uv0; +varying vec3 oNormal; +varying vec3 oVPos; +#if DEPTH_SHADOWRECEIVER + varying vec4 oLightSpacePos; +#endif + +//--------------------------------------------- +//Main Pixel Shader +//--------------------------------------------- +void main(void) +{ + vec4 color = texture2D( diffuseMap, _uv0 ); + + float fShadow = 1.0; +#if DEPTH_SHADOWRECEIVER + fShadow = calcDepthShadow( shadowMap, oLightSpacePos, invShadowMapSize ); +#endif + + vec4 baseColour = texture2D( diffuseMap, _uv0 ); + + //Blinn-Phong lighting + vec3 normal = normalize( oNormal ); + vec3 lightDir = lightPosition.xyz - oVPos * lightPosition.w; + vec3 eyeDir = normalize( cameraPosition - oVPos ); + + float fLength = length( lightDir ); + lightDir = normalize( lightDir ); + + float NdotL = max( 0.0, dot( normal, lightDir ) ); + vec3 halfVector = normalize(lightDir + eyeDir); + float HdotN = max( 0.0, dot( halfVector, normal ) ); + + vec3 ambient = lightAmbient * baseColour.xyz; + vec3 diffuse = lightDiffuse * NdotL * baseColour.xyz; + vec3 specular = lightSpecular * pow( HdotN, lightGloss ); + + vec3 directLighting = (diffuse + specular) * fShadow; + + gl_FragColor = vec4( directLighting + ambient, baseColour.a ); + //gl_FragColor = baseColour; +} diff --git a/res/dist/media/materials/programs/Instancing.program b/res/dist/media/materials/programs/Instancing.program new file mode 100644 index 00000000000..5adbbb61246 --- /dev/null +++ b/res/dist/media/materials/programs/Instancing.program @@ -0,0 +1,84 @@ +//--------------------------------------------------------------------------- +//These materials/shaders are part of the NEW InstanceManager implementation +//Written by Matias N. Goldberg ("dark_sylinc") +//--------------------------------------------------------------------------- + +//-------------------------------------------------------------- +// GLSL Programs +//-------------------------------------------------------------- +fragment_program Ogre/Shadow/Utils glsl +{ + source shadows.glsl +} + +fragment_program Ogre/Instancing_glsl_ps glsl +{ + source Instancing.frag + attach Ogre/Shadow/Utils + + preprocessor_defines DEPTH_SHADOWRECEIVER=1 + + default_params + { + param_named diffuseMap int 0 + param_named shadowMap int 1 + } +} + +fragment_program Ogre/Instancing/shadow_caster_glsl_ps glsl +{ + source DepthShadowmapCasterFp.glsl + + preprocessor_defines LINEAR_RANGE=1 +} + +//-------------------------------------------------------------- +// CG Programs +//-------------------------------------------------------------- +fragment_program Ogre/Instancing_cg_ps cg +{ + source Instancing_ps.cg + entry_point main_ps + profiles ps_3_0 ps_2_x fp40 + + compile_arguments -DDEPTH_SHADOWRECEIVER +} + +fragment_program Ogre/Instancing/shadow_caster_cg_ps cg +{ + source depthshadowobject.cg + profiles ps_3_0 ps_2_x fp40 + entry_point main_fp + compile_arguments -DSHADOWCASTER=1 -DDEPTH_SHADOWCASTER=1 -DDEPTH_SHADOWRECEIVER=0 + + default_params + { + } +} + +//-------------------------------------------------------------- +// Unified CG/GLSL Programs +//-------------------------------------------------------------- +fragment_program Ogre/Instancing_ps unified +{ + delegate Ogre/Instancing_glsl_ps + delegate Ogre/Instancing_cg_ps + + default_params + { + param_named_auto lightPosition light_position 0 + param_named_auto cameraPosition camera_position 0 + param_named_auto lightAmbient ambient_light_colour + param_named_auto lightDiffuse light_diffuse_colour 0 + param_named_auto lightSpecular light_specular_colour 0 + param_named_auto lightGloss surface_shininess + + param_named_auto invShadowMapSize inverse_texture_size 1 + } +} + +fragment_program Ogre/Instancing/shadow_caster_ps unified +{ + delegate Ogre/Instancing/shadow_caster_glsl_ps + delegate Ogre/Instancing/shadow_caster_cg_ps +} diff --git a/res/dist/media/materials/programs/InstancingMisc.cg b/res/dist/media/materials/programs/InstancingMisc.cg new file mode 100644 index 00000000000..f586aa72940 --- /dev/null +++ b/res/dist/media/materials/programs/InstancingMisc.cg @@ -0,0 +1,63 @@ +//--------------------------------------------------------------------------- +//These materials/shaders are part of the NEW InstanceManager implementation +//Written by Matias N. Goldberg ("dark_sylinc") +//--------------------------------------------------------------------------- + +//This shader is not instancing related, but is used in the Instancing tests for lighting +//consistency (i.e. the ground) + +//--------------------------------------------- +//Vertex Shader Input +//--------------------------------------------- +struct VS_INPUT +{ + float4 Position : POSITION; + float3 Normal : NORMAL; + float2 uv0 : TEXCOORD0; +}; + +#include "InstancingVertexInterpolators.cg" + +//--------------------------------------------- +//Main Vertex Shader +//--------------------------------------------- +VS_OUTPUT main_vs( in VS_INPUT input, + uniform float4x4 viewProjMatrix, + uniform float4x4 worldMatrix + +#if defined( DEPTH_SHADOWCASTER ) || defined( DEPTH_SHADOWRECEIVER ) + , uniform float4 depthRange +#endif +#ifdef DEPTH_SHADOWRECEIVER + , uniform float4x4 texViewProjMatrix +#endif + ) +{ + VS_OUTPUT output; + + float4 worldPos = mul( worldMatrix, input.Position ); + float3 worldNorm = mul( (float3x3)(worldMatrix), input.Normal ); + + //Transform the position + output.Position = mul( viewProjMatrix, worldPos ); + +#ifdef DEPTH_SHADOWCASTER + output.ps.unused = float3( 0 ); + output.ps.depth = (output.Position.z - depthRange.x + SHADOW_BIAS) * depthRange.w; +#else + output.ps.uv0 = input.uv0; + + //Pass Normal and position for Blinn Phong lighting + output.ps.Normal = worldNorm; + output.ps.vPos = worldPos.xyz; + + #ifdef DEPTH_SHADOWRECEIVER + // Calculate the position of vertex in light space to do shadows + output.ps.lightSpacePos = mul( texViewProjMatrix, worldPos ); + // make linear + output.ps.lightSpacePos.z = (output.ps.lightSpacePos.z - depthRange.x) * depthRange.w; + #endif +#endif + + return output; +} diff --git a/res/dist/media/materials/programs/InstancingMisc.vert b/res/dist/media/materials/programs/InstancingMisc.vert new file mode 100644 index 00000000000..f79ee37f3cc --- /dev/null +++ b/res/dist/media/materials/programs/InstancingMisc.vert @@ -0,0 +1,62 @@ +//--------------------------------------------------------------------------- +//These materials/shaders are part of the NEW InstanceManager implementation +//Written by Matias N. Goldberg ("dark_sylinc") +//--------------------------------------------------------------------------- +#version 120 + +//Vertex input +attribute vec4 vertex; +attribute vec3 normal; +attribute vec3 tangent; +attribute vec4 uv0; +attribute vec4 blendIndices; +attribute vec4 blendWeights; + +//Parameters +uniform mat4 viewProjMatrix; +uniform mat4 worldMatrix; + +#if (DEPTH_SHADOWCASTER || DEPTH_SHADOWRECEIVER) +uniform vec4 depthRange; +#endif + +#if DEPTH_SHADOWRECEIVER +uniform mat4 texViewProjMatrix; +#endif + +//Output +#if DEPTH_SHADOWCASTER + varying vec2 depth; +#else + varying vec2 _uv0; + varying vec3 oNormal; + varying vec3 oVPos; + #if DEPTH_SHADOWRECEIVER + varying vec4 oLightSpacePos; + #endif +#endif +//--------------------------------------------- +//Main Vertex Shader +//--------------------------------------------- +void main(void) +{ + vec4 worldPos = vertex * worldMatrix; + vec3 worldNorm = normal * mat3(worldMatrix); + + //Transform the position + gl_Position = viewProjMatrix * worldPos; + +#if DEPTH_SHADOWCASTER + depth.x = (gl_Position.z - depthRange.x) * depthRange.w; + depth.y = depthRange.w; +#else + _uv0 = uv0.xy; + oNormal = worldNorm; + oVPos = worldPos.xyz; + + #if DEPTH_SHADOWRECEIVER + oLightSpacePos = texViewProjMatrix * worldPos; + oLightSpacePos.z = (oLightSpacePos.z - depthRange.x) * depthRange.w; + #endif +#endif +} diff --git a/res/dist/media/materials/programs/InstancingVertexInterpolators.cg b/res/dist/media/materials/programs/InstancingVertexInterpolators.cg new file mode 100644 index 00000000000..45cfd6c9091 --- /dev/null +++ b/res/dist/media/materials/programs/InstancingVertexInterpolators.cg @@ -0,0 +1,34 @@ +//--------------------------------------------------------------------------- +//These materials/shaders are part of the NEW InstanceManager implementation +//Written by Matias N. Goldberg ("dark_sylinc") +//--------------------------------------------------------------------------- + +//--------------------------------------------- +//Pixel Shader Input +//--------------------------------------------- +struct PS_INPUT +{ +#ifdef DEPTH_SHADOWCASTER + float3 unused : TEXCOORD0; + float depth : TEXCOORD1; +#else + float2 uv0 : TEXCOORD0; + float3 Normal : TEXCOORD1; + float3 vPos : TEXCOORD2; + + #ifdef DEPTH_SHADOWRECEIVER + float4 lightSpacePos : TEXCOORD3; + #endif +#endif +}; + +#define SHADOW_BIAS 0 + +//--------------------------------------------- +//Vertex Shader Output +//--------------------------------------------- +struct VS_OUTPUT +{ + float4 Position : POSITION; + PS_INPUT ps; +}; diff --git a/res/dist/media/materials/programs/Instancing_ps.cg b/res/dist/media/materials/programs/Instancing_ps.cg new file mode 100644 index 00000000000..00d80ff9642 --- /dev/null +++ b/res/dist/media/materials/programs/Instancing_ps.cg @@ -0,0 +1,57 @@ +//--------------------------------------------------------------------------- +//These materials/shaders are part of the NEW InstanceManager implementation +//Written by Matias N. Goldberg ("dark_sylinc") +//--------------------------------------------------------------------------- + +#include "InstancingVertexInterpolators.cg" + +#include "shadows.cg" + +//--------------------------------------------- +//Main Pixel Shader +//--------------------------------------------- +half4 main_ps( PS_INPUT input , + uniform float4 lightPosition, + uniform float3 cameraPosition, + uniform half3 lightAmbient, + uniform half3 lightDiffuse, + uniform half3 lightSpecular, + uniform half4 lightAttenuation, + uniform half lightGloss, + + //Textures + uniform sampler2D diffuseMap : register(s0) + +#ifdef DEPTH_SHADOWRECEIVER + , uniform float invShadowMapSize, + uniform sampler2D shadowMap : register(s1) +#endif + ) : COLOR0 +{ + float fShadow = 1.0f; +#ifdef DEPTH_SHADOWRECEIVER + fShadow = calcDepthShadow( shadowMap, input.lightSpacePos, invShadowMapSize ); +#endif + + const half4 baseColour = tex2D( diffuseMap, input.uv0 ); + + //Blinn-Phong lighting + const half3 normal = normalize( input.Normal ); + half3 lightDir = lightPosition.xyz - input.vPos * lightPosition.w; + half3 eyeDir = normalize( cameraPosition - input.vPos ); + + const half fLength = length( lightDir ); + lightDir = normalize( lightDir ); + + const half NdotL = max( 0.0f, dot( normal, lightDir ) ); + half3 halfVector = normalize(lightDir + eyeDir); + const half HdotN = max( 0.0f, dot( halfVector, normal ) ); + + const half3 ambient = lightAmbient * baseColour.xyz; + const half3 diffuse = lightDiffuse * NdotL * baseColour.xyz; + const half3 specular = lightSpecular * pow( HdotN, lightGloss ); + + const half3 directLighting = (diffuse + specular) * fShadow; + + return half4( directLighting + ambient, baseColour.a ); +} diff --git a/res/dist/media/materials/programs/InvertFP.cg b/res/dist/media/materials/programs/InvertFP.cg new file mode 100644 index 00000000000..4e34426871d --- /dev/null +++ b/res/dist/media/materials/programs/InvertFP.cg @@ -0,0 +1,6 @@ +sampler2D RT : register(s0); + +float4 Invert_ps (float4 pos : POSITION, float2 iTexCoord : TEXCOORD0) : COLOR +{ + return 1 - tex2D(RT, iTexCoord); +} diff --git a/res/dist/media/materials/programs/InvertFP.glsles b/res/dist/media/materials/programs/InvertFP.glsles new file mode 100644 index 00000000000..86c5d72cf78 --- /dev/null +++ b/res/dist/media/materials/programs/InvertFP.glsles @@ -0,0 +1,13 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform sampler2D RT; +varying vec2 uv0; +varying vec2 uv1; + +void main() +{ + gl_FragColor = 1.0 - texture2D(RT, uv0); +} diff --git a/res/dist/media/materials/programs/LaplaceFP.cg b/res/dist/media/materials/programs/LaplaceFP.cg new file mode 100644 index 00000000000..f96b5008ddf --- /dev/null +++ b/res/dist/media/materials/programs/LaplaceFP.cg @@ -0,0 +1,37 @@ +sampler2D Image : register(s0); + +// The Laplace filter approximates the second order derivate, +// that is, the rate of change of slope in the image. It can be +// used for edge detection. The Laplace filter gives negative +// response on the higher side of the edge and positive response +// on the lower side. + +// This is the filter kernel: +// 0 1 0 +// 1 -4 1 +// 0 1 0 + + + +float4 Laplace_ps ( float4 pos : POSITION, + float2 texCoord: TEXCOORD0, + uniform float scale, + uniform float pixelSize) : COLOR +{ + + float2 samples[4] = { + 0, -1, + -1, 0, + 1, 0, + 0, 1 + }; + float4 laplace = -4 * tex2D(Image, texCoord); + + // Sample the neighbor pixels + for (int i = 0; i < 4; i++){ + laplace += tex2D(Image, texCoord + pixelSize * samples[i]); + } + + return (0.5 + scale * laplace); +} + diff --git a/res/dist/media/materials/programs/LaplaceFP.glsles b/res/dist/media/materials/programs/LaplaceFP.glsles new file mode 100644 index 00000000000..0c4104c59e6 --- /dev/null +++ b/res/dist/media/materials/programs/LaplaceFP.glsles @@ -0,0 +1,40 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform sampler2D Image; +uniform float scale; +uniform float pixelSize; +varying vec2 uv0; + +// The Laplace filter approximates the second order derivate, +// that is, the rate of change of slope in the image. It can be +// used for edge detection. The Laplace filter gives negative +// response on the higher side of the edge and positive response +// on the lower side. + +// This is the filter kernel: +// 0 1 0 +// 1 -4 1 +// 0 1 0 + +void main() +{ + vec2 samples[4]; + samples[0] = vec2(0, -1); + samples[1] = vec2(-1, 0); + samples[2] = vec2(1, 0); + samples[3] = vec2(0, 1); + + mediump vec4 tc = texture2D(Image, uv0); + vec4 laplace = -4.0 * tc; + + // Sample the neighbor pixels + for (int i = 0; i < 4; i++){ + laplace += texture2D(Image, uv0 + pixelSize * samples[i]); + } + + gl_FragColor = (0.5 + scale * laplace); +} + diff --git a/res/dist/media/materials/programs/LightToHeatFp.glsles b/res/dist/media/materials/programs/LightToHeatFp.glsles new file mode 100644 index 00000000000..4fe7e5554c7 --- /dev/null +++ b/res/dist/media/materials/programs/LightToHeatFp.glsles @@ -0,0 +1,39 @@ +#version 100 + +precision mediump int; +precision mediump float; + +uniform vec4 random_fractions; +uniform vec4 heatBiasScale; +uniform vec4 depth_modulator; + +uniform sampler2D Input; // output of HeatVisionCaster_fp (NdotV) +uniform sampler2D NoiseMap; +uniform sampler2D HeatLookup; + +varying vec4 diffuse; +varying vec2 uv; + +void main() +{ + float depth, heat, interference; + + // Output constant color: + depth = texture2D( Input, uv ).x; + depth *= (depth * depth_modulator).x; + + heat = (depth * heatBiasScale.y); + +// if (depth > 0) + { + interference = -0.5 + texture2D( NoiseMap, uv + vec2( random_fractions.x, random_fractions.y ) ).x; + interference *= interference; + interference *= 1.0 - heat; + heat += interference;//+ heatBiasScale.x; + } + + // Clamp UVs + heat = max( 0.005, min( 0.995, heat ) ); + gl_FragColor = texture2D( HeatLookup, vec2( heat, 0.0 ) ); +} + diff --git a/res/dist/media/materials/programs/LightToHeatVp.glsles b/res/dist/media/materials/programs/LightToHeatVp.glsles new file mode 100644 index 00000000000..a32020ef78f --- /dev/null +++ b/res/dist/media/materials/programs/LightToHeatVp.glsles @@ -0,0 +1,17 @@ +#version 100 + +precision mediump int; +precision mediump float; + + +attribute vec4 position; +uniform float flipping; +varying vec2 uv; + +void main() +{ + vec4 inPos = position; + gl_Position = vec4(inPos.x, flipping * inPos.y, 0.0, 1.0); + inPos.xy = sign(inPos.xy); + uv = (vec2(inPos.x, -inPos.y) + 1.0)/2.0; +} diff --git a/res/dist/media/materials/programs/NightVisionFP.cg b/res/dist/media/materials/programs/NightVisionFP.cg new file mode 100644 index 00000000000..5bbd831835b --- /dev/null +++ b/res/dist/media/materials/programs/NightVisionFP.cg @@ -0,0 +1,27 @@ +sampler2D RT : register(s0); +sampler3D noiseVol : register(s1); + +float4 NightVision_ps( float4 pos : POSITION, + float2 TexCoord : TEXCOORD0, + uniform float4 lum, + uniform float time) : COLOR +{ + float4 oC; + oC = tex2D(RT, TexCoord); + + //obtain luminence value + oC = dot(oC,lum); + + //add some random noise + oC += 0.2 *(tex3D(noiseVol, float3(TexCoord*5,time)))- 0.05; + + //add lens circle effect + //(could be optimised by using texture) + float dist = distance(TexCoord, float2(0.5,0.5)); + oC *= smoothstep(0.5,0.45,dist); + + //add rb to the brightest pixels + oC.rb = max (oC.r - 0.75, 0)*4; + + return oC ; +} \ No newline at end of file diff --git a/res/dist/media/materials/programs/NightVisionFP.glsles b/res/dist/media/materials/programs/NightVisionFP.glsles new file mode 100644 index 00000000000..33252974e1b --- /dev/null +++ b/res/dist/media/materials/programs/NightVisionFP.glsles @@ -0,0 +1,26 @@ +sampler RT : register(s0); +sampler noiseVol : register(s1); + +float4 NightVision_ps( float2 TexCoord : TEXCOORD0, + uniform float4 lum, + uniform float time) : COLOR +{ + float4 oC; + oC = tex2D(RT, TexCoord); + + //obtain luminence value + oC = dot(oC,lum); + + //add some random noise + oC += 0.2 *(tex3D(noiseVol, float3(TexCoord*5,time)))- 0.05; + + //add lens circle effect + //(could be optimised by using texture) + float dist = distance(TexCoord, float2(0.5,0.5)); + oC *= smoothstep(0.5,0.45,dist); + + //add rb to the brightest pixels + oC.rb = max (oC.r - 0.75, 0)*4; + + return oC ; +} \ No newline at end of file diff --git a/res/dist/media/materials/programs/Ocean2GLSL.frag b/res/dist/media/materials/programs/Ocean2GLSL.frag new file mode 100644 index 00000000000..024b68eb37e --- /dev/null +++ b/res/dist/media/materials/programs/Ocean2GLSL.frag @@ -0,0 +1,71 @@ +/*********************************************************************NVMH3**** +Copyright NVIDIA Corporation 2003 +TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED +*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS +BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES +WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, +BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS) +ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS +BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + + +Comments: + Simple ocean shader with animated bump map and geometric waves + Based partly on "Effective Water Simulation From Physical Models", GPU Gems + +11 Aug 05: converted from HLSL to GLSL by Jeff Doyle (nfz) to work in Ogre + +******************************************************************************/ + + +uniform sampler2D NormalMap; +uniform samplerCube EnvironmentMap; +uniform vec4 deepColor; +uniform vec4 shallowColor; +uniform vec4 reflectionColor; +uniform float reflectionAmount; +uniform float reflectionBlur; +uniform float waterAmount; +uniform float fresnelPower; +uniform float fresnelBias; +uniform float hdrMultiplier; + +varying mat3 rotMatrix; // first row of the 3x3 transform from tangent to cube space +varying vec2 bumpCoord0; +varying vec2 bumpCoord1; +varying vec2 bumpCoord2; +varying vec3 eyeVector; + + +void main(void) +{ + // sum normal maps + // sample from 3 different points so no texture repetition is noticeable + vec4 t0 = texture2D(NormalMap, bumpCoord0) * 2.0 - 1.0; + vec4 t1 = texture2D(NormalMap, bumpCoord1) * 2.0 - 1.0; + vec4 t2 = texture2D(NormalMap, bumpCoord2) * 2.0 - 1.0; + vec3 N = t0.xyz + t1.xyz + t2.xyz; + + N = normalize(rotMatrix * N); + + // reflection + vec3 E = normalize(eyeVector); + vec3 R = reflect(E, N); + // Ogre conversion for cube map lookup + R.z = -R.z; + + vec4 reflection = textureCube(EnvironmentMap, R, reflectionBlur); + // cheap hdr effect + reflection.rgb *= (reflection.r + reflection.g + reflection.b) * hdrMultiplier; + + // fresnel + float facing = 1.0 - dot(-E, N); + float fresnel = clamp(fresnelBias + pow(facing, fresnelPower), 0.0, 1.0); + + vec4 waterColor = mix(shallowColor, deepColor, facing) * waterAmount; + + reflection = mix(waterColor, reflection * reflectionColor, fresnel) * reflectionAmount; + gl_FragColor = waterColor + reflection; +} diff --git a/res/dist/media/materials/programs/Ocean2GLSL.vert b/res/dist/media/materials/programs/Ocean2GLSL.vert new file mode 100644 index 00000000000..89a4cc76a04 --- /dev/null +++ b/res/dist/media/materials/programs/Ocean2GLSL.vert @@ -0,0 +1,91 @@ +/*********************************************************************NVMH3**** +Copyright NVIDIA Corporation 2003 +TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED +*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY +AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS +BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES +WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS, +BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY LOSS) +ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF NVIDIA HAS +BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. + + +Comments: + Simple ocean shader with animated bump map and geometric waves + Based partly on "Effective Water Simulation From Physical Models", GPU Gems + +11 Aug 05: converted from HLSL to GLSL by Jeff Doyle (nfz) to work in Ogre + +******************************************************************************/ + +uniform vec3 eyePosition; +uniform float BumpScale; +uniform vec2 textureScale; +uniform vec2 bumpSpeed; +uniform float time; +uniform float waveFreq; +uniform float waveAmp; + +varying mat3 rotMatrix; // transform from tangent to obj space +varying vec2 bumpCoord0; +varying vec2 bumpCoord1; +varying vec2 bumpCoord2; +varying vec3 eyeVector; + +// wave functions +struct Wave { + float freq; // 2*PI / wavelength + float amp; // amplitude + float phase; // speed * 2*PI / wavelength + vec2 dir; +}; + + +void main(void) +{ + + #define NWAVES 2 + + Wave wave[NWAVES]; + + wave[0] = Wave( waveFreq, waveAmp, 0.5, vec2(-1, 0) ); + wave[1] = Wave( 3.0 * waveFreq, 0.33 * waveAmp, 1.7, vec2(-0.7, 0.7) ); + + + vec4 P = gl_Vertex; + + // sum waves + float ddx = 0.0, ddy = 0.0; + float deriv; + float angle; + + // wave synthesis using two sine waves at different frequencies and phase shift + for(int i = 0; i