Difference between revisions of "ShaderCelshading"

Revision as of 13:46, 18 March 2007

EP3-OFB
0xCD7FE87A
0x1C0532FA
0x30A51061
0xFFF61EBE
# celshading

#
# Cel Shaders
#
# Implements a simple cel-shader with diffuse, specular, and edge terms,
# an outline (using offset normal trick), and environment map. Everything
# is optional except the diffuse stage. One stage each for diffuse/specular/edge.


#beginshader CelShadedMaterial
#description Simple Cel shader (one light)

#BeginStdAttrBlock

set csRampTexture       "64shade"
#attrdescription Lookup texture for diffuse intensity.

sete csShadeFilter point (point bilinear)
#attrdescription Filtering of the shade ramp

sete csColorFilter point (point bilinear)
#attrdescription Filtering of any color ramp


setb csAddSpecular false
#attrdescription Whether to enable specular intensity term.

set csSpecRampTexture "blackwhite"
#attrdescription Lookup texture for specular intensity

setf csShininess 100  # min:0 max:10000
#attrdescription Shininess of specular intensity highlight.
#attrdescription The shader may be more efficient if you
#attrdescription leave this at one and use the texture ramp
#attrdescription to modulate sharpness.


setb csAddEdge true
#attrdescription Whether to enable the edge intensity term.

set csEdgeRampTexture "blackwhite"
#attrdescription Lookup texture for edge intensity: how much the 
#attrdescription surface faces the camera. The left of the texture
#attrdescription faces the camera, the middle is edge-on, and the right 
#attrdescription faces away. This can be used to provide an outline or fresnel effect.

sete csEdgeFilter point (point bilinear)
#attrdescription Filtering of the edge ramp

setb csEdgeRampTextureAlphaInvert true
#attrdescription Whether to invert alpha from edge intensity ramp texture.

setf csEdgeOffset 0.3 # min:-1 max:1
#attrdescription Applies bias to the edge intensity term,
#attrdescription shifting it towards the camera (positive) or
#attrdescription away from the camera (negative).

setf csEdgeLightDamping 0 # min:-1000 max:1000
#attrdescription Offsets the edge term by diffuse lighting, which has
#attrdescription the effect of suppressing it in lit areas.


setb csRouteColorFromAlpha true
#attrdescription Whether to use vertex alpha rather than 'v' texture 
#attrdescription coordinate to select a color ramp.


setb csAddOutline false
#attrdescription Whether to add in an outline

setf csOutlineWidth 0.01 # min:0 max:1
#attrdescription Width of outline

setv3 csOutlineColor (1, 0.3, 0)
#attrdescription Color of the outline

setf csOutlineAlpha 1 # min:0 max:1
#attrdescription Opacity of the outline.


setb csAddEnvironmentMap false
#attrdescription Whether to add in an environment cube map.

set csEnvironmentMapTexture "reflectionoutdoorwater-envcube"
#attrdescription Environment cube map texture

setv3 csEnvironmentMapTint (1, 1, 1)
#attrdescription Color to tint the environment map

setf csEnvironmentMapStrength 0.4 # min:0 max:1
#attrdescription Overall environment map strength

setb csEnvironmentMapCameraRelative false
#attrdescription Whether cube map is camera relative

setb csParticleMode false
#attrdescription Whether material should respect particle attributes

seti  csMatLayer 0 # min:-32 max:32
#attrdescription Layer for drawing. Higher numbers are drawn later.


setb csUseCameraLight true
#attrdescription Whether to use the given camera light instead of normal
#attrdescription lighting.

setv4 csCameraLightDir (1, 0, 0.5, 0)
#attrdescription Direction of camera light


#EndStdAttrBlock

define CelShadedMaterial()
   material
      create DetermineHardwareSupport()	         
	   if ($useFixedFunctionPath or $useSWVertexShaderPath)
		   shader -layer ($csMatLayer * 8)
		      pass -fixedFunction
               colorScalar $csOutlineColor $csOutlineAlpha
               create LightingStates()
               stage                  
                  texture $csRampTexture
                  textureBlend multiply(texture diffuse) select(texture)
               end
		      end
		   end
	   else
		   create CelShadedMaterialRender()
	   endif		
	end
enddef

define CelShadedMaterialRender()   
   # Debugging
   #set csAddEdge false
   #set csAddSpecular true
   #set csRampTexture blackwhite
   #set csRouteColorFromAlpha false
   #set csAddEnvironmentMap false 
   #setb csAddOutline false
   #setf csOutlineWidth 0.1
   #setf csOutlineAlpha 1
   #setb csParticleMode true
   #set csSpecRampTexture "blackwhite"
   #setf csShininess 1
   #set stdMatBaseTextureEnabled false
   #set stdMatDiffCoef (0, 0, 0)
   #set stdMatFillMode wireframe

   if ($csParticleMode)
      attributes
         attribute colorAlpha4 float4
         attribute scale4      float4
         attribute info4       float4
      end
   endif
   
		            
   shader -layer ($csMatLayer * 8)
      if (not hasVertexFormat(color, 0))
         set csRouteColorFromAlpha false
      endif
      
      vertexFormatPred position      0 true
      vertexFormatPred normal        0 true
      if ($stdMatBaseTextureEnabled)
         vertexFormatPred texcoord   0 true
      endif
      vertexFormatPred color         0 $csRouteColorFromAlpha
   
      	create SetupSkinningStateAndPredicates()
		create SetupMorphingStateAndPredicates()

      if ($csAddOutline) 
         pass               
         
            if ($doSkinning or $doMorphing)
               create PreprocessVertexShader()
            endif
            
            
            # was create VS_NormalOffsetProgram($csOutlineWidth)
            shaderProgram -target vertexProgram -method assemble

               bindConstants 0  -bindingID geomToCamera        -constantCount 3
               bindConstants 3  -bindingID cameraToClip        -constantCount 4
               bindConstants 7  -bindingID immediateData       -data ($csOutlineWidth, 1, 0.005, 1)
               if ($csParticleMode)
                  bindConstants 8  -bindingID immediateData    -data @scale4
                  bindConstants 9  -bindingID immediateData    -data @info4 
               endif
               
               shaderSource
                  vs_1_1
                  dcl_position0 v0
                  dcl_normal0   v1
                  
                  # transform normal to camera space
                  mov  r3, c7       # so we can multiply below if in particle mode
                  mov  r0.w, r3.w
                  m3x3 r0,   v1, c0
               endShaderSource
               
               if ($csParticleMode)
                  shaderSource
                     mul  r1,   c8,  v0
                     m4x3 r2,   r1,  c0         # position in camera space.                     
                     mul  r3.x, r3.x, c9.z      # aspect from info4
                  endShaderSource
               else
                  shaderSource   "m4x3 r2, v0,  c0"         # position in camera space.
               endif
                  
               shaderSource
                  mov  r2.w, r3.w
                  mad  r2,   r0,  r3.x, r2      # add offset.
                  #mul  r2.y, r2.y, c7.y      # cheat away from the camera in camera space.
         
                  m4x4 r3, r2, c3               # to clip space.
                  mad  r3.z, r3.w, c7.z, r3.z   # cheat back depth in clip space: z' += eps, -> z += eps * w. 
                  mov oPos, r3
               endShaderSource
            end
            
            create NonStandardLighting()
            
            alphaBlend srcFactor(one) add dstFactor(zero)
            depthTest true -enableDepthWrite true
            depthTestFunction acceptIfLess
            cullmode cullCounterClockwise
            if ($csOutlineAlpha < 1)
               alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
            endif
            fillmode $stdMatFillMode
            
            colorScalar $csOutlineColor $csOutlineAlpha
            stage                  
               textureBlend select(colorScalar) select(colorScalar)
            end
         end
      endif
      
      # MAIN CEL SHADER PASS
      pass
         if (not $csAddOutline)
            create PreprocessVertexShader()
         endif
         
         seti ts 1
         if ($stdMatBaseTextureEnabled)
            seti texReg $ts
            seti ts ($ts + 1)
         endif
         if ($csAddEdge)
            seti edgeReg $ts
            seti ts ($ts + 1)
         endif
         if ($csAddSpecular)
            seti specReg $ts
         endif

         shaderProgram -target vertexProgram -method assemble
            
            bindConstants 0  -bindingID geomToClip          -constantCount 4
            bindConstants 4  -bindingID geomToCamera        -constantCount 3
            bindConstants 7  -bindingID immediateData       -data ($csEdgeOffset, $csShininess, 0.5, 1)
            bindConstants 8  -bindingID immediateData       -data ($csEdgeLightDamping, 0, 0, 0)
            
            if ($csUseCameraLight)
               bindConstants 10 -data $csCameraLightDir
            else
               bindConstants 10 -bindingID camLocalToDirLight1 -constantCount 1
            endif
            
            if ($csParticleMode)
               bindConstants 11 -bindingID immediateData    -data @colorAlpha4
               bindConstants 12 -bindingID immediateData    -data @scale4
            endif
            
            shaderSource 
               vs_1_1
               dcl_position0 v0
               dcl_normal0   v1
               dcl_texcoord0 v2
            endShaderSource

            if (hasVertexFormat(texcoord, 1))
               shaderSource "dcl_texcoord1 v3"
            endif

            if ($csRouteColorFromAlpha)
               shaderSource "dcl_color0 v4"
            endif
               
            # r0 = N
            # r1 = H
            # r2 = E
            # r3 = scratch
            # r4 = local position
            
            if ($csParticleMode)
               shaderSource "mul r4, v0, c12"
            else
               shaderSource "mov r4, v0"
            endif
            
            shaderSource                  
               # transform position
               m4x4 oPos, r4, c0
               
               # transform normal to camera space
               mov r0.w, c7.w
               m3x3 r0, v1, c4
               
               # N.L in camera space.
               dp3 r3.x, r0, c10

               # position in camera space
               mov r2.w, c7.w
               m4x3 r2, r4, c4

               # vector from point to eye, E
               mov r2, -r2

               # normalize E
               # create VS_Normalize(r2 r2)
                  dp3 r2.w, r2,    r2
                  rsq r2.w, r2.w
                  mul r2,   r2,    r2.w

               # find H = (L + E) / 2
               add r1, c10, r2
               mul r1, r1, c7.z

               # normalize H
               # create VS_Normalize(r1 r1)
                  dp3 r1, r1,    r1
                  rsq r1, r1.w
                  mul r1, r1,    r1.w
               
               # N.H in camera space.
               dp3 r3.y, r0, r1

               # lit: (N.L) (N.S) -> clamped diff and spec
               # exponent
               mov r3.w, c7.y   
               lit r1, r3
               
               # diffuse intensity
               mov oT0.x, r1.y    
            endShaderSource
            
            if ($csRouteColorFromAlpha)
               shaderSource "mov oT0.y, v4.w"    # pass through color0 alpha
            else
               if ($stdMatBaseTextureEnabled and (hasVertexFormat(texcoord, 1)))
                  shaderSource "mov oT0.y, v3.y"    # pass through t1.v
               else
                  shaderSource "mov oT0.y, v2.y"    # pass through t0.v
               endif
            endif
            if ($stdMatBaseTextureEnabled)
               shaderSource "mov oT${texReg}, v2"
            endif
            if ($csAddEdge)
               shaderSource "dp3 r3, r0, r2"                    # N . E    
               if ($csEdgeLightDamping != 0)
                  shaderSource "mad r3, r1.y, c8.x, r3"         # offset by scaled diffuse term
               endif
               shaderSource "add oT${edgeReg}.x, c7.x, r3.x"    # edge intensity + k
            endif
            if ($csAddSpecular)
               shaderSource "mov oT${specReg}.x, r1.z"          # specular intensity
            endif
            if ($csParticleMode)
               shaderSource "mov oD0, c11"          # particle colour/alpha
            endif
         end

         #######################################################
         
         create NonStandardLighting()
            
         if ($csAddOutline) 
            depthTestFunction acceptIfLessOrEqual
         endif

         if ($stdMatBaseTextureEnabled)
            if ($csUseCameraLight)
               colorScalar ($stdMatDiffCoef * (0.25).xxx)
            else
               colorScalar -lightRadiance directional 0 ($stdMatDiffCoef * (0.25).xxx)
            endif
            
         else
            if ($csUseCameraLight)
               colorScalar $stdMatDiffCoef            
            else
               colorScalar -lightRadiance directional 0 $stdMatDiffCoef            
            endif               
         endif

         if ($csParticleMode)
            alphaBlend srcFactor(srcAlpha) add dstFactor(invSrcAlpha)
         endif
         
         fillmode $stdMatFillMode
            
         stage
            texture $csRampTexture 
            textureMIPFilterHint disabled
            textureFilterHint $csShadeFilter $csColorFilter
            textureAddressing clamp clamp
            textureBlend multiply(texture colorScalar) select(texture)
         end
         if ($stdMatBaseTextureEnabled)
            # base texture stage
            stage
               texture $stdMatBaseTextureName
               textureAddressing $stdMatBaseTextureAddressingU $stdMatBaseTextureAddressingV $stdMatBaseTextureAddressingW

               textureBlend multiplyScale4(texture outRegister) multiply(texture outRegister)
            end
         endif
         if ($csParticleMode) 
            stage
               textureBlend multiply(outRegister diffuse) multiply(outRegister diffuse)
            end
         endif
         if ($csAddEdge)
            stage
               texture $csEdgeRampTexture
               textureAddressing clamp clamp
               textureFilterHint $csEdgeFilter $csEdgeFilter
               if ($csEdgeRampTextureAlphaInvert)
                  textureBlend lerpTextureAlpha(outRegister texture) select(outRegister)
               else
                  textureBlend lerpTextureAlpha(texture outRegister) select(outRegister)
               endif
            end
         endif
         if ($csAddSpecular)
            stage
               texture $csSpecRampTexture
               textureMIPFilterHint disabled
               textureFilterHint bilinear bilinear # $csShadeFilter $csColorFilter
               textureAddressing clamp clamp
               textureBlend lerpTextureAlpha(texture outRegister) select(outRegister)
            end
         endif
      end
      if ($csAddEnvironmentMap)
         pass
            alphaBlend srcFactor(srcAlpha) add dstFactor(one)
            depthTest true -enableDepthWrite false
            depthTestFunction acceptIfEqual

            # we must use a vertex program again, or we'll get inconsistent
            # depth results with the previous pass.
            shaderProgram
               
               bindConstants 0  -bindingID geomToClip        -constantCount 4
               bindConstants 4  -bindingID geomToCamera      -constantCount 3
               bindConstants 7  -bindingID immediateData     -data (0, 0, 0, 1)
               
               shaderSource 
                  vs_1_1
                  dcl_position0 v0
                  dcl_normal0   v1
                  
                  m4x4 oPos, v0, c0
               endShaderSource
               
               if ($csEnvironmentMapCameraRelative)
                  shaderSource
                     # transform normal to camera space
                     mov r0.w, c7.w
                     m3x3 r0, v1, c4

                     # look up cube map.
                     mov oT0, r0
                  endShaderSource
               else
                  shaderSource "mov oT0, v1"
               endif
            end
            
            colorScalar $csEnvironmentMapTint $csEnvironmentMapStrength
            
            fillmode $stdMatFillMode
            
            stage
               texture $csEnvironmentMapTexture
               textureMIPFilterHint disabled
               textureFilterHint bilinear bilinear
               textureAddressing clamp clamp clamp
               
               textureBlend multiply(texture colorScalar) multiply(texture colorScalar)
            end
         end
      endif
   end
enddef

#endshader CelShadedMaterial