Can anyone help me fix this FX shader?

Author

Message

Chenak

23

Years of Service

User Offline

Joined: 13th Sep 2002

Location: United Kingdom

Posted: 9th Sep 2003 02:23

Link

Hi there, i got this per pixel lighting shader and i cant get it to work, there are not any errors when it compiles but if it is applied to an object, the object disappears.

Can anyone help?

//shared texture tNormalizer;
//shared texture tBump;
//shared texture tDiffuse;

string XFile = "sphere.x";

texture tAtenuacionXY < string name = "norm.tga"; >;
texture tAtenuacionZ < string name = "bass.tga"; >;
texture tDiffuse < string name = "bass.tga"; >;
texture tNormalizer < string name = "norm.tga"; >;
texture tBump < string name = "gloss.tga"; >;

//texture tAtenuacionXY;
//texture tAtenuacionZ;

float4 vPosLight <  string UIDirectional = "Light Direction"; >;
float4 vPosViewer;
float4 vScaleLight <  string UIDirectional = "Light Scale"; >;
float4 vColorLight <  string UIDirectional = "Light Color"; >;

float4x4 mViewProjection :  WORLDVIEWPROJECTION;

vertexshader transformAttenuation = 
asm
{ 
vs_1_1

//-------------------------------
//Constant registers
//-------------------------------
// c0-c3        - world*view*proj
// c8           - light position(In object space)
// c9           - 1 / lightRange
def c6, 0.5, 0, 0, 0                            // helper constant

//------------------------------
// Used input registers
//------------------------------
dcl_position v0

//------------------------------
// output position 
//------------------------------
//
m4x4 oPos, v0, c0

//------------------------------
// compute texture coordinates for attenuation
//------------------------------
//

add r7.xyz, -v0, c8                             // light position - vertex pos
mul r2.xyz, r7, c9                              // (light position - vertex pos) / lightRange
mad r4.xyz, r2, c6.x, c6.x                      // map to 0 to 1 range

mov oT0.xy, r4                                  // t0 = texture coordinates for attenuation texture 1

mov oT1.x, r4.z                                 // t1 = texture coordinates for attenuation texture 2
mov oT1.y, c6.w
};

pixelshader shaderAttenuation = 
asm
{
ps_1_1

//------------------------------
// load textures
//------------------------------
//
tex t0                                          // load attenuation texture 1
tex t1                                          // load attenuation texture 2

//------------------------------
// compute attenuation per pixel
//------------------------------
//

mul r0,t0,t1                                    // output = exp(-2*(x*x+y*y))*exp(-2*z*z)
};

vertexshader transformSpecularDiffuse = 
asm
{
vs_1_1

//-------------------------------
//Constant registers
//-------------------------------
// c0-c3        - world*view*proj
// c8           - light position(In object space)
// c10          - vPosViewer(In object space)
def c6, -1, 0, 0, 0                             // helper constant
def c7, 2, -1, 0, 0                             // helper constant

//------------------------------
// Input registers
//------------------------------
dcl_position v0
dcl_tangent v1
dcl_binormal v2
dcl_normal v3
dcl_texcoord v4

//------------------------------
// output position 
//------------------------------
//
m4x4 oPos, v0, c0

//------------------------------
// Compute the tangent space matrix to transform from object space to tangent space
//------------------------------
//
mad r7.xyz, c7.x, v1, c7.y                      //bias vector tangent to (-1,1)
mad r8.xyz, c7.x, v2, c7.y                      //bias vector binormal to (-1,1)
mad r9.xyz, c7.x, v3, c7.y                      //bias vector normal to (-1,1)

//------------------------------
// Compute L vector in tangent space
//------------------------------
//
add r10, -v0, c8                                // light position - vPos
dp3 r7.w, r10, r10                              // Normalize (lightpostion-vPos)
rsq r7.w, r7.w
mul r11.xyz, r10, r7.w

m3x3 oT2.xyz, r11, r7                           // t2 = L vector in tangent space

//------------------------------
// Compute H vector in tangent space
//------------------------------
//
add r4, -v0, c4                                 // V vector
add r6, r10, r4                                 // L + V
dp3 r6.w, r6, r6                                // Normalize (L+V)
rsq r6.w, r6.w
mul r5.xyz, r6, r6.w

m3x3 oT3.xyz, r5, r7                            // t3 = H vector in tangent space

//------------------------------
// output texture coordinates 
//------------------------------
//
mov oT0.xy, v4                                  // t0 = texture coordinate
mov oT1.xy, v4                                  // t1 = texture coordinate
};

pixelshader shaderSpecularDiffuse = 
asm
{
ps_1_1

//-------------------------------
//Constant registers
//-------------------------------
// c1           - lightColor
def c0, 4.0f, 1.0f, 0.0f, -0.75f                // Helper constant

//------------------------------
// Load textures
//------------------------------
//
tex t0                                          // Normal
tex t1                                          // diffuse
tex t2                                          // L
tex t3                                          // H

//------------------------------
// compute output color
//------------------------------
//
dp3_sat r1.xyzw,t3_bx2,t0_bx2                   // max(0,dot(N,H))
dp3_sat r0.rgb,t2_bx2,t0_bx2                    // max(0,dot(N,L))
+mad_x4_sat r1.w,r1.w,r1.w,c0.w                 // specular = saturate(4*(dot(N,H)^2-0.75))
mul r1.w,r1.w,r1.w                              // specular = specular*specular
mul r0.rgb,r0,t1                                // diffuse = dot(N,L)*diffuse texture map
+mul_x2_sat r1.w,r1.w,t0.w                      // specular = saturate(specular*2*gloss map)
add_sat r0.rgb,r0,r1.w                          // specular + diffuse
mul r0.rgb,r0,c1                                // (specular+diffuse)*lightColor
+mov r0.a,t1.a                                  // alpha output = alpha diffuse map for transparency.
};

technique pixelShader1_1_asm
{
    pass P0
    {                            
        ALPHABLENDENABLE = False;
        ColorWriteEnable = 0x8;
                   
        Texture[0]   = <tAtenuacionXY>; 
        Texture[1]   = <tAtenuacionZ>; 
                          
                          
        AddressU[0] = Clamp;
        AddressV[0] = Clamp;
        
        AddressU[1] = Clamp;
        AddressV[1] = Clamp;

VertexShaderConstant[0] = <mViewProjection>; 
        VertexShaderConstant1[8] = <vPosLight>;
        VertexShaderConstant1[9] = <vScaleLight>;

Vertexshader = <transformAttenuation>;                 
        PixelShader = <shaderAttenuation>;       
    }        
    pass P1
    {                    
        ALPHABLENDENABLE = True;
        SrcBlend = DestAlpha;        
        DestBlend = One;         
    
        
        ColorWriteEnable = 0xF;
        
        AddressU[0] = Wrap;
        AddressV[0] = Wrap;
        
        AddressU[1] = Wrap;
        AddressV[1] = Wrap;
        
        AddressU[2] = Clamp;
        AddressV[2] = Clamp;
        
        AddressU[3] = Clamp;
        AddressV[3] = Clamp;
        
        Texture[0]   = <tBump>; 
        Texture[1]   = <tDiffuse>; 
        Texture[2]   = <tNormalizer>; 
        Texture[3]   = <tNormalizer>; 
        
        VertexShaderConstant[0] = <mViewProjection>; 
        VertexShaderConstant1[8] = <vPosLight>;
        VertexShaderConstant1[10] = <vPosViewer>;
        
        PixelShaderConstant1[1] = <vColorLight>;

Vertexshader = <transformSpecularDiffuse>;         
        PixelShader = <shaderSpecularDiffuse>;       
    }
}

vertexshader transform_pixelshader1_4 = 
asm
{
vs_1_1
//-------------------------------
//Constant registers
//-------------------------------
// c0-c3        - world*view*proj
// c8           - light position(In object space)
// c9           - 1 / lightRange
// c10          - vPosViewer(In object space)
def c6, 0.5, 0, 0, 0                            // Helper constant
def c7, 2, -1, 0, 0                             // Helper constant

//------------------------------
// Input registers
//------------------------------
dcl_position v0
dcl_tangent v1
dcl_binormal v2
dcl_normal v3
dcl_texcoord v4

//------------------------------
// output position 
//------------------------------
//
m4x4 oPos, v0, c0

//------------------------------
// Compute the tangent space matrix to transform from object space to tangent space
//------------------------------
//
mad r7.xyz, c7.x, v1, c7.y                      //bias vector tangent to (-1,1)
mad r8.xyz, c7.x, v2, c7.y                      //bias vector binormal to (-1,1)
mad r9.xyz, c7.x, v3, c7.y                      //bias vector normal to (-1,1)

//------------------------------
// Compute L vector in tangent space
//------------------------------
//
add r10, -v0, c8                                // light position - vPos
dp3 r7.w, r10, r10                              // Normalize (lightpostion-vPos)
rsq r7.w, r7.w
mul r11.xyz, r10, r7.w

m3x3 oT1.xyz, r11, r7                           // t1 = L vector in tangent space

//------------------------------
// Compute H vector in tangent space
//------------------------------
//
add r4, -v0, c4                                 // V vector
add r6, r10, r4                                 // L + V
dp3 r6.w, r6, r6                                // Normalize (L+V)
rsq r6.w, r6.w
mul r5.xyz, r6, r6.w

m3x3 oT2.xyz, r5, r7                            // t2 = H vector in tangent space

//------------------------------
// output texture coordinates 
//------------------------------
//
mov oT0.xy, v4                                  // t0 = texture coordinate

//------------------------------
// compute texture coordinates for attenuation
//------------------------------
//
mul r2.xyz, r10, c9                             // (light position - vertex pos) / lightRange
mad r4.xyz, r2, c6.x, c6.x                      // map to 0 to 1 range

mov oT3.xy, r4                                  // t3 = texture coordinates for attenuation texture 1

mov oT4.x, r4.z                                 // t4 = texture coordinates for attenuation texture 2
mov oT4.y, c6.w
};

pixelshader shader_pixelshader1_4 = 
asm
{
ps_1_4

//-------------------------------
//Constant registers
//-------------------------------
// c1           - lightColor
def c0, 4.0f, 1.0f, 0.0f, -0.75f                // helper constant

//------------------------------
// Load textures
//------------------------------
//
texld r0,t0                                     // Diffuse
texld r1,t0                                     // Normal
texld r2,t1                                     // L
texld r3,t2                                     // H
texld r4,t3                                     // attenuation texture 1
texld r5,t4                                     // attenuation texture 2

//------------------------------
// compute output color
//------------------------------
//
dp3_sat r2.w,r1_bx2,r3_bx2                      // max(0,dot(N,H))
dp3_sat r1.rgb,r2_bx2,r1_bx2                    // max(0,dot(N,L)) 
+mad_x4_sat r2.w,r2.w,r2.w,c0.w                 // specular = saturate(4*(dot(N,H)^2-0.75))
mul_sat r5.rgb,r4,r5                            // attenuation = attenuation(x,y)*attenuation(z)
+mul r2.w,r2.w,r2.w                             // specular = specular*specular
mul_sat r0.rgb,r0,r1                            // diffuse = max(0,dot(N,L))*diffuse color
+mul_x2_sat r2.w,r2.w,r1.w                      // specular = saturate(specular*gloss*2)
add_sat r0.rgb,r0,r2.w                          // color = saturate(diffuse + specular)
mul r0.rgb,r0,c1                                // color = color*lightColor
mul r0.rgb,r0,r5                                // color = color*attenuation
};

technique pixelShader1_4_asm
{
    pass P0
    {                            
        ALPHABLENDENABLE = True;
        SrcBlend = ONE;
        DestBlend = ONE;
        ColorWriteEnable = 0xf;
                   
        Texture[0]   = <tDiffuse>; 
        Texture[1]   = <tBump>; 
        Texture[2]   = <tNormalizer>; 
        Texture[3]   = <tNormalizer>; 
        Texture[4]   = <tAtenuacionXY>; 
        Texture[5]   = <tAtenuacionZ>; 
                          
                          
        AddressU[0] = Wrap;
        AddressV[0] = Wrap;
        
        AddressU[1] = Wrap;
        AddressV[1] = Wrap;
        
        AddressU[2] = Clamp;
        AddressV[2] = Clamp;
        
        AddressU[3] = Clamp;
        AddressV[3] = Clamp;
        
        AddressU[4] = Clamp;
        AddressV[4] = Clamp;
        
        AddressU[5] = Clamp;
        AddressV[5] = Clamp;

VertexShaderConstant[0]  = <mViewProjection>; 
        VertexShaderConstant1[8]  = <vPosLight>;
        VertexShaderConstant1[9]  = <vScaleLight>;
        VertexShaderConstant1[10] = <vPosViewer>;

PixelShaderConstant1[1]   = <vColorLight>;

Vertexshader = <transform_pixelshader1_4>;                 
        PixelShader = <shader_pixelshader1_4>;       
    }
}

pixelshader shader_pixelshader2_0 =
asm
{
ps_2_0

//-------------------------------
//Constant registers
//-------------------------------
// c1           - lightColor
def c31, 2.0f, 1.0f, 0.0f, 4.0f                 // helper constant
def c30, 2.0f, 1.0f, 0.0f, -0.75f               // helper constant

//------------------------------
// Input registers
//------------------------------
//
dcl t0.xy                                       // texture coordinates
dcl t1.xyz                                      // light vector tangent 
dcl t2.xyz                                      // eye vector tangent
dcl t3.xy                                       // texture coords attenuation xy
dcl t4.xy                                       // texture coords attenuation z

//------------------------------
// Input texture samplers
//------------------------------
dcl_2d s0                                       // diffuse
dcl_2d s1                                       // normal
dcl_2d s2                                       // attenuation xy
dcl_2d s3                                       // attenuation z

//------------------------------
// load normal
//------------------------------
//
texld r1, t0, s1                                // load normal 
mad r0.rgb, r1, c31.r, -c31.g                   // bias normal to range -1,1

//------------------------------
// compute diffuse contribution 
//------------------------------
//
nrm r1.rgb,t1                                   // normalize L vector
dp3_sat r1.rgb,r1,r0                            // dot(N,L)

texld r4,t0,s0                                  // load diffuse color
mul r1.rgb,r1,r4                                // diffuse = dot(N,L)*matDiffuse

//------------------------------
// compute specular contribution 
//------------------------------
//
nrm r2.rgb,t2                                   // Normalize half vector
dp3_sat r2.w,r2,r0                              // dot(N,H)
mad_sat r2.w,r2.w,r2.w,c30.w                    // specular = saturate(dot(N,H)^2-0.75) 
mul_sat r2.w,r2.w,c31.w                         // specular = specular*4
mul r2.w,r2.w,r2.w                              // specular = specular*specular
mul r2.w,r2.w, r1.w                             // specular = specular * gloss
add_sat r2.w,r2.w,r2.w                          // speuclar = specular*2

//------------------------------
// compute attenuation 
//------------------------------
//
texld r6,t3,s2                                  // load attenuation texture 1
texld r7,t4,s3                                  // load attenuation texture 2
mul r6.rgb,r6,r7                                // attenuation = attenuation(x,y)*attenuation(z)

//------------------------------
// compute final color 
//------------------------------
//
add_sat r4.rgb, r1,r2.w                         // color = diffuse + specular
mul r4.rgb,r4,c1                                // color = color*lightColor
mul r4.rgb,r4,r6                                // color = color*attenuation

mov oC0, r4                                     //color output 
};

technique pixelShader2_0_asm
{
    pass P0
    {                            
        ALPHABLENDENABLE = True;
        SrcBlend = ONE;
        DestBlend = ONE;
        ColorWriteEnable = 0xf;
                   
        Texture[0]   = <tDiffuse>; 
        Texture[1]   = <tBump>;         
        Texture[2]   = <tAtenuacionXY>; 
        Texture[3]   = <tAtenuacionZ>; 
                          
                          
        AddressU[0] = Wrap;
        AddressV[0] = Wrap;
        
        AddressU[1] = Wrap;
        AddressV[1] = Wrap;
        
        AddressU[2] = Clamp;
        AddressV[2] = Clamp;
                        
        AddressU[3] = Clamp;
        AddressV[3] = Clamp;

VertexShaderConstant[0]  = <mViewProjection>; 
        VertexShaderConstant1[8]  = <vPosLight>;
        VertexShaderConstant1[9]  = <vScaleLight>;
        VertexShaderConstant1[10] = <vPosViewer>;

PixelShaderConstant1[1]   = <vColorLight>;

Vertexshader = <transform_pixelshader1_4>;                 
        PixelShader = <shader_pixelshader2_0>;       
    }
}

+ Code Snippet

//shared texture tNormalizer;
//shared texture tBump;
//shared texture tDiffuse;

string XFile = "sphere.x";

texture tAtenuacionXY < string name = "norm.tga"; >;
texture tAtenuacionZ < string name = "bass.tga"; >;
texture tDiffuse < string name = "bass.tga"; >;
texture tNormalizer < string name = "norm.tga"; >;
texture tBump < string name = "gloss.tga"; >;

//texture tAtenuacionXY;
//texture tAtenuacionZ;

float4 vPosLight <  string UIDirectional = "Light Direction"; >;
float4 vPosViewer;
float4 vScaleLight <  string UIDirectional = "Light Scale"; >;
float4 vColorLight <  string UIDirectional = "Light Color"; >;


float4x4 mViewProjection :  WORLDVIEWPROJECTION;


vertexshader transformAttenuation = 
asm
{ 
vs_1_1

//-------------------------------
//Constant registers
//-------------------------------
// c0-c3        - world*view*proj
// c8           - light position(In object space)
// c9           - 1 / lightRange
def c6, 0.5, 0, 0, 0                            // helper constant

//------------------------------
// Used input registers
//------------------------------
dcl_position v0


//------------------------------
// output position 
//------------------------------
//
m4x4 oPos, v0, c0 

//------------------------------
// compute texture coordinates for attenuation
//------------------------------
//

add r7.xyz, -v0, c8                             // light position - vertex pos
mul r2.xyz, r7, c9                              // (light position - vertex pos) / lightRange
mad r4.xyz, r2, c6.x, c6.x                      // map to 0 to 1 range

mov oT0.xy, r4                                  // t0 = texture coordinates for attenuation texture 1

mov oT1.x, r4.z                                 // t1 = texture coordinates for attenuation texture 2
mov oT1.y, c6.w
};

pixelshader shaderAttenuation = 
asm
{
ps_1_1

//------------------------------
// load textures
//------------------------------
//
tex t0                                          // load attenuation texture 1
tex t1                                          // load attenuation texture 2

//------------------------------
// compute attenuation per pixel
//------------------------------
//

mul r0,t0,t1                                    // output = exp(-2*(x*x+y*y))*exp(-2*z*z)
};

vertexshader transformSpecularDiffuse = 
asm
{
vs_1_1

//-------------------------------
//Constant registers
//-------------------------------
// c0-c3        - world*view*proj
// c8           - light position(In object space)
// c10          - vPosViewer(In object space)
def c6, -1, 0, 0, 0                             // helper constant
def c7, 2, -1, 0, 0                             // helper constant

//------------------------------
// Input registers
//------------------------------
dcl_position v0
dcl_tangent v1
dcl_binormal v2
dcl_normal v3
dcl_texcoord v4

//------------------------------
// output position 
//------------------------------
//
m4x4 oPos, v0, c0 

//------------------------------
// Compute the tangent space matrix to transform from object space to tangent space
//------------------------------
//
mad r7.xyz, c7.x, v1, c7.y                      //bias vector tangent to (-1,1)
mad r8.xyz, c7.x, v2, c7.y                      //bias vector binormal to (-1,1)
mad r9.xyz, c7.x, v3, c7.y                      //bias vector normal to (-1,1)

//------------------------------
// Compute L vector in tangent space
//------------------------------
//
add r10, -v0, c8                                // light position - vPos
dp3 r7.w, r10, r10                              // Normalize (lightpostion-vPos)
rsq r7.w, r7.w
mul r11.xyz, r10, r7.w

m3x3 oT2.xyz, r11, r7                           // t2 = L vector in tangent space

//------------------------------
// Compute H vector in tangent space
//------------------------------
//
add r4, -v0, c4                                 // V vector
add r6, r10, r4                                 // L + V
dp3 r6.w, r6, r6                                // Normalize (L+V)
rsq r6.w, r6.w
mul r5.xyz, r6, r6.w

m3x3 oT3.xyz, r5, r7                            // t3 = H vector in tangent space 

//------------------------------
// output texture coordinates 
//------------------------------
//
mov oT0.xy, v4                                  // t0 = texture coordinate
mov oT1.xy, v4                                  // t1 = texture coordinate
};

pixelshader shaderSpecularDiffuse = 
asm
{
ps_1_1

//-------------------------------
//Constant registers
//-------------------------------
// c1           - lightColor
def c0, 4.0f, 1.0f, 0.0f, -0.75f                // Helper constant

//------------------------------
// Load textures
//------------------------------
//
tex t0                                          // Normal
tex t1                                          // diffuse
tex t2                                          // L
tex t3                                          // H

//------------------------------
// compute output color
//------------------------------
//
dp3_sat r1.xyzw,t3_bx2,t0_bx2                   // max(0,dot(N,H))
dp3_sat r0.rgb,t2_bx2,t0_bx2                    // max(0,dot(N,L))
+mad_x4_sat r1.w,r1.w,r1.w,c0.w                 // specular = saturate(4*(dot(N,H)^2-0.75))
mul r1.w,r1.w,r1.w                              // specular = specular*specular
mul r0.rgb,r0,t1                                // diffuse = dot(N,L)*diffuse texture map
+mul_x2_sat r1.w,r1.w,t0.w                      // specular = saturate(specular*2*gloss map)
add_sat r0.rgb,r0,r1.w                          // specular + diffuse
mul r0.rgb,r0,c1                                // (specular+diffuse)*lightColor
+mov r0.a,t1.a                                  // alpha output = alpha diffuse map for transparency.
};


technique pixelShader1_1_asm
{
    pass P0
    {                            
        ALPHABLENDENABLE = False;
        ColorWriteEnable = 0x8;
                   
        Texture[0]   = <tAtenuacionXY>; 
        Texture[1]   = <tAtenuacionZ>; 
                          
                          
        AddressU[0] = Clamp;
        AddressV[0] = Clamp;
        
        AddressU[1] = Clamp;
        AddressV[1] = Clamp;

        VertexShaderConstant[0] = <mViewProjection>; 
        VertexShaderConstant1[8] = <vPosLight>;
        VertexShaderConstant1[9] = <vScaleLight>;
        
               

        Vertexshader = <transformAttenuation>;                 
        PixelShader = <shaderAttenuation>;       
    }        
    pass P1
    {                    
        ALPHABLENDENABLE = True;
        SrcBlend = DestAlpha;        
        DestBlend = One;         
    
        
        ColorWriteEnable = 0xF;
        
        AddressU[0] = Wrap;
        AddressV[0] = Wrap;
        
        AddressU[1] = Wrap;
        AddressV[1] = Wrap;
        
        AddressU[2] = Clamp;
        AddressV[2] = Clamp;
        
        AddressU[3] = Clamp;
        AddressV[3] = Clamp;
        
        Texture[0]   = <tBump>; 
        Texture[1]   = <tDiffuse>; 
        Texture[2]   = <tNormalizer>; 
        Texture[3]   = <tNormalizer>; 
        
        VertexShaderConstant[0] = <mViewProjection>; 
        VertexShaderConstant1[8] = <vPosLight>;
        VertexShaderConstant1[10] = <vPosViewer>;
        
        PixelShaderConstant1[1] = <vColorLight>;                
  
                                

        Vertexshader = <transformSpecularDiffuse>;         
        PixelShader = <shaderSpecularDiffuse>;       
    }
}


vertexshader transform_pixelshader1_4 = 
asm
{
vs_1_1
//-------------------------------
//Constant registers
//-------------------------------
// c0-c3        - world*view*proj
// c8           - light position(In object space)
// c9           - 1 / lightRange
// c10          - vPosViewer(In object space)
def c6, 0.5, 0, 0, 0                            // Helper constant
def c7, 2, -1, 0, 0                             // Helper constant

//------------------------------
// Input registers
//------------------------------
dcl_position v0
dcl_tangent v1
dcl_binormal v2
dcl_normal v3
dcl_texcoord v4

//------------------------------
// output position 
//------------------------------
//
m4x4 oPos, v0, c0 

//------------------------------
// Compute the tangent space matrix to transform from object space to tangent space
//------------------------------
//
mad r7.xyz, c7.x, v1, c7.y                      //bias vector tangent to (-1,1)
mad r8.xyz, c7.x, v2, c7.y                      //bias vector binormal to (-1,1)
mad r9.xyz, c7.x, v3, c7.y                      //bias vector normal to (-1,1)

//------------------------------
// Compute L vector in tangent space
//------------------------------
//
add r10, -v0, c8                                // light position - vPos
dp3 r7.w, r10, r10                              // Normalize (lightpostion-vPos)
rsq r7.w, r7.w
mul r11.xyz, r10, r7.w

m3x3 oT1.xyz, r11, r7                           // t1 = L vector in tangent space

//------------------------------
// Compute H vector in tangent space
//------------------------------
//
add r4, -v0, c4                                 // V vector
add r6, r10, r4                                 // L + V
dp3 r6.w, r6, r6                                // Normalize (L+V)
rsq r6.w, r6.w
mul r5.xyz, r6, r6.w

m3x3 oT2.xyz, r5, r7                            // t2 = H vector in tangent space 


//------------------------------
// output texture coordinates 
//------------------------------
//
mov oT0.xy, v4                                  // t0 = texture coordinate


//------------------------------
// compute texture coordinates for attenuation
//------------------------------
//
mul r2.xyz, r10, c9                             // (light position - vertex pos) / lightRange
mad r4.xyz, r2, c6.x, c6.x                      // map to 0 to 1 range

mov oT3.xy, r4                                  // t3 = texture coordinates for attenuation texture 1

mov oT4.x, r4.z                                 // t4 = texture coordinates for attenuation texture 2
mov oT4.y, c6.w
};


pixelshader shader_pixelshader1_4 = 
asm
{
ps_1_4

//-------------------------------
//Constant registers
//-------------------------------
// c1           - lightColor
def c0, 4.0f, 1.0f, 0.0f, -0.75f                // helper constant

//------------------------------
// Load textures
//------------------------------
//
texld r0,t0                                     // Diffuse
texld r1,t0                                     // Normal
texld r2,t1                                     // L
texld r3,t2                                     // H
texld r4,t3                                     // attenuation texture 1
texld r5,t4                                     // attenuation texture 2

//------------------------------
// compute output color
//------------------------------
//
dp3_sat r2.w,r1_bx2,r3_bx2                      // max(0,dot(N,H))
dp3_sat r1.rgb,r2_bx2,r1_bx2                    // max(0,dot(N,L)) 
+mad_x4_sat r2.w,r2.w,r2.w,c0.w                 // specular = saturate(4*(dot(N,H)^2-0.75))
mul_sat r5.rgb,r4,r5                            // attenuation = attenuation(x,y)*attenuation(z)
+mul r2.w,r2.w,r2.w                             // specular = specular*specular
mul_sat r0.rgb,r0,r1                            // diffuse = max(0,dot(N,L))*diffuse color
+mul_x2_sat r2.w,r2.w,r1.w                      // specular = saturate(specular*gloss*2)
add_sat r0.rgb,r0,r2.w                          // color = saturate(diffuse + specular)
mul r0.rgb,r0,c1                                // color = color*lightColor
mul r0.rgb,r0,r5                                // color = color*attenuation
};

technique pixelShader1_4_asm
{
    pass P0
    {                            
        ALPHABLENDENABLE = True;
        SrcBlend = ONE;
        DestBlend = ONE;
        ColorWriteEnable = 0xf;
                   
        Texture[0]   = <tDiffuse>; 
        Texture[1]   = <tBump>; 
        Texture[2]   = <tNormalizer>; 
        Texture[3]   = <tNormalizer>; 
        Texture[4]   = <tAtenuacionXY>; 
        Texture[5]   = <tAtenuacionZ>; 
                          
                          
        AddressU[0] = Wrap;
        AddressV[0] = Wrap;
        
        AddressU[1] = Wrap;
        AddressV[1] = Wrap;
        
        AddressU[2] = Clamp;
        AddressV[2] = Clamp;
        
        AddressU[3] = Clamp;
        AddressV[3] = Clamp;
        
        AddressU[4] = Clamp;
        AddressV[4] = Clamp;
        
        AddressU[5] = Clamp;
        AddressV[5] = Clamp;

        VertexShaderConstant[0]  = <mViewProjection>; 
        VertexShaderConstant1[8]  = <vPosLight>;
        VertexShaderConstant1[9]  = <vScaleLight>;
        VertexShaderConstant1[10] = <vPosViewer>;
        

        PixelShaderConstant1[1]   = <vColorLight>;                               

        Vertexshader = <transform_pixelshader1_4>;                 
        PixelShader = <shader_pixelshader1_4>;       
    }
}

pixelshader shader_pixelshader2_0 =
asm
{
ps_2_0

//-------------------------------
//Constant registers
//-------------------------------
// c1           - lightColor
def c31, 2.0f, 1.0f, 0.0f, 4.0f                 // helper constant
def c30, 2.0f, 1.0f, 0.0f, -0.75f               // helper constant


//------------------------------
// Input registers
//------------------------------
//
dcl t0.xy                                       // texture coordinates
dcl t1.xyz                                      // light vector tangent 
dcl t2.xyz                                      // eye vector tangent
dcl t3.xy                                       // texture coords attenuation xy
dcl t4.xy                                       // texture coords attenuation z


//------------------------------
// Input texture samplers
//------------------------------
dcl_2d s0                                       // diffuse
dcl_2d s1                                       // normal
dcl_2d s2                                       // attenuation xy
dcl_2d s3                                       // attenuation z


//------------------------------
// load normal
//------------------------------
//
texld r1, t0, s1                                // load normal 
mad r0.rgb, r1, c31.r, -c31.g                   // bias normal to range -1,1


//------------------------------
// compute diffuse contribution 
//------------------------------
//
nrm r1.rgb,t1                                   // normalize L vector
dp3_sat r1.rgb,r1,r0                            // dot(N,L)

texld r4,t0,s0                                  // load diffuse color
mul r1.rgb,r1,r4                                // diffuse = dot(N,L)*matDiffuse 

//------------------------------
// compute specular contribution 
//------------------------------
//
nrm r2.rgb,t2                                   // Normalize half vector
dp3_sat r2.w,r2,r0                              // dot(N,H)
mad_sat r2.w,r2.w,r2.w,c30.w                    // specular = saturate(dot(N,H)^2-0.75) 
mul_sat r2.w,r2.w,c31.w                         // specular = specular*4
mul r2.w,r2.w,r2.w                              // specular = specular*specular
mul r2.w,r2.w, r1.w                             // specular = specular * gloss
add_sat r2.w,r2.w,r2.w                          // speuclar = specular*2


//------------------------------
// compute attenuation 
//------------------------------
//
texld r6,t3,s2                                  // load attenuation texture 1
texld r7,t4,s3                                  // load attenuation texture 2
mul r6.rgb,r6,r7                                // attenuation = attenuation(x,y)*attenuation(z)

//------------------------------
// compute final color 
//------------------------------
//
add_sat r4.rgb, r1,r2.w                         // color = diffuse + specular
mul r4.rgb,r4,c1                                // color = color*lightColor
mul r4.rgb,r4,r6                                // color = color*attenuation

mov oC0, r4                                     //color output 
};

technique pixelShader2_0_asm
{
    pass P0
    {                            
        ALPHABLENDENABLE = True;
        SrcBlend = ONE;
        DestBlend = ONE;
        ColorWriteEnable = 0xf;
                   
        Texture[0]   = <tDiffuse>; 
        Texture[1]   = <tBump>;         
        Texture[2]   = <tAtenuacionXY>; 
        Texture[3]   = <tAtenuacionZ>; 
                          
                          
        AddressU[0] = Wrap;
        AddressV[0] = Wrap;
        
        AddressU[1] = Wrap;
        AddressV[1] = Wrap;
        
        AddressU[2] = Clamp;
        AddressV[2] = Clamp;
                        
        AddressU[3] = Clamp;
        AddressV[3] = Clamp;

        VertexShaderConstant[0]  = <mViewProjection>; 
        VertexShaderConstant1[8]  = <vPosLight>;
        VertexShaderConstant1[9]  = <vScaleLight>;
        VertexShaderConstant1[10] = <vPosViewer>;
        

        PixelShaderConstant1[1]   = <vColorLight>;                               

        Vertexshader = <transform_pixelshader1_4>;                 
        PixelShader = <shader_pixelshader2_0>;       
    }
}

Thanks

Once you start down the Dark Path, forever will it dominate your destiny...

Back to top

Profile PM

Neophyte

23

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 9th Sep 2003 07:30

Link

Quick question: Whats your graphics card?

Back to top

Profile PM

Chenak

23

Years of Service

User Offline

Joined: 13th Sep 2002

Location: United Kingdom

Posted: 9th Sep 2003 19:17 Edited at: 9th Sep 2003 19:41

Link

GF4Ti4600, it should work with it cos i got the example program somewhere with source which is were the shader came from, the only prob is it's made in c/c++ and i cant understand a word of it

.

i dont have to do a load of maths n stuff within dbpro do i? if so can u tell me how do it please

Once you start down the Dark Path, forever will it dominate your destiny...

Back to top

Profile PM

Neophyte

23

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 10th Sep 2003 11:34

Link

I'm not sure your GFX card can run it. I see some PS 1.4 and 2.0 in there and the Geforce4 series doesn't support those two.

Back to top

Profile PM

Chenak

23

Years of Service

User Offline

Joined: 13th Sep 2002

Location: United Kingdom

Posted: 10th Sep 2003 19:10

Link

It does cos it contains 3 different techniques, my card can support the first one which has vs 1.1 and ps 1.1 shaders. And as i've said, the fx file works fine with the example program it came with. I'll post a link when i find it.

Once you start down the Dark Path, forever will it dominate your destiny...

Back to top

Profile PM

Chenak

23

Years of Service

User Offline

Joined: 13th Sep 2002

Location: United Kingdom

Posted: 10th Sep 2003 19:13

Link

Here's the link, there's an example program with source on it somewhere.

http://personal.telefonica.terra.es/web/codegarrofi/perPixelLighting/perPixelLighting.htm

Once you start down the Dark Path, forever will it dominate your destiny...

Back to top

Profile PM

Neophyte

23

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 11th Sep 2003 07:41

Link

Well I dled the source and everything but I have no idea what the file format for the head is. How did you load it? What converter did you use?

Back to top

Profile PM

Bulleyes

23

Years of Service

User Offline

Joined: 3rd Nov 2002

Location: Cyberjaya, Malaysia

Posted: 11th Sep 2003 07:58

Link

Hmmm... there is a strange problem that happened to me before as well. I don't know whether this is related your problem.

After I completed my FX file, it loaded perfectly on my computer. But when I try to run it on my friend's computer, nothing showed up! A total blank! Initially I thought it is the shader problem. But eventually, after tracing the code for 1.5 hour, I basically concluded that the model didn't get displayed afterall.

It really stumped me! My friend's graphics card was a GeForce 3, and mine is a GeForce 4 TI4200. I don't know whether this is a bug in DBpro or not. Even it is, I don't really know how to report it. As you know, it works fine on my PC (and even some other PC). But the object just won't showed up in my friend's GeForce 3.

Bad Nose Entertainment - Where games are forged from the flames of talent and passion.

http://www.badnose.com/

Back to top

Profile PM Email Website

Chenak

23

Years of Service

User Offline

Joined: 13th Sep 2002

Location: United Kingdom

Posted: 11th Sep 2003 18:59

Link

@Neophyte: i didnt use the head i just used a 3dmesh i got from somewhere.

@Bulleyes : Yere its annoying ain't it

. Maybe its something to do with the GF3? You could post the shader up here and i can try it if you want. What does it do?

Once you start down the Dark Path, forever will it dominate your destiny...

Back to top

Profile PM

Bulleyes

23

Years of Service

User Offline

Joined: 3rd Nov 2002

Location: Cyberjaya, Malaysia

Posted: 11th Sep 2003 20:29

Link

It's a Bump + Spec map effect. I think you had seen my posting before. Anyway, it is at:

http://developer.thegamecreators.com/?m=forum_view&t=16371&b=1

Tell me if there is any errors.

Bad Nose Entertainment - Where games are forged from the flames of talent and passion.

http://www.badnose.com/

Back to top

Profile PM Email Website

Chenak

23

Years of Service

User Offline

Joined: 13th Sep 2002

Location: United Kingdom

Posted: 12th Sep 2003 01:03

Link

I've tried it and it seems that the object disappears if the camera is between a particular angle. Thats really strange...

I would test it further but i've got a bad virus on my comp. Its that jeefo virus and nearly every single exe file on the computer has been infected (over 1034!) so i may be gone for a while before i can test it out.

*Sigh* i hate viruses.

bye

Once you start down the Dark Path, forever will it dominate your destiny...

Back to top

Profile PM

Neophyte

23

Years of Service

User Offline

Joined: 23rd Feb 2003

Location: United States

Posted: 12th Sep 2003 02:06

Link

@Inferno

"i didnt use the head i just used a 3dmesh i got from somewhere."

Then that would be your problem. From what I've learned from the source file he's precalculated the normals and the diffuse values into textures. You need those textures in order for the shader to run. I believe they are named "normals" and "difuse" and came with the source.

Back to top

Profile PM

Sorry your browser is not supported!

DarkBASIC Professional Discussion / Can anyone help me fix this FX shader?