Difference between revisions of "TEST-STRCMP4CODES"

From SimsWiki
Jump to: navigation, search
Line 1: Line 1:
−
EP6-BV
 
−
0xCD7FE87A
 
−
0x1C0532FA
 
−
0x7BE04D32
 
−
0xFFE2C895
 
−
# common
 
−
 
 
#
 
#
−
# Common materials for Sims2 and ContentViewer
+
# 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
  
−
# shader definition files
+
materialDefinition TerrainSnowMaterial
 +
  setDefinition TerrainSnowShader   
 +
end
  
−
include "vsFragments.matShad"
+
materialDefinition RoadSnowMaterial
 +
  setDefinition LightSnow
 +
  addParam snowTexture snow-light-pass2 
 +
  addParam snowTexture2 snow-light-pass1 
 +
  addParam singlePass true
 +
  addParam page 0
 +
end
  
−
include "standard.matShad"
+
materialDefinition LightSnowMaterial
 +
  setDefinition LightSnow
 +
  addParam snowTexture snow-light-pass2
 +
  addParam snowTexture2 snow-light-pass1
 +
  addParam singlePass false
 +
  addParam page 0 
 +
end
  
−
include "predefined.matShad"
+
materialDefinition terrainLightingMaterial
−
include "water.matShad"
+
  setDefinition TerrainLighting
−
include "sims.matShad"
+
end
−
include "overrides.matShad"
+
  
 +
materialDefinition waterOnTerrain
 +
  setDefinition TerrainWater
 +
end
  
−
include "glow.matShad"
+
materialDefinition XrayCursorBoxDirtyRectMaterial
−
include "overlays.matShad"
+
  setDefinition XRayCursorMaterial
 +
end
  
−
# Effects stuff (see GameData/Effects)
+
define GeneralSnowMaterialFF()
−
include "Effects/config.matShad"
+
  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
  
−
include "poolWater.matShad"
+
define GeneralReflectiveMaterial()
−
include "celShading.matShad"
+
  create StandardMaterial()
−
include "rug.matShad"
+
enddef
−
include "imposters.matShad"
+
  
−
# post-process effects materials (glow etc)
+
materialDefinition puddle_liquid_rain
−
include "postProcessEffects.matshad"
+
  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
  
−
# reflection materials
+
materialDefinition puddle_liquid_blue
−
include "reflection.matshad"
+
  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
  
  
−
# Research materials that may need to be removed before
+
#endshader
−
# ship.
+
−
include "Research/ramp.matShad"
+

Revision as of 13:11, 5 March 2008

  2. Shaders for terrain tiles

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

  1. multiplier on terrain (grass/paints) both on the lot and
  2. lot skirts. (See lotSkirt.matShad.)

setc terrainMatDiffCoef (0.9, 0.9, 0.9)

  1. 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

  1. ==============================================================================

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

  1. ==============================================================================

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


  1. ==============================================================================

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

  1. ==============================================================================

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


  1. ==============================================================================

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

  1. ==============================================================================

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


  1. endshader
Retrieved from "http://simswiki.info/index.php?title=TEST-STRCMP4CODES&oldid=22516"
Personal tools
Namespaces

Variants
Actions
Navigation
game select
Toolbox