Difference between revisions of "ShaderTerrain"

From SimsWiki
Jump to: navigation, search
(EP0-TS2)
 
(EP6-BV)
 
(5 intermediate revisions by one user not shown)
Line 1: Line 1:
 
<pre>
 
<pre>
  
−
EP0-TS2
+
EP6-BV
 
0xCD7FE87A
 
0xCD7FE87A
 
0x1C0532FA
 
0x1C0532FA
Line 26: Line 26:
 
setf  paintTextureScale                  20
 
setf  paintTextureScale                  20
 
setf  paintDetailTextureScale            4.0
 
setf  paintDetailTextureScale            4.0
 +
setb  hasCutout false
  
 
#==============================================================================
 
#==============================================================================
  
−
define TerrainCanvasShaderShader()
+
define TerrainCanvasShaderShaderVS_PS()
−
   shader -layer (($terrainMatLayer - 3) * 8)
+
   pass
−
       vertexFormatPred position     0 true
+
       fillmode $stdMatFillMode      
−
       vertexFormatPred normal        0 true
+
       depthTest true -enableDepthWrite true                
−
       vertexFormatPred texcoord      0 true
+
        
−
       vertexFormatPred blendindices  0 false
+
       if ($hasCutout)                       
−
       vertexFormatPred targetindices 0 false
+
        depthTestFunction acceptIfEqual
−
       viewerRenderTypePred viewerRenderType
+
       else
−
 
+
        depthTestFunction acceptIfLessOrEqual
−
       pass -fixedFunction
+
       endif
−
         create LightingStatesNoStdLights()
+
     
−
        fillmode $stdMatFillMode
+
       shaderProgram -target vertexProgram -method compile -version 1_1
−
 
+
         bindConstants 0 -bindingID geomToClip -constantCount 4
−
        if ($stdMatLightingDebug)
+
bindConstants 4 -bindingID immediateData -data (1/$canvasBaseTextureScale, 1/$canvasDetailTextureScale, 0, 0)
−
            stage
+
−
              texture $stdMatBaseTextureName ${stdMatBaseTextureParam}
+
shaderSource
−
              textureBlend multiply(texture outRegister) select(outRegister)
+
  float4x4 clipSpaceMatrix  : register(c0);
−
            end  
+
  float4  textureConstants : register(c4);
−
         else
+
−
             stage
+
struct InputVertex
−
              texture "${texture}"
+
{
−
               textureAddressing tile tile
+
float3 position: POSITION0;
−
               ffTextureMatrix -scalev ($canvasBaseTextureScale, $canvasBaseTextureScale) -invert
+
float2 texcoord : TEXCOORD0;
−
               ffTextureCoordsSource 0
+
};
−
               textureBlend multiply(texture outRegister) select(outRegister)
+
−
             end  
+
struct OutputVertex
−
            stage
+
{
−
              texture "${texture}_detail"
+
float4 clipPosition : POSITION;
−
              textureAddressing tile tile
+
float2 txBase  : TEXCOORD0;
−
              ffTextureMatrix -scalev ($canvasDetailTextureScale, $canvasDetailTextureScale) -invert
+
float2 txDetail: TEXCOORD1;
−
              ffTextureCoordsSource 0
+
};
−
              textureBlend lerpTextureAlpha(texture outRegister) select(outRegister)
+
−
            end
+
OutputVertex VertexMain( InputVertex i)
−
         endif
+
{
−
       end      
+
  OutputVertex o;
 +
  o.clipPosition = mul(float4(i.position, 1), clipSpaceMatrix);
 +
  o.txBase  = i.texcoord * textureConstants.x;
 +
  o.txDetail = i.texcoord * textureConstants.y;  
 +
  return o;
 +
}
 +
endShaderSource 
 +
      end # end shader program
 +
     
 +
     
 +
      shaderProgram -target pixelProgram -method compile -version 1_1     
 +
         shaderSource                           
 +
             sampler base;
 +
            sampler detail;
 +
            struct cInputPixel
 +
            {              
 +
               float2 tcBase : TEXCOORD0;
 +
               float2 tcDetail : TEXCOORD1;
 +
            };
 +
           
 +
            float4 PixelMain(cInputPixel pi) : COLOR
 +
            {       
 +
              float4 baseColor  = tex2D(base, pi.tcBase);                                               
 +
               float4 detailColor = tex2D(detail, pi.tcDetail);                             
 +
               float4 result = (detailColor.a * detailColor) + ((1 - detailColor.a) * baseColor);             
 +
              return result;                       
 +
             }
 +
        endShaderSource
 +
      end # end shader program     
 +
       
 +
      sampler base
 +
        texture "${texture}"
 +
        textureAddressing tile tile
 +
      end
 +
     
 +
      sampler detail
 +
        texture "${texture}_detail"
 +
         textureAddressing tile tile
 +
       end    
 
   end
 
   end
 
enddef
 
enddef
  
 +
define TerrainCanvasShaderShaderFF()
 +
  pass -fixedFunction       
 +
      fillmode $stdMatFillMode
 +
     
 +
      depthTest true -enableDepthWrite true                 
 +
     
 +
      if ($hasCutout)                       
 +
        depthTestFunction acceptIfEqual
 +
      else
 +
        depthTestFunction acceptIfLessOrEqual
 +
      endif
 +
             
 +
      stage
 +
        texture "${texture}"
 +
        textureAddressing tile tile
 +
        ffTextureMatrix -scalev ($canvasBaseTextureScale, $canvasBaseTextureScale) -invert
 +
        ffTextureCoordsSource 0
 +
        textureBlend select(texture) select(texture)
 +
      end
 +
      stage
 +
        texture "${texture}_detail"
 +
        textureAddressing tile tile
 +
        ffTextureMatrix -scalev ($canvasDetailTextureScale, $canvasDetailTextureScale) -invert
 +
        ffTextureCoordsSource 0
 +
        textureBlend lerpTextureAlpha(texture outRegister) select(outRegister)
 +
      end
 +
  end     
 +
enddef
  
 
define TerrainCanvasShader()
 
define TerrainCanvasShader()
 
   material
 
   material
−
       if ($stdMatLightingDebug)
+
       shader -layer (($terrainMatLayer - 3) * 8)
−
         create LightingDebugStandardMaterialOverrides()
+
        vertexFormatPred position      0 true
−
      endif
+
        vertexFormatPred normal        0 true
−
      create TerrainCanvasShaderShader()
+
        vertexFormatPred texcoord      0 true
 +
        viewerRenderTypePred viewerRenderType
 +
       
 +
         create DetermineHardwareSupport()
 +
        if (viewerRenderType = $kRenderTypeShadowMap)
 +
        create ShadowMapVS_PS()
 +
      else
 +
            if ($useHWShader1Path or $useHWShader2Path)
 +
        create TerrainCanvasShaderShaderVS_PS()
 +
        else 
 +
              create TerrainCanvasShaderShaderFF()
 +
            endif
 +
        endif
 +
      end
 +
     
 
       shader
 
       shader
 
       end
 
       end
 
   end
 
   end
 
enddef
 
enddef
−
 
−
 
  
 
#==============================================================================
 
#==============================================================================
 +
 +
define TerrainPaintShaderVS_PS()
 +
  shader -layer (($terrainMatLayer - 2) * 8)
 +
      vertexFormatPred position      0 true
 +
      vertexFormatPred texcoord      0 true
 +
      pass
 +
        fillmode $stdMatFillMode
 +
        alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
 +
       
 +
        alphaTest true 10
 +
        alphaTestFunction acceptIfGreater
 +
       
 +
        depthTest true -enableDepthWrite false
 +
        if (viewerRenderType = $kRenderTypeImposter)
 +
            depthTestFunction acceptIfLessOrEqual
 +
        else
 +
            depthTestFunction acceptIfEqual
 +
        endif
 +
       
 +
        shaderProgram -target vertexProgram -method compile -version 1_1
 +
            bindConstants 0 -bindingID geomToClip -constantCount 4
 +
  bindConstants 4 -bindingID immediateData -data (1/$canvasBaseTextureScale, 1/$canvasDetailTextureScale, $alphaMapScaleU, $alphaMapScaleV)
 +
 
 +
  shaderSource
 +
      float4x4 clipSpaceMatrix  : register(c0);
 +
      float4  textureConstants : register(c4);
 +
 
 +
  struct InputVertex
 +
  {
 +
  float3 position: POSITION0;
 +
  float2 texcoord : TEXCOORD0;
 +
  };
 +
 
 +
  struct OutputVertex
 +
  {
 +
  float4 clipPosition : POSITION;
 +
  float2 txBase  : TEXCOORD0;
 +
  float2 txDetail: TEXCOORD1;
 +
  float2 txAlpha : TEXCOORD2;
 +
  };
 +
 
 +
  OutputVertex VertexMain( InputVertex i)
 +
  {
 +
      OutputVertex o;
 +
      o.clipPosition = mul(float4(i.position, 1), clipSpaceMatrix);
 +
      o.txBase  = i.texcoord * textureConstants.x;
 +
      o.txDetail = i.texcoord * textureConstants.y;  
 +
      o.txAlpha  = i.texcoord.xy * textureConstants.zw;
 +
      return o;
 +
  }
 +
  endShaderSource 
 +
        end # end shader program
 +
       
 +
       
 +
        shaderProgram -target pixelProgram -method compile -version 1_1     
 +
            shaderSource                           
 +
              sampler base;
 +
              sampler detail;
 +
              sampler alphaMap;
 +
              struct cInputPixel
 +
              {             
 +
                  float2 tcBase : TEXCOORD0;
 +
                  float2 tcDetail : TEXCOORD1;
 +
                  float2 tcAlpha  : TEXCOORD2;
 +
              };
 +
             
 +
              float4 PixelMain(cInputPixel pi) : COLOR
 +
              {       
 +
                  float4 baseColor  = tex2D(base, pi.tcBase);                                               
 +
                  float4 detailColor = tex2D(detail, pi.tcDetail);                             
 +
                  float4 alphaColor  = tex2D(alphaMap, pi.tcAlpha);
 +
                  float4 result = (detailColor.a * detailColor) + ((1 - detailColor.a) * baseColor);             
 +
                  result.a = alphaColor.a;
 +
                  return result;                       
 +
              }
 +
            endShaderSource
 +
        end # end shader program     
 +
           
 +
        sampler base
 +
            texture $paintTexture
 +
            textureAddressing tile tile
 +
        end
 +
       
 +
        sampler detail
 +
            texture "${paintTexture}_detail"
 +
            textureAddressing tile tile
 +
        end
 +
       
 +
        sampler alphaMap
 +
            texture $alphaMap
 +
            textureAddressing clamp clamp
 +
        end     
 +
      end
 +
  end
 +
enddef
  
 
define TerrainPaintShader(addDetail)
 
define TerrainPaintShader(addDetail)
 
   shader -layer (($terrainMatLayer - 2) * 8)
 
   shader -layer (($terrainMatLayer - 2) * 8)
 
       vertexFormatPred position      0 true
 
       vertexFormatPred position      0 true
−
      vertexFormatPred normal        0 true
 
 
       vertexFormatPred texcoord      0 true
 
       vertexFormatPred texcoord      0 true
−
      vertexFormatPred blendindices  0 false
 
−
      vertexFormatPred targetindices 0 false
 
−
      #viewerRenderTypePred viewerRenderType
 
 
        
 
        
−
       pass -fixedFunction
+
       pass -fixedFunction        
−
        create LightingStatesNoStdLights()
+
 
         fillmode $stdMatFillMode
 
         fillmode $stdMatFillMode
  
Line 101: Line 270:
 
         alphaTestFunction acceptIfGreater
 
         alphaTestFunction acceptIfGreater
 
          
 
          
−
         if ($stdMatLightingDebug)
+
        depthTest true -enableDepthWrite false
 +
         if (viewerRenderType = $kRenderTypeImposter)
 +
            depthTestFunction acceptIfLessOrEqual
 +
        else
 +
            depthTestFunction acceptIfEqual
 +
        endif
 +
       
 +
        if (&addDetail)
 
             stage
 
             stage
−
               texture $stdMatBaseTextureName ${stdMatBaseTextureParam}
+
               texture $paintTexture
−
               textureBlend multiply(texture outRegister) select(outRegister)
+
              textureAddressing tile tile
 +
              ffTextureMatrix -scalev ($paintTextureScale, $paintTextureScale) -invert
 +
              textureTransformType vector2
 +
              ffTextureCoordsSource 0
 +
              textureBlend select(texture) select(outRegister)
 +
            end
 +
            stage
 +
              texture "${paintTexture}_detail"
 +
              textureAddressing tile tile
 +
              ffTextureMatrix -scalev ($paintDetailTextureScale, $paintDetailTextureScale) -invert
 +
              textureTransformType vector2
 +
              ffTextureCoordsSource 0
 +
               textureBlend lerpTextureAlpha(texture outRegister) select(outRegister)
 
             end  
 
             end  
 
         else
 
         else
−
             if (&addDetail)
+
             stage
−
               stage
+
               texture $paintTexture
−
                  texture $paintTexture
+
              textureAddressing tile tile
−
                  textureAddressing tile tile
+
              ffTextureMatrix -scalev ($paintTextureScale, $paintTextureScale) -invert
−
                  ffTextureMatrix -scalev ($paintTextureScale, $paintTextureScale) -invert
+
              textureTransformType vector2
−
                  textureTransformType vector2
+
               ffTextureCoordsSource 0
−
                  ffTextureCoordsSource 0
+
               textureBlend select(texture) select(outRegister)
−
                  textureBlend select(texture) select(outRegister)
+
            end  
−
               end
+
−
              stage
+
−
                  texture "${paintTexture}_detail"
+
−
                  textureAddressing tile tile
+
−
                  ffTextureMatrix -scalev ($paintDetailTextureScale, $paintDetailTextureScale) -invert
+
−
                  textureTransformType vector2
+
−
                  ffTextureCoordsSource 0
+
−
                  textureBlend lerpTextureAlpha(texture outRegister) select(outRegister)
+
−
               end
+
−
            else
+
−
              stage
+
−
                  texture $paintTexture
+
−
                  textureAddressing tile tile
+
−
                  ffTextureMatrix -scalev ($paintTextureScale, $paintTextureScale) -invert
+
−
                  textureTransformType vector2
+
−
                  ffTextureCoordsSource 0
+
−
                  textureBlend select(texture) select(outRegister)
+
−
              end  
+
−
            endif
+
 
         endif
 
         endif
 
         stage
 
         stage
Line 149: Line 318:
 
define TerrainPaint()
 
define TerrainPaint()
 
   material
 
   material
−
       if ($stdMatLightingDebug)
+
      create DetermineHardwareSupport()
−
         create LightingDebugStandardMaterialOverrides()
+
     
−
      endif
+
       if (viewerRenderType != $kRenderTypeShadowMap)  
−
      create TerrainPaintShader(true)
+
         if ($useHWShader1Path or $useHWShader2Path)
−
      create TerrainPaintShader(false)
+
      create TerrainPaintShaderVS_PS()
−
      shader
+
      else           
−
      end
+
            create TerrainPaintShader(true)
 +
            create TerrainPaintShader(false)
 +
            shader
 +
            end
 +
        endif     
 +
      endif     
 
   end
 
   end
 
enddef
 
enddef
Line 161: Line 335:
  
 
#==============================================================================
 
#==============================================================================
 +
define TerrainLightingVS_PS()
 +
  pass
 +
      fillmode $stdMatFillMode
 +
      alphaBlend srcFactor(destColor) add dstFactor(zero)           
 +
      depthTest true -enableDepthWrite false           
 +
      depthTestFunction acceptIfEqual
 +
     
 +
      shaderProgram -target vertexProgram -method compile -version 1_1
 +
        bindConstants 0 -bindingID geomToClip -constantCount 4
 +
bindConstants 4 -bindingID immediateData -data (1/64, 0, 0, 0)
 +
 +
shaderSource
 +
  float4x4 clipSpaceMatrix  : register(c0);
 +
  float4  textureConstants : register(c4);  
 +
 +
struct InputVertex
 +
{
 +
float3 position: POSITION0;
 +
float2 texcoord : TEXCOORD0;
 +
};
 +
 +
struct OutputVertex
 +
{
 +
float4 clipPosition : POSITION;
 +
float2 txBase  : TEXCOORD0;
 +
};
 +
 +
OutputVertex VertexMain( InputVertex i)
 +
{
 +
  OutputVertex o;
 +
  o.clipPosition = mul(float4(i.position, 1), clipSpaceMatrix);
 +
  o.txBase  = i.texcoord * textureConstants.xx;  
 +
  return o;
 +
}
 +
endShaderSource 
 +
      end # end shader program
 +
     
 +
     
 +
      shaderProgram -target pixelProgram -method compile -version 1_1
 +
        bindConstants 0 -bindingID immediateData -data ($terrainMatDiffCoef.x, $terrainMatDiffCoef.y, $terrainMatDiffCoef.z, 1)       
 +
       
 +
        shaderSource 
 +
            float4  terrainDiffCoef  : register(c0);
 +
                                   
 +
            sampler base;           
 +
            struct cInputPixel
 +
            {             
 +
              float2 tcBase : TEXCOORD0;             
 +
            };
 +
           
 +
            float4 PixelMain(cInputPixel pi) : COLOR
 +
            {       
 +
              float4 baseColor  = tex2D(base, pi.tcBase);                                                             
 +
              float4 result = 2.0*(baseColor*terrainDiffCoef);             
 +
              result.a = terrainDiffCoef.w;
 +
              return result;                       
 +
            }
 +
        endShaderSource
 +
      end # end shader program     
 +
       
 +
      sampler base
 +
        texture "floorLightMap_0"  # at the moment is deterministically mapped to page 0
 +
        textureAddressing tile tile
 +
      end           
 +
  end 
 +
enddef
 +
 
define TerrainLighting()
 
define TerrainLighting()
 
   material
 
   material
Line 167: Line 408:
 
       shader -layer (($terrainMatLayer - 1) * 8)
 
       shader -layer (($terrainMatLayer - 1) * 8)
 
         vertexFormatPred position      0 true
 
         vertexFormatPred position      0 true
−
        vertexFormatPred normal        0 true
 
 
         vertexFormatPred texcoord      0 true
 
         vertexFormatPred texcoord      0 true
−
         vertexFormatPred blendindices  0 false
+
         if (viewerRenderType != $kRenderTypeShadowMap)           
−
        vertexFormatPred targetindices 0 false
+
            if ($useHWShader2Path or $useHWShader1Path)
 +
              create TerrainLightingVS_PS()
 +
            else
 +
              pass -fixedFunction           
 +
                  fillmode $stdMatFillMode
  
−
        pass -fixedFunction
+
                  alphaBlend srcFactor(destColor) add dstFactor(zero)
−
            create LightingStatesNoStdLights()
+
−
            fillmode $stdMatFillMode
+
  
−
            alphaBlend srcFactor(destColor) add dstFactor(zero)
+
                  colorScalar $terrainMatDiffCoef 1  # important that alpha be one for ARGB capture.
  
−
            colorScalar $terrainMatDiffCoef 1  # important that alpha be one for ARGB capture.
+
                  ffDepthOffset 0
 +
                  depthTest true -enableDepthWrite false           
 +
                  depthTestFunction acceptIfEqual
  
−
            ffDepthOffset 0
+
                  stage
−
            depthTest true -enableDepthWrite false
+
                    texture "floorLightMap_0"  # at the moment is deterministically mapped to page 0
 +
                    # A page holds 64x64 tiles. A tile is one world unit wide.
 +
                    ffTextureMatrix -scalev (1/64, 1/64)
 +
                    textureTransformType vector2
 +
                    ffTextureCoordsSource 0
 +
                    textureBlend multiplyScale2(texture colorScalar) select(colorScalar)
 +
                  end
 +
              end                   
 +
                         
 +
              pass -fixedFunction
 +
                  create LightingStatesNoStdLights()
 +
                  fillmode $stdMatFillMode
  
−
            stage
+
                   alphaBlend srcFactor(zero) add dstFactor(one)
−
              texture "floorLightMap_0"  # at the moment is deterministically mapped to page 0
+
     
−
              # A page holds 64x64 tiles. A tile is one world unit wide.
+
                  ffDepthOffset 0
−
              ffTextureMatrix -scalev (1/64, 1/64)
+
                  depthTest true -enableDepthWrite false
−
              textureTransformType vector2
+
                  alphaTest true 100
−
              ffTextureCoordsSource 0
+
                  alphaTestFunction acceptIfLess
−
              textureBlend multiplyScale2(texture colorScalar) select(colorScalar)
+
     
−
            end
+
                  stage
−
        end   
+
                    texture "floorLightMap_0"  # at the moment is deterministically mapped to page 0
−
       
+
                    ffTextureMatrix -scalev (1/64, 1/64)
−
        if ($lmIntegratedShadows)
+
                    textureTransformType vector2
−
            pass -fixedFunction
+
                    ffTextureCoordsSource 0
−
              create LightingStatesNoStdLights()
+
                    textureBlend select(texture) select(texture)
−
              fillmode $stdMatFillMode
+
                  end  
−
             
+
              end            
−
              alphaBlend srcFactor(destColor) add dstFactor(zero)
+
            endif        
−
             
+
         endif
−
              depthTest true -enableDepthWrite true
+
−
              depthTestFunction acceptIfLess
+
−
              alphaTest true 100
+
−
              alphaTestFunction acceptIfGreater
+
−
 
+
−
              colorScalar (0.61, 0.61, 0.61)  # needs to be set by tsUserEtc
+
−
 
+
−
              ffDepthOffset 1
+
−
 
+
−
              stage
+
−
                   texture "floorLightMap_0" 
+
−
                  ffTextureMatrix -scalev (1/64, 1/64)
+
−
                  textureTransformType vector2
+
−
                  ffTextureCoordsSource 0
+
−
                  textureBlend select(colorScalar) select(texture)
+
−
              end
+
−
            end
+
−
        elseif (not ($useHWShader2Path or $useHWShader1Path)) # must match condition in OverlayShadowMaterialDef
+
−
            pass -fixedFunction
+
−
              create LightingStatesNoStdLights()
+
−
              fillmode $stdMatFillMode
+
−
 
+
−
              alphaBlend srcFactor(zero) add dstFactor(one)
+
−
 
+
−
              ffDepthOffset 1
+
−
              depthTest true -enableDepthWrite true
+
−
              alphaTest true 100
+
−
              alphaTestFunction acceptIfLess
+
−
 
+
−
              stage
+
−
                  texture "floorLightMap_0"  # at the moment is deterministically mapped to page 0
+
−
                  ffTextureMatrix -scalev (1/64, 1/64)
+
−
                  textureTransformType vector2
+
−
                  ffTextureCoordsSource 0
+
−
                  textureBlend select(texture) select(texture)
+
−
              end  
+
−
            end
+
−
        endif
+
−
          
+
 
       end
 
       end
 
   end
 
   end
Line 278: Line 494:
 
       vertexFormatPred targetindices 0 false
 
       vertexFormatPred targetindices 0 false
 
       viewerRenderTypePred viewerRenderType
 
       viewerRenderTypePred viewerRenderType
 +
       
 +
      setb cubeMapSupport (queryBooleanGraphicsDeviceCap(hasCubeMapSupport)) 
 +
      create DetermineHardwareSupport()           
 
        
 
        
−
       pass -fixedFunction
+
       pass -fixedFunction        
 
         # disable lighting, disable normalize normals, enable local viewer
 
         # disable lighting, disable normalize normals, enable local viewer
−
         create LightingStatesNoStdLightsParam(false true)             
+
         if ($useSWVertexShaderPath)
−
         alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
+
            create LightingStatesNoStdLights()
 +
        else
 +
            create LightingStatesNoStdLightsParam(false true)             
 +
        endif       
 +
         alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)                
  
 
         fillmode $stdMatFillMode
 
         fillmode $stdMatFillMode
−
         colorScalar (1, 1, 1) -applyTextureLightColor 0 0
+
         colorScalar (1, 1, 1) -applyTextureLightColor 0 0                          
−
       
+
                 
 
         stage
 
         stage
−
             texture reflectionoutdoorwater-envcube
+
             if ($cubeMapSupport)
−
            textureMIPFilterHint disabled  
+
              texture reflectionoutdoorwater-envcube
 +
              textureMIPFilterHint disabled  
  
−
            ffTextureCoordsSource fromReflectionVector
+
              ffTextureCoordsSource fromReflectionVector
−
            textureTransformType vector3
+
              textureTransformType vector3
−
            ffTextureMatrix -orientCameraToGlobal
+
              ffTextureMatrix -orientCameraToGlobal
  
−
            textureAddressing clamp clamp clamp
+
              textureAddressing clamp clamp clamp
−
            textureBlend multiply(texture colorScalar) select(diffuse)
+
              textureBlend multiply(texture colorScalar) select(diffuse)
−
         end
+
            else
 +
              colorScalar (0.3,0.5,1.0)  -applyTextureLightColor 0 0   
 +
              textureBlend select(colorScalar) select(diffuse)
 +
            endif
 +
         end          
 
       end   
 
       end   
 
        
 
        
−
       if (&withBumpMap)
+
       if (&withBumpMap)        
 
         pass -fixedFunction
 
         pass -fixedFunction
 
             create LightingStatesNoStdLights()
 
             create LightingStatesNoStdLights()
Line 340: Line 568:
 
define TerrainWater()
 
define TerrainWater()
 
   material
 
   material
−
       # only activate the water w/ bump shader for pixel shader capable HW
+
       # only activate the water w/ bump shader for pixel shader capable HW    
−
       if (queryIntegerGraphicsDeviceCap(maxPixelProgramVersionMajor) != 0)
+
       if (tsFrozenPond)
−
        create TerrainWaterShader(true)
+
        create TerrainWaterFrozen()
 +
      else
 +
        if (queryIntegerGraphicsDeviceCap(maxPixelProgramVersionMajor) != 0)        
 +
            create TerrainWaterShader(true)
 +
        endif
 +
        create TerrainWaterShader(false)  # fallback without bumps       
 
       endif
 
       endif
−
      create TerrainWaterShader(false)  # fallback without bumps
 
 
   end
 
   end
 
enddef
 
enddef
 +
 +
define TerrainWaterFrozen()
 +
  shader -layer 1
 +
      pass -fixedFunction
 +
            create LightingStatesNoStdLightsParam(false false)                         
 +
        alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
 +
        fillmode $stdMatFillMode
 +
        colorScalar (0.45, 0.45, 0.5, 0.475) -applyTextureLightColor 0 0
 +
       
 +
        stage
 +
            texture "ice-pond-surface"
 +
            textureAddressing tile tile                                                 
 +
            ffTextureCoordsSource fromPosition
 +
            ffTextureMatrix -cameraToGlobal -scale (5) -invert
 +
            textureBlend multiply(texture colorScalar) select(colorScalar)
 +
        end                       
 +
       
 +
        stage
 +
            texture "ice-pond-surface"
 +
            textureAddressing tile tile                                                 
 +
            ffTextureCoordsSource fromPosition
 +
            ffTextureMatrix -cameraToGlobal -scale (17) -invert                   
 +
            textureBlend multiplyAdd(texture colorScalar outRegister) add(colorScalar outRegister)
 +
        end
 +
      end                     
 +
  end
 +
enddef
  
 
#==============================================================================
 
#==============================================================================
 +
 +
define TerrainSnowShader() 
 +
  create DetermineHardwareSupport()
 +
  if ($useHWShader1Path or $useHWShader2Path)
 +
create TerrainSnow()
 +
else 
 +
      create TerrainSnowFF()
 +
  endif     
 +
enddef
 +
 +
define TerrainSnowFF()
 +
  material
 +
      shader -layer 0
 +
        pass -fixedFunction
 +
            depthTest true -enableDepthWrite true
 +
            if (tsIsDay)
 +
              colorScalar (0.5, 0.5, 0.52, 1)
 +
            else
 +
              colorScalar (0.15, 0.15, 0.375, 1)
 +
            endif
 +
             
 +
              stage                                       
 +
                  texture "snow-ground-diffuse"
 +
                  textureAddressing tile tile 
 +
                  ffTextureCoordsSource fromPosition
 +
                  ffTextureMatrix -cameraToGlobal -scalev (2, 2) -invert                           
 +
                  textureBlend multiply(texture colorScalar) select(colorScalar)
 +
              end           
 +
             
 +
              stage                                       
 +
                  texture "snow-ground-diffuse"
 +
                  textureAddressing tile tile 
 +
                  ffTextureCoordsSource fromPosition
 +
                  ffTextureMatrix -cameraToGlobal -scalev (13, 13) -invert                           
 +
                  textureBlend multiplyAdd(texture colorScalar outRegister) select(colorScalar)
 +
              end           
 +
        end
 +
      end
 +
  end
 +
enddef
 +
 +
define TerrainSnowPS1() 
 +
  shaderProgram -target pixelProgram -method compile -version 1_1 # -disassemble "c:\sims2ep5\hlslPS1_1.txt"                           
 +
      bindConstants 0 -bindingID cursorTerrainPosition -constantCount 1 -constantType float
 +
      if (tsIsDay)       
 +
        bindConstants 1 -bindingID immediateData -data (1.1, 1.1, 1.175, 1)       
 +
      else
 +
        bindConstants 1 -bindingID immediateData -data (0.35, 0.35, 1.0, 1)       
 +
      endif
 +
           
 +
      shaderSource
 +
        sampler normmap;
 +
                                                                                               
 +
        float4 cursorPos : register(c0);
 +
        float4 colorFactor : register(c1);
 +
       
 +
        struct v2f
 +
        {
 +
            float4 hpos : POSITION;                           
 +
            float4 color : COLOR0;            
 +
        float3 worldPos : COLOR1;              
 +
        float3 bumpCoords : TEXCOORD0;
 +
        float3 tanLightDir : TEXCOORD1;                                
 +
        };
 +
 +
        float4 PixelMain(v2f pi) : COLOR
 +
        {     
 +
            float4 normal = 2.0f * (tex2D(normmap, pi.bumpCoords) - 0.5f); 
 +
            float3 diffuse = saturate(dot(pi.tanLightDir, normal.xyz))*colorFactor.xyz;           
 +
            return float4(diffuse.xyz + pi.color, 1.0f);                       
 +
        }
 +
      endShaderSource                                                                                                           
 +
  end                                           
 +
 
 +
  sampler normmap
 +
      texture "snow-ground-bump"
 +
      textureAddressing tile tile
 +
  end
 +
 
 +
enddef
 +
 +
define TerrainSnowPS2() 
 +
  shaderProgram -target pixelProgram -method compile -version ${psVersion}_0  # -disassemble "c:\sims2ep5\hlslPS1_1.txt"                           
 +
      bindConstants 0 -bindingID cursorTerrainPosition -constantCount 1 -constantType float                       
 +
  if (tsIsDay)       
 +
        bindConstants 1 -bindingID immediateData -data (1.1, 1.1, 1.175, 1)       
 +
      else
 +
        bindConstants 1 -bindingID immediateData -data (0.35, 0.35, 1.0, 1)       
 +
      endif
 +
 +
      shaderSource                       
 +
       
 +
        sampler normmap;       
 +
       
 +
        float4 cursorPos : register(c0);
 +
        float4 colorFactor : register(c1);
 +
       
 +
        struct v2f
 +
        {
 +
            float4 hpos : POSITION;                           
 +
        float4 color : COLOR0;                                        
 +
        float3 worldPos : COLOR1;             
 +
        float2 bumpCoords : TEXCOORD0;                                 
 +
        float3 tanLightDir : TEXCOORD1;                                     
 +
        };
 +
 +
        float4 PixelMain(v2f pi) : COLOR
 +
        {                                                 
 +
            float4 normal0 = 2.0f * (tex2D(normmap, pi.bumpCoords) - 0.5f);                       
 +
            float4 normal1 = 2.0f * (tex2D(normmap, pi.bumpCoords*0.4f) - 0.5f);
 +
            float4 normal = 0.5f*(normal0+normal1);
 +
            float3 diffuse0 = saturate(dot(pi.tanLightDir, normal.xyz))*colorFactor.xyz;           
 +
           
 +
            float3 diffVec = cursorPos-pi.worldPos;           
 +
            diffVec *= 64.0f;
 +
            float blend = saturate(dot(diffVec, diffVec));                                                                                               
 +
            return float4(saturate(float3(diffuse0.xyz + pi.color.xxx)), blend);                       
 +
        }
 +
      endShaderSource
 +
  end                                           
 +
 
 +
  sampler normmap
 +
      texture "snow-ground-bump"
 +
      textureAddressing tile tile
 +
  end             
 +
 
 +
enddef
 +
 +
define TerrainSnowVS1()
 +
  shaderProgram -target vertexProgram -method compile -version 1_1
 +
      bindConstants 0 -bindingID  geomToClip    -constantCount 4       
 +
      bindConstants 4 -bindingID  geomToCamera  -constantCount 3
 +
bindConstants 7 -bindingID  cameraToGeom  -constantCount 3
 +
bindConstants 15 -bindingID ambientLight -constantCount 1 -constantType float                        
 +
bindConstants 18 -bindingID allStandardLightData -constantCount 4 -constantType float      
 +
 +
if (tsIsDay)       
 +
        bindConstants 10 -bindingID immediateData -data (1.2, 1.2, 1.2, 1)       
 +
      else
 +
        bindConstants 10 -bindingID immediateData -data (0.64, 0.64, 1.1, 1)       
 +
      endif
 +
     
 +
      bindConstants 12 -bindingID geomToGlobal -constantCount 3
 +
                   
 +
      bindConstants 22 -bindingID cameraToClipWithDepthOffset -constantCount 4 -data(0, 0, 0, 0)
 +
 +
shaderSource
 +
float4x4 modelviewproj : register(c0);
 +
float4x3 modelview : register(c4);
 +
float4x3 modelviewInv : register(c7);            
 +
        // light direction
 +
float4 lightDir0 : register(c18);
 +
float4 lightDir1 : register(c26);
 +
float4x4 cameraToClipWithDOMatrix : register(c22);
 +
        float4 ambient : register(c15);                                 
 +
        float4x3 modelToWorld : register(c12);
 +
     
 +
struct a2v
 +
        {
 +
            float4 pos : POSITION;                   
 +
            float3 normal : NORMAL;
 +
            float2 tangent : TEXCOORD0;
 +
            float2 bumpcoord : TEXCOORD1;                   
 +
        };
 +
 +
        struct v2f
 +
        {
 +
            float4 hpos : POSITION;                                         
 +
        float4 color : COLOR0;                                    
 +
        float3 worldPos : COLOR1;        
 +
        float2 bumpCoords : TEXCOORD0;
 +
        float3 tanLightDir : TEXCOORD1;                                                                                                                                       
 +
        };
 +
       
 +
        v2f VertexMain(a2v IN)
 +
        {
 +
        v2f OUT;
 +
 +
        // vertex position in object space
 +
        float4 pos = float4(IN.pos.x,IN.pos.y,IN.pos.z,1.0);  
 +
       
 +
        float3 tangent = float3(IN.tangent.x, IN.tangent.y, 0);
 +
                         
 +
        // compute binormal
 +
        float3 binormal = normalize(cross(IN.normal, tangent));
 +
       
 +
        // tangent space matrix
 +
        float3x3 tbn = float3x3(tangent, binormal, IN.normal);
 +
       
 +
        // light direction in object space                  
 +
        float3 lt0 = mul(lightDir0, (float3x3)modelviewInv);
 +
       
 +
        // light 0 direction in tangent space                                    
 +
        OUT.tanLightDir = normalize(mul(tbn, lt0));
 +
                       
 +
        OUT.bumpCoords = float2(IN.bumpcoord.x, IN.bumpcoord.y);
 +
       
 +
        // compute tangent space view vector
 +
        // object space view point
 +
        float3 viewPoint = mul(float4(0, 0, 0, 1), modelviewInv).xyz;
 +
        float3 viewVecObj = normalize(viewPoint - IN.pos.xyz);
 +
       
 +
        // object space light
 +
        float3 lightDirObj = normalize(mul(lightDir0, (float3x3)modelviewInv));
 +
       
 +
        // half angle vector in object space
 +
        float3 halfWayVector = normalize(lightDirObj + viewVecObj);                  
 +
       
 +
        // transform half angle vector to tangent space
 +
        //OUT.tanHalfAngle.xyz = normalize(mul(tbn, halfWayVector));
 +
       
 +
        // specular shadowing term
 +
        //OUT.tanHalfAngle.w = max(dot(halfWayVector, IN.normal), 0);                  
 +
       
 +
        // vertex position in clip space
 +
        float3 hposView = mul(pos, modelview);
 +
            OUT.hpos = mul(float4(hposView, 1), cameraToClipWithDOMatrix);                                     
 +
           
 +
            // vertex position in world space
 +
            OUT.worldPos = mul(pos, modelToWorld)/64.0f;                                           
 +
                                                             
 +
        OUT.color.xyz = ambient.xyz*0.3f;
 +
        OUT.color.w = 1.0;        
 +
        return OUT;
 +
        }
 +
                 
 +
endShaderSource
 +
  end # end shader program 
 +
enddef
 +
 +
define TerrainSnow()
 +
  material
 +
      shader -layer 1       
 +
        validateRenderShaderContext -vertexFormat position 0 required
 +
        validateRenderShaderContext -vertexFormat normal 0 required
 +
        validateRenderShaderContext -vertexFormat texcoord 0 required
 +
        validateRenderShaderContext -vertexFormat texcoord 1 required
 +
       
 +
        create DetermineHardwareSupport()
 +
                         
 +
        pass
 +
            alphaTest true 5
 +
            alphaTestFunction acceptIfGreater
 +
 +
            alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
 +
            depthTest true -enableDepthWrite true
 +
           
 +
            create TerrainSnowVS1()
 +
           
 +
            if ($useHWShader1Path)
 +
              create TerrainSnowPS1()
 +
            elseif ($useHWShader2Path)             
 +
              create TerrainSnowPS2()
 +
            endif
 +
                                                 
 +
        end # end pass
 +
       
 +
      end #end shader
 +
  end # end material
 +
enddef
 +
 +
define XRayCursorMaterial()
 +
  material
 +
      shader -layer (0)
 +
        pass -fixedFunction -modifiedEachFrameHint
 +
            alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
 +
            depthTest true -enableDepthWrite false
 +
                       
 +
            colorScalar (1, 1, 0, 0.0)
 +
            stage
 +
              textureBlend select(colorScalar) select(colorScalar)
 +
            end
 +
        end
 +
      end
 +
  end
 +
enddef
 +
 +
define LightSnowDayPS(psFullVersion)
 +
  shaderProgram -target pixelProgram -method compile -version &psFullVersion
 +
      if ($singlePass)
 +
        bindConstants 0 -bindingID immediateData -data (0, 0, 0, 0) -constantType float
 +
      else
 +
        bindConstants 0 -bindingID immediateData -data (1, 0, 0, 0) -constantType float
 +
      endif
 +
     
 +
      shaderSource   
 +
        float scale2Factor : register(c0);       
 +
                               
 +
        sampler base;           
 +
        sampler base2;
 +
        struct cInputPixel
 +
        {             
 +
            float2 txScale1  : TEXCOORD0;
 +
float2 txScale2  : TEXCOORD1;
 +
        };
 +
       
 +
        float4 PixelMain(cInputPixel pi) : COLOR
 +
        {       
 +
            float4 scale1Color = tex2D(base, pi.txScale1);                                               
 +
            float4 scale2Color = tex2D(base2, pi.txScale2)*scale2Factor.x;                             
 +
            float4 result = (scale1Color + scale2Color);           
 +
            return result;                       
 +
        }
 +
      endShaderSource
 +
  end # end shader program     
 +
enddef
 +
 +
define LightSnowNightPS(psFullVersion)
 +
  shaderProgram -target pixelProgram -method compile -version &psFullVersion
 +
      if ($singlePass)
 +
        bindConstants 0 -bindingID immediateData -data (0, 0, 0, 0) -constantType float
 +
      else
 +
        bindConstants 0 -bindingID immediateData -data (1, 1, 0, 0) -constantType float
 +
      endif
 +
     
 +
      shaderSource   
 +
        float2 scale2Factor : register(c0);       
 +
                               
 +
        sampler base; 
 +
        sampler base2;
 +
        sampler lightMap;         
 +
        struct cInputPixel
 +
        {             
 +
            float2 txScale1  : TEXCOORD0;
 +
float2 txScale2  : TEXCOORD1;
 +
float2 txltMap  : TEXCOORD2;
 +
        };
 +
       
 +
        float4 PixelMain(cInputPixel pi) : COLOR
 +
        {       
 +
            float4 scale1Color = tex2D(base, pi.txScale1);                                               
 +
            scale1color.xyz = scale1color.xyz;
 +
            float4 scale2Color = tex2D(base2, pi.txScale2)*scale2Factor.x;
 +
            float4 result = (scale1Color + scale2Color);             
 +
            float4 lightMapColor = tex2D(lightMap, pi.txltMap);
 +
            return float4(result.xyz*lightMapColor.xyz, result.w);                       
 +
        }
 +
      endShaderSource
 +
  end # end shader program     
 +
enddef
 +
 +
 +
define LightSnowVS_PS()
 +
  pass
 +
      alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
 +
      depthTest true -enableDepthWrite false     
 +
      depthTestFunction acceptIfEqual
 +
     
 +
      shaderProgram -target vertexProgram -method compile -version 1_1
 +
        bindConstants 0 -bindingID geomToClip -constantCount 4
 +
        bindConstants 4 -bindingID geomToGlobal -constantCount 3
 +
        bindConstants 8 -bindingID immediateData -data (1/(($scaleStage1).x), 1/(($scaleStage1).y), 1/(($scaleStage2).x), 1/(($scaleStage2).y)) -constantType float
 +
 +
shaderSource
 +
  float4x4 clipSpaceMatrix  : register(c0);  
 +
  float4x3 modelToWorld : register(c4);
 +
  float4 scaleData : register(c8);
 +
 +
struct InputVertex
 +
{
 +
float3 position: POSITION0;
 +
float2 txCoord : TEXCOORD0;
 +
};
 +
 +
struct OutputVertex
 +
{
 +
float4 clipPosition : POSITION;
 +
float2 txScale1  : TEXCOORD0;
 +
float2 txScale2  : TEXCOORD1;
 +
float2 txltMap    : TEXCOORD2;
 +
};
 +
 +
OutputVertex VertexMain( InputVertex i)
 +
{
 +
  OutputVertex o;
 +
  o.clipPosition = mul(float4(i.position, 1), clipSpaceMatrix);
 +
  float3 worldPos = mul(float4(i.position.xyz, 1.0f), modelToWorld);
 +
  o.txScale1  = worldPos.xy * scaleData.xy;
 +
  o.txScale2  = worldPos.xy * scaleData.zw;
 +
  o.txltMap  = i.txCoord;
 +
  return o;
 +
}
 +
endShaderSource 
 +
      end # end shader program
 +
     
 +
      if (tsIsDay)
 +
        if ($useHWShader1Path)
 +
      create LightSnowDayPS("1_1")
 +
      else 
 +
            create LightSnowDayPS(${psVersion}_0)
 +
        endif
 +
      else
 +
        if ($useHWShader1Path)
 +
      create LightSnowNightPS("1_1")
 +
      else 
 +
            create LightSnowNightPS(${psVersion}_0)
 +
        endif
 +
      endif
 +
       
 +
      sampler base
 +
        texture "${snowTexture}"
 +
        textureAddressing tile tile
 +
      end
 +
     
 +
      sampler base2
 +
        texture "${snowTexture2}"
 +
        textureAddressing tile tile
 +
      end
 +
     
 +
      if (not tsIsDay)
 +
        sampler lightMap
 +
            texture "floorLightMap_${page}"
 +
            textureAddressing tile tile
 +
        end
 +
      endif
 +
  end
 +
enddef
 +
 +
define LightSnowFF()
 +
  pass -fixedFunction       
 +
      alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
 +
      fillmode $stdMatFillMode           
 +
      depthTest true -enableDepthWrite false                       
 +
     
 +
      if ($kRaiseLightSnowFF)
 +
        ffDepthOffset 2
 +
        depthTestFunction acceptIfLessOrEqual     
 +
      else
 +
        depthTestFunction acceptIfEqual     
 +
      endif     
 +
             
 +
      stage
 +
        texture $snowTexture
 +
        textureAddressing tile tile
 +
        ffTextureCoordsSource fromPosition
 +
        ffTextureMatrix -cameraToGlobal -scalev $scaleStage1 -invert             
 +
        textureBlend select(texture) select(texture)
 +
      end
 +
     
 +
      if (not $singlePass)         
 +
        stage
 +
            texture $snowTexture2
 +
            textureAddressing tile tile
 +
            ffTextureMatrix  -cameraToGlobal -scalev $scaleStage2 -invert
 +
            ffTextureCoordsSource fromPosition
 +
            textureBlend add(texture outRegister) add(outRegister texture)
 +
        end
 +
      else
 +
        # a dummy stage so if the shader has to fail it should fail
 +
        stage           
 +
            texture "floorLightMap_${page}"
 +
            textureBlend select(outRegister) select(outRegister)
 +
        end
 +
      endif     
 +
 +
     
 +
      if (not tsIsDay)
 +
        stage
 +
            texture "floorLightMap_${page}"
 +
            textureAddressing tile tile
 +
            ffTextureCoordsSource 0                                           
 +
            textureBlend multiplyScale2(texture outRegister) select(outRegister)
 +
        end
 +
      endif
 +
     
 +
      # a dummy stage so if the shader has to fail it should fail
 +
      stage           
 +
        texture "floorLightMap_${page}"
 +
        textureBlend select(outRegister) select(outRegister)
 +
      end
 +
 
 +
  end     
 +
enddef
 +
 +
define LightSnowFFLowEnd()
 +
  pass -fixedFunction       
 +
      alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
 +
      fillmode $stdMatFillMode           
 +
      depthTest true -enableDepthWrite false                 
 +
      ffDepthOffset 1
 +
      depthTestFunction acceptIfLessOrEqual     
 +
     
 +
      if (tsIsDay)       
 +
        colorScalar (1, 1, 1, 1)       
 +
      else
 +
        colorScalar (0.17, 0.17, 0.43, 1)       
 +
      endif
 +
             
 +
      stage
 +
        texture $snowTexture
 +
        textureAddressing tile tile
 +
        ffTextureCoordsSource fromPosition
 +
        ffTextureMatrix -cameraToGlobal -scalev $scaleStage1 -invert             
 +
        textureBlend multiply(texture colorScalar) select(texture)
 +
      end
 +
     
 +
      if (not $singlePass)         
 +
        stage
 +
            texture $snowTexture
 +
            textureAddressing tile tile
 +
            ffTextureMatrix  -cameraToGlobal -scalev $scaleStage2 -invert
 +
            ffTextureCoordsSource fromPosition
 +
            textureBlend multiplyAdd(texture colorScalar outRegister) add(outRegister texture)
 +
        end
 +
      else
 +
        stage
 +
            texture $snowTexture
 +
            textureAddressing tile tile
 +
            ffTextureCoordsSource fromPosition
 +
            ffTextureMatrix -cameraToGlobal -scalev $scaleStage1 -invert             
 +
            textureBlend multiplyAdd(texture colorScalar outRegister) select(outRegister)
 +
        end
 +
      endif     
 +
 +
  end     
 +
enddef
 +
 +
define LightSnow()
 +
  material
 +
      setv2 scaleStage1 (23, 23)
 +
      setv2 scaleStage2 (17, 17)
 +
     
 +
      if (tsHasHail)
 +
        set snowTexture "hail-ground-surface"
 +
        set snowTexture2 "hail-ground-surface"
 +
        setv2 scaleStage1 (4, 4)
 +
        setv2 scaleStage2 (3, 3)
 +
      endif
 +
 +
      shader -layer (-1)
 +
        create DetermineHardwareSupport()           
 +
        if ((not $kRaiseLightSnowFF and $useHWShader1Path) or $useHWShader2Path)
 +
      create LightSnowVS_PS()
 +
      else 
 +
            create LightSnowFF() # can use more than two stages
 +
        endif
 +
      end
 +
     
 +
      shader -layer (-1)      #if the above shader fails for some reason
 +
        create LightSnowFFLowEnd()
 +
      end
 +
  end 
 +
enddef
 +
 +
materialDefinition TerrainSnowMaterial
 +
  setDefinition TerrainSnowShader   
 +
end
 +
 +
materialDefinition RoadSnowMaterial
 +
  setDefinition LightSnow
 +
  addParam snowTexture snow-light-pass2 
 +
  addParam snowTexture2 snow-light-pass1 
 +
  addParam singlePass true
 +
  addParam page 0
 +
end
 +
 +
materialDefinition LightSnowMaterial
 +
  setDefinition LightSnow
 +
  addParam snowTexture snow-light-pass2
 +
  addParam snowTexture2 snow-light-pass1
 +
  addParam singlePass false
 +
  addParam page 0 
 +
end
  
 
materialDefinition terrainLightingMaterial
 
materialDefinition terrainLightingMaterial
Line 357: Line 1,179:
 
   setDefinition TerrainWater
 
   setDefinition TerrainWater
 
end
 
end
 +
 +
materialDefinition XrayCursorBoxDirtyRectMaterial
 +
  setDefinition XRayCursorMaterial
 +
end
 +
 +
define GeneralSnowMaterialFF()
 +
  material     
 +
      shader -layer ($stdMatLayer)
 +
        pass -fixedFunction           
 +
            create LightingStatesParam(false false)     
 +
            setv3 half (0.5,0.5,0.5)
 +
            if ($stdMatSpecPower != 0)
 +
        ffMatCoef -amb ($stdMatDiffCoef * $half) -ambAlpha $stdMatAlphaMultiplier -diff ($stdMatDiffCoef * $half) -diffAlpha $stdMatAlphaMultiplier -spec $stdMatSpecCoef -specPow $stdMatSpecPower
 +
        addSpecular true
 +
        else
 +
        ffMatCoef -amb ($stdMatDiffCoef * $half) -ambAlpha $stdMatAlphaMultiplier -diff ($stdMatDiffCoef * $half) -diffAlpha $stdMatAlphaMultiplier -spec (0,0,0) -specPow 0
 +
        endif
 +
       
 +
        create StandardShaderFBAlphaState($stdMatAlphaBlendMode)
 +
                       
 +
       
 +
        stage
 +
            texture $stdMatBaseTextureName
 +
            textureBlend multiplyScale2(diffuse texture) select(texture)
 +
        end        
 +
       
 +
        if (tsIsDay)
 +
        colorScalar $colorToAdd
 +
            stage            
 +
              textureBlend add(outRegister colorScalar) select(outRegister)
 +
            end                
 +
        endif
 +
       
 +
      end
 +
           
 +
      end
 +
  end
 +
enddef
 +
 +
define GeneralReflectiveMaterial()
 +
  create StandardMaterial()
 +
enddef
 +
 +
materialDefinition puddle_liquid_rain
 +
  setDefinition GeneralReflectiveMaterial
 +
  addParam deprecatedStdMatInvDiffuseCoeffMultiplier 1.2
 +
  addParam forceHighQualitySkinning 0
 +
  addParam forceIgnoreShapeBlend 0
 +
  addParam reflectivity 0.1
 +
  addParam stdMatAlphaBlendMode blend
 +
  addParam stdMatAlphaMultiplier 0.5
 +
  addParam stdMatAlphaRefValue 127
 +
  addParam stdMatAlphaTestEnabled 0
 +
  addParam stdMatBaseTextureAlphaReplicate 0
 +
  addParam stdMatCullMode cullClockwise
 +
  addParam stdMatDiffCoef 0.39,0.46,0.49
 +
  addParam stdMatEmissiveCoef 0,0,0
 +
  addParam stdMatEnvCubeBlurFactor 0.000000
 +
  addParam stdMatEnvCubeCoef 0.3,0.3,0.3
 +
  addParam stdMatEnvCubeLockedToCamera 0
 +
  addParam stdMatEnvCubeMode reflection
 +
  addParam stdMatEnvCubeTextureName reflectionkitchenhighcontrast-envcube
 +
  addParam stdMatFillMode solid
 +
  addParam stdMatLayer 0
 +
  addParam stdMatLightingEnabled 1
 +
  addParam stdMatMinLightRangeHint 4
 +
  addParam stdMatSpecCoef 0.54,0.72,0.76
 +
  addParam stdMatSpecPower 22     
 +
  addParam stdMatAddLayer -10
 +
end
 +
 +
materialDefinition puddle_liquid_blue
 +
  setDefinition GeneralReflectiveMaterial
 +
  addParam deprecatedStdMatInvDiffuseCoeffMultiplier 1.2
 +
  addParam forceHighQualitySkinning 0
 +
  addParam forceIgnoreShapeBlend 0
 +
  addParam reflectivity 0.1
 +
  addParam stdMatAlphaBlendMode blend
 +
  addParam stdMatAlphaMultiplier 0.5
 +
  addParam stdMatAlphaRefValue 127
 +
  addParam stdMatAlphaTestEnabled 0
 +
  addParam stdMatBaseTextureAlphaReplicate 0
 +
  addParam stdMatCullMode cullClockwise
 +
  addParam stdMatDiffCoef 0.23,0.41,0.49
 +
  addParam stdMatEmissiveCoef 0,0,0
 +
  addParam stdMatEnvCubeBlurFactor 0.000000
 +
  addParam stdMatEnvCubeCoef 0.1,0.1,0.1
 +
  addParam stdMatEnvCubeLockedToCamera 0
 +
  addParam stdMatEnvCubeMode reflection
 +
  addParam stdMatEnvCubeTextureName reflectionkitchenhighcontrast-envcube
 +
  addParam stdMatFillMode solid
 +
  addParam stdMatLayer 0
 +
  addParam stdMatLightingEnabled 1
 +
  addParam stdMatMinLightRangeHint 4
 +
  addParam stdMatSpecCoef 0.55,0.55,0.55
 +
  addParam stdMatSpecPower 6.1 
 +
  addParam stdMatAddLayer -10
 +
end
 +
  
 
#endshader
 
#endshader
  
 
</pre>
 
</pre>

Latest revision as of 05:56, 7 September 2007


EP6-BV
0xCD7FE87A
0x1C0532FA
0x4CE399AB
0xFF1AFA1C
# terrain

#
# Shaders for terrain tiles
#
#

setf  waterbumpMapScale    4.0
setv3 thumbnailMatDiffCoef (0.75, 0.93, 0.75)
seti  terrainMatLayer -2

# multiplier on terrain (grass/paints) both on the lot and
# lot skirts. (See lotSkirt.matShad.)
setc terrainMatDiffCoef (0.9, 0.9, 0.9)

# Specifies the number of tiles over which the paint & bump textures should be applied.
setf  canvasDetailTextureScale            4
setf  canvasBaseTextureScale             20
setf  paintTextureScale                  20
setf  paintDetailTextureScale            4.0
setb  hasCutout false

#==============================================================================

define TerrainCanvasShaderShaderVS_PS()
   pass
      fillmode $stdMatFillMode      
      depthTest true -enableDepthWrite true                  
      
      if ($hasCutout)                         
         depthTestFunction acceptIfEqual
      else
         depthTestFunction acceptIfLessOrEqual
      endif
      
      shaderProgram -target vertexProgram -method compile -version 1_1
         bindConstants 0 -bindingID geomToClip -constantCount 4			
			bindConstants 4 -bindingID immediateData -data (1/$canvasBaseTextureScale, 1/$canvasDetailTextureScale, 0, 0)
			
			shaderSource
			   float4x4 clipSpaceMatrix  : register(c0);
			   float4   textureConstants : register(c4);
			
			struct InputVertex
				{
					float3 position: POSITION0;
					float2 texcoord : TEXCOORD0;
				};
				
				struct OutputVertex
				{
					float4 clipPosition : POSITION;
					float2 txBase  : TEXCOORD0;
					float2 txDetail: TEXCOORD1;
				};
				
				OutputVertex VertexMain( InputVertex i)
				{
				   OutputVertex o;
				   o.clipPosition = mul(float4(i.position, 1), clipSpaceMatrix);
				   o.txBase   = i.texcoord * textureConstants.x;
				   o.txDetail = i.texcoord * textureConstants.y;				   
				   return o;
				}
			endShaderSource  
      end # end shader program
      
      
      shaderProgram -target pixelProgram -method compile -version 1_1      
         shaderSource                            
            sampler base;
            sampler detail;
            struct cInputPixel
            {               
               float2 tcBase : TEXCOORD0;
               float2 tcDetail : TEXCOORD1;
            };
            
            float4 PixelMain(cInputPixel pi) : COLOR
            {         
               float4 baseColor   = tex2D(base, pi.tcBase);                                                
               float4 detailColor = tex2D(detail, pi.tcDetail);                              
               float4 result = (detailColor.a * detailColor) + ((1 - detailColor.a) * baseColor);               
               return result;                        
            }
         endShaderSource
      end # end shader program      
         
      sampler base
         texture "${texture}"
         textureAddressing tile tile
      end
      
      sampler detail
         texture "${texture}_detail"
         textureAddressing tile tile
      end      
   end
enddef

define TerrainCanvasShaderShaderFF()
   pass -fixedFunction         
      fillmode $stdMatFillMode
      
      depthTest true -enableDepthWrite true                  
      
      if ($hasCutout)                         
         depthTestFunction acceptIfEqual
      else
         depthTestFunction acceptIfLessOrEqual
      endif
               
      stage
         texture "${texture}"
         textureAddressing tile tile
         ffTextureMatrix -scalev ($canvasBaseTextureScale, $canvasBaseTextureScale) -invert
         ffTextureCoordsSource 0
         textureBlend select(texture) select(texture)
      end 
      stage
         texture "${texture}_detail"
         textureAddressing tile tile
         ffTextureMatrix -scalev ($canvasDetailTextureScale, $canvasDetailTextureScale) -invert
         ffTextureCoordsSource 0
         textureBlend lerpTextureAlpha(texture outRegister) select(outRegister)
      end 
   end       
enddef

define TerrainCanvasShader()
   material
      shader -layer (($terrainMatLayer - 3) * 8)
         vertexFormatPred position      0 true
         vertexFormatPred normal        0 true
         vertexFormatPred texcoord      0 true
         viewerRenderTypePred viewerRenderType
         
         create DetermineHardwareSupport()
         if (viewerRenderType = $kRenderTypeShadowMap)
	         create ShadowMapVS_PS()
	      else
            if ($useHWShader1Path or $useHWShader2Path)	
		         create TerrainCanvasShaderShaderVS_PS()		
	         else   
               create TerrainCanvasShaderShaderFF()
            endif
         endif
      end
      
      shader
      end
   end
enddef

#==============================================================================

define TerrainPaintShaderVS_PS()
   shader -layer (($terrainMatLayer - 2) * 8)
      vertexFormatPred position      0 true
      vertexFormatPred texcoord      0 true
      pass
         fillmode $stdMatFillMode
         alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
         
         alphaTest true 10
         alphaTestFunction acceptIfGreater
         
         depthTest true -enableDepthWrite false
         if (viewerRenderType = $kRenderTypeImposter)
            depthTestFunction acceptIfLessOrEqual
         else
            depthTestFunction acceptIfEqual
         endif
         
         shaderProgram -target vertexProgram -method compile -version 1_1
            bindConstants 0 -bindingID geomToClip -constantCount 4			
			   bindConstants 4 -bindingID immediateData -data (1/$canvasBaseTextureScale, 1/$canvasDetailTextureScale, $alphaMapScaleU, $alphaMapScaleV)
   			
			   shaderSource
			      float4x4 clipSpaceMatrix  : register(c0);
			      float4   textureConstants : register(c4);
   			
			   struct InputVertex
				   {
					   float3 position: POSITION0;
					   float2 texcoord : TEXCOORD0;
				   };
   				
				   struct OutputVertex
				   {
					   float4 clipPosition : POSITION;
					   float2 txBase  : TEXCOORD0;
					   float2 txDetail: TEXCOORD1;
					   float2 txAlpha : TEXCOORD2;
				   };
   				
				   OutputVertex VertexMain( InputVertex i)
				   {
				      OutputVertex o;
				      o.clipPosition = mul(float4(i.position, 1), clipSpaceMatrix);
				      o.txBase   = i.texcoord * textureConstants.x;
				      o.txDetail = i.texcoord * textureConstants.y;				   
				      o.txAlpha  = i.texcoord.xy * textureConstants.zw;
				      return o;
				   }
			   endShaderSource  
         end # end shader program
         
         
         shaderProgram -target pixelProgram -method compile -version 1_1      
            shaderSource                            
               sampler base;
               sampler detail;
               sampler alphaMap;
               struct cInputPixel
               {               
                  float2 tcBase : TEXCOORD0;
                  float2 tcDetail : TEXCOORD1;
                  float2 tcAlpha  : TEXCOORD2;
               };
               
               float4 PixelMain(cInputPixel pi) : COLOR
               {         
                  float4 baseColor   = tex2D(base, pi.tcBase);                                                
                  float4 detailColor = tex2D(detail, pi.tcDetail);                              
                  float4 alphaColor  = tex2D(alphaMap, pi.tcAlpha);
                  float4 result = (detailColor.a * detailColor) + ((1 - detailColor.a) * baseColor);               
                  result.a = alphaColor.a;
                  return result;                        
               }
            endShaderSource
         end # end shader program      
            
         sampler base
            texture $paintTexture
            textureAddressing tile tile
         end
         
         sampler detail
            texture "${paintTexture}_detail"
            textureAddressing tile tile
         end
         
         sampler alphaMap
            texture $alphaMap
            textureAddressing clamp clamp
         end      
      end
   end
enddef

define TerrainPaintShader(addDetail)
   shader -layer (($terrainMatLayer - 2) * 8)
      vertexFormatPred position      0 true
      vertexFormatPred texcoord      0 true
      
      pass -fixedFunction         
         fillmode $stdMatFillMode

         alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
         
         alphaTest true 10
         alphaTestFunction acceptIfGreater
         
         depthTest true -enableDepthWrite false
         if (viewerRenderType = $kRenderTypeImposter)
            depthTestFunction acceptIfLessOrEqual
         else
            depthTestFunction acceptIfEqual
         endif
         
         if (&addDetail)
            stage
               texture $paintTexture
               textureAddressing tile tile
               ffTextureMatrix -scalev ($paintTextureScale, $paintTextureScale) -invert
               textureTransformType vector2
               ffTextureCoordsSource 0
               textureBlend select(texture) select(outRegister)
            end 
            stage
               texture "${paintTexture}_detail"
               textureAddressing tile tile
               ffTextureMatrix -scalev ($paintDetailTextureScale, $paintDetailTextureScale) -invert
               textureTransformType vector2
               ffTextureCoordsSource 0
               textureBlend lerpTextureAlpha(texture outRegister) select(outRegister)
            end 
         else
            stage
               texture $paintTexture
               textureAddressing tile tile
               ffTextureMatrix -scalev ($paintTextureScale, $paintTextureScale) -invert
               textureTransformType vector2
               ffTextureCoordsSource 0
               textureBlend select(texture) select(outRegister)
            end 
         endif
         stage
            texture $alphaMap
            textureAddressing clamp clamp
            ffTextureMatrix -scalev ($alphaMapScaleU, $alphaMapScaleV)
            ffTextureCoordsSource 0
            textureBlend select(outRegister) select(texture)
         end 
      end       
   end
enddef


define TerrainPaint()
   material
      create DetermineHardwareSupport()
      
      if (viewerRenderType != $kRenderTypeShadowMap)   
         if ($useHWShader1Path or $useHWShader2Path)	
		      create TerrainPaintShaderVS_PS()
	      else            
            create TerrainPaintShader(true)
            create TerrainPaintShader(false)
            shader
            end
         endif      
      endif      
   end
enddef


#==============================================================================
define TerrainLightingVS_PS()
   pass
      fillmode $stdMatFillMode
      alphaBlend srcFactor(destColor) add dstFactor(zero)            
      depthTest true -enableDepthWrite false            
      depthTestFunction acceptIfEqual
      
      shaderProgram -target vertexProgram -method compile -version 1_1
         bindConstants 0 -bindingID geomToClip -constantCount 4			
			bindConstants 4 -bindingID immediateData -data (1/64, 0, 0, 0)			
			
			shaderSource
			   float4x4 clipSpaceMatrix  : register(c0);
			   float4   textureConstants : register(c4);			   
			
			struct InputVertex
				{
					float3 position: POSITION0;
					float2 texcoord : TEXCOORD0;
				};
				
				struct OutputVertex
				{
					float4 clipPosition : POSITION;
					float2 txBase  : TEXCOORD0;					
				};
				
				OutputVertex VertexMain( InputVertex i)
				{
				   OutputVertex o;
				   o.clipPosition = mul(float4(i.position, 1), clipSpaceMatrix);
				   o.txBase   = i.texcoord * textureConstants.xx;				   
				   return o;
				}
			endShaderSource  
      end # end shader program
      
      
      shaderProgram -target pixelProgram -method compile -version 1_1
         bindConstants 0 -bindingID immediateData -data ($terrainMatDiffCoef.x, $terrainMatDiffCoef.y, $terrainMatDiffCoef.z, 1)         
         
         shaderSource   
            float4   terrainDiffCoef  : register(c0);
                                     
            sampler base;            
            struct cInputPixel
            {               
               float2 tcBase : TEXCOORD0;               
            };
            
            float4 PixelMain(cInputPixel pi) : COLOR
            {         
               float4 baseColor   = tex2D(base, pi.tcBase);                                                               
               float4 result = 2.0*(baseColor*terrainDiffCoef);               
               result.a = terrainDiffCoef.w;
               return result;                        
            }
         endShaderSource
      end # end shader program      
         
      sampler base
         texture "floorLightMap_0"  # at the moment is deterministically mapped to page 0
         textureAddressing tile tile
      end            
   end   
enddef

define TerrainLighting()
   material
   	create DetermineHardwareSupport()

      shader -layer (($terrainMatLayer - 1) * 8)
         vertexFormatPred position      0 true
         vertexFormatPred texcoord      0 true
         if (viewerRenderType != $kRenderTypeShadowMap)            
            if ($useHWShader2Path or $useHWShader1Path)
               create TerrainLightingVS_PS()
            else
               pass -fixedFunction            
                  fillmode $stdMatFillMode

                  alphaBlend srcFactor(destColor) add dstFactor(zero)

                  colorScalar $terrainMatDiffCoef 1  # important that alpha be one for ARGB capture.

                  ffDepthOffset 0
                  depthTest true -enableDepthWrite false            
                  depthTestFunction acceptIfEqual

                  stage
                     texture "floorLightMap_0"  # at the moment is deterministically mapped to page 0
                     # A page holds 64x64 tiles. A tile is one world unit wide.
                     ffTextureMatrix -scalev (1/64, 1/64)
                     textureTransformType vector2
                     ffTextureCoordsSource 0
                     textureBlend multiplyScale2(texture colorScalar) select(colorScalar)
                  end 
               end                     
                           
               pass -fixedFunction
                  create LightingStatesNoStdLights()
                  fillmode $stdMatFillMode

                  alphaBlend srcFactor(zero) add dstFactor(one)
      
                  ffDepthOffset 0
                  depthTest true -enableDepthWrite false
                  alphaTest true 100
                  alphaTestFunction acceptIfLess
      
                  stage
                     texture "floorLightMap_0"  # at the moment is deterministically mapped to page 0
                     ffTextureMatrix -scalev (1/64, 1/64)
                     textureTransformType vector2
                     ffTextureCoordsSource 0
                     textureBlend select(texture) select(texture)
                  end 
               end             
            endif         
         endif
      end
   end
enddef

#==============================================================================
define TerrainToolThumbnail()
   material
      shader -layer ($terrainMatLayer * 8)
         vertexFormatPred position      0 true
         vertexFormatPred normal        0 true
         vertexFormatPred texcoord      0 true
         vertexFormatPred blendindices  0 false
         vertexFormatPred targetindices 0 false

         pass -fixedFunction
            create LightingStates()
            alphaBlend srcFactor(srcAlpha) add dstFactor(zero)
            colorScalar $thumbnailMatDiffCoef
            fillmode $stdMatFillMode
            
            stage
               texture $paintTexture
               textureAddressing tile tile
               textureBlend multiplyScale2(texture diffuse) select(texture)
            end 
         end       
      end
   end
enddef

define TerrainWaterShader(withBumpMap)
   shader -layer 1
      vertexFormatPred position      0 true
      vertexFormatPred normal        0 true
      vertexFormatPred color         0 true
      vertexFormatPred texcoord      0 true
      vertexFormatPred blendindices  0 false
      vertexFormatPred targetindices 0 false
      viewerRenderTypePred viewerRenderType
         
      setb cubeMapSupport (queryBooleanGraphicsDeviceCap(hasCubeMapSupport))   
      create DetermineHardwareSupport()            
      
      pass -fixedFunction         
         # disable lighting, disable normalize normals, enable local viewer
         if ($useSWVertexShaderPath)
            create LightingStatesNoStdLights()
         else
            create LightingStatesNoStdLightsParam(false true)            
         endif         
         alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)                  

         fillmode $stdMatFillMode
         colorScalar (1, 1, 1) -applyTextureLightColor 0 0                           
                  
         stage
            if ($cubeMapSupport)
               texture reflectionoutdoorwater-envcube
               textureMIPFilterHint disabled 

               ffTextureCoordsSource fromReflectionVector
               textureTransformType vector3
               ffTextureMatrix -orientCameraToGlobal

               textureAddressing clamp clamp clamp
               textureBlend multiply(texture colorScalar) select(diffuse)
            else
               colorScalar (0.3,0.5,1.0)  -applyTextureLightColor 0 0     
               textureBlend select(colorScalar) select(diffuse)
            endif
         end           
      end   
      
      if (&withBumpMap)         
         pass -fixedFunction
            create LightingStatesNoStdLights()
            alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
            fillmode $stdMatFillMode
            colorScalar (1.0, 1.0, 1.0, 0.3) -applyTextureLightColor 0 0
         
            stage 
               texture "water-1-bump"
               textureAddressing tile tile
               # -atrans waveformType cycles/sec offset (startU, startV)  (endU, endV)
               textureMatrixAnimation -targetType fixedFunction -aorigin (0, 0) -atrans sine 0.04 0 (0, 0) (1, 0)  -ascale sawtooth 1 0 ($waterbumpMapScale, $waterbumpMapScale)
               textureTransformType vector2
               ffTextureCoordsSource 0
               textureBlend select(texture) select(texture)
            end 
   
            stage
               texture "water-2-bump"
               textureAddressing tile tile
               # -atrans waveformType cycles/sec offset (startU, startV)  (endU, endV)
               textureMatrixAnimation -targetType fixedFunction -aorigin (0, 0) -atrans sine 0.04 0 (1, 0) (0, 0)  -ascale sawtooth 1 0 ($waterbumpMapScale, $waterbumpMapScale)
               textureTransformType vector2
               ffTextureCoordsSource 0
               textureBlend multiply(texture outRegister) select(texture)
            end 
            
            stage
               # does this work out on GF2 due to reg combiners?
               textureBlend multiply(outRegister colorScalar) select(colorScalar)
            end 
         end  
      endif
   end
enddef


#==============================================================================
define TerrainWater()
   material
      # only activate the water w/ bump shader for pixel shader capable HW      
      if (tsFrozenPond)
         create TerrainWaterFrozen()
      else
         if (queryIntegerGraphicsDeviceCap(maxPixelProgramVersionMajor) != 0)         
            create TerrainWaterShader(true)
         endif
         create TerrainWaterShader(false)  # fallback without bumps         
      endif
   end
enddef

define TerrainWaterFrozen()
   shader -layer 1
      pass -fixedFunction
            create LightingStatesNoStdLightsParam(false false)                           
         alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
         fillmode $stdMatFillMode
         colorScalar (0.45, 0.45, 0.5, 0.475) -applyTextureLightColor 0 0
         
         stage
            texture "ice-pond-surface"
            textureAddressing tile tile                                                   
            ffTextureCoordsSource fromPosition
            ffTextureMatrix -cameraToGlobal -scale (5) -invert
            textureBlend multiply(texture colorScalar) select(colorScalar)
         end                         
         
         stage
            texture "ice-pond-surface"
            textureAddressing tile tile                                                   
            ffTextureCoordsSource fromPosition
            ffTextureMatrix -cameraToGlobal -scale (17) -invert                    
            textureBlend multiplyAdd(texture colorScalar outRegister) add(colorScalar outRegister)
         end
      end                       
   end
enddef 

#==============================================================================

define TerrainSnowShader()   
   create DetermineHardwareSupport()
   if ($useHWShader1Path or $useHWShader2Path)
		create TerrainSnow()		
	else   
      create TerrainSnowFF()
   endif      
enddef

define TerrainSnowFF()
   material
      shader -layer 0
         pass -fixedFunction
            depthTest true -enableDepthWrite true
            if (tsIsDay)
               colorScalar (0.5, 0.5, 0.52, 1)
            else
               colorScalar (0.15, 0.15, 0.375, 1)
            endif
               
               stage                                         
                  texture "snow-ground-diffuse"
                  textureAddressing tile tile  
                  ffTextureCoordsSource fromPosition
                  ffTextureMatrix -cameraToGlobal -scalev (2, 2) -invert                            
                  textureBlend multiply(texture colorScalar) select(colorScalar)
               end            
               
               stage                                         
                  texture "snow-ground-diffuse"
                  textureAddressing tile tile  
                  ffTextureCoordsSource fromPosition
                  ffTextureMatrix -cameraToGlobal -scalev (13, 13) -invert                            
                  textureBlend multiplyAdd(texture colorScalar outRegister) select(colorScalar)
               end            
         end
      end
   end
enddef

define TerrainSnowPS1()   
   shaderProgram -target pixelProgram -method compile -version 1_1 # -disassemble "c:\sims2ep5\hlslPS1_1.txt"                            
      bindConstants 0 -bindingID cursorTerrainPosition -constantCount 1 -constantType float
      if (tsIsDay)         
         bindConstants 1 -bindingID immediateData -data (1.1, 1.1, 1.175, 1)         
      else
         bindConstants 1 -bindingID immediateData -data (0.35, 0.35, 1.0, 1)         
      endif
            
      shaderSource 
         sampler normmap;
                                                                                                
         float4 cursorPos : register(c0);
         float4 colorFactor : register(c1);
         
         struct v2f
         {
            float4 hpos	: POSITION;                             
            float4 color : COLOR0;	             
	         float3 worldPos : COLOR1;	               
	         float3 bumpCoords : TEXCOORD0;
	         float3 tanLightDir : TEXCOORD1;	                                 
         };

         float4 PixelMain(v2f pi) : COLOR
         {      
            float4 normal = 2.0f * (tex2D(normmap, pi.bumpCoords) - 0.5f);  
            float3 diffuse = saturate(dot(pi.tanLightDir, normal.xyz))*colorFactor.xyz;            
            return float4(diffuse.xyz + pi.color, 1.0f);                        
         }
      endShaderSource                                                                                                             
   end                                            
   
   sampler normmap
      texture "snow-ground-bump"
      textureAddressing tile tile
   end 
   
enddef

define TerrainSnowPS2()   
   shaderProgram -target pixelProgram -method compile -version ${psVersion}_0  # -disassemble "c:\sims2ep5\hlslPS1_1.txt"                            
      bindConstants 0 -bindingID cursorTerrainPosition -constantCount 1 -constantType float                        
  		if (tsIsDay)         
         bindConstants 1 -bindingID immediateData -data (1.1, 1.1, 1.175, 1)         
      else
         bindConstants 1 -bindingID immediateData -data (0.35, 0.35, 1.0, 1)         
      endif

      shaderSource                         
         
         sampler normmap;         
         
         float4 cursorPos : register(c0);
         float4 colorFactor : register(c1);
         
         struct v2f
         {
            float4 hpos	: POSITION;                             
	         float4 color : COLOR0;	                     	                     
	         float3 worldPos : COLOR1;              
	         float2 bumpCoords : TEXCOORD0;               	                     
	         float3 tanLightDir : TEXCOORD1;   	   	                     	      	         
         };

         float4 PixelMain(v2f pi) : COLOR
         {                                                  
            float4 normal0 = 2.0f * (tex2D(normmap, pi.bumpCoords) - 0.5f);                        
            float4 normal1 = 2.0f * (tex2D(normmap, pi.bumpCoords*0.4f) - 0.5f);
            float4 normal = 0.5f*(normal0+normal1);
            float3 diffuse0 = saturate(dot(pi.tanLightDir, normal.xyz))*colorFactor.xyz;            
            
            float3 diffVec = cursorPos-pi.worldPos;            
            diffVec *= 64.0f;
            float blend = saturate(dot(diffVec, diffVec));                                                                                                
            return float4(saturate(float3(diffuse0.xyz + pi.color.xxx)), blend);                        
         }
      endShaderSource
   end                                            
   
   sampler normmap
      texture "snow-ground-bump"
      textureAddressing tile tile
   end               
   
enddef

define TerrainSnowVS1()
   shaderProgram -target vertexProgram -method compile -version 1_1
      bindConstants 0 -bindingID  geomToClip     -constantCount 4        
      bindConstants 4 -bindingID  geomToCamera   -constantCount 3
		bindConstants 7 -bindingID  cameraToGeom   -constantCount 3			
		bindConstants 15 -bindingID ambientLight -constantCount 1 -constantType float	                   			      
		bindConstants 18 -bindingID allStandardLightData -constantCount 4 -constantType float			      
		
		if (tsIsDay)         
         bindConstants 10 -bindingID immediateData -data (1.2, 1.2, 1.2, 1)         
      else
         bindConstants 10 -bindingID immediateData -data (0.64, 0.64, 1.1, 1)         
      endif
      
      bindConstants 12 -bindingID geomToGlobal -constantCount 3
                     
      bindConstants 22 -bindingID cameraToClipWithDepthOffset -constantCount 4 -data(0, 0, 0, 0) 
		
		shaderSource
			float4x4 modelviewproj : register(c0);
			float4x3 modelview : register(c4);
			float4x3 modelviewInv : register(c7);				      				      
         // light direction
			float4 lightDir0 : register(c18);
			float4 lightDir1 : register(c26);
			float4x4 cameraToClipWithDOMatrix : register(c22);
         float4 ambient : register(c15);                                   
         float4x3 modelToWorld : register(c12);
				      			
			struct a2v 
         {
            float4 pos		: POSITION;                     
            float3 normal	: NORMAL;
            float2 tangent	: TEXCOORD0; 
            float2 bumpcoord : TEXCOORD1;                    
         };

         struct v2f
         {
            float4 hpos		 : POSITION;                                          
	         float4 color : COLOR0;	                  	                  
	         float3 worldPos : COLOR1;	         
	         float2 bumpCoords : TEXCOORD0;
	         float3 tanLightDir : TEXCOORD1;    	               	                 	                  	                  	               	                 	                  	                  
         };
         
         v2f VertexMain(a2v IN)
         {
	         v2f OUT;

	         // vertex position in object space
	         float4 pos = float4(IN.pos.x,IN.pos.y,IN.pos.z,1.0);	  
	         
	         float3 tangent = float3(IN.tangent.x, IN.tangent.y, 0);
	                  	         
	         // compute binormal
	         float3 binormal = normalize(cross(IN.normal, tangent));
	         
	         // tangent space matrix
	         float3x3 tbn = float3x3(tangent, binormal, IN.normal);
	         
	         // light direction in object space	                  
	         float3 lt0 = mul(lightDir0, (float3x3)modelviewInv);
	         
	         // light 0 direction in tangent space	                  	                  
	         OUT.tanLightDir = normalize(mul(tbn, lt0));
	         	         	         
	         OUT.bumpCoords = float2(IN.bumpcoord.x, IN.bumpcoord.y);
	         
	         // compute tangent space view vector
	         // object space view point
	         float3 viewPoint = mul(float4(0, 0, 0, 1), modelviewInv).xyz;
	         float3 viewVecObj = normalize(viewPoint - IN.pos.xyz);
	         
	         // object space light
	         float3 lightDirObj = normalize(mul(lightDir0, (float3x3)modelviewInv));
	         
	         // half angle vector in object space
	         float3 halfWayVector = normalize(lightDirObj + viewVecObj);	                  
	         
	         // transform half angle vector to tangent space
	         //OUT.tanHalfAngle.xyz = normalize(mul(tbn, halfWayVector));
	         
	         // specular shadowing term
	         //OUT.tanHalfAngle.w = max(dot(halfWayVector, IN.normal), 0);	                  
	         
	         // vertex position in clip space
	         float3 hposView = mul(pos, modelview);
            OUT.hpos = mul(float4(hposView, 1), cameraToClipWithDOMatrix);                     	                   
            
            // vertex position in world space
            OUT.worldPos = mul(pos, modelToWorld)/64.0f;                                             
	                  	                                    		         
	         OUT.color.xyz = ambient.xyz*0.3f;
	         OUT.color.w = 1.0;	         
	         return OUT;
         }
                  			
		endShaderSource
   end # end shader program   
enddef

define TerrainSnow()
   material
      shader -layer 1         
         validateRenderShaderContext -vertexFormat position 0 required
         validateRenderShaderContext -vertexFormat normal 0 required
         validateRenderShaderContext -vertexFormat texcoord 0 required
         validateRenderShaderContext -vertexFormat texcoord 1 required
         
         create DetermineHardwareSupport()
                          
         pass 
            alphaTest true 5
            alphaTestFunction acceptIfGreater

            alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
            depthTest true -enableDepthWrite true
            
            create TerrainSnowVS1()
            
            if ($useHWShader1Path)
               create TerrainSnowPS1()
            elseif ($useHWShader2Path)               
               create TerrainSnowPS2()
            endif
                                                   
         end # end pass
         
      end #end shader
   end # end material
enddef

define XRayCursorMaterial()
   material
      shader -layer (0)
         pass -fixedFunction -modifiedEachFrameHint
            alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
            depthTest true -enableDepthWrite false
                        
            colorScalar (1, 1, 0, 0.0)
            stage
               textureBlend select(colorScalar) select(colorScalar)
            end
         end
      end
   end
enddef

define LightSnowDayPS(psFullVersion)
   shaderProgram -target pixelProgram -method compile -version &psFullVersion
      if ($singlePass)
         bindConstants 0 -bindingID immediateData -data (0, 0, 0, 0) -constantType float
      else
         bindConstants 0 -bindingID immediateData -data (1, 0, 0, 0) -constantType float
      endif
      
      shaderSource     
         float scale2Factor : register(c0);         
                                 
         sampler base;            
         sampler base2;
         struct cInputPixel
         {               
            float2 txScale1  : TEXCOORD0;
				float2 txScale2  : TEXCOORD1;
         };
         
         float4 PixelMain(cInputPixel pi) : COLOR
         {         
            float4 scale1Color = tex2D(base, pi.txScale1);                                                
            float4 scale2Color = tex2D(base2, pi.txScale2)*scale2Factor.x;                              
            float4 result = (scale1Color + scale2Color);            
            return result;                        
         }
      endShaderSource
   end # end shader program      
enddef

define LightSnowNightPS(psFullVersion)
   shaderProgram -target pixelProgram -method compile -version &psFullVersion
      if ($singlePass)
         bindConstants 0 -bindingID immediateData -data (0, 0, 0, 0) -constantType float
      else
         bindConstants 0 -bindingID immediateData -data (1, 1, 0, 0) -constantType float
      endif
      
      shaderSource     
         float2 scale2Factor : register(c0);         
                                 
         sampler base;  
         sampler base2;
         sampler lightMap;          
         struct cInputPixel
         {               
            float2 txScale1  : TEXCOORD0;
				float2 txScale2  : TEXCOORD1;
				float2 txltMap   : TEXCOORD2;
         };
         
         float4 PixelMain(cInputPixel pi) : COLOR
         {         
            float4 scale1Color = tex2D(base, pi.txScale1);                                                
            scale1color.xyz = scale1color.xyz;
            float4 scale2Color = tex2D(base2, pi.txScale2)*scale2Factor.x;
            float4 result = (scale1Color + scale2Color);               
            float4 lightMapColor = tex2D(lightMap, pi.txltMap);
            return float4(result.xyz*lightMapColor.xyz, result.w);                        
         }
      endShaderSource
   end # end shader program      
enddef


define LightSnowVS_PS()
   pass
      alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
      depthTest true -enableDepthWrite false      
      depthTestFunction acceptIfEqual
      
      shaderProgram -target vertexProgram -method compile -version 1_1
         bindConstants 0 -bindingID geomToClip -constantCount 4						
         bindConstants 4 -bindingID geomToGlobal -constantCount 3
         bindConstants 8 -bindingID immediateData -data (1/(($scaleStage1).x), 1/(($scaleStage1).y), 1/(($scaleStage2).x), 1/(($scaleStage2).y)) -constantType float
			
			shaderSource
			   float4x4 clipSpaceMatrix  : register(c0);			   
			   float4x3 modelToWorld : register(c4);
			   float4 scaleData : register(c8);
			
			struct InputVertex
				{
					float3 position: POSITION0;					
					float2 txCoord : TEXCOORD0;
				};
				
				struct OutputVertex
				{
					float4 clipPosition : POSITION;
					float2 txScale1  : TEXCOORD0;
					float2 txScale2  : TEXCOORD1;
					float2 txltMap    : TEXCOORD2;
				};
				
				OutputVertex VertexMain( InputVertex i)
				{
				   OutputVertex o;
				   o.clipPosition = mul(float4(i.position, 1), clipSpaceMatrix);
				   float3 worldPos = mul(float4(i.position.xyz, 1.0f), modelToWorld);
				   o.txScale1   = worldPos.xy * scaleData.xy;
				   o.txScale2   = worldPos.xy * scaleData.zw;
				   o.txltMap  = i.txCoord;
				   return o;
				}
			endShaderSource  
      end # end shader program
      
      if (tsIsDay)
         if ($useHWShader1Path)	
		      create LightSnowDayPS("1_1")
	      else   
            create LightSnowDayPS(${psVersion}_0)
         endif
      else
         if ($useHWShader1Path)	
		      create LightSnowNightPS("1_1")
	      else   
            create LightSnowNightPS(${psVersion}_0)
         endif
      endif
         
      sampler base
         texture "${snowTexture}"
         textureAddressing tile tile
      end
      
      sampler base2
         texture "${snowTexture2}"
         textureAddressing tile tile
      end
      
      if (not tsIsDay)
         sampler lightMap
            texture "floorLightMap_${page}"
            textureAddressing tile tile
         end
      endif
   end
enddef

define LightSnowFF()
   pass -fixedFunction         
      alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
      fillmode $stdMatFillMode            
      depthTest true -enableDepthWrite false                        
      
      if ($kRaiseLightSnowFF)
         ffDepthOffset 2
         depthTestFunction acceptIfLessOrEqual      
      else
         depthTestFunction acceptIfEqual      
      endif      
              
      stage
         texture $snowTexture
         textureAddressing tile tile
         ffTextureCoordsSource fromPosition
         ffTextureMatrix -cameraToGlobal -scalev $scaleStage1 -invert               
         textureBlend select(texture) select(texture)
      end
      
      if (not $singlePass)           
         stage
            texture $snowTexture2
            textureAddressing tile tile
            ffTextureMatrix  -cameraToGlobal -scalev $scaleStage2 -invert
            ffTextureCoordsSource fromPosition
            textureBlend add(texture outRegister) add(outRegister texture)
         end
      else
         # a dummy stage so if the shader has to fail it should fail
         stage            
            texture "floorLightMap_${page}"
            textureBlend select(outRegister) select(outRegister)
         end
      endif      

      
      if (not tsIsDay)
         stage
            texture "floorLightMap_${page}"
            textureAddressing tile tile
            ffTextureCoordsSource 0                                            
            textureBlend multiplyScale2(texture outRegister) select(outRegister)
         end
      endif
      
      # a dummy stage so if the shader has to fail it should fail
      stage            
         texture "floorLightMap_${page}"
         textureBlend select(outRegister) select(outRegister)
      end
   
   end      
enddef

define LightSnowFFLowEnd()
   pass -fixedFunction         
      alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
      fillmode $stdMatFillMode            
      depthTest true -enableDepthWrite false                  
      ffDepthOffset 1
      depthTestFunction acceptIfLessOrEqual      
      
      if (tsIsDay)         
         colorScalar (1, 1, 1, 1)         
      else
         colorScalar (0.17, 0.17, 0.43, 1)         
      endif
              
      stage
         texture $snowTexture
         textureAddressing tile tile
         ffTextureCoordsSource fromPosition
         ffTextureMatrix -cameraToGlobal -scalev $scaleStage1 -invert               
         textureBlend multiply(texture colorScalar) select(texture)
      end
      
      if (not $singlePass)           
         stage
            texture $snowTexture
            textureAddressing tile tile
            ffTextureMatrix  -cameraToGlobal -scalev $scaleStage2 -invert
            ffTextureCoordsSource fromPosition
            textureBlend multiplyAdd(texture colorScalar outRegister) add(outRegister texture)
         end
      else
         stage
            texture $snowTexture
            textureAddressing tile tile
            ffTextureCoordsSource fromPosition
            ffTextureMatrix -cameraToGlobal -scalev $scaleStage1 -invert               
            textureBlend multiplyAdd(texture colorScalar outRegister) select(outRegister)
         end
      endif      

   end      
enddef

define LightSnow()
   material
      setv2 scaleStage1 (23, 23)
      setv2 scaleStage2 (17, 17)
      
      if (tsHasHail)
         set snowTexture "hail-ground-surface"
         set snowTexture2 "hail-ground-surface"
         setv2 scaleStage1 (4, 4)
         setv2 scaleStage2 (3, 3)
      endif

      shader -layer (-1)
         create DetermineHardwareSupport()            
         if ((not $kRaiseLightSnowFF and $useHWShader1Path) or $useHWShader2Path)	
		      create LightSnowVS_PS()		
	      else   
            create LightSnowFF() # can use more than two stages
         endif
      end
      
      shader -layer (-1)      #if the above shader fails for some reason
         create LightSnowFFLowEnd()
      end
   end   
enddef

materialDefinition TerrainSnowMaterial
   setDefinition TerrainSnowShader     
end

materialDefinition RoadSnowMaterial
   setDefinition LightSnow
   addParam snowTexture snow-light-pass2   
   addParam snowTexture2 snow-light-pass1   
   addParam singlePass true
   addParam page 0
end

materialDefinition LightSnowMaterial
   setDefinition LightSnow
   addParam snowTexture snow-light-pass2
   addParam snowTexture2 snow-light-pass1
   addParam singlePass false
   addParam page 0   
end 

materialDefinition terrainLightingMaterial
   setDefinition TerrainLighting
end

materialDefinition waterOnTerrain
   setDefinition TerrainWater
end

materialDefinition XrayCursorBoxDirtyRectMaterial
   setDefinition XRayCursorMaterial
end

define GeneralSnowMaterialFF()
   material      
      shader -layer ($stdMatLayer)
         pass -fixedFunction            
            create LightingStatesParam(false false)      
            setv3 half (0.5,0.5,0.5)
            if ($stdMatSpecPower !=	0)
		         ffMatCoef -amb ($stdMatDiffCoef * $half) -ambAlpha	$stdMatAlphaMultiplier -diff ($stdMatDiffCoef * $half)	-diffAlpha $stdMatAlphaMultiplier -spec $stdMatSpecCoef -specPow	$stdMatSpecPower
		         addSpecular	true
	         else
		         ffMatCoef -amb ($stdMatDiffCoef * $half) -ambAlpha	$stdMatAlphaMultiplier -diff ($stdMatDiffCoef * $half)	-diffAlpha $stdMatAlphaMultiplier -spec (0,0,0) -specPow	0
	         endif
   	      
	         create StandardShaderFBAlphaState($stdMatAlphaBlendMode)
   	         	         	      
   	      
	         stage
	            texture $stdMatBaseTextureName
	            textureBlend multiplyScale2(diffuse texture) select(texture)
	         end	         
	         
	         if (tsIsDay)
	         colorScalar $colorToAdd
	            stage	            
	               textureBlend add(outRegister colorScalar) select(outRegister)
	            end	         	         
	         endif
	         
	      end
	      	      
      end
   end
enddef

define GeneralReflectiveMaterial()
   create StandardMaterial()
enddef

materialDefinition puddle_liquid_rain
   setDefinition GeneralReflectiveMaterial
   addParam deprecatedStdMatInvDiffuseCoeffMultiplier 1.2
   addParam forceHighQualitySkinning 0
   addParam forceIgnoreShapeBlend 0
   addParam reflectivity 0.1
   addParam stdMatAlphaBlendMode blend
   addParam stdMatAlphaMultiplier 0.5
   addParam stdMatAlphaRefValue 127
   addParam stdMatAlphaTestEnabled 0
   addParam stdMatBaseTextureAlphaReplicate 0
   addParam stdMatCullMode cullClockwise
   addParam stdMatDiffCoef 0.39,0.46,0.49
   addParam stdMatEmissiveCoef 0,0,0
   addParam stdMatEnvCubeBlurFactor 0.000000
   addParam stdMatEnvCubeCoef 0.3,0.3,0.3
   addParam stdMatEnvCubeLockedToCamera 0
   addParam stdMatEnvCubeMode reflection
   addParam stdMatEnvCubeTextureName reflectionkitchenhighcontrast-envcube
   addParam stdMatFillMode solid
   addParam stdMatLayer 0
   addParam stdMatLightingEnabled 1
   addParam stdMatMinLightRangeHint 4
   addParam stdMatSpecCoef 0.54,0.72,0.76
   addParam stdMatSpecPower 22      
   addParam stdMatAddLayer -10
end

materialDefinition puddle_liquid_blue
   setDefinition GeneralReflectiveMaterial
   addParam deprecatedStdMatInvDiffuseCoeffMultiplier 1.2
   addParam forceHighQualitySkinning 0
   addParam forceIgnoreShapeBlend 0
   addParam reflectivity 0.1
   addParam stdMatAlphaBlendMode blend
   addParam stdMatAlphaMultiplier 0.5
   addParam stdMatAlphaRefValue 127
   addParam stdMatAlphaTestEnabled 0
   addParam stdMatBaseTextureAlphaReplicate 0
   addParam stdMatCullMode cullClockwise
   addParam stdMatDiffCoef 0.23,0.41,0.49
   addParam stdMatEmissiveCoef 0,0,0
   addParam stdMatEnvCubeBlurFactor 0.000000
   addParam stdMatEnvCubeCoef 0.1,0.1,0.1
   addParam stdMatEnvCubeLockedToCamera 0
   addParam stdMatEnvCubeMode reflection
   addParam stdMatEnvCubeTextureName reflectionkitchenhighcontrast-envcube
   addParam stdMatFillMode solid
   addParam stdMatLayer 0
   addParam stdMatLightingEnabled 1
   addParam stdMatMinLightRangeHint 4
   addParam stdMatSpecCoef 0.55,0.55,0.55
   addParam stdMatSpecPower 6.1   
   addParam stdMatAddLayer -10
end


#endshader
Retrieved from "http://simswiki.info/index.php?title=ShaderTerrain&oldid=20225"
Personal tools
Namespaces

Variants
Actions
Navigation
game select
Toolbox