HLSL problèmes

Question

lumineux point que je suis en train de créer une lumière simple point HLSL pour quelques jours maintenant, je suis ce guide: D3DBook:(Lighting) Direct Light Sources

Plus précisément la fonction d'atténuation et la section sur les feux de points. Voici mon code:

//------------------------------------------------------------------------------------------------------ 
// Global params provided by the app 
//------------------------------------------------------------------------------------------------------ 
uniform extern float4x4 gWVP; 
uniform extern float4x4 gWorldViewIT; //for normals 
uniform extern float4x4 gWorldView;//work out view vector from all vertices 
uniform extern float4x4 gLightMatrix;//light in view space 
uniform extern float4x4 gWorld; 

uniform extern float4 gDiffuseMtrl; 
uniform extern float4 gAmbMtrl; 
uniform extern float4 gSpecMtrl; 

//lights 
uniform extern float4 gLightCol = {1, 1, 1, 1}; //set to white 
//uniform extern float4 gLightPos[4]; 
uniform extern float4 gLightPos[4] = {{0,0,3,0},{0,0,-1,0},{0,100,1,0},{0,-100,0,0}}; 
uniform extern float gLightPow[4] = {25,25,0.1,0.1};//range of light 


uniform extern float roughness;//roughness per object 
uniform extern float ref;//reflectance at normal//used in fresnel calculation 

//pi 
const shared float pi= 3.14159f; 

//attenuation constants 
const float a_a = 0.0f; 
const float a_b = 0.1f; 
const float a_c = 1.0f; 


//calculate light attenuation 
float atten(float distance, float range, float a, float b, float c) 
{ 
    float atten = 1.0f/((a * distance * distance) + (b * distance) + c); 

    //step clamps to 0 if out of range 
    return step(distance, range) * saturate(atten); 
} 


//--------------------------------------------------------------------------------------------------------------------------- 
// Input channel (vertex shader) 
//--------------------------------------------------------------------------------------------------------------------------- 
struct InputVS 
{ 
    float3 posL : POSITION0; 
    float3 Norm : NORMAL; 

}; 
//--------------------------------------------------------------------------------------------------------------------------- 
// Output channel (vertex shader) 
//--------------------------------------------------------------------------------------------------------------------------- 
struct OutputVS 
{ 
    float4 posH  : POSITION0; 
    float4 col  : COLOR0; 
}; 

//vertex shader//passthrough 
OutputVS gourardVS(InputVS input) 
{ 
    float n = 1/roughness; 
    //Zero out our output 
    OutputVS outVS = (OutputVS)0; 

    //Transform to homogeneous clipspace 
    outVS.posH = mul(float4(input.posL, 1.0f), gWVP); 

    float4 col_amb = gAmbMtrl*gLightCol; 
    float4 col_diff = gDiffuseMtrl*gLightCol; 
    float4 col_spec = gSpecMtrl*gLightCol; 

    //ambient term 
    float4 ambient={0.2, 0.2, 0.2, 1.00f}; 

    float4 finalColour=0; 

    float diff = 0; 

    float3 pWorld = mul(float4(input.posL, 1.0f), gWorld).xyz; 

    //normal 
    float3 N =normalize(mul(float4(input.Norm, 1.0f),gWorldViewIT)); 

    //point lights 
    float attenu = atten(distance(pWorld, gLightPos[1]), gLightPow[1], a_a, a_b, a_c); 

    float3 l_dir= normalize(gLightPos[1] - pWorld); 

    //n dot l 
    float dotNL = max(0, dot(N, l_dir)); 

    finalColour = float4(attenu * dotNL * col_diff); 
    //} 
    outVS.col = finalColour;// + (ambient * col_amb); 
    outVS.col.a = 1; 


    //return 
    return outVS; 
} 
//--------------------------------------------------------------------------------------------------------------------------- 
// Input channel pixel shader 
//--------------------------------------------------------------------------------------------------------------------------- 
struct InputPS{ 
    float4 posH  : POSITION0; 
    float4 col  : COLOR0; 
}; 

float4 noPS(InputPS input): COLOR 
{ 
return input.col; 
} 

technique Phong{ 
    pass P0 
    { 
      Lighting  = TRUE; 
      SpecularEnable = TRUE; 
     vertexShader = compile vs_3_0 gourardVS(); 
     pixelShader = compile ps_3_0 noPS(); 
     //specify render device states associated with the pass 
     //FillMode = WireFrame; 
     //ShadeMode = Gouraud; 
    } 
} 

Je suis sûr que les matrices étant passées en sont corrects comme je l'ai réorientés ce à partir d'un exemple de la lumière directionnelle, donc cela ne laisse que le code HLSL comme source du problème. Cela produit les sommets corrects, mais ils sont presque éteints, peu importe les valeurs que j'utilise sur la position de la lumière et les tableaux de puissance.

Answer 1

J'ai finalement trouvé le problème, la direction de la lumière est dans l'espace mondial alors que les Normales sont en vue d'espace, je l'avais oublié de transformer la direction de la lumière par la matrice de vue (gLightMatrix) voici le code révisé:

... 
float3 l_dir= normalize(gLightPos[1] - pWorld); 

float3 L=normalize(mul(l_dir, gLightMatrix)); 

//n dot l 
float dotNL = max(0, dot(N, L)); 

finalColour = float4(attenu * dotNL * col_diff); 
... 

Merci quand même, à tous ceux qui ont jeté un coup d'œil.