Sorry your browser is not supported!

/*****************************************************
Cartoon.fx - Cartoon Shader
By: Preston "NWC_Omega" Chaderton

This is a little shader that gives an object a little
more "cartoony" appearance.  It doesn't smoothly shade
the model like normal and it gives it an outline.

The first pass draws the object.  It accesses a certain
area on the shading texture (toon.dds) based on the 
diffuse value generated by a single light.  It then blends
this with the specified base texture (base.dds) to create
the cartoon like shading.

With the second pass, it draws the outline.  It pushes
each vertex along it's normal by a certain amount, then
draws the object with a cw cull.  This gives it a basic
outline, which, while it doesn't look the best, does it's
job.

It was created in FX Composer and then in Notepad for use in
Dark Basic Pro.  It compiles under VS 1.1 and PS 1.1 for the
less powerful computers.

It runs at 350 FPS on my Intel Celeron 1.3 Ghrz, 512 MB
Ram, NVIDIA GeForce FX 5200 when applied to a sphere 
with 3278 triangles in a test program running at 
640x480x32.

****************************************************/

// stroke thickness
float S = 3;
// light direction (view space)
float3 lightDir  = {0.577, -0.577, 0.577};

// light intensity
float4 I_a = { 0.1f, 0.1f, 0.1f, 1.0f };    // ambient
float4 I_d = { 1.0f, 1.0f, 1.0f, 1.0f };    // diffuse
float4 I_s = { 1.0f, 1.0f, 1.0f, 1.0f };    // specular

// material reflectivity
float4 k_a = { 1.0f, 1.0f, 1.0f, 1.0f};
float4 k_d = {1.0f, 1.0f, 1.0f, 1.0f};
float4 k_s = { 1.0f, 1.0f, 1.0f, 1.0f};
int n = 32;

// texture
texture Tex0 < 
                string texturetype = "2D" ; 
                string name = "base.dds"; 
             >;
             
texture Tex1 <
                string texturetype = "2D" ;
                string name = "toon.dds";
             >;

// transformations
float4x4 World      : WORLD;
float4x4 View       : VIEW;
float4x4 Projection : PROJECTION;

struct VS_OUTPUT
{
    float4 Pos  : POSITION;
    float4 Diff : COLOR0;
    float4 Spec : COLOR1;
    float2 Tex  : TEXCOORD0;
    float2  TexB : TEXCOORD1;
};

VS_OUTPUT VS(
    float3 Pos  : POSITION, 
    float3 Norm : NORMAL, 
    float2 Tex  : TEXCOORD0)
{
    VS_OUTPUT Out = (VS_OUTPUT)0;
    float3 L = -lightDir;
    float4x4 WorldView = mul(World, View);
    float3 P = mul(float4(Pos, 1), (float4x3)WorldView);  // position (view space)
    float3 N = normalize(mul(Norm, (float3x3)World)); // normal (view space)
    float3 R = normalize(2 * dot(N, L) * N - L);          // reflection vector (view space)
    float3 V = -normalize(P);                             // view direction (view space)
    Out.Pos  = mul(float4(P, 1), Projection);             // position (projected)
    Out.Diff = I_a * k_a + I_d * k_d * max(0, dot(N, L)); // diffuse + ambient
    Out.Spec = I_s * k_s * pow(max(0, dot(R, V)), n/4);   // specular
    Out.Tex  = Tex;
    Out.TexB = Out.Diff.r;                                       
    return Out;
}

VS_OUTPUT OUTLINEVS(
    float3 Pos  : POSITION, 
    float3 Norm : NORMAL, 
    float2 Tex  : TEXCOORD0)
{
    VS_OUTPUT Out = (VS_OUTPUT)0;
    float3 L = -lightDir;
    float4x4 WorldView = mul(World, View);
    float3 N = normalize(mul(Norm, (float3x3)WorldView)); // normal (view space)
    float3 P = mul(float4(Pos, 1), (float4x3)WorldView) + S * N;
    float3 R = normalize(2 * dot(N, L) * N - L);          // reflection vector (view space)
    float3 V = -normalize(P);                             // view direction (view space)
    Out.Pos  = mul(float4(P, 1), Projection);             // position (projected)
    Out.Diff = (0.01,0.01,0.01,1);                                 // diffuse + ambient
    Out.Spec = I_s * k_s * pow(max(0, dot(R, V)), n/4);   // specular
    Out.Tex  = Tex;                                       
    return Out;
}

sampler MainSamp = sampler_state
{
    Texture   = (Tex0);
    MipFilter = LINEAR;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
};

sampler ToonSamp = sampler_state
{
    Texture   = (Tex1);
    MipFilter = LINEAR;
    MinFilter = LINEAR;
    MagFilter = LINEAR;
    AddressU  = CLAMP;        
    AddressV  = CLAMP;
    AddressW  = CLAMP;
};


float4 PS(
    float4 Diff : COLOR0,
    float4 Spec : COLOR1,
    float2 Tex  : TEXCOORD0,
    float2 TexB : TEXCOORD1) : COLOR
{
    float2 TexC = (TexB.x,0);
    return tex2D(MainSamp, Tex)*tex2D(ToonSamp,TexB);
}

float4 OUTLINEPS() : COLOR
{
    float4 ReturnThis = (0.01f,0.01f,0.01f,0.01f);
    return ReturnThis;
}

technique TVertexAndPixelShader
{
    pass P0
    {
        // shaders
        VertexShader = compile vs_1_1 VS();
        PixelShader  = compile ps_1_1 PS();
    }  
    
    pass P1
    {
        VertexShader = compile vs_1_1 OUTLINEVS();
        PixelShader  = compile ps_1_1 OUTLINEPS();
        
        ZEnable = true;
        ZWriteEnable = true;
        CullMode = cw;
	AlphaBlendEnable = false;     
    }
}

      ZENABLE = TRUE;
      FILLMODE = SOLID;
      SHADEMODE = FLAT;
      ZWRITEENABLE = TRUE;

//--------------------------------------------------------------//
// Vertex Shader
//--------------------------------------------------------------//

string XFile = "default.x";
texture sky < string name = "sky.tga"; >;
texture cloud < string name = "cloud.tga"; >;
matrix wvp : worldViewProjection;
float time : Time0_X;

VertexShader Atmospheric_Effects_CloudsEffect_ASM_Single_Pass_Vertex_Shader_ = asm
{
   vs.1.1
   
   dcl_position   v0
   dcl_normal     v1
   dcl_texcoord   v2
   
   def c9, 0.005f, 0.02f, -0.004f, 0.002f
   def c10, 0.878f, 0.33f, 2.5f, 2.5f
   def c11, 0.009f, -0.017f, -0.015f, 0.007f
   def c12, 1.0f, 1.02f, 4.17f, 4.1f 


   m4x4 oPos, v0, c0 
     
   mov  r4, v2      // output base tex coord
   mov  oT4, r4  
   
   mov  r0, c7.xxxx  // (time*cloud0vel)
   mul  r1, c9.xyxy, r0
   
   mul  r2, c9.zwzw, r0  // (time*cloud0disvel) 
   
   mad  oT0, r4.yx, c10.xyxy, r1.xy
   mad  oT1, r4.yx, c10.zwzw, r2.xy
   
   mul  r1, c11.xyxy, r0  // (time*cloud1vel)
   
   mul  r2, c11.zwzw, r0  // (time*cloud1disvel)
   
   mad  oT2, r4.yx, c12.xyxy, r1.xy
   mad  oT3, r4.yx, c12.zwzw, r2.xy
   
   
   
   
   
   

};


//--------------------------------------------------------------//
// Pixel Shader
//--------------------------------------------------------------//
PixelShader Atmospheric_Effects_CloudsEffect_ASM_Single_Pass_Pixel_Shader_ = asm
{
   ps.1.4
   
   def c0, 0.0f, 0.5f, 1.0f, 2.0f
   def c1, -0.157f, 0.13f, 0.0f, 0.02f
   def c2, 0.525f, 0.421f, 0.712f, 0.698f
   def c3, 0.05f, -0.085f, 0.0f, 0.02f
   def c4, 0.293f, 0.231f, 0.795f, 0.348f
   def c5, 0.871f, 0.532f, 0.0863f, 0.77f

   texld  r0, t1
   texld  r1, t1
   texcrd r2.rgb, t0
   texcrd r3.rgb, t2


   
      mad r0.rgb, c1, r0_bx2, r2 ; perturb base map coords by cloud coords
      mad r1.rgb, c3, r1_bx2, r3 ; perturb base map coords by cloud coords
   
   phase
   
   texld r0, r0
   texld r1, r1
   texld r2, t4
   
      mov_x2 r3.rgb, r2.a              ; alpha of horizon (glow map)
      +mul_sat r3.a, 1-r0.a, 1-r1.a    ; mask edges for cloud glow
    
      mad_sat r0.rgb, 1-r0.a, c2, c2.a ; scale and bias inverted clouds layer 0
      +mov_x2_sat r0.a, r0.a           ; boost cloud alpha 0
   
      mad_sat r1.rgb, 1-r1.a, c4, c4.a ; scale and bias inverted clouds layer 1
      +mov_x2_sat r1.a, r1.a           ; boost cloud alpha 1
   
      lrp r0.rgb, r1.a, r1, r0         ; combine cloud layers
      +mov r4.a, c5.a                  ; ...
   
      mul_x2 r3, r3.a, r3              ; multiply glow by edges of clouds
      mad_x2 r3, r3, c5, r4.a          ; scale and bias glowing sections of clouds
   
      mul r0.rgb, r3, r0               ; multiply glow by combination of cloud layers
      +add_d2_sat r0.a, r0.a, r1.a     ; add alphas of cloud layers
   
      lrp_sat r0, r0.a, r0, r2         ; lerp between clouds and horizon
   
   

};

//--------------------------------------------------------------//
// Technique Section for Atmospheric Effects
//--------------------------------------------------------------//
technique CloudsEffect_ASM
{
   pass Single_Pass
   {

	VertexShaderConstant[0] = <wvp>;
	VertexShaderConstant[7] = <time>;

	Texture[0] = <cloud>;
	Texture[1] = <cloud>;
	Texture[2] = <sky>;
	
	AddressU[2] = Wrap;
	AddressV[2] = Wrap;
	AddressU[1] = Wrap;
	AddressV[1] = Wrap;
	AddressU[0] = Wrap;
	AddressV[0] = Wrap;

      ZENABLE = TRUE;
      FILLMODE = SOLID;
      SHADEMODE = FLAT;
      ZWRITEENABLE = FALSE;
      ALPHATESTENABLE = FALSE;
      LASTPIXEL = TRUE;
      SRCBLEND = ONE;
      DESTBLEND = ZERO;
      CULLMODE = NONE;
      ALPHAREF = 0x0;
      ALPHAFUNC = LESS;
      DITHERENABLE = FALSE;
      ALPHABLENDENABLE = FALSE;
      FOGENABLE = FALSE;
      SPECULARENABLE = FALSE;
      FOGCOLOR = 0xFFFFFFFF;
      FOGTABLEMODE = NONE;
      FOGSTART = 0.000000;
      FOGEND = 0.000000;
      FOGDENSITY = 5.000000;
      STENCILENABLE = FALSE;
      STENCILFAIL = KEEP;
      STENCILZFAIL = KEEP;
      STENCILPASS = KEEP;
      STENCILFUNC = ALWAYS;
      STENCILREF = 0x0;
      STENCILMASK = 0xffffffff;
      STENCILWRITEMASK = 0xffffffff;
      TEXTUREFACTOR = 0x0;

      CLIPPING = FALSE;
      LIGHTING = FALSE;
      AMBIENT = 0xffffffff;
      FOGVERTEXMODE = NONE;
      COLORVERTEX = TRUE;
      LOCALVIEWER = TRUE;
      NORMALIZENORMALS = FALSE;
      DIFFUSEMATERIALSOURCE = COLOR1;
      SPECULARMATERIALSOURCE = COLOR2;
      AMBIENTMATERIALSOURCE = COLOR2;
      EMISSIVEMATERIALSOURCE = COLOR2;
      VERTEXBLEND = DISABLE;
      CLIPPLANEENABLE = 0;
      POINTSIZE = 0.000000;
      POINTSIZE_MIN = 0.000000;
      POINTSPRITEENABLE = FALSE;
      POINTSCALEENABLE = FALSE;
      POINTSCALE_A = 0.000000;
      POINTSCALE_B = 0.000000;
      POINTSCALE_C = 0.000000;
      MULTISAMPLEANTIALIAS = TRUE;
      MULTISAMPLEMASK = 0xffffffff;
      COLORWRITEENABLE = RED | GREEN | BLUE | ALPHA;
      TWEENFACTOR = 0.000000;
      BLENDOP = ADD;
      POSITIONDEGREE = CUBIC;
      NORMALDEGREE = LINEAR;

      VertexShader = (Atmospheric_Effects_CloudsEffect_ASM_Single_Pass_Vertex_Shader_);
      PixelShader = (Atmospheric_Effects_CloudsEffect_ASM_Single_Pass_Pixel_Shader_);
   }

}