Difference between revisions of "TEST-STRCMP4CODES"

From SimsWiki
Jump to: navigation, search
 
(59 intermediate revisions by one user not shown)
Line 1: Line 1:
  pass
+
define TransparentMirrorReflection()
#fillmode wireframe
+
  material
alphaBlend srcFactor(one) add dstFactor(one)
+
       if (viewerRenderType = $kRenderTypeShadow)
+
         create StandardShaderShadow()
       shaderProgram -target vertexProgram -method compile -version 1_1
+
       else
     
+
         if (viewerRenderType = $kRenderTypeThumbnail)
        bindConstants 0 -bindingID geomToClip -constantCount 4
+
            create TransparentBlankMirrorMaterial($kRenderTypeThumbnail)
        bindConstants 4 -bindingID geomToCamera -constantCount 3
+
         else           
     
+
             if (not $mirrorReflectionsEnabled)
        bindConstants 7 -bindingID frameInfo
+
              set currentType (viewerRenderType)
     
+
              create TransparentBlankMirrorMaterial($currentType)
        bindConstants 11 -bindingID immediateData -data ($wmXRepeat, 0, $wmXWaveHeight, $wmXSpeed)
+
             else
         bindConstants 12 -bindingID immediateData -data (0, $wmYRepeat, $wmYWaveHeight, $wmYSpeed)
+
              create TransparentMirrorReflectionMaterial()
        
+
             endif           
         # pre-evaluate these
+
        endif       
        setf xscale (-$wmXRepeat * $wmXWaveHeight)
+
      endif
        setf yscale (-$wmYRepeat * $wmYWaveHeight)
+
  end
         bindConstants 13 -bindingID immediateData -data ($xscale,$yscale, 1,0)
+
enddef
        bindConstants 14 -bindingID allStandardLightData -constantCount 4 -constantType float
+
 
        bindConstants 18 -bindingID cameraToGlobal -constantCount 3
+
define TransparentBlankMirrorMaterial(renderType)
 
+
      shader
        shaderSource
+
        validateRenderShaderContext -viewerRenderType  &renderType
     
+
             float4 frameInfo : register(c7);
+
            float4 waveDataX : register(c11);
+
            float4 waveDataY : register(c12);
+
             float4 waveDataHelper : register(c13);
+
            float4x4 clipSpaceMatrix : register(c0);
+
             float4x3 cameraSpaceMatrix : register(c4);
+
            float4x3 cameraToGlobalMatrix : register(c18);
+
           
+
            float4 lightDirection : register(c14);
+
            float4 lightColor : register(c15);
+
            const static float4 refractionWeights={1,1,2,0};
+
           
+
            struct InputVertex
+
            {
+
              float4 position: POSITION0;
+
              float3 normal : NORMAL0;
+
              float2 texc : TEXCOORD0;
+
            };
+
           
+
            struct OutputVertex
+
            {
+
              float4 clipPosition : POSITION;
+
              float3 normal : TEXCOORD0;
+
              float3 viewVector : TEXCOORD1;
+
 
          
 
          
             };
+
        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
 
              
 
              
             static float2 waveCenter1 = {0.0, 0.0};
+
             colorScalar (0,0,0) 0.5
            static float2 waveCenter2 = {-0.6, 0.2};
+
             stage
           
+
               textureBlend select(colorScalar) select(colorScalar)
            static float2 timeScale = {2,1};
+
            end           
            static float2 waveHeight = {0.04, 0.02};
+
        end
             static float2 distScale = {12, 8};
+
      end     
           
+
enddef
           
+
           
+
            float4 ComputeWavePositionTwoWay(float2 pos1, float2 pos2)
+
            {
+
           
+
  float2 vec;
+
               float4 dist;
+
             
+
              vec = waveCenter1 - pos1;
+
              dist.x = dot(vec, vec);
+
             
+
              vec = waveCenter2 - pos1;
+
              dist.y = dot(vec,vec);
+
             
+
  vec = waveCenter2 - pos2;
+
              dist.z = dot(vec, vec);
+
             
+
              vec = waveCenter2 - pos2;
+
              dist.w = dot(vec,vec);
+
 
+
  dist *= distScale.xyxy;
+
 
+
  float4 sinResult = sin(dist + frameInfo.w * timeScale.xyxy);
+
  
  //sinResult = 1.0- abs(sinResult);
+
define TransparentMirrorReflectionMaterial()
+
     
  return(sinResult);
+
      shader -layer -9998  # this material must render first
+
        validateRenderShaderContext -viewerRenderType $kRenderTypeMirror  # reflection render
            }
+
           
+
            float2 ComputeWavePosition(float2 pos1)
+
            {
+
           
+
  float2 vec;
+
              float2 dist;
+
 
+
  vec = waveCenter1 - pos1;
+
              dist.x = dot(vec, vec);
+
             
+
              vec = waveCenter2 - pos1;
+
              dist.y = dot(vec,vec);
+
               
+
  dist *= distScale.xy;
+
 
+
  float2 sinResult = sin(dist + frameInfo.w * timeScale);
+
  
  //sinResult = 1.0- abs(sinResult);
+
        pass -renderEachFrame
+
             renderTarget $reflectionRenderTarget -setViewport viewportFromParentRenderContext
  return(sinResult);
+
 
+
             depthTest true -enableDepthWrite true
             }
+
           
+
             OutputVertex VertexMain( InputVertex inputVertex)
+
            {
+
              // Do Y-direction waves
+
              // r0 = (x, y, z, t)
+
             
+
              OutputVertex outputVertex;
+
+
float4 pos = inputVertex.position;
+
+
float2 sample1, sample2, sample3;
+
+
sample1 = inputVertex.position;
+
sample2 = inputVertex.position;
+
sample3 = inputVertex.position;
+
sample2.x += 0.1;
+
sample3.y += 0.1;
+
+
float4 heights1=ComputeWavePositionTwoWay(sample1, sample2);
+
float2 heights2=ComputeWavePosition(sample3);
+
+
+
float3 pos1, pos2;
+
pos1 = pos;
+
pos2 = pos;
+
+
  pos.z += (heights1.x* waveHeight.x);// + heights1.y *  waveHeight.y);
+
  pos1.z += (heights1.z* waveHeight.x);// + heights1.w *  waveHeight.y);
+
  pos2.z += (heights2.x* waveHeight.x);// + heights2.y *  waveHeight.y);
+
+
pos1.x +=0.1;
+
pos2.y +=0.1;
+
float3 vec1, vec2;
+
vec1 = normalize(pos1 - pos);
+
vec2 = normalize(pos2 - pos);
+
+
float3 normal = cross(vec1, vec2);
+
+
normal = mul(normal, (float3x3)cameraSpaceMatrix);
+
  
float3 viewVector = mul(pos, cameraSpaceMatrix);
+
            applyStencilStateForOverlappingReflections
+
 
outputVertex.viewVector = normalize(-viewVector);
+
            alphaBlend srcFactor(zero) add dstFactor(one)
+
 
               outputVertex.clipPosition = mul(pos, clipSpaceMatrix);
+
            cullmode none
              outputVertex.normal = normal;
+
 
               return(outputVertex);
+
            shaderProgram -target vertexProgram -method assemble           
                
+
              bindConstants 0 -bindingID geomToClipFromParentView -constantCount 4
        }
+
              shaderSource
              
+
                  vs_1_1
         endShaderSource
+
                  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
 
        
 
        
       end # end shaderProgram
+
       shader -layer 6     
          
+
         validateRenderShaderContext -viewerRenderType $kRenderTypeNormal
      shaderProgram -target pixelProgram -method assemble
+
        pass -modifiedEachFrameHint
        bindConstants 0 -bindingID allStandardLightData -constantCount 4 -constantType float
+
            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
  
        shaderSource
+
            alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
             ps_2_0
+
             depthTest true -enableDepthWrite false
             def c10,20,4,0,0
+
             colorScalar (0,0,0) 0.25
            def c11, 0,0.5,1,2
+
 
            dcl t0
+
             stage
             dcl t1 ; v
+
              textureAddressing clamp clamp
dcl_cube s0
+
              texture $reflectionRenderTarget
     
+
              textureBlend select(texture) select(colorScalar)
            nrm r0, t0      ; n
+
            end
           
+
            add r1, r0, r0  ; 2N
+
           
+
            dp3 r1.w, r0, t1 ; N.V
+
mad r2.xyz, r1, r1.w, -t1    ; 2N * (N.V) -V
+
+
texld r5, r2, s0
+
+
dp3 r3.x, r2, c0  ; R.L
+
pow r4, r3.x, c10.x
+
+
mov_sat r1.x, r1.w
+
+
add r6.x, c11.z, -r1.x      ; 1 - Fresnel
+
+
pow r3.y, r6.x, c10.y  ; N.V ^ 4
+
+
mul r7, r5, r3.y
+
mad r4, r4, r3.y, r7
+
mul r4, r4, c11.y
+
+
mov oC0, r4
+
 
              
 
              
         endShaderSource
+
         end
 
       end
 
       end
     
 
      sampler 0
 
texture $wmReflectionTexture
 
textureAddressing clamp clamp clamp
 
      end
 
  end  # pass
 
 
 
 
enddef
 
enddef
 +
 +
#---------------------------------------------------------------------------------------------------------------#
 +
 +
materialDefinition transparent_mirror_reflection
 +
  setDefinition TransparentMirrorReflection
 +
end

Latest revision as of 05: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