Sign in to follow this  
Followers 0
Medo Mex

Working with Light Shader

3 posts in this topic

I'm trying to get light shader to work, unfortunately it's crashing, what's going wrong?

 

C++:

D3DXMATRIX mWorld = model->WorldMatrix();
D3DXMATRIX mViewProjection = GetCameraProjection();

float g_numLights = 1;
float g_sceneAmbient[4] = {0.0f, 0.0f, 0.0f, 1.0f};

// Set the matrices for the shader.
pEffect->SetMatrix("worldMatrix", &mWorld);
pEffect->SetMatrix("worldInverseTransposeMatrix", &mWorld);
pEffect->SetMatrix("worldViewProjectionMatrix", &mViewProjection);

// Set the camera position.
pEffect->SetValue("cameraPos", &GetCameraPosition(), sizeof(GetCameraPosition()));

// Set the scene global ambient term.
pEffect->SetValue("globalAmbient", &g_sceneAmbient, sizeof(g_sceneAmbient));

// Set the number of active lights.
pEffect->SetValue("numLights", &g_numLights, sizeof(g_numLights));

UINT passes = 0;
HRESULT hr = pEffect->Begin(&passes, 0);
assert(SUCCEEDED(hr));
hr = pEffect->BeginPass(0);
assert(SUCCEEDED(hr));

// Render
model->render();

pEffect->EndPass();
pEffect->End();
 

Light Shader:

#define MAX_POINT_LIGHTS 8

struct PointLight
{
float3 pos;
float4 ambient;
float4 diffuse;
float4 specular;
float radius;
};


struct Material
{
float4 ambient;
float4 diffuse;
float4 emissive;
float4 specular;
float shininess;
};


//-----------------------------------------------------------------------------
// Globals.
//-----------------------------------------------------------------------------


float4x4 worldMatrix;
float4x4 worldInverseTransposeMatrix;
float4x4 worldViewProjectionMatrix;


float3 cameraPos;
float4 globalAmbient;
int numLights;


PointLight lights[MAX_POINT_LIGHTS];
Material material;


//-----------------------------------------------------------------------------
// Textures.
//-----------------------------------------------------------------------------


texture colorMapTexture;
texture normalMapTexture;


sampler2D colorMap = sampler_state
{
Texture = <colorMapTexture>;
    MagFilter = Linear;
    MinFilter = Anisotropic;
    MipFilter = Linear;
    MaxAnisotropy = 16;
};


sampler2D normalMap = sampler_state
{
    Texture = <normalMapTexture>;
    MagFilter = Linear;
    MinFilter = Anisotropic;
    MipFilter = Linear;
    MaxAnisotropy = 16;
};


//-----------------------------------------------------------------------------
// Vertex Shaders.
//-----------------------------------------------------------------------------


struct VS_INPUT
{
float3 position : POSITION;
float2 texCoord : TEXCOORD0;
float3 normal : NORMAL;
    float4 tangent : TANGENT;
};


struct VS_OUTPUT
{
float4 position : POSITION;
float3 worldPos : TEXCOORD0;
float2 texCoord : TEXCOORD1;
float3 normal : TEXCOORD2;
float3 tangent : TEXCOORD3;
float3 bitangent : TEXCOORD4;
};


VS_OUTPUT VS_PointLighting(VS_INPUT IN)
{
VS_OUTPUT OUT;


OUT.position = mul(float4(IN.position, 1.0f), worldViewProjectionMatrix);
OUT.worldPos = mul(float4(IN.position, 1.0f), worldMatrix).xyz;
OUT.texCoord = IN.texCoord;


OUT.normal = mul(IN.normal, (float3x3)worldInverseTransposeMatrix);
OUT.tangent = mul(IN.tangent.xyz, (float3x3)worldInverseTransposeMatrix);
OUT.bitangent = cross(OUT.normal, OUT.tangent) * IN.tangent.w;


return OUT;
}


//-----------------------------------------------------------------------------
// Pixel Shaders.
//-----------------------------------------------------------------------------

float4 PS_PointLighting(VS_OUTPUT IN) : COLOR
{
    float3 t = normalize(IN.tangent);
    float3 b = normalize(IN.bitangent);
    float3 n = normalize(IN.normal);


    float3x3 tbnMatrix = float3x3(t.x, b.x, n.x,
                             t.y, b.y, n.y,
                             t.z, b.z, n.z);
                                
    float3 v = normalize(mul(cameraPos - IN.worldPos, tbnMatrix));
    float3 l = float3(0.0f, 0.0f, 0.0f);
    float3 h = float3(0.0f, 0.0f, 0.0f);
    
    float atten = 0.0f;
    float nDotL = 0.0f;
    float nDotH = 0.0f;
    float power = 0.0f;
    
    float4 color = float4(0.0f, 0.0f, 0.0f, 0.0f);
    
    n = normalize(tex2D(normalMap, IN.texCoord).rgb * 2.0f - 1.0f);


    for (int i = 0; i < numLights; ++i)
    {
        l = mul((lights[i].pos - IN.worldPos) / lights[i].radius, tbnMatrix);
        atten = saturate(1.0f - dot(l, l));
        
        l = normalize(l);
        h = normalize(l + v);
        
        nDotL = saturate(dot(n, l));
        nDotH = saturate(dot(n, h));
        power = (nDotL == 0.0f) ? 0.0f : pow(nDotH, material.shininess);
        
        color += (material.ambient * (globalAmbient + (atten * lights[i].ambient))) +
                 (material.diffuse * lights[i].diffuse * nDotL * atten) +
                 (material.specular * lights[i].specular * power * atten);
    }
                   
return color * tex2D(colorMap, IN.texCoord);
}


//-----------------------------------------------------------------------------
// Techniques.
//-----------------------------------------------------------------------------


technique NormalMappingPointLighting
{
    pass
    {
        VertexShader = compile vs_3_0 VS_PointLighting();
        PixelShader = compile ps_3_0 PS_PointLighting();
    }
}

 

-1

Share this post


Link to post
Share on other sites

If you are in debug mode for D3D then there should be warnings or errors in the output window of Visual Studio.

Edited by menohack
1

Share this post


Link to post
Share on other sites

Besides from the D3D errors in the output window also do some common debug errors.  Where is it crashing exactly? If the program crashes, more than likely its in the C++ code. Whether your hlsls is working or not, that's going to be thing to look at once you fix the crash error. Normally, a crash happens when you're accessing objects with dangling pointers. Are you sure pEffect points to a valid memory? Were you able to compile your HLSL and returned a valid pEffect object? 

0

Share this post


Link to post
Share on other sites

I want to mention that the graphics card crash and the device get lost, so I'm guessing that the problem is related to the Shader processing.

 

Yes, pEffect points to to a valid memory.

0

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!


Register a new account

Sign in

Already have an account? Sign in here.


Sign In Now
Sign in to follow this  
Followers 0