Difference between revisions of "ShaderPool"

Revision as of 12:37, 26 March 2007

EP2-NL
0xCD7FE87A
0x1C0532FA
0x6852819C
0xFF76EA99
# poolwater

##############################################################
# Pool Water
#

seti poolWaterLayer 5

##############################################################
# Simple water material
#
# This material modulates the vertices by two sin waves --
# one in X and one in Y. It then produces reflection and
# refraction direction texture coordinates suitable for a
# cubic environment map.


#beginshader PoolWaterMaterialTwoWave
#description Pool water with X/Y waves

#BeginStdAttrBlock


setf wmTransparency  0.5
#attrdescription Water transparency

setf wmXSpeed        3     # min:0 max:100
#attrdescription Lookup texture for diffuse intensity.
setf wmXRepeat       1     # min:0 max:100
#attrdescription Lookup texture for diffuse intensity.
setf wmXWaveHeight   0.1   # min:0 max:100
#attrdescription Lookup texture for diffuse intensity.

setf wmYSpeed        5     # min:0 max:100
#attrdescription Lookup texture for diffuse intensity.
setf wmYRepeat       1.8   # min:0 max:100
#attrdescription Lookup texture for diffuse intensity.
setf wmYWaveHeight   0.2   # min:0 max:100
#attrdescription Lookup texture for diffuse intensity.

set wmReflectionTexture reflectionoutdoorwater-envcube
#attrdescription Environment cube map texture for reflection

setb wmRefractionEnabled false
#attrdescription Whether refraction is enabled

set wmRefractionTexture reflectionoutdoorwater-envcube
#attrdescription Environment cube map texture for refraction


#EndStdAttrBlock

define PoolWaterSurfaceMaterial()
   material      
      shader -layer $poolWaterLayer
         validateRenderShaderContext -vertexFormat position 0 required
 
         create DetermineHardwareSupport()
    
         if ($useSWVertexShaderPath or $useFixedFunctionPath)
            # The vertex shader to ripple the water surface is deemed too expensive for SWVS.
            # Note that because on some low-end cards shaders are turned off, DetermineHardwareSupport()
            # will set $useFixedFunctionPath to true and $useSWVertexShaderPath to false; however, 
            # since the device is in swvp mode, the RegularWavesHLSL shader would validate anyway, which
            # we don't want. Therefore here we do the simplified water surface if using either SWVS or FFP.
            create SimplifiedWaterSurface()
         else
            create RegularWavesHLSL()                        
         endif
         
      end #end shader
      
      # basic fallback.
      shader -layer $poolWaterLayer
         create SimplifiedWaterSurface()          
      end #end shader
      
   end  #end material
enddef

define SimplifiedWaterSurface()
   pass -fixedFunction      
      alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
      depthTest true -enableDepthWrite false
      colorScalar (0.2,0.3,1.0) 0.4      
      stage
         textureBlend select(colorScalar) select(colorScalar)
      end
   end
enddef


define RegularWavesHLSL()
	
   #DRIVERBUG
   # The -clipAlways flag is needed to work around what appears to be a driver bug.
   # On NVIDIA GF2 class HW, the presence of the cube map texture in the pass below
   # leads to a large performance drop whenever the pass is rendered with clipping disabled.
   # Rendering this pass with clipping enabled avoids the performance drop. In addition,
   # substituting a 2D texture for the cube map texture, or rendering this pass in HW
   # using fixed function vertex processing also avoids the performance drop (but would obviously
   # not have the desired visual result).
   # The cause of this is unknown. This was observed on a GF4GO, driver version 42.58.
	pass -clipAlways -modifiedEachFrameHint
		#fillmode wireframe
		alphaBlend srcFactor(one) add dstFactor(one)
      seti textureLights (numLightsOfType(environmentCube))           
   
		shaderProgram -target vertexProgram -method compile -version 1_1

			bindConstants 0 -bindingID geomToClip -constantCount 4
			bindConstants 4 -bindingID geomToCamera -constantCount 3

			bindConstants 7 -bindingID frameInfo 

			bindConstants 11 -bindingID immediateData -data ($wmXRepeat, 0, $wmXWaveHeight, $wmXSpeed)
			bindConstants 12 -bindingID immediateData -data (0, $wmYRepeat, $wmYWaveHeight, $wmYSpeed)

			# pre-evaluate these
			setf xscale (-$wmXRepeat * $wmXWaveHeight)
			setf yscale (-$wmYRepeat * $wmYWaveHeight)
			bindConstants 13 -bindingID immediateData -data ($xscale,$yscale, 1,0)
			bindConstants 14 -bindingID allStandardLightData -constantCount 4 -constantType float
			bindConstants 18 -bindingID cameraToGlobal -constantCount 3
         
         if (tsIsDay)         
            bindConstants 25 -bindingID immediateData -data (0.75, 0.75, 0.75, 1)         
         else
            bindConstants 25 -bindingID immediateData -data (0.2, 0.2, 0.2, 1)         
         endif

			shaderSource

				float4 frameInfo : register(c7);
				float4 waveDataX : register(c11);
				float4 waveDataY : register(c12);
				float4 waveDataHelper : register(c13);
				float4x4 clipSpaceMatrix : register(c0);
				float4x3 cameraSpaceMatrix : register(c4);
				float4x3 cameraToGlobalMatrix : register(c18);
				
            float4 nightColor: register(c25);
            
				float4 lightDirection : register(c14);
				float4 lightColor : register(c15);
				const static float4 refractionWeights={1,1,2,0};
				
				const static float4 layerBlue={0.3, 0.7, 1.0, 1};
				
				struct InputVertex
				{
					float3 position: POSITION0;
					float3 normal : NORMAL0;
				};
				
				struct OutputVertex
				{
					float4 clipPosition : POSITION;
					float4 diffuseColor: COLOR0;
					float4 specularColor: COLOR1;
					float3 reflection : TEXCOORD0;
					
				};
            
		
		
				OutputVertex VertexMain( InputVertex inputVertex)
				{
					// Do	Y-direction	waves
					// r0	= (x, y, z,	t)
					
					OutputVertex outputVertex;
					
					float4 posAndTime;
					posAndTime.xyz = inputVertex.position;
					posAndTime.w = frameInfo.w;
					
					float temp = dot(posAndTime, waveDataX);
								
					// z = h * sin(...)

					float z;
					// scale temp to fit -pi +pi range
					//temp = temp *  (1 / (2 * 3.14159)) + 0.5;
					
					float3 waveNormal;
					
					z = sin(temp) * waveDataX.z + inputVertex.position.z;
					
					waveNormal.x = cos(temp) * waveDataHelper.x + inputVertex.normal.x;
					
					temp = dot(posAndTime, waveDataY);
					//temp = temp *  (1 / (2 * 3.14159)) + 0.5;
					
					z +=  sin(temp) * waveDataY.z;
					
					waveNormal.y = cos(temp) * waveDataHelper.y + inputVertex.normal.y;
					
					waveNormal.z = inputVertex.normal.z;
					
					waveNormal = normalize(waveNormal);
					
					posAndTime.w = 1.0;
					posAndTime.z = z;
					
					outputVertex.clipPosition = mul( posAndTime, clipSpaceMatrix);
					
					float3 cameraSpaceNormal = normalize(mul(waveNormal, cameraSpaceMatrix));

					float3 cameraSpacePosition = mul( posAndTime, cameraSpaceMatrix);
					
					float3 viewVector = normalize(-cameraSpacePosition);
					
					float3 R = reflect(viewVector, cameraSpaceNormal);
					
					outputVertex.reflection = mul( -R, cameraToGlobalMatrix);
					
							
					float fresnel = dot(viewVector , cameraSpaceNormal);
							
					float rdotl = saturate(dot(R, lightDirection));
					
					float I = pow(rdotl+0.1, 15); // fudge factor to punch up the highlights.
					
               nightColor = nightColor * 2;                           
                           
					outputVertex.diffuseColor = ((1.0 - fresnel) * saturate(nightColor) * 0.5) * layerBlue;
					
					outputVertex.specularColor = I;
					return(outputVertex);
					
				}


			endShaderSource  
		end # shaderProgram
		
		stage
			texture $wmReflectionTexture
			textureAddressing clamp clamp clamp
			textureBlend multiply(texture diffuse) select(diffuse)
		end
      
      
		addSpecular true
					
	end # end pass

enddef


define HighEndWaterSurface()


   pass
		#fillmode wireframe
		alphaBlend srcFactor(one) add dstFactor(one)
		
      shaderProgram -target vertexProgram -method compile -version 1_1
      
         bindConstants 0 -bindingID geomToClip -constantCount 4
         bindConstants 4 -bindingID geomToCamera -constantCount 3
      
         bindConstants 7 -bindingID frameInfo 
      
         bindConstants 11 -bindingID immediateData -data ($wmXRepeat, 0, $wmXWaveHeight, $wmXSpeed)
         bindConstants 12 -bindingID immediateData -data (0, $wmYRepeat, $wmYWaveHeight, $wmYSpeed)
      
         # pre-evaluate these
         setf xscale (-$wmXRepeat * $wmXWaveHeight)
         setf yscale (-$wmYRepeat * $wmYWaveHeight)
         bindConstants 13 -bindingID immediateData -data ($xscale,$yscale, 1,0)
         bindConstants 14 -bindingID allStandardLightData -constantCount 4 -constantType float
         bindConstants 18 -bindingID cameraToGlobal -constantCount 3
   
         shaderSource
      
            float4 frameInfo : register(c7);
            float4 waveDataX : register(c11);
            float4 waveDataY : register(c12);
            float4 waveDataHelper : register(c13);
            float4x4 clipSpaceMatrix : register(c0);
            float4x3 cameraSpaceMatrix : register(c4);
            float4x3 cameraToGlobalMatrix : register(c18);
            
            float4 lightDirection : register(c14);
            float4 lightColor : register(c15);
            const static float4 refractionWeights={1,1,2,0};
            
            struct InputVertex
            {
               float4 position: POSITION0;
               float3 normal : NORMAL0;
               float2 texc : TEXCOORD0;
            };
            
            struct OutputVertex
            {
               float4 clipPosition : POSITION;
               float3 normal : TEXCOORD0;
               float3 viewVector : TEXCOORD1;
         
            };
            
            static float2 waveCenter1 = {0.0, 0.0};
            static float2 waveCenter2 = {-0.6, 0.2};
            
            static float2 timeScale = {2,1};
            static float2 waveHeight = {0.04, 0.02};
            static float2 distScale = {12, 8};
            
            
            
            float4 ComputeWavePositionTwoWay(float2 pos1, float2 pos2)
            {
            
			   float2 vec;
               float4 dist;
               
               vec = waveCenter1 - pos1;
               dist.x = dot(vec, vec);
               
               vec = waveCenter2 - pos1;
               dist.y = dot(vec,vec);
               
			   vec = waveCenter2 - pos2;
               dist.z = dot(vec, vec);
               
               vec = waveCenter2 - pos2;
               dist.w = dot(vec,vec);
		   
			   dist *= distScale.xyxy;
			   
			   float4 sinResult = sin(dist + frameInfo.w * timeScale.xyxy);

			   //sinResult = 1.0- abs(sinResult);
				
			   return(sinResult);
				
            }
            
            float2 ComputeWavePosition(float2 pos1)
            {
            
			   float2 vec;
               float2 dist;
			   
			   vec = waveCenter1 - pos1;
               dist.x = dot(vec, vec);
               
               vec = waveCenter2 - pos1;
               dist.y = dot(vec,vec);
               		   
			   dist *= distScale.xy;
			   
			   float2 sinResult = sin(dist + frameInfo.w * timeScale);

			   //sinResult = 1.0- abs(sinResult);
				
			   return(sinResult);
				
            }
            
            OutputVertex VertexMain( InputVertex inputVertex)
            {
               // Do	Y-direction	waves
               // r0	= (x, y, z,	t)
               
               OutputVertex outputVertex;
			
				float4 pos = inputVertex.position;
				
				float2 sample1, sample2, sample3;
				
				sample1 = inputVertex.position;
				sample2 = inputVertex.position;
				sample3 = inputVertex.position;
				sample2.x += 0.1;
				sample3.y += 0.1;
				
				float4 heights1=ComputeWavePositionTwoWay(sample1, sample2);
				float2 heights2=ComputeWavePosition(sample3);
				
				
			float3 pos1, pos2;
				pos1 = pos;
				pos2 = pos;
				
			   pos.z += (heights1.x* waveHeight.x);// + heights1.y *  waveHeight.y);
			   pos1.z += (heights1.z* waveHeight.x);// + heights1.w *  waveHeight.y);
			   pos2.z += (heights2.x* waveHeight.x);// + heights2.y *  waveHeight.y);
				
				pos1.x +=0.1;
				pos2.y +=0.1;
				float3 vec1, vec2;
				vec1 = normalize(pos1 - pos);
				vec2 = normalize(pos2 - pos);
				
				float3 normal = cross(vec1, vec2);
				
				normal = mul(normal, (float3x3)cameraSpaceMatrix);

				float3 viewVector = mul(pos, cameraSpaceMatrix);
			
				outputVertex.viewVector = normalize(-viewVector);
				
               outputVertex.clipPosition = mul(pos, clipSpaceMatrix);
               outputVertex.normal = normal;
               return(outputVertex);
               
         }
            
         endShaderSource
      
      end # end shaderProgram
         
      shaderProgram -target pixelProgram -method assemble
         bindConstants 0 -bindingID allStandardLightData -constantCount 4 -constantType float

         shaderSource
            ps_2_0
            def c10,20,4,0,0
            def c11, 0,0.5,1,2
            dcl t0
            dcl t1 ; v
			dcl_cube s0
			      
            nrm r0, t0       ; n
            
            add r1, r0, r0  ; 2N
            
            dp3 r1.w, r0, t1 ; N.V
			mad r2.xyz, r1, r1.w, -t1     ; 2N * (N.V) -V 
			
			texld r5, r2, s0
			
			dp3 r3.x, r2, c0  ; R.L
			pow r4, r3.x, c10.x
			
			mov_sat r1.x, r1.w
			
			add r6.x, c11.z, -r1.x       ; 1 - Fresnel
			
			pow r3.y, r6.x, c10.y   ; N.V ^ 4
		
			mul r7, r5, r3.y
			mad r4, r4, r3.y, r7
			mul r4, r4, c11.y
			
			mov oC0, r4
            
         endShaderSource
      end
      
      sampler 0 
		texture $wmReflectionTexture
		textureAddressing clamp clamp clamp
      end
   end  # pass
   
enddef


#endshader PoolWaterSurfaceMaterial



# NOTE: 
# refraction in vector terms:
#   v  = incoming unit vector
#   n  = surface normal
#   v' = refracted vector
#   a  = refraction ratio, ni / nr =~ 0.75 for air->water
#
# v' = v - sn
# where s = sqrt(1 - a^2 (1 - (v.n)^2))  - v.n.



##########################################################
# Caustics
#

define TiledTextureAnimShaderProgram(tilesX tilesY speed)
   shaderProgram -target vertexProgram -method assemble
   
      bindConstants 0 -bindingID frameInfo            # for time in .w
      bindConstants 1 -data      (&tilesX, &tilesY, &speed, 1)         # tx, ty, speed
      bindConstants 2 -data      ((1/&tilesX), (1/&tilesY), (&tilesY - 1), 1) # 1/tx 1/ty ty-1      
      if (tsIsDay)
         bindConstants 3 -bindingID immediateData -data (0.75, 0.75, 0.75, 1)
      else
         bindConstants 3 -bindingID immediateData -data (0.2, 0.2, 0.2, 1)
      endif
      
      shaderSource
         vs_1_1
         dcl_position v0
         dcl_texcoord v1

         mov oPos, v0  # clip space quad, no transforms needed.
      
         # tiled texture animation
         mov r0, c0
         mul r1, c1.z, r0.w
         frc r5.y, r1.y
         
         mul r1, c1.y, r5.y    # f -> [0, ty)
         frc r5.y, r1
         sub r3.y, r1, r5.y    # v' = floor(f)
         
         mul r1, c1.x, r5.y    # f -> [0, tx)
         frc r5.y, r1
         sub r3.x, r1, r5.y    # u' = floor(f)

         add r8.xy, v1.xy,  r3.xy
         mul oT0.xy, r8.xy, c2.xy
         
         mov oD0, c3 # also spit out diffuse color with modcolor information
         
      endShaderSource
   
   end		
enddef

define CausticsGeneratorMaterial()   
   material      
      # This material updates a render target with the current frame
      # of the tile animation. This is the only way to handle a repeated
      # animating texture (not to mention using it for projective texturing)
      # in the absence of clip maps.
      
      create DetermineHardwareSupport()
      
      if ($causticsEnabled and $useFixedFunctionPath = false and $useSWVertexShaderPath = false)
      
         shader -layer +9999 

            pass              
               renderClipSpaceRect
               
               renderTarget causticsTile -fixed (64, 64) -allocateDepthBuffer false -undo

               create TiledTextureAnimShaderProgram(8 4 1)
               
               alphaBlend srcFactor(one) add dstFactor(zero)
               alphaTest false 0
               alphaTestFunction acceptIfGreater

               depthTest false -enableDepthWrite false
               depthTestFunction accept

               # 7/24/2004 Fix bug with kRenderTypeNormal default stencil state and nv40.  
               # It reads random stencil values even this target has no depth stencil target.               
               # This stencil call will break pixo, but pixo does not show caustics.
               stencil false

               fillmode $stdMatFillMode                             
               
               shaderProgram -target pixelProgram -method compile -version 1_1               
                  shaderSource                            
                     sampler caustics;
                     struct cInputPixel
                     {
                        float4 color : COLOR;
                        float2 tc0 : TEXCOORD0;
                     };
                     float4 PixelMain(cInputPixel pi) : COLOR
                     {         
                        float4 texColor = tex2D(caustics, pi.tc0);                                                
                        return texColor*pi.color;                        
                     }
                  endShaderSource
               end                                                     
               
               sampler 0
                  texture causticsTiled
                  textureAddressing tile tile                  
               end
                              
            end   
         end
      else
         shader
         
         end
      endif
   end
enddef
 
setf causticsStrength 0.8
setf causticsBaseStrength 0.5

### dTS2

###################################################
# Materials
#


# Pool surface materials
materialDefinition "poolWater-0"
   setDefinition PoolWaterSurfaceMaterial
   addParam stdMatDiffCoef (0, 0, 1)   
   addParam wmRefractionEnabled true
end

materialDefinition "poolWater-1"
   setDefinition PoolWaterSurfaceMaterial   
   addParam stdMatLightingEnabled false
   addParam stdMatLayer 0
   
   addParam stdMatDiffCoef (1, 1, 1)   

   addParam wmReflectionTexture swimming_pool-envcube

   addParam wmTransparency 0.4

   addParam wmXSpeed        3
   addParam wmXRepeat       5
   addParam wmXWaveHeight   0.01 
   
   addParam wmYSpeed        3
   addParam wmYRepeat       6
   addParam wmYWaveHeight   0.01 
end

materialDefinition "poolWater-2"
   setDefinition PoolWaterSurfaceMaterial
   addParam stdMatLightingEnabled false
   addParam stdMatLayer 0
   
   addParam stdMatDiffCoef (0, 0, 1)   

   addParam wmTransparency 0.5

   addParam wmXSpeed        3
   addParam wmXRepeat       12
   addParam wmXWaveHeight   0 #0.02 
   
   addParam wmYSpeed        3
   addParam wmYRepeat       12 
   addParam wmYWaveHeight   0 # 0.02 
end

materialDefinition "poolWater-4"
   setDefinition WaterAnimatingTextures
   addParam waterSpeed 0.3
end


# Pool depth layer materials

# this is here soley because the layering on standard material
# is too constrained. We need a layer less than 7, or we'll
# render over transparent areas of Sims (e.g. hair) when
# they're in the pool at a shallow view angle. 
setc poolLayerColour (0, 0.5, 1.0, 1.0)
define PoolDepthLayerMaterial()
   material     
      create DetermineHardwareSupport() 
      if ($useSWVertexShaderPath or $useFixedFunctionPath)
         shader
         end
      else
         shader -layer $poolWaterLayer
            validateRenderShaderContext -vertexFormat position 0 required
            validateRenderShaderContext -vertexFormat texcoord 0 required
            
            pass
               alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
			      depthTest true -enableDepthWrite false
               #fillmode wireframe
               shaderProgram -target vertexProgram -method compile -version 1_1
                  bindConstants 0 -bindingID geomToClip -constantCount 4
                  bindConstants 4 -bindingID immediateData -data ($poolLayerColour)
                  
                  shaderSource
                     float4x4 clipSpaceMatrix      : register(c0);
                     float4   poolLayer            : register(c4);
                     
                     struct cVertexIn
                     {
                        float3 mPosition : POSITION0;   
                        float2 alpha     : TEXCOORD0;                  
                     };
                     
                     struct cVertexOut
                     {
                        float4 mClipPosition : POSITION;                     
                        float4 mColor        : COLOR0;
                     };
                     
                     cVertexOut VertexMain(cVertexIn vertexIn)
                     {                 
                        cVertexOut result;                                                                        
                        result.mClipPosition = mul(float4(vertexIn.mPosition, 1), clipSpaceMatrix);                     
                        result.mColor = float4(poolLayer.r, poolLayer.g, poolLayer.b, poolLayer.a * vertexIn.alpha.x); 
                        return result;         
                     }
                     
                  endShaderSource
               end                       
               
               shaderProgram -target pixelProgram -method compile -version 1_1
                  shaderSource                  
                     float4 PixelMain(float4 color : COLOR) : COLOR
                     {                                             
                        return color;
                     }
                  endShaderSource
               end                        
            end         
         end
      endif
   end
enddef

materialDefinition "poolWaterLayer-0"
   # this layer does nothing but create the caustics tile.
   setDefinition CausticsGeneratorMaterial   
end 

materialDefinition "poolWaterLayer-1"
   setDefinition PoolDepthLayerMaterial   
   addParam poolLayerColour (0, 0.5, 1.0, 0.2)
end
materialDefinition "poolWaterLayer-2" 
   setDefinition PoolDepthLayerMaterial  
   addParam poolLayerColour (0, 0.5, 1.0, 0.2)    
end
materialDefinition "poolWaterLayer-3"
   setDefinition PoolDepthLayerMaterial
   addParam poolLayerColour (0, 0.5, 1.0, 0.5)   
end

### dTS2

materialDefinition mtl_0
   setDefinition CausticsGeneratorMaterial
end