splash-damage/etqw-sdk
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
etqw-sdk/base/renderprogs/water.rprog

1253 lines
34 KiB
Text
Raw Normal View History

as released 2008-05-29
2008-05-29 00:00:00 +00:00
renderBinding water_tint { vector { 1 } }
renderBinding water_distortion { vector { 1 } }
renderBinding water_fresnel { vector { 1 } }
renderBinding water_glare { vector { 1 } }
renderBinding water_offset { vector { 1 } } // how many pixels to offset the refraction (only use for special hacks like the sniper rifle scope)
renderBinding water_desat { vector { 1 } }
/*
A static surface with cubemap reflections
*/
renderProgram water/simple_cube {
program vertex arb { <%
OPTION ARB_position_invariant;
TEMP R0, R1, R2, bitangent;
XPD bitangent, $normalAttrib, $tangentAttrib;
MUL bitangent, bitangent, $tangentAttrib.w;
# bumpmap texture coords
DP4 result.texcoord[0].x, $texCoordAttrib, $diffuseMatrix_s;
DP4 result.texcoord[0].y, $texCoordAttrib, $diffuseMatrix_t;
# vector to eye
SUB R1, $positionAttrib, $viewOrigin;
$if ( r_shaderQuality > 1 )
DP3 R0.x, R1, $transposedModelMatrix_x;
DP3 R0.y, R1, $transposedModelMatrix_y;
DP3 R0.z, R1, $transposedModelMatrix_z;
DP3 R0.w, R0, R0;
RSQ R0.w, R0.w;
MUL result.texcoord[2].xyz, R0, R0.w;
$else
DP3 result.texcoord[2].x, R1, $transposedModelMatrix_x;
DP3 result.texcoord[2].y, R1, $transposedModelMatrix_y;
DP3 result.texcoord[2].z, R1, $transposedModelMatrix_z;
$endif
DP3 R1.w, R1, R1;
RSQ R0.w, R1.w;
MUL result.texcoord[2].w, R0.w, R1.w;
# tangent->world matrix
DP3 result.texcoord[3].x, $tangentAttrib, $transposedModelMatrix_x;
DP3 result.texcoord[3].y, bitangent, $transposedModelMatrix_x;
DP3 result.texcoord[3].z, $normalAttrib, $transposedModelMatrix_x;
DP3 result.texcoord[4].x, $tangentAttrib, $transposedModelMatrix_y;
DP3 result.texcoord[4].y, bitangent, $transposedModelMatrix_y;
DP3 result.texcoord[4].z, $normalAttrib, $transposedModelMatrix_y;
DP3 result.texcoord[5].x, $tangentAttrib, $transposedModelMatrix_z;
DP3 result.texcoord[5].y, bitangent, $transposedModelMatrix_z;
DP3 result.texcoord[5].z, $normalAttrib, $transposedModelMatrix_z;
MOV result.color, $colorAttrib;
# this doesn't even change per vertex so don't bother to calculate it per pixel
# texture 1 takes the deform magnitude and scales it by the projection distance
PARAM vec = { 1, 0, 0, 1 };
MOV R0, vec;
DP4 R0.z, $positionAttrib, state.matrix.modelview.row[2];
DP4 R1, R0, state.matrix.projection.row[0];
DP4 R2, R0, state.matrix.projection.row[3];
# don't let the recip get near zero for polygons that cross the view plane
MAX R2, R2, 1;
RCP R2, R2.w;
MUL R1, R1, R2;
# clamp the distance so the the deformations don't get too wacky near the view
MIN R1, R1, 0.02;
MUL R1, R1, $water_distortion;
MUL result.texcoord[1], R1, $currentRenderTexelSize;
$if ( r_megaDrawMethod != 0 )
TEMP _F1, _F2;
SUB _F2, $positionAttrib, $viewOrigin;
DP3 _F1.x, _F2, _F2;
RSQ _F1.y, _F1.x;
MUL _F1.x, _F1.y, _F1.x;
MAD result.color.secondary, _F1.x, $fogDepths.z, $fogDepths.w;
$endif
%> }
program fragment arb { <%
OPTION ARB_precision_hint_fastest;
TEMP R0, R1, R2, R3, R4, eye, mix, spec;
# get normal from normal map
TEX R0, fragment.texcoord[0], $bumpMap, 2D;
$if !r_dxnNormalMaps
MOV R0.x, R0.a;
$endif
MAD R2, R0, 2, -1;
MUL R2.xy, R2, $water_distortion.z;
$if r_normalizeNormalMaps
TEMP NR1;
MOV R2.z, 0;
DP3 NR1.x, R2,R2;
ADD NR1.x, 1, -NR1.x;
RSQ NR1.x, NR1.x;
RCP R2.z, NR1.x;
$endif
# put in world space
DP3 R1.x, R2, fragment.texcoord[3];
DP3 R1.y, R2, fragment.texcoord[4];
DP3 R1.z, R2, fragment.texcoord[5];
#MAD result.color, R1, 0.5, 0.5;
# warped texcoords ( normalmap * scale ) + fragpos
MAD R3, R1, fragment.texcoord[1], fragment.position;
ADD R3, $water_offset, R3;
# normalize to eye
DP3 eye.w, fragment.texcoord[2], fragment.texcoord[2];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[2], eye.w;
#MAD result.color, eye, 0.5, 0.5;
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, R1;
MUL R2, R2, 2;
MAD R4, -R1, R2.x, eye;
#spec
$if ( r_shaderQuality < 1 )
DP3_SAT R0, R4, $sunDirection;
TEX spec, R0, $map, 2D;
MUL spec, spec, $sunColor;
MUL spec, spec, $water_glare;
$endif
# reflect refract mixing (sorta fresnel)
DP3 R1, -eye, R1;
ADD R1, R1, 1;
POW R1, R1.x, $water_fresnel.x;
RCP_SAT mix, R1.x;
# lookup textures and interpolate
TEX R1, R3, $currentRender, RECT;
MUL R1, R1, $water_tint; #modulate with water color
TEX R2, R4, $environmentCubeMap, CUBE;
LRP R2, $water_desat, 0.5, R2;
SUB R3, R2, R1;
MAD R3, R3, mix, R1;
$if ( r_shaderQuality < 1 )
ADD result.color, R3, spec;
$else
MOV result.color, R3;
$endif
ADD result.color.a, spec.r, spec.g;
%> }
}
renderProgram water/simple_cube_fallback {
program vertex reference water/simple_cube
program fragment arb { <%
OPTION ARB_precision_hint_fastest;
TEMP R0, R1, R2, R3, R4, eye, mix, spec;
# get normal from normal map
TEX R0, fragment.texcoord[0], $bumpMap, 2D;
$if !r_dxnNormalMaps
MOV R0.x, R0.a;
$endif
MAD R2, R0, 2, -1;
MUL R2.xy, R2, $water_distortion.z;
$if r_normalizeNormalMaps
TEMP NR1;
MOV R2.z, 0;
DP3 NR1.x, R2,R2;
ADD NR1.x, 1, -NR1.x;
RSQ NR1.x, NR1.x;
RCP R2.z, NR1.x;
$endif
# put in world space
DP3 R1.x, R2, fragment.texcoord[3];
DP3 R1.y, R2, fragment.texcoord[4];
DP3 R1.z, R2, fragment.texcoord[5];
# warped texcoords ( normalmap * scale ) + fragpos
MAD R3, R1, fragment.texcoord[1], fragment.position;
ADD R3, $water_offset, R3;
# normalize to eye
DP3 eye.w, fragment.texcoord[2], fragment.texcoord[2];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[2], eye.w;
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, R1;
MUL R2, R2, 2;
MAD R4, -R1, R2.x, eye;
# reflect refract mixing (sorta fresnel)
DP3 R1, -eye, R1;
ADD R1, R1, 1;
POW R1, R1.x, $water_fresnel.x;
RCP_SAT mix, R1.x;
# lookup textures and interpolate
TEX R2, R4, $environmentCubeMap, CUBE;
LRP R3, $water_desat, 0.5, R2;
MOV result.color, R3;
MOV result.color.a, 0.3;
%> }
}
//Exactly like the normal simple_cube but the diffuseMap alpha channel is used as an mask image..
renderProgram water/simple_cube_mask {
program vertex reference water/simple_cube
program fragment arb { <%
OPTION ARB_precision_hint_fastest;
TEMP R0, R1, R2, R3, R4, eye, mix, spec;
# get mask
TEX R1, fragment.texcoord[0], $diffuseMap, 2D;
SUB R1.a, R1.a, 0.2;
KIL R1.a;
#MOV result.color, R1.a;
# get normal from normal map
TEX R0, fragment.texcoord[0], $bumpMap, 2D;
$if !r_dxnNormalMaps
MOV R0.x, R0.a;
$endif
MAD R2, R0, 2, -1;
MUL R2.xy, R2, $water_distortion.z;
$if r_normalizeNormalMaps
TEMP NR1;
MOV R2.z, 0;
DP3 NR1.x, R2,R2;
ADD NR1.x, 1, -NR1.x;
RSQ NR1.x, NR1.x;
RCP R2.z, NR1.x;
$endif
# put in world space
DP3 R1.x, R2, fragment.texcoord[3];
DP3 R1.y, R2, fragment.texcoord[4];
DP3 R1.z, R2, fragment.texcoord[5];
#MAD result.color, R1, 0.5, 0.5;
# warped texcoords ( normalmap * scale ) + fragpos
MAD R3, R1, fragment.texcoord[1], fragment.position;
ADD R3, $water_offset, R3;
# normalize to eye
DP3 eye.w, fragment.texcoord[2], fragment.texcoord[2];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[2], eye.w;
#MAD result.color, eye, 0.5, 0.5;
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, R1;
MUL R2, R2, 2;
MAD R4, -R1, R2.x, eye;
#spec
$if ( r_shaderQuality < 1 )
DP3_SAT R0, R4, $sunDirection;
TEX spec, R0, $map, 2D;
MUL spec, spec, $sunColor;
MUL spec, spec, $water_glare;
$endif
# reflect refract mixing (sorta fresnel)
DP3 R1, -eye, R1;
ADD R1, R1, 1;
POW R1, R1.x, $water_fresnel.x;
RCP_SAT mix, R1.x;
# lookup textures and interpolate
TEX R1, R3, $currentRender, RECT;
MUL R1, R1, $water_tint; #modulate with water color
TEX R2, R4, $environmentCubeMap, CUBE;
LRP R2, $water_desat, 0.5, R2;
SUB R3, R2, R1;
MAD R3, R3, mix, R1;
$if ( r_shaderQuality < 1 )
ADD result.color, R3, spec;
$else
MOV result.color, R3;
$endif
ADD result.color.a, spec.r, spec.g;
%> }
}
renderProgram water/simple_cube_alpha {
program vertex reference water/simple_cube
program fragment arb { <%
OPTION ARB_precision_hint_fastest;
TEMP R0, R1, R2, R3, R4, eye, mix, spec;
# get mask
TEMP diffuse;
TEX diffuse, fragment.texcoord[0], $diffuseMap, 2D;
SUB R1.a, diffuse.a, 0.0002;
KIL R1.a;
#MOV result.color, R1.a;
# get normal from normal map
TEX R0, fragment.texcoord[0], $bumpMap, 2D;
$if !r_dxnNormalMaps
MOV R0.x, R0.a;
$endif
MAD R2, R0, 2, -1;
MUL R2.xy, R2, $water_distortion.z;
$if r_normalizeNormalMaps
TEMP NR1;
MOV R2.z, 0;
DP3 NR1.x, R2,R2;
ADD NR1.x, 1, -NR1.x;
RSQ NR1.x, NR1.x;
RCP R2.z, NR1.x;
$endif
# put in world space
DP3 R1.x, R2, fragment.texcoord[3];
DP3 R1.y, R2, fragment.texcoord[4];
DP3 R1.z, R2, fragment.texcoord[5];
# warped texcoords ( normalmap * scale ) + fragpos
MAD R3, R1, fragment.texcoord[1], fragment.position;
ADD R3, $water_offset, R3;
# normalize to eye
DP3 eye.w, fragment.texcoord[2], fragment.texcoord[2];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[2], eye.w;
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, R1;
MUL R2, R2, 2;
MAD R4, -R1, R2.x, eye;
#spec
$if ( r_shaderQuality < 1 )
DP3_SAT R0, R4, $sunDirection;
TEX spec, R0, $map, 2D;
MUL spec, spec, $sunColor;
MUL spec, spec, $water_glare;
$endif
# reflect refract mixing (sorta fresnel)
DP3 R1, -eye, R1;
MAX R1, R1, -R1;
ADD R1, R1, 1;
POW R1, R1.x, $water_fresnel.x;
RCP_SAT mix, R1.x;
TEMP baseimg;
TEX baseimg, fragment.position, $currentRender, RECT;
# lookup textures and interpolate
TEX R1, R3, $currentRender, RECT;
MUL R1, R1, $water_tint; #modulate with water color
TEX R2, R4, $environmentCubeMap, CUBE;
LRP R2, $water_desat, 0.5, R2;
SUB R3, R2, R1;
MAD R3, R3, mix, R1;
TEMP out;
$if ( r_shaderQuality < 1 )
ADD out, R3, spec;
$else
MOV out, R3;
$endif
ADD result.color.a, spec.r, spec.g;
MUL_SAT diffuse.a, diffuse.a, 3;
LRP result.color.rgb, diffuse.a, out, baseimg;
%> }
}
renderProgram water/wake_cube {
program vertex reference water/simple_cube
program fragment arb { <%
OPTION ARB_precision_hint_fastest;
TEMP R0, R1, R2, R3, R4, eye, mix, spec, mask;
# get normal from normal map
TEX R0, fragment.texcoord[0], $bumpMap, 2D;
$if !r_dxnNormalMaps
MOV R0.x, R0.a;
$endif
MAD R2, R0, 2, -1;
MUL R2.xy, R2, $water_distortion.z;
$if r_normalizeNormalMaps
MOV R2.z, 0;
DP3 R1.x, R2,R2;
ADD R1.x, 1, -R1.x;
RSQ R1.x, R1.x;
RCP R2.z, R1.x;
$endif
TEX mask, fragment.texcoord[0], $mask, 2D;
# put in world space
DP3 R1.x, R2, fragment.texcoord[3];
DP3 R1.y, R2, fragment.texcoord[4];
DP3 R1.z, R2, fragment.texcoord[5];
#MAD result.color, R1, 0.5, 0.5;
# warped texcoords
MUL R3, $water_distortion, $currentRenderTexelSize;
MAD R3, R3, R1, fragment.position;
# normalize to eye
DP3 eye.w, fragment.texcoord[2], fragment.texcoord[2];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[2], eye.w;
#MAD result.color, eye, 0.5, 0.5;
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, R1;
MUL R2, R2, 2;
MAD R4, -R1, R2.x, eye;
#spec
DP3_SAT R0, R4, $sunDirection;
TEX spec, R0, $map, 2D;
MUL spec, spec, $sunColor;
MUL spec, spec, $water_glare;
# reflect refract mixing (sorta fresnel)
DP3 R1, -eye, R1;
ADD R1, R1, 1;
POW R1, R1.x, $water_fresnel.x;
RCP_SAT mix, R1.x;
# lookup textures and interpolate
TEX R1, R3, $currentRender, RECT;
MUL R1, R1, $water_tint; #modulate with water color
TEX R2, R4, $environmentCubeMap, CUBE;
SUB R3, R2, R1;
MAD R3, R3, mix, R1;
ADD result.color, R3, spec;
MUL result.color.a, fragment.color.a, mask.r;
%> }
}
renderBinding water_lerp { vector { 1 } }
/*
A static surface with cubemap reflections, interpolates between two normal maps for the refraction/reflection vector
*/
renderProgram water/simple_cube_interpolate {
earlycullversion water/simple_cube_interpolate_early
program vertex reference water/simple_cube
program fragment arb { <%
OPTION ARB_precision_hint_fastest;
TEMP R0, R1, R2, R3, R4, eye, mix, spec;
# get normals from normal maps
TEX R0, fragment.texcoord[0], $bumpMap, 2D;
TEX R1, fragment.texcoord[0], $bumpMap2, 2D;
# interpolate
LRP R2, $water_lerp, R1, R0;
$if !r_dxnNormalMaps
MOV R2.x, R2.a;
$endif
MAD R2, R2, 2, -1;
MUL R2.xy, R2, $water_distortion.z;
MUL_SAT R0.a, fragment.texcoord[2].w, 0.0001;
SUB R1, 0, R2;
MAD R2, R2, R0.a, R1;
$if r_normalizeNormalMaps
TEMP NR1;
MOV R2.z, 0;
DP3 NR1.x, R2,R2;
ADD NR1.x, 1, -NR1.x;
RSQ NR1.x, NR1.x;
RCP R2.z, NR1.x;
$endif
# put in world space
DP3 R1.x, R2, fragment.texcoord[3];
DP3 R1.y, R2, fragment.texcoord[4];
DP3 R1.z, R2, fragment.texcoord[5];
# warped texcoords
$if ( r_shaderQuality < 2 )
MUL R3, $water_distortion, $currentRenderTexelSize;
MUL R3, R3, fragment.color.r;
MAD R3, R3, R1, fragment.position;
$else
MOV R3, fragment.position;
$endif
# normalize to eye
$if ( r_shaderQuality < 2 )
DP3 eye.w, fragment.texcoord[2], fragment.texcoord[2];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[2], eye.w;
$else
MOV eye, fragment.texcoord[2];
$endif
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, R1;
MUL R2, R2, 2;
MAD R4, -R1, R2.x, eye;
#spec
$if ( r_shaderQuality < 1 )
DP3_SAT R0, R4, $sunDirection;
TEX spec, R0, $map, 2D;
MUL spec, spec, $sunColor;
MUL spec, spec, $water_glare;
MUL spec, spec, fragment.color.r;
$endif
# reflect refract mixing (sorta fresnel)
$if ( r_shaderQuality < 2 )
DP3 R1, -eye, R1;
ADD R1, R1, 1;
POW R1, R1.x, $water_fresnel.x;
RCP_SAT mix, R1.x;
MUL mix, mix, fragment.color.r;
$else
MOV mix, 0.125;
$endif
# lookup textures and interpolate
TEX R1, R3, $currentRender, RECT;
MUL R1, R1, $water_tint; #modulate with water color
TEX R2, R4, $environmentCubeMap, CUBE;
SUB R3, R2, R1;
MAD R3, R3, mix, R1;
TEMP _finalcolor;
$if ( r_shaderQuality < 1 )
ADD _finalcolor, R3, spec;
$else
MOV _finalcolor, R3;
$endif
ADD result.color.a, spec.r, spec.g;
$if ( r_megaDrawMethod != 0 )
LRP result.color.rgb, fragment.color.secondary.x, $fogColor, _finalcolor;
$else
MOV result.color.rgb, _finalcolor;
$endif
#MAD result.color.rgb, R4, 0.5, 0.5;
#MUL result.color.rgb, fragment.texcoord[2].w, 0.00005;
%> }
}
renderProgram water/simple_cube_interpolate_early {
program vertex arb { <%
OPTION ARB_position_invariant;
TEMP R0, R1, R2, bitangent;
XPD bitangent, $normalAttrib, $tangentAttrib;
MUL bitangent, bitangent, $tangentAttrib.w;
# bumpmap texture coords
DP4 result.texcoord[0].x, $texCoordAttrib, $diffuseMatrix_s;
DP4 result.texcoord[0].y, $texCoordAttrib, $diffuseMatrix_t;
# vector to eye
SUB R1, $positionAttrib, $viewOrigin;
$if ( r_shaderQuality > 1 )
DP3 R0.x, R1, $transposedModelMatrix_x;
DP3 R0.y, R1, $transposedModelMatrix_y;
DP3 R0.z, R1, $transposedModelMatrix_z;
DP3 R0.w, R0, R0;
RSQ R0.w, R0.w;
MUL result.texcoord[2].xyz, R0, R0.w;
$else
DP3 result.texcoord[2].x, R1, $transposedModelMatrix_x;
DP3 result.texcoord[2].y, R1, $transposedModelMatrix_y;
DP3 result.texcoord[2].z, R1, $transposedModelMatrix_z;
$endif
# DP3 result.texcoord[2].x, R1, $transposedModelMatrix_x;
# DP3 result.texcoord[2].y, R1, $transposedModelMatrix_y;
# DP3 result.texcoord[2].z, R1, $transposedModelMatrix_z;
DP3 R1.w, R1, R1;
RSQ R0.w, R1.w;
MUL result.texcoord[2].w, R0.w, R1.w;
# tangent->world matrix
DP3 result.texcoord[3].x, $tangentAttrib, $transposedModelMatrix_x;
DP3 result.texcoord[3].y, bitangent, $transposedModelMatrix_x;
DP3 result.texcoord[3].z, $normalAttrib, $transposedModelMatrix_x;
DP3 result.texcoord[4].x, $tangentAttrib, $transposedModelMatrix_y;
DP3 result.texcoord[4].y, bitangent, $transposedModelMatrix_y;
DP3 result.texcoord[4].z, $normalAttrib, $transposedModelMatrix_y;
DP3 result.texcoord[5].x, $tangentAttrib, $transposedModelMatrix_z;
DP3 result.texcoord[5].y, bitangent, $transposedModelMatrix_z;
DP3 result.texcoord[5].z, $normalAttrib, $transposedModelMatrix_z;
MOV result.color, $colorAttrib;
# this doesn't even change per vertex so don't bother to calculate it per pixel
# texture 1 takes the deform magnitude and scales it by the projection distance
PARAM vec = { 1, 0, 0, 1 };
MOV R0, vec;
DP4 R0.z, $positionAttrib, state.matrix.modelview.row[2];
DP4 R1, R0, state.matrix.projection.row[0];
DP4 R2, R0, state.matrix.projection.row[3];
# don't let the recip get near zero for polygons that cross the view plane
MAX R2, R2, 1;
RCP R2, R2.w;
MUL R1, R1, R2;
# clamp the distance so the the deformations don't get too wacky near the view
MIN R1, R1, 0.02;
MUL R1, R1, $water_distortion;
MUL result.texcoord[1], R1, $currentRenderTexelSize;
$if ( r_megaDrawMethod != 0 )
TEMP _F1, _F2;
SUB _F2, $positionAttrib, $viewOrigin;
DP3 _F1.x, _F2, _F2;
RSQ _F1.y, _F1.x;
MUL _F1.x, _F1.y, _F1.x;
MAD result.color.secondary, _F1.x, $fogDepths.z, $fogDepths.w;
$endif
SUB result.texcoord[6], $positionAttrib, $viewOrigin;
%> }
program fragment arb { <%
OPTION ARB_precision_hint_fastest;
TEMP R0, R1, R2, R3, R4, eye, mix, spec;
MUL R0.x, $foliageHackDistance, $foliageHackDistance;
DP3 R1.x, fragment.texcoord[6], fragment.texcoord[6];
SUB R2.x, R1, R0;
KIL R2.x;
TEMP blend;
MUL_SAT blend, R2.x, 0.0001;
# get normals from normal maps
TEX R0, fragment.texcoord[0], $bumpMap, 2D;
TEX R1, fragment.texcoord[0], $bumpMap2, 2D;
# interpolate
LRP R2, $water_lerp, R1, R0;
$if !r_dxnNormalMaps
MOV R2.x, R2.a;
$endif
MAD R2, R2, 2, -1;
MUL R2.xy, R2, $water_distortion.z;
MUL_SAT R0.a, fragment.texcoord[2].w, 0.000001;
SUB R1, 0, R2;
MAD R2, R2, R0.a, R1;
$if r_normalizeNormalMaps
TEMP NR1;
MOV R2.z, 0;
DP3 NR1.x, R2,R2;
ADD NR1.x, 1, -NR1.x;
RSQ NR1.x, NR1.x;
RCP R2.z, NR1.x;
$endif
# put in world space
DP3 R1.x, R2, fragment.texcoord[3];
DP3 R1.y, R2, fragment.texcoord[4];
DP3 R1.z, R2, fragment.texcoord[5];
# warped texcoords
#MUL R4, fragment.texcoord[1].w, $water_distortion;
#MAD R3, R1, R4, fragment.texcoord[1];
$if ( r_shaderQuality < 2 )
MUL R3, $water_distortion, $currentRenderTexelSize;
MUL R3, R3, fragment.color.r;
MAD R3, R3, R1, fragment.position;
$else
MOV R3, fragment.position;
$endif
# normalize to eye
$if ( r_shaderQuality < 2 )
DP3 eye.w, fragment.texcoord[2], fragment.texcoord[2];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[2], eye.w;
$else
MOV eye, fragment.texcoord[2];
$endif
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, R1;
MUL R2, R2, 2;
MAD R4, -R1, R2.x, eye;
#spec
$if ( r_shaderQuality < 1 )
DP3_SAT R0, R4, $sunDirection;
TEX spec, R0, $map, 2D;
MUL spec, spec, $sunColor;
MUL spec, spec, $water_glare;
MUL spec, spec, fragment.color.r;
$endif
# reflect refract mixing (sorta fresnel)
$if ( r_shaderQuality < 2 )
DP3 R1, -eye, R1;
ADD R1, R1, 1;
POW R1, R1.x, $water_fresnel.x;
RCP_SAT mix, R1.x;
MUL mix, mix, fragment.color.r;
$else
MOV mix, 0.125;
$endif
MUL mix, mix, blend.x;
MUL spec, spec, blend.x;
# lookup textures and interpolate
TEX R1, R3, $currentRender, RECT;
#MUL R1, R1, $water_tint; #modulate with water color
TEX R2, R4, $environmentCubeMap, CUBE;
SUB R3, R2, R1;
MAD R3, R3, mix, R1;
TEMP _finalcolor;
$if ( r_shaderQuality < 1 )
ADD _finalcolor, R3, spec;
$else
MOV _finalcolor, R3;
$endif
ADD result.color.a, spec.r, spec.g;
$if ( r_megaDrawMethod != 0 )
MUL R1.x, fragment.color.secondary.x, blend.x;
LRP result.color.rgb, R1.x, $fogColor, _finalcolor;
$else
MOV result.color.rgb, _finalcolor;
$endif
#TEX R1, fragment.position, $currentRender, RECT;
#MOV result.color, R1;
%> }
}
/*
A static surface with cubemap reflections, interpolates between two normal maps for the refraction/reflection vector
*/
renderProgram water/simple_cube_interpolate_imgseq {
program vertex reference water/simple_cube
program fragment arb { <%
OPTION ARB_precision_hint_fastest;
TEMP R0, R1, R2, R3, R4, eye, mix, spec;
$if ( r_shaderQuality < 1 )
# get normals from normal maps
TEX R0, fragment.texcoord[0], $imgSequenceCur, 2D;
TEX R1, fragment.texcoord[0], $imgSequenceNext, 2D;
# interpolate
LRP R2, $imgSequenceBlend, R1, R0;
$if !r_dxnNormalMaps
MOV R2.x, R2.a;
$endif
MAD R2, R2, 2, -1;
$else
TEX R2, fragment.texcoord[0], $imgSequenceCur, 2D;
$if !r_dxnNormalMaps
MOV R2.x, R2.a;
$endif
MAD R2, R2, 2, -1;
$endif
MUL R2.xy, R2, $water_distortion.z;
MUL_SAT R0.a, fragment.texcoord[2].w, 0.0001;
SUB R1, 0, R2;
MAD R2, R2, R0.a, R1;
$if r_normalizeNormalMaps
TEMP NR1;
MOV R2.z, 0;
DP3 NR1.x, R2,R2;
ADD NR1.x, 1, -NR1.x;
RSQ NR1.x, NR1.x;
RCP R2.z, NR1.x;
$endif
# put in world space
DP3 R1.x, R2, fragment.texcoord[3];
DP3 R1.y, R2, fragment.texcoord[4];
DP3 R1.z, R2, fragment.texcoord[5];
# warped texcoords
#MUL R4, fragment.texcoord[1].w, $water_distortion;
#MAD R3, R1, R4, fragment.texcoord[1];
MUL R3, $water_distortion, $currentRenderTexelSize;
MUL R3, R3, fragment.color.r;
MAD R3, R3, R1, fragment.position;
# normalize to eye
DP3 eye.w, fragment.texcoord[2], fragment.texcoord[2];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[2], eye.w;
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, R1;
MUL R2, R2, 2;
MAD R4, -R1, R2.x, eye;
$if ( r_shaderQuality < 1 )
DP3_SAT R0, R4, $sunDirection;
TEX spec, R0, $map, 2D;
MUL spec, spec, $sunColor;
MUL spec, spec, $water_glare;
MUL spec, spec, fragment.color.r;
$endif
# reflect refract mixing (sorta fresnel)
DP3 R1, -eye, R1;
ADD R1, R1, 1;
POW R1, R1.x, $water_fresnel.x;
RCP_SAT mix, R1.x;
MUL mix, mix, fragment.color.r;
# lookup textures and interpolate
TEX R1, R3, $currentRender, RECT;
MUL R1, R1, $water_tint; #modulate with water color
TEX R2, R4, $environmentCubeMap, CUBE;
SUB R3, R2, R1;
MAD R3, R3, mix, R1;
$if ( r_shaderQuality < 1 )
ADD result.color, R3, spec;
$else
MOV result.color, R3;
$endif
ADD result.color.a, spec.r, spec.g;
#MUL result.color.rgb, fragment.texcoord[2].w, 0.00005;
%> }
}
//////////////////////////////////////////////////////////
//// Shoreline stuff
//////////////////////////////////////////////////////////
renderProgram water/shoreline_froth {
program vertex arb { <%
OPTION ARB_position_invariant;
TEMP R0, R1, R2, bitangent;
XPD bitangent, $normalAttrib, $tangentAttrib;
MUL bitangent, bitangent, $tangentAttrib.w;
# bumpmap texture coords
DP4 result.texcoord[0].x, $texCoordAttrib, $diffuseMatrix_s;
DP4 result.texcoord[0].y, $texCoordAttrib, $diffuseMatrix_t;
# vector to eye
SUB R1, $positionAttrib, $viewOrigin;
DP3 result.texcoord[3].x, R1, $transposedModelMatrix_x;
DP3 result.texcoord[3].y, R1, $transposedModelMatrix_y;
DP3 result.texcoord[3].z, R1, $transposedModelMatrix_z;
# tangent->world matrix
DP3 result.texcoord[4].x, $tangentAttrib, $transposedModelMatrix_x;
DP3 result.texcoord[4].y, bitangent, $transposedModelMatrix_x;
DP3 result.texcoord[4].z, $normalAttrib, $transposedModelMatrix_x;
DP3 result.texcoord[5].x, $tangentAttrib, $transposedModelMatrix_y;
DP3 result.texcoord[5].y, bitangent, $transposedModelMatrix_y;
DP3 result.texcoord[5].z, $normalAttrib, $transposedModelMatrix_y;
DP3 result.texcoord[6].x, $tangentAttrib, $transposedModelMatrix_z;
DP3 result.texcoord[6].y, bitangent, $transposedModelMatrix_z;
DP3 result.texcoord[6].z, $normalAttrib, $transposedModelMatrix_z;
MAD R0, $colorAttrib, $colorModulate, $colorAdd;
MUL result.color, $diffuseColor, R0;
%> }
program fragment arb { <%
OPTION ARB_precision_hint_fastest;
TEMP R0, R1, R2, R3, R4, eye, mix, spec;
# get diffuse
TEX R1, fragment.texcoord[0], $diffuseMap, 2D;
# get normal from normal map
TEX R0, fragment.texcoord[0], $bumpMap, 2D;
$if !r_dxnNormalMaps
MOV R0.x, R0.a;
$endif
MAD R2, R0, 2, -1;
$if r_normalizeNormalMaps
TEMP NR1;
MOV R2.z, 0;
DP3 NR1.x, R2,R2;
ADD NR1.x, 1, -NR1.x;
RSQ NR1.x, NR1.x;
RCP R2.z, NR1.x;
$endif
# put in world space
DP3 R0.x, R2, fragment.texcoord[4];
DP3 R0.y, R2, fragment.texcoord[5];
DP3 R0.z, R2, fragment.texcoord[6];
# normalize to eye
DP3 eye.w, fragment.texcoord[3], fragment.texcoord[3];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[3], eye.w;
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, R0;
MUL R2, R2, 2;
MAD R4, -R0, R2.x, eye;
# specular
DP3_SAT R0, R4, $sunDirection;
TEX spec, R0, $map, 2D;
MUL spec, spec, $sunColor;
MUL spec, spec, $water_glare;
MUL spec, spec, fragment.color.r;
MOV spec.a, 0;
ADD result.color, spec, R1;
MUL result.color.a, R1, fragment.color.a;
#MOV result.color, fragment.color.a;
#MAD result.color, R4, 0.5, 0.5;
%> }
}
renderProgram water/shoreline_wetshine {
program vertex arb { <%
OPTION ARB_position_invariant;
TEMP R0, R1, R2, bitangent;
XPD bitangent, $normalAttrib, $tangentAttrib;
MUL bitangent, bitangent, $tangentAttrib.w;
# bumpmap texture coords
DP4 result.texcoord[0].x, $texCoordAttrib, $diffuseMatrix_s;
DP4 result.texcoord[0].y, $texCoordAttrib, $diffuseMatrix_t;
# sand texture coords
DP4 result.texcoord[1].x, $texCoordAttrib, $bumpMatrix_s;
DP4 result.texcoord[1].y, $texCoordAttrib, $bumpMatrix_t;
# vector to eye
SUB R1, $positionAttrib, $viewOrigin;
DP3 result.texcoord[3].x, R1, $transposedModelMatrix_x;
DP3 result.texcoord[3].y, R1, $transposedModelMatrix_y;
DP3 result.texcoord[3].z, R1, $transposedModelMatrix_z;
# tangent->world matrix
DP3 result.texcoord[4].x, $tangentAttrib, $transposedModelMatrix_x;
DP3 result.texcoord[4].y, bitangent, $transposedModelMatrix_x;
DP3 result.texcoord[4].z, $normalAttrib, $transposedModelMatrix_x;
DP3 result.texcoord[5].x, $tangentAttrib, $transposedModelMatrix_y;
DP3 result.texcoord[5].y, bitangent, $transposedModelMatrix_y;
DP3 result.texcoord[5].z, $normalAttrib, $transposedModelMatrix_y;
DP3 result.texcoord[6].x, $tangentAttrib, $transposedModelMatrix_z;
DP3 result.texcoord[6].y, bitangent, $transposedModelMatrix_z;
DP3 result.texcoord[6].z, $normalAttrib, $transposedModelMatrix_z;
MAD R0, $colorAttrib, $colorModulate, $colorAdd;
MUL result.color, $diffuseColor, R0;
%> }
program fragment arb { <%
OPTION ARB_precision_hint_fastest;
TEMP R0, R1, R2, R3, R4, eye, mix, spec;
# get diffuse-mask
TEX R1, fragment.texcoord[0], $diffuseMap, 2D;
# get normal from normal map
TEX R0, fragment.texcoord[1], $bumpMap, 2D;
$if !r_dxnNormalMaps
MOV R0.x, R0.a;
$endif
MAD R2, R0, 2, -1;
$if r_normalizeNormalMaps
TEMP NR1;
MOV R2.z, 0;
DP3 NR1.x, R2,R2;
ADD NR1.x, 1, -NR1.x;
RSQ NR1.x, NR1.x;
RCP R2.z, NR1.x;
$endif
# put in world space
DP3 R0.x, R2, fragment.texcoord[4];
DP3 R0.y, R2, fragment.texcoord[5];
DP3 R0.z, R2, fragment.texcoord[6];
# normalize to eye
DP3 eye.w, fragment.texcoord[3], fragment.texcoord[3];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[3], eye.w;
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, R0;
MUL R2, R2, 2;
MAD R4, -R0, R2.x, eye;
# specular
DP3_SAT R0, R4, $sunDirection;
TEX spec, R0, $map, 2D;
MUL spec, spec, $sunColor;
MUL spec, spec, $water_glare;
MUL spec, spec, R1.x;
MUL result.color, spec, fragment.color.r;
%> }
}
renderProgram water/runningwater {
program vertex arb { <%
OPTION ARB_position_invariant;
TEMP R0, R1;
DP4 result.texcoord.x, $texCoordAttrib, $diffuseMatrix_s;
DP4 result.texcoord.y, $texCoordAttrib, $diffuseMatrix_t;
TEMP bitangent;
XPD bitangent, $normalAttrib, $tangentAttrib;
MUL bitangent, bitangent, $tangentAttrib.w;
# vector to eye
SUB R1, $positionAttrib, $viewOrigin;
DP3 result.texcoord[3].x, R1, $transposedModelMatrix_x;
DP3 result.texcoord[3].y, R1, $transposedModelMatrix_y;
DP3 result.texcoord[3].z, R1, $transposedModelMatrix_z;
# tangent->world matrix
DP3 result.texcoord[4].x, $tangentAttrib, $transposedModelMatrix_x;
DP3 result.texcoord[4].y, bitangent, $transposedModelMatrix_x;
DP3 result.texcoord[4].z, $normalAttrib, $transposedModelMatrix_x;
DP3 result.texcoord[5].x, $tangentAttrib, $transposedModelMatrix_y;
DP3 result.texcoord[5].y, bitangent, $transposedModelMatrix_y;
DP3 result.texcoord[5].z, $normalAttrib, $transposedModelMatrix_y;
DP3 result.texcoord[6].x, $tangentAttrib, $transposedModelMatrix_z;
DP3 result.texcoord[6].y, bitangent, $transposedModelMatrix_z;
DP3 result.texcoord[6].z, $normalAttrib, $transposedModelMatrix_z;
MAD R0, $colorAttrib, $colorModulate, $colorAdd;
MUL result.color, $diffuseColor, R0;
%> }
program fragment arb { <%
# get diffuse-mask
TEMP diffuse, test, R0, R2;
TEX diffuse, fragment.texcoord[0], $diffuseMap, 2D;
SUB test, diffuse.w, 0.001;
KIL test.w;
TEX R0, fragment.texcoord[0], $bumpMap, 2D;
MOV R0.x, R0.a;
MAD R2, R0, 2, -1;
$if r_normalizeNormalMaps
TEMP NR1;
MOV R2.z, 0;
DP3 NR1.x, R2,R2;
ADD NR1.x, 1, -NR1.x;
RSQ NR1.x, NR1.x;
RCP R2.z, NR1.x;
$endif
MAD R0, R2, $water_distortion, fragment.position;
TEMP scr;
TEX scr, R0, $currentRender, RECT;
# put in world space
TEMP worldNormal;
DP3 worldNormal.x, R2, fragment.texcoord[4];
DP3 worldNormal.y, R2, fragment.texcoord[5];
DP3 worldNormal.z, R2, fragment.texcoord[6];
# normalize to eye
TEMP eye;
DP3 eye.w, fragment.texcoord[3], fragment.texcoord[3];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[3], eye.w;
TEMP reflection;
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, worldNormal;
MUL R2, R2, 2;
MAD reflection, -worldNormal, R2.x, eye;
TEMP specdp;
DP3_SAT specdp, reflection, $sunDirectionWorld;
MUL specdp, specdp, specdp;
MUL specdp, specdp, specdp;
MUL specdp, specdp, diffuse.a;
MUL specdp, specdp, $water_glare;
TEMP combined;
MAD combined, diffuse, fragment.color, scr;
ADD result.color, combined, specdp;
%> }
}
renderProgram water/runningwaterEnv {
program vertex reference water/runningwater
program fragment arb { <%
# get diffuse-mask
TEMP diffuse, test, R0, R1, R2, mix;
TEX diffuse, fragment.texcoord[0], $diffuseMap, 2D;
SUB test, diffuse.w, 0.000001;
KIL test.w;
TEX R0, fragment.texcoord[0], $bumpMap, 2D;
MOV R0.x, R0.a;
MAD R2, R0, 2, -1;
$if r_normalizeNormalMaps
TEMP NR1;
MOV R2.z, 0;
DP3 NR1.x, R2,R2;
ADD NR1.x, 1, -NR1.x;
RSQ NR1.x, NR1.x;
RCP R2.z, NR1.x;
$endif
MAD R0, R2, $water_distortion, fragment.position;
TEMP scr;
TEX scr, R0, $currentRender, RECT;
# put in world space
TEMP worldNormal;
DP3 worldNormal.x, R2, fragment.texcoord[4];
DP3 worldNormal.y, R2, fragment.texcoord[5];
DP3 worldNormal.z, R2, fragment.texcoord[6];
# normalize to eye
TEMP eye;
DP3 eye.w, fragment.texcoord[3], fragment.texcoord[3];
RSQ eye.w, eye.w;
MUL eye, fragment.texcoord[3], eye.w;
TEMP reflection;
# calc reflection vector: i - 2 * dot(i, n) * n
DP3 R2, eye, worldNormal;
MUL R2, R2, 2;
MAD reflection, -worldNormal, R2.x, eye;
# reflect refract mixing (sorta fresnel)
DP3 R1, -eye, worldNormal;
ADD R1, R1, 1;
POW R1, R1.x, $water_fresnel.x;
RCP_SAT mix, R1.x;
TEMP specdp;
DP3_SAT specdp, reflection, $sunDirectionWorld;
MUL specdp, specdp, specdp;
MUL specdp, specdp, specdp;
MUL specdp, specdp, diffuse.a;
MUL specdp, specdp, $water_glare;
TEMP env;
TEX env, reflection, $environmentCubeMap, CUBE;
TEMP combined;
MUL combined, diffuse, fragment.color;
# MUL combined, combined, R0;
# MAD combined, v2n, env, combined;
ADD combined, combined, scr;
ADD result.color, combined, specdp;
TEMP invmix;
SUB invmix, 1, mix;
MUL combined, combined, invmix;
MAD result.color, env, mix, combined;
MOV result.color.a, diffuse;
%> }
}
Reference in a new issue Copy permalink