Nice effect!
Tweet
Lightmapped material with reflection cubemap and dpmeshcollisions
textures/texturepackname/texturename
{
dpreflectcube textures/texturepackname/reflect1
dpmeshcollisions
{
map $lightmap
rgbGen identity
tcGen lightmap
}
{
map textures/texturepackname/texturename
rgbGen identity
blendFunc GL_DST_COLOR GL_ZERO
}
}
!!ARBvp1.0
OPTION ARB_position_invariant;
# attrib[10] is the surface tangent[0]
# attrib[11] is the surface tangent[1]
# matrix[2] is the mirror matrix
# env[0] is the eye origin in local space
# local[0] is the bump map scale
# local[1] is the bump map scroll
# local[2] is the sun light origin
PARAM transform[3] = { { 0.5, 0.0, 0.0, 0.5 }, { 0.0, 0.5, 0.0, 0.5 }, { 0.0, 0.0, 0.0, 1.0 } };
TEMP tmp;
# Scale and scroll the bump map texcoord and put it into texcoord[0]
MAD result.texcoord[0], vertex.texcoord[0], program.local[0], program.local[1];
# Copy the diffuse/specular map texcoord to texcoord[1]
MOV result.texcoord[1], vertex.texcoord[0];
# Generate the reflection map texcoord and put it into texcoord[2]
DP4 tmp.x, vertex.position, state.matrix.program[2].transpose.row[0];
DP4 tmp.y, vertex.position, state.matrix.program[2].transpose.row[1];
DP4 tmp.w, vertex.position, state.matrix.program[2].transpose.row[3];
DP4 result.texcoord[2].x, tmp, transform[0];
DP4 result.texcoord[2].y, tmp, transform[1];
DP4 result.texcoord[2].w, tmp, transform[2];
# Compute the eye vector in tangent space and put it into texcoord[3]
SUB tmp, program.env[0], vertex.position;
DP3 result.texcoord[3].x, tmp, vertex.attrib[10];
DP3 result.texcoord[3].y, tmp, vertex.attrib[11];
DP3 result.texcoord[3].z, tmp, vertex.normal;
# Compute the light vector in tangent space and put it into texcoord[4]
SUB tmp, program.local[2], vertex.position;
DP3 result.texcoord[4].x, tmp, vertex.attrib[10];
DP3 result.texcoord[4].y, tmp, vertex.attrib[11];
DP3 result.texcoord[4].z, tmp, vertex.normal;
END
# =============================================================================
!!ARBfp1.0
OPTION ARB_precision_hint_fastest;
# texcoord[0] is the bump map texcoord
# texcoord[1] is the diffuse/specular map texcoord
# texcoord[2] is the reflection map texcoord
# texcoord[3] is the eye vector in tangent space
# texcoord[4] is the light vector in tangent space
# texture[0] is the bump map
# texture[1] is the diffuse map
# texture[2] is the specular map
# texture[3] is the reflection map
# texture[4] is the refraction map
# env[0] is the fragment.position to 0.0 - 1.0 conversion
# env[1] is the 1.0 to _currentRender conversion
# env[2] is the light scale setting
# local[0] is the diffuse (water) color modulate
# local[1] is the specular (sun) color modulate
# local[2] is the specular (sun) exponent
# local[3] is the reflection deform magnitude
# local[4] is the refraction deform magnitude
TEMP eyeVec, lightVec, reflectionVec;
TEMP normal, diffuse, specular, reflection, refraction;
TEMP color, blend, fresnel, specularFalloff;
TEMP tmp;
# Load the normal vector from the bump map
TEX normal, fragment.texcoord[0], texture[0], 2D;
MAD normal.xyz, normal, 2.0, -1.0;
# Offset the diffuse/specular map texcoord
ADD tmp.xy, normal, fragment.texcoord[1];
# Load the diffuse map with the modified texcoord
TEX diffuse, tmp, texture[1], 2D;
MUL diffuse.xyz, diffuse, program.env[2];
MUL diffuse.xyz, diffuse, program.local[0];
# Load the specular map with the modified texcoord
TEX specular, tmp, texture[2], 2D;
MUL specular.xyz, specular, program.env[2];
MUL specular.xyz, specular, program.local[1];
# Offset the reflection map texcoord
MOV tmp, fragment.texcoord[2];
MAD tmp.xy, normal, program.local[3], tmp;
# Load the reflection map with the modified texcoord
TXP reflection, tmp, texture[3], 2D;
# Offset the refraction map texcoord
MUL tmp, fragment.position, program.env[0];
MAD_SAT tmp.xy, normal, program.local[4], tmp;
MUL tmp.xy, tmp, program.env[1];
# Load the refraction map with the modified texcoord
TEX refraction, tmp, texture[4], 2D;
# Normalize the eye vector
DP3 eyeVec.w, fragment.texcoord[3], fragment.texcoord[3];
RSQ eyeVec.w, eyeVec.w;
MUL eyeVec, eyeVec.w, fragment.texcoord[3];
# Normalize the light vector
DP3 lightVec.w, fragment.texcoord[4], fragment.texcoord[4];
RSQ lightVec.w, lightVec.w;
MUL lightVec, lightVec.w, fragment.texcoord[4];
# Compute the reflection vector
DP3 reflectionVec, normal, lightVec;
MUL reflectionVec, reflectionVec, 2.0;
MAD reflectionVec, reflectionVec, normal, -lightVec;
# Compute specular lighting and bias the result so that it always has some specularity
DP3_SAT specularFalloff.w, reflectionVec, eyeVec;
POW specularFalloff.w, specularFalloff.w, program.local[2].w;
ADD specularFalloff.w, specularFalloff.w, 0.25;
# Compute the fresnel term
DP3 fresnel.w, normal, eyeVec;
SUB fresnel.w, 1.0, fresnel.w;
# Compute diffuse + specular color
MAD color.xyz, specular, specularFalloff.w, diffuse;
# Blend between the reflection and refraction maps
LRP blend.xyz, fresnel.w, reflection, refraction;
# Add them together to become the final fragment color
ADD result.color.xyz, color, blend;
# Alpha will be equal to the fresnel term
MOV result.color.w, fresnel.w;
END
... Have fun.
(better known as: the ctf logo of DoE/ROGUE)
Comment