Difference between revisions of "TEST-STRCMP4CODES"

From SimsWiki
Jump to: navigation, search
 
(43 intermediate revisions by one user not shown)
Line 1: Line 1:
define LotSkirtPSWater()
+
define TransparentMirrorReflection()
    shader -layer ($poolWaterLayer+1)
+
  material
        validateRenderShaderContext -vertexFormat position 0 required
+
      if (viewerRenderType = $kRenderTypeShadow)
pass -clipAlways -modifiedEachFrameHint
+
        create StandardShaderShadow()
#fillmode wireframe
+
      else
alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
+
        if (viewerRenderType = $kRenderTypeThumbnail)
seti textureLights (numLightsOfType(environmentCube))
+
            create TransparentBlankMirrorMaterial($kRenderTypeThumbnail)
depthTest true -enableDepthWrite false          
+
        else           
 
+
            if (not $mirrorReflectionsEnabled)
shaderProgram -target vertexProgram -method compile -version 1_1
+
              set currentType (viewerRenderType)
 +
              create TransparentBlankMirrorMaterial($currentType)
 +
            else
 +
              create TransparentMirrorReflectionMaterial()
 +
            endif           
 +
         endif       
 +
      endif
 +
  end
 +
enddef
  
bindConstants 0 -bindingID geomToClip -constantCount 4
+
define TransparentBlankMirrorMaterial(renderType)
bindConstants 4 -bindingID geomToCamera -constantCount 3
+
      shader
 +
        validateRenderShaderContext -viewerRenderType  &renderType
 +
       
 +
        pass           
 +
            shaderProgram -target vertexProgram -method assemble
 +
              bindConstants 0 -bindingID geomToClip -constantCount 4
 +
              shaderSource
 +
                  vs_1_1
 +
                  dcl_position v0
 +
                  m4x4 oPos, v0, c0
 +
              endShaderSource
 +
            end
 +
           
 +
            colorScalar (0,0,0) 0.5
 +
            stage
 +
              textureBlend select(colorScalar) select(colorScalar)
 +
            end           
 +
        end
 +
      end     
 +
enddef
  
bindConstants 7 -bindingID frameInfo
+
define TransparentMirrorReflectionMaterial()
 +
     
 +
      shader -layer -9998  # this material must render first
 +
        validateRenderShaderContext -viewerRenderType $kRenderTypeMirror  # reflection render
  
bindConstants 11 -bindingID immediateData -data ($wmXRepeat, 0, $wmXWaveHeight, $wmXSpeed)
+
        pass -renderEachFrame
bindConstants 12 -bindingID immediateData -data (0, $wmYRepeat, $wmYWaveHeight, $wmYSpeed)
+
            renderTarget $reflectionRenderTarget -setViewport viewportFromParentRenderContext
  
# pre-evaluate these
+
            depthTest true -enableDepthWrite true
setf xscale (-$wmXRepeat * $wmXWaveHeight)
+
setf yscale (-$wmYRepeat * $wmYWaveHeight)
+
bindConstants 13 -bindingID immediateData -data ($xscale,$yscale, 1,0)
+
bindConstants 14 -bindingID allStandardLightData -constantCount 4 -constantType float
+
bindConstants 18 -bindingID cameraToGlobal -constantCount 3
+
bindConstants 21 -bindingID cameraToGeom -constantCount 3
+
+
if (tsIsDay)     
+
bindConstants 25 -bindingID immediateData -data (0.75, 0.75, 0.75, 1)
+
bindConstants 28 -bindingID immediateData -data (-0.3, 0.1, 0.1, 0.0)       
+
else
+
bindConstants 25 -bindingID immediateData -data (0.2, 0.2, 0.2, 1)
+
bindConstants 28 -bindingID immediateData -data (-0.3, -0.2, -0.1, 0.0)     
+
endif
+
  
shaderSource
+
            applyStencilStateForOverlappingReflections
  
float4 frameInfo : register(c7);
+
             alphaBlend srcFactor(zero) add dstFactor(one)
float4 waveDataX : register(c11);
+
float4 waveDataY : register(c12);
+
float4 waveDataHelper : register(c13);
+
float4x4 clipSpaceMatrix : register(c0);
+
float4x3 cameraSpaceMatrix : register(c4);
+
float4x3 cameraToGlobalMatrix : register(c18);
+
float4x3 cameraToGeomMatrix : register(c21);
+
+
float4 nightColor: register(c25);
+
float4 waterTint: register(c28);
+
           
+
float4 lightDirection : register(c14);
+
float4 lightColor : register(c15);
+
float4 lightSpecular : register(c16);
+
+
const static float4 refractionWeights={1,1,2,0};
+
const static float4 layerBlue={1.0, 1.0, 1.0, 1.0};
+
+
struct InputVertex
+
{
+
float3 position: POSITION0;
+
float3 normal : NORMAL0;
+
float2 alpha  : TEXCOORD1;
+
};
+
+
struct OutputVertex
+
{
+
float4 clipPosition : POSITION;
+
float4 sPos        : TEXCOORD0;
+
float2 Wave0        : TEXCOORD1;
+
float2 Wave1        : TEXCOORD2;
+
float2 Wave2        : TEXCOORD3;
+
float2 Wave3        : TEXCOORD4;
+
float3 Eye          : TEXCOORD5;
+
float4 specular    : COLOR0; 
+
float4 colorTint    : COLOR1;
+
};
+
           
+
+
+
OutputVertex VertexMain( InputVertex inputVertex)
+
{
+
// Do Y-direction waves
+
// r0 = (x, y, z, t)
+
+
OutputVertex outputVertex;
+
+
float4 posAndTime;
+
posAndTime.xyz = inputVertex.position;
+
posAndTime.w = frameInfo.w;
+
+
float temp = dot(posAndTime, waveDataX);
+
float z = sin(temp) * waveDataX.z + inputVertex.position.z;
+
temp = dot(posAndTime, waveDataY);
+
posAndTime.z =  z + sin(temp) * waveDataY.z ;//-0.1f; //The -.01 is a fudge factor to remove some of the edge creep associated with moving the height of the wave. -tom
+
posAndTime.w = 1.0f;
+
+
outputVertex.clipPosition = mul( posAndTime, clipSpaceMatrix);
+
outputVertex.sPos = float4(0.5f*(outputVertex.clipPosition.ww - outputVertex.clipPosition.xy), outputVertex.clipPosition.ww);
+
+
float3 waveNormal = normalize(inputVertex.normal + float3(cos(temp)*waveDataHelper.xy, 0));
+
float3 cameraSpaceNormal = normalize(mul(waveNormal, cameraSpaceMatrix));
+
float3 cameraSpacePosition = mul( posAndTime, cameraSpaceMatrix);
+
float3 viewVector = normalize(-cameraSpacePosition);
+
+
float3 halfVector = normalize(viewVector + lightDirection);
+
outputVertex.specular = lightSpecular*pow(dot(cameraSpaceNormal, halfVector), 50)*nightColor*lightColor*0.5;
+
+
+
float2 fTranslation=float2(fmod(frameInfo.w, 100)*0.005, fmod(frameInfo.w, 100)*0.005);
+
float2 vTexCoords = posAndTime.xy*0.05;
+
               
+
// Output bump layers texture coordinates   
+
float fSinTranslation=sin(fTranslation*100)*0.005;
+
float2 vTranslation0=fTranslation+fSinTranslation;
+
float2 vTranslation1=fTranslation-fSinTranslation;
+
float2 vTranslation2=fTranslation;
+
               
+
// Scale texture coordinates to get mix of low/high frequency details
+
outputVertex.Wave0.xy = vTexCoords.xy*0.01+fTranslation*2.0;
+
outputVertex.Wave1.xy = vTexCoords.xy+fTranslation*2.5;
+
outputVertex.Wave2.xy = vTexCoords.xy+fTranslation*-2.3;
+
outputVertex.Wave3.xy = vTexCoords.xy*0.1+fTranslation*1.5;               
+
                                   
+
// compute binormal
+
float3 binormal = normalize(cross(waveNormal, float3(1.0f, 0.0f, 0.0f)));              
+
float3 tangent = normalize(cross(binormal, waveNormal));
+
           
+
// tangent space matrix
+
float3x3 objToTangentSpace = float3x3(tangent, binormal, waveNormal);
+
           
+
float3 viewVectorInObjSpace = mul(viewVector, (float3x3)cameraToGeomMatrix);
+
           
+
outputVertex.Eye.xyz = mul(objToTangentSpace, viewVectorInObjSpace);
+
outputVertex.colorTint = waterTint;
+
outputVertex.colorTint.a = inputVertex.alpha.xxxx;
+
// outputVertex.color = waterTint.xxxx;
+
+
return(outputVertex);
+
}
+
+
endShaderSource 
+
end # shaderProgram
+
+
shaderProgram -target pixelProgram -method compile -version 2_0             
+
shaderSource                           
+
sampler reflect; 
+
sampler bump;         
+
struct cInputPixel
+
{             
+
float4 sPos        : TEXCOORD0;             
+
float2 Wave0        : TEXCOORD1;
+
float2 Wave1        : TEXCOORD2;
+
float2 Wave2        : TEXCOORD3;
+
float2 Wave3        : TEXCOORD4;
+
float3 Eye          : TEXCOORD5;
+
float4 specular    : COLOR0;
+
float4 colorTint    : COLOR1;
+
};
+
           
+
float Fresnel(float NdotL, float fresnelBias, float fresnelPow, float facing)
+
{             
+
return max(fresnelBias + (1.0f - fresnelBias)*pow(facing, fresnelPow), 0.0);
+
}
+
           
+
float4 PixelMain(cInputPixel pi) : COLOR
+
{       
+
float3 vEye = normalize(pi.Eye);
+
  
// Get bump layers
+
            cullmode none
float3 vBumpTexA = tex2D(bump, pi.Wave0.xy).xyz;
+
 
float3 vBumpTexB = tex2D(bump, pi.Wave1.xy).xyz;
+
            shaderProgram -target vertexProgram -method assemble           
float3 vBumpTexC = tex2D(bump, pi.Wave2.xy).xyz;
+
              bindConstants 0 -bindingID geomToClipFromParentView -constantCount 4
float3 vBumpTexD = tex2D(bump, pi.Wave3.xy).xyz;
+
              shaderSource
               
+
                  vs_1_1
// Average bump layers
+
                  dcl_position v0
float3 vBumpTex=normalize(2.0 * (vBumpTexA.xyz + vBumpTexB.xyz + vBumpTexC.xyz + vBumpTexD.xyz)-4.0);
+
                  def c5, 1,0,0,1
               
+
                  m4x4 r0,  v0,  c0
// Apply individual bump scale for refraction and reflection               
+
                  mov oPos.x,  -r0
float3 vReflBump = vBumpTex.xyz ;
+
                  mov oPos.yzw, r0                 
float4 vReflection = tex2Dproj(reflect, pi.sPos + float4(vReflBump.xy, 0.0f, 0.0f));//*0.001 + float4(2.0*vBumpTexD-1.0f.xxx, 1);
+
              endShaderSource
             
+
            end
// Compute Fresnel term
+
        end
float NdotL = max(dot(vEye, vReflBump), 0);
+
      end
float facing = (1.0 - NdotL);
+
 
float fresnel = Fresnel(NdotL, 0.1, 0.5, facing);
+
      shader -layer 6
         
+
        validateRenderShaderContext -viewerRenderType $kRenderTypeNormal
vReflection.a = fresnel * 0.5;
+
        pass -modifiedEachFrameHint
+
            shaderProgram -target vertexProgram -method assemble           
return saturate(vReflection + pi.colorTint);
+
              bindConstants 0 -bindingID geomToClip -constantCount 4
}
+
              bindConstants 4 -bindingID clipToViewTarget -constantCount 4
endShaderSource
+
              shaderSource
end                                                    
+
                  vs_1_1
     
+
                  dcl_position v0
sampler reflect
+
                  def c8,   -0.5, -0.5, 1, 1
texture "OceanReflection"
+
                  def c9,     0.5,  0.5, 0, 0
textureAddressing clamp clamp
+
                  def c10,   0.25, 0.25, 0, 0
end
+
                  m4x4 r0,  v0,  c0
     
+
                  mov oPos, r0
sampler bump
+
                  mul r2, c9, r0.w
texture "poolShape-body-bump"
+
                  mad r4, r0, c8, r2
textureAddressing tile tile
+
                  rcp r3.x, c4.x                                 
end  
+
                  rcp r3.y, c5.y
           
+
                  mov r3.zw, c9.zw
end # end pass
+
                  mul r3, r3, c10
end
+
                  mad r6, r0, r3, r4
 +
                  mov oT0, r6.xyww
 +
              endShaderSource             
 +
            end
 +
 
 +
            alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
 +
            depthTest true -enableDepthWrite false
 +
            colorScalar (0,0,0) 0.25
 +
 
 +
            stage
 +
              textureTransformType vector3 homogeneous
 +
              textureAddressing clamp clamp
 +
              texture $reflectionRenderTarget
 +
              textureBlend select(texture) select(colorScalar)
 +
            end
 +
                     
 +
        end
 +
      end
 +
     
 +
      shader -layer 6     
 +
        validateRenderShaderContext -viewerRenderType $kRenderTypeNormal
 +
        pass -modifiedEachFrameHint
 +
            shaderProgram -target vertexProgram -method assemble           
 +
              bindConstants 0 -bindingID geomToClip -constantCount 4
 +
              bindConstants 4 -bindingID clipToViewTarget -constantCount 4
 +
              shaderSource
 +
                  vs_1_1
 +
                  dcl_position v0
 +
                  def c8,    -0.5, -0.5, 1, 1
 +
                  def c9,     0.5, 0.5, 0, 0
 +
                  def c10,   0.25, 0.25, 0, 0
 +
                  m4x4 r0,  v0,  c0
 +
                  mov oPos, r0
 +
                  mul r2, c9, r0.w
 +
                  mad r4, r0, c8, r2
 +
                  rcp r3.x, c4.x                                 
 +
                  rcp r3.y, c5.y
 +
                  mov r3.zw, c9.zw
 +
                  mul r3, r3, c10
 +
                  mad r1, r0, r3, r4
 +
                  rcp r1.w, r1.w
 +
                  mul oT0.xy, r1.w, r1.xy
 +
              endShaderSource              
 +
            end
 +
 
 +
            alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
 +
            depthTest true -enableDepthWrite false
 +
            colorScalar (0,0,0) 0.25
 +
 
 +
            stage
 +
              textureAddressing clamp clamp
 +
              texture $reflectionRenderTarget
 +
              textureBlend select(texture) select(colorScalar)
 +
            end
 +
           
 +
        end
 +
      end
 
enddef
 
enddef
 +
 +
#---------------------------------------------------------------------------------------------------------------#
 +
 +
materialDefinition transparent_mirror_reflection
 +
  setDefinition TransparentMirrorReflection
 +
end

Latest revision as of 00:44, 9 July 2009

define TransparentMirrorReflection()

  material
     if (viewerRenderType = $kRenderTypeShadow)
        create StandardShaderShadow()
     else
        if (viewerRenderType = $kRenderTypeThumbnail)
           create TransparentBlankMirrorMaterial($kRenderTypeThumbnail)
        else            
           if (not $mirrorReflectionsEnabled)
              set currentType (viewerRenderType)
              create TransparentBlankMirrorMaterial($currentType)
           else
              create TransparentMirrorReflectionMaterial()
           endif            
        endif         
     endif
  end

enddef

define TransparentBlankMirrorMaterial(renderType)

     shader
        validateRenderShaderContext -viewerRenderType  &renderType
        
        pass             
           shaderProgram -target vertexProgram -method assemble
              bindConstants 0 -bindingID geomToClip -constantCount 4
              shaderSource
                 vs_1_1
                 dcl_position v0
                 m4x4 oPos, v0, c0
              endShaderSource
           end
           
           colorScalar (0,0,0) 0.5
           stage
              textureBlend select(colorScalar) select(colorScalar)
           end            
        end
     end      

enddef

define TransparentMirrorReflectionMaterial()

     shader -layer -9998   # this material must render first
        validateRenderShaderContext -viewerRenderType $kRenderTypeMirror  # reflection render
        pass -renderEachFrame
           renderTarget $reflectionRenderTarget -setViewport viewportFromParentRenderContext
           depthTest true -enableDepthWrite true
           applyStencilStateForOverlappingReflections
           alphaBlend srcFactor(zero) add dstFactor(one)
           cullmode none
           shaderProgram -target vertexProgram -method assemble            
              bindConstants 0 -bindingID geomToClipFromParentView -constantCount 4
              shaderSource
                 vs_1_1
                 dcl_position v0
                 def c5, 1,0,0,1
                 m4x4 r0,   v0,  c0
                 mov oPos.x,  -r0
                 mov oPos.yzw, r0                  
              endShaderSource
           end
        end
     end
     shader -layer 6
        validateRenderShaderContext -viewerRenderType $kRenderTypeNormal
        pass -modifiedEachFrameHint
           shaderProgram -target vertexProgram -method assemble            
              bindConstants 0 -bindingID geomToClip -constantCount 4
              bindConstants 4 -bindingID clipToViewTarget -constantCount 4
              shaderSource
                 vs_1_1
                 dcl_position v0
                 def c8,    -0.5, -0.5, 1, 1
                 def c9,     0.5,  0.5, 0, 0 
                 def c10,    0.25, 0.25, 0, 0
                 m4x4 r0,   v0,  c0
                 mov oPos, r0
                 mul r2, c9, r0.w
                 mad r4, r0, c8, r2
                 rcp r3.x, c4.x                                   
                 rcp r3.y, c5.y
                 mov r3.zw, c9.zw
                 mul r3, r3, c10
                 mad r6, r0, r3, r4
                 mov oT0, r6.xyww
              endShaderSource               
           end
           alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
           depthTest true -enableDepthWrite false
           colorScalar (0,0,0) 0.25
           stage
              textureTransformType vector3 homogeneous
              textureAddressing clamp clamp
              texture $reflectionRenderTarget
              textureBlend select(texture) select(colorScalar)
           end
                      
        end
     end
     
     shader -layer 6      
        validateRenderShaderContext -viewerRenderType $kRenderTypeNormal
        pass -modifiedEachFrameHint
           shaderProgram -target vertexProgram -method assemble            
              bindConstants 0 -bindingID geomToClip -constantCount 4
              bindConstants 4 -bindingID clipToViewTarget -constantCount 4
              shaderSource
                 vs_1_1
                 dcl_position v0
                 def c8,    -0.5, -0.5, 1, 1
                 def c9,     0.5,  0.5, 0, 0
                 def c10,    0.25, 0.25, 0, 0
                 m4x4 r0,   v0,  c0
                 mov oPos, r0
                 mul r2, c9, r0.w
                 mad r4, r0, c8, r2
                 rcp r3.x, c4.x                                   
                 rcp r3.y, c5.y
                 mov r3.zw, c9.zw
                 mul r3, r3, c10
                 mad r1, r0, r3, r4
                 rcp r1.w, r1.w
                 mul oT0.xy, r1.w, r1.xy
              endShaderSource               
           end
           alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
           depthTest true -enableDepthWrite false
           colorScalar (0,0,0) 0.25
           stage
              textureAddressing clamp clamp
              texture $reflectionRenderTarget
              textureBlend select(texture) select(colorScalar)
           end
           
        end
     end

enddef

  1. ---------------------------------------------------------------------------------------------------------------#

materialDefinition transparent_mirror_reflection

  setDefinition TransparentMirrorReflection

end

Personal tools
Namespaces

Variants
Actions
Navigation
game select
Toolbox