2 registered members (AndrewAMD, juanex),
1,247
guests, and 6
spiders. |
Key:
Admin,
Global Mod,
Mod
|
|
|
NM not working in ATI
#227290
09/13/08 17:24
09/13/08 17:24
|
Joined: Jun 2007
Posts: 236 acknex.exe
ACKNEX007
OP
Member
|
OP
Member
Joined: Jun 2007
Posts: 236
acknex.exe
|
i am using a normal mapping code and its working fine in nvidia. but not in ATI. can anyone help me please ? one of the shader i got from wiki is too bright. (i tried everything) and other one is not loading UV maps.
can u give me a good working normal mapping shader plz ?
thanks a lot
/*********************************************************************************************** / Copyright 2006 by Taco Cohen. All rights reserved / 2007 Modified and adapted to A7 (jcl) /***********************************************************************************************/
/*********************************************************************************************** / Global Variables: /***********************************************************************************************/ // Tweakables: static const float AmbientIntensity = 0.5f; // The intensity of the ambient light. static const float DiffuseIntensity = 1.0f; // The intensity of the diffuse light. static const float SpecularIntensity = 1.0f; // The intensity of the specular light. static const float SpecularPower = 8.0f; // The specular power. Used as 'glossyness' factor. static const float4 SunColor = {0.9f, 0.9f, 0.5f, 1.0f}; // Color vector of the sunlight.
// Application fed data: const float4x4 matWorldViewProj; // World*view*projection matrix. const float4x4 matWorld; // World matrix. const float4 vecAmbient; // Ambient color. const float4 vecSunDir; // The sun direction vector. const float4 vecViewPos; // View position.
float3x3 matTangent;
texture entSkin1; // Color map. sampler ColorMapSampler = sampler_state // Color map sampler. { Texture = <entSkin1>; MipFilter = LINEAR; MinFilter = LINEAR; MagFilter = LINEAR; AddressU = Wrap; Addressv = Wrap; };
texture entSkin2; // Normal map. sampler NormalMapSampler = sampler_state // Normal map sampler. { Texture = <entSkin2>; MipFilter = LINEAR; MinFilter = LINEAR; MagFilter = LINEAR; AddressU = Wrap; Addressv = Wrap; };
/*********************************************************************************************** / Vertex Shader: /***********************************************************************************************/ void NormalMapVS( in float4 InPos : POSITION, in float3 InNormal : NORMAL, in float2 InTex : TEXCOORD0, in float4 InTangent : TEXCOORD2, out float4 OutPos : POSITION, out float2 OutTex : TEXCOORD0, out float3 OutViewDir: TEXCOORD1, out float3 OutSunDir: TEXCOORD2) { // Transform the vertex from object space to clip space: OutPos = mul(InPos, matWorldViewProj); // Pass the texture coordinate to the pixel shader: OutTex = InTex; // Compute 3x3 matrix to transform from world space to tangent space: matTangent[0] = mul(InTangent.xyz, matWorld); //matTangent[1] = mul(cross(InTangent.xyz,InNormal), matWorld); matTangent[1] = mul(cross(InTangent.xyz,InNormal)*InTangent.w, matWorld); matTangent[2] = mul(InNormal, matWorld); // Calculate the view direction vector in tangent space: OutViewDir = normalize(mul(matTangent, vecViewPos - mul(InPos, matWorld))); // Calculate the light direction vector in tangent space: OutSunDir = normalize(mul(matTangent, -vecSunDir)); }
/*********************************************************************************************** / Pixel Shader: /***********************************************************************************************/ float4 NormalMapPS( in float2 InTex : TEXCOORD0, in float3 InViewDir : TEXCOORD1, in float3 InSunDir : TEXCOORD2) : COLOR { // Read the normal from the normal map and convert from [0..1] to [-1..1] range float3 BumpNormal = 2 * tex2D(NormalMapSampler, InTex) - 1; // Calculate the ambient term: float4 Ambient = AmbientIntensity * vecAmbient; // Calculate the diffuse term: float4 Diffuse = DiffuseIntensity * saturate(dot(InSunDir, BumpNormal)); Diffuse *= SunColor; // Calculate the reflection vector: float3 R = normalize(2 * dot(BumpNormal, InSunDir) * BumpNormal - InSunDir); // Calculate the specular term: InViewDir = normalize(InViewDir); float Specular = pow(saturate(dot(R, InViewDir)), SpecularPower) * SpecularIntensity; // Fetch the pixel color from the color map: float4 Color = tex2D(ColorMapSampler, InTex); // Calculate final color: return (Ambient + Diffuse + Specular) * Color; }
/*********************************************************************************************** / Technique: /***********************************************************************************************/ technique SpecularTechnique { pass p0 { CullMode = None; VertexShader = compile vs_2_0 NormalMapVS(); PixelShader = compile ps_2_0 NormalMapPS(); } pass p1 { CULLMODE=CW; vertexShaderConstant[0]=<matWorldViewProj>; vertexShaderConstant[16]=0.05; // outline_thickness, def0.001 << CHANGE THIS TO CHANGE OUTLINE THICKNESS vertexShader=asm { vs.1.1 dcl_position v0 dcl_normal v3 dcl_texcoord v7 mov r0,v0 mul r1,c16.x,v3 // Scale the normal add r0.xyz,r0.xyz,r1.xyz // Shell offset (vertex pos + Scaled Normal) m4x4 oPos,r0,c0 // Transorm position to clip space }; pixelShader=asm { ps.1.1 def c0,0.1,0.1,0.1,1 // outline rgba << CHANGE THIS TO CHANGE OUTLINE COLOUR mov r0,c0 }; } }
|
|
|
Re: NM not working in ATI
[Re: ACKNEX007]
#227295
09/13/08 18:03
09/13/08 18:03
|
Joined: Mar 2006
Posts: 2,758 Antwerp,Belgium
frazzle
Expert
|
Expert
Joined: Mar 2006
Posts: 2,758
Antwerp,Belgium
|
First of all, did you use this shader directly with the composer from ATI ? If yes, it's quite logic that it doesn't work since each compiler has got different keywords for the engine to be recognised Btw, I would find it strange that it would work when using it in the composer of Nvidia. If no, could you show us the shader code ^^ ? can u give me a good working normal mapping shader plz ? The normal mapping code from Taco Cohen is certainly a working one thus I suggest that you use that one without using the 2 passes. I'll repost the code here just in case:
/***********************************************************************************************
/ Copyright 2006 by Taco Cohen. All rights reserved
/***********************************************************************************************/
/***********************************************************************************************
/ Global Variables:
/***********************************************************************************************/
// Tweakables:
static const float AmbientIntensity = 1.0f; // The intensity of the ambient light.
static const float DiffuseIntensity = 1.0f; // The intensity of the diffuse light.
static const float SpecularIntensity = 1.0f; // The intensity of the specular light.
static const float SpecularPower = 8.0f; // The specular power. Used as 'glossyness' factor.
static const float4 SunColor = {0.9f, 0.9f, 0.5f, 1.0f}; // Color vector of the sunlight.
// Application fed data:
const float4x4 matWorldViewProj; // World*view*projection matrix.
const float4x4 matWorld; // World matrix.
const float4 vecAmbient; // Ambient color.
const float4 vecSunDir; // The sun direction vector.
const float4 vecViewPos; // View position.
texture entSkin1; // Color map.
sampler ColorMapSampler = sampler_state // Color map sampler.
{
Texture = <entSkin1>;
AddressU = Clamp;
AddressV = Clamp;
};
texture entSkin2; // Normal map.
sampler NormalMapSampler = sampler_state // Normal map sampler.
{
Texture = <entSkin2>;
AddressU = Clamp;
AddressV = Clamp;
};
/***********************************************************************************************
/ Vertex Shader:
/***********************************************************************************************/
void NormalMapVS( in float4 InPos : POSITION,
in float3 InNormal : NORMAL,
in float2 InTex : TEXCOORD0,
in float3 InTangent : TEXCOORD2,
out float4 OutPos : POSITION,
out float2 OutTex : TEXCOORD0,
out float3 OutViewDir: TEXCOORD1,
out float3 OutSunDir: TEXCOORD2)
{
// Transform the vertex from object space to clip space:
OutPos = mul(InPos, matWorldViewProj);
// Pass the texture coordinate to the pixel shader:
OutTex = InTex;
// Compute 3x3 matrix to transform from world space to tangent space:
half3x3 worldToTangentSpace;
worldToTangentSpace[0] = mul(InTangent, matWorld);
worldToTangentSpace[1] = mul(cross(InTangent, InNormal), matWorld);
worldToTangentSpace[2] = mul(InNormal, matWorld);
// Calculate the view direction vector in tangent space:
OutViewDir = normalize(mul(worldToTangentSpace, vecViewPos - mul(InPos, matWorld)));
// Calculate the light direction vector in tangent space:
OutSunDir = normalize(mul(worldToTangentSpace, -vecSunDir));
}
/***********************************************************************************************
/ Pixel Shader:
/***********************************************************************************************/
float4 NormalMapPS( in float2 InTex : TEXCOORD0,
in float3 InViewDir : TEXCOORD1,
in float3 InSunDir : TEXCOORD2) : COLOR
{
// Read the normal from the normal map and convert from [0..1] to [-1..1] range
float3 BumpNormal = 2 * tex2D(NormalMapSampler, InTex) - 1;
// Calculate the ambient term:
float4 Ambient = AmbientIntensity * vecAmbient;
// Calculate the diffuse term:
float4 Diffuse = DiffuseIntensity * saturate(dot(InSunDir, BumpNormal));
Diffuse *= SunColor;
// Calculate the reflection vector:
float3 R = normalize(2 * dot(BumpNormal, InSunDir) * BumpNormal - InSunDir);
// Calculate the specular term:
InViewDir = normalize(InViewDir);
float Specular = pow(saturate(dot(R, InViewDir)), SpecularPower) * SpecularIntensity;
// Fetch the pixel color from the color map:
float4 Color = tex2D(ColorMapSampler, InTex);
// Calculate final color:
return (Ambient + Diffuse + Specular) * Color;
}
/***********************************************************************************************
/ Technique:
/***********************************************************************************************/
technique SpecularTechnique
{
pass P0
{
VertexShader = compile vs_2_0 NormalMapVS();
PixelShader = compile ps_2_0 NormalMapPS();
}
}
Cheers Frazzle
Antec® Case Intel® X58 Chipset Intel® i7 975 Quad Core 8 GB RAM DDR3 SSD OCZ®-VERTEX2 3.5 x4 ; HD 600 GB NVIDIA® GeForce GTX 295 Memory 1795GB
|
|
|
Re: NM not working in ATI
[Re: frazzle]
#227305
09/13/08 18:30
09/13/08 18:30
|
Joined: Jun 2007
Posts: 236 acknex.exe
ACKNEX007
OP
Member
|
OP
Member
Joined: Jun 2007
Posts: 236
acknex.exe
|
thanks for reply. i got it working by using this shader. because it dynamic light. i needed to add lights. but only one light is looking nice. other side is a bit dark. if i add more lights its too dark. cannot i use sun light without dynamics on this shader ? becasue i am using it in a level model. not character. thanks.
========================= //-------------------------------------------------------------- // Diffuse and specular shader // -------------------------------------------------------------
float4x4 matWorldViewProj; float4x4 matWorld; float4 vecLightPos[8]; //light position float4 vecLightColor[8]; //light position float4 vecViewPos; float4 vecFog;
texture entSkin1; //this is the color map texture entSkin2; //this is the normal map
sampler ColorMapSampler = sampler_state { Texture = <entSkin1>; MinFilter = Linear; MagFilter = Linear; MipFilter = Linear; AddressU = wrap; AddressV = wrap; };
sampler BumpMapSampler = sampler_state { Texture = <entSkin2>; MinFilter = Linear; MagFilter = Linear; MipFilter = Linear; AddressU = wrap; AddressV = wrap; };
// ------------------------------------------------------------- // 2.0 // -------------------------------------------------------------
struct VS_OUTPUT0 { float4 Pos : POSITION; float2 Tex : TEXCOORD0; float3 View : TEXCOORD1; float3 Light1 : TEXCOORD2; float Att1 : TEXCOORD3; float3 Light2 : TEXCOORD4; float Att2 : TEXCOORD5;
float Fog : FOG; };
VS_OUTPUT0 VS_PASS0(float4 Pos : POSITION, float2 texcoord0 : TEXCOORD0, float3 Normal : NORMAL, float3 Tangent : TEXCOORD0 ) { VS_OUTPUT0 Out = (VS_OUTPUT0)0; Out.Pos = mul(Pos, matWorldViewProj); // transform Position // compute the 3x3 tranform matrix // to transform from world space to tangent space float3x3 worldToTangentSpace; worldToTangentSpace[0] = mul(Tangent, matWorld); worldToTangentSpace[1] = mul(cross(Tangent, Normal), matWorld); worldToTangentSpace[2] = mul(Normal, matWorld); Out.Tex = texcoord0.xy;
float3 PosWorld = mul(Pos, matWorld);
float3 Viewer = PosWorld - vecViewPos; Out.View = mul(worldToTangentSpace, - Viewer); // V
//light 1 float3 Light1 = PosWorld - vecLightPos[0] ; Out.Light1.xyz = mul(worldToTangentSpace, -Light1); // L Out.Att1 = distance(PosWorld,vecLightPos[0])/vecLightPos[0].w; // Point light //light 2 float3 Light2 = PosWorld - vecLightPos[1] ; Out.Light2.xyz = mul(worldToTangentSpace, -Light2); // L Out.Att2 = distance(PosWorld,vecLightPos[1])/vecLightPos[1].w; // Point light
float ofog = 1 - (distance(PosWorld, vecViewPos) - vecFog.x) * (vecFog.z); Out.Fog = ofog;
return Out; }
struct PS_INPUT0 { float2 Tex : TEXCOORD0; float3 View : TEXCOORD1; float3 Light1 : TEXCOORD2; float Att1 : TEXCOORD3; float3 Light2 : TEXCOORD4; float Att2 : TEXCOORD5; };
float4 PS_PASS0( PS_INPUT0 psInStruct ):COLOR { float4 color = tex2D(ColorMapSampler, psInStruct.Tex); // fetch color map float3 bumpNormal = 2 * (tex2D(BumpMapSampler, psInStruct.Tex) - 0.5); // fetch bump map float4 gloss = tex2D( BumpMapSampler, psInStruct.Tex ); float3 ViewDir = normalize(psInStruct.View);
//light1 float3 LightDir1 = normalize(psInStruct.Light1); float4 diff1 = saturate(dot(bumpNormal, LightDir1)); // diffuse component float shadow1 = saturate(4 * diff1); float3 Reflect1 = normalize(2 * diff1 * bumpNormal - LightDir1); // R float4 spec1 = pow(saturate(dot(Reflect1, ViewDir)), 15); float4 Attenuation1 = saturate(dot(psInStruct.Att1, psInStruct.Att1)); //light2 float3 LightDir2 = normalize(psInStruct.Light2); float4 diff2 = saturate(dot(bumpNormal, LightDir2)); // diffuse component float shadow2 = saturate(4 * diff2); float3 Reflect2 = normalize(2 * diff2 * bumpNormal - LightDir2); // R float4 spec2 = pow(saturate(dot(Reflect2, ViewDir)), 15); float4 Attenuation2 = saturate(dot(psInStruct.Att2, psInStruct.Att2));
return ( (0.3 * color) + //ambient ((shadow1 * (color * diff1 + (spec1*gloss.w)) * (1 -Attenuation1))*vecLightColor[0])+ ((shadow2 * (color * diff2 + (spec2*gloss.w)) * (1 -Attenuation2))*vecLightColor[1]) ); }
struct VS_OUTPUT1 { float4 Pos : POSITION; float2 Tex : TEXCOORD0; float3 View : TEXCOORD1; float3 Light3 : TEXCOORD2; float Att3 : TEXCOORD3; float3 Light4 : TEXCOORD4; float Att4 : TEXCOORD5;
float Fog : FOG; };
VS_OUTPUT1 VS_PASS1(float4 Pos : POSITION, float2 texcoord0 : TEXCOORD0, float3 Normal : NORMAL, float3 Tangent : TEXCOORD0 ) { VS_OUTPUT1 Out = (VS_OUTPUT1)0; Out.Pos = mul(Pos, matWorldViewProj); // transform Position // compute the 3x3 tranform matrix // to transform from world space to tangent space float3x3 worldToTangentSpace; worldToTangentSpace[0] = mul(Tangent, matWorld); worldToTangentSpace[1] = mul(cross(Tangent, Normal), matWorld); worldToTangentSpace[2] = mul(Normal, matWorld); Out.Tex = texcoord0.xy;
float3 PosWorld = mul(Pos, matWorld);
float3 Viewer = PosWorld - vecViewPos; Out.View = mul(worldToTangentSpace, -Viewer); // V //light 3 float3 Light3 = PosWorld - vecLightPos[2] ; Out.Light3.xyz = mul(worldToTangentSpace, -Light3); // L Out.Att3 = distance(PosWorld,vecLightPos[2])/vecLightPos[2].w; // Point light //light 4 float3 Light4 = PosWorld - vecLightPos[3] ; Out.Light4.xyz = mul(worldToTangentSpace, -Light4); // L Out.Att4 = distance(PosWorld,vecLightPos[3])/vecLightPos[3].w; // Point light
float ofog = 1 - (distance(PosWorld, vecViewPos) - vecFog.x) * (vecFog.z); Out.Fog = ofog;
return Out; }
struct PS_INPUT1 { float2 Tex : TEXCOORD0; float3 View : TEXCOORD1; float3 Light3 : TEXCOORD2; float Att3 : TEXCOORD3; float3 Light4 : TEXCOORD4; float Att4 : TEXCOORD5; };
float4 PS_PASS1( PS_INPUT1 psInStruct ):COLOR { float4 color = tex2D(ColorMapSampler, psInStruct.Tex); // fetch color map float3 bumpNormal = 2 * (tex2D(BumpMapSampler, psInStruct.Tex) - 0.5); // fetch bump map float4 gloss = tex2D( BumpMapSampler, psInStruct.Tex ); float3 ViewDir = normalize(psInStruct.View);
//light3 float3 LightDir3 = normalize(psInStruct.Light3); float4 diff3 = saturate(dot(bumpNormal, LightDir3)); // diffuse component float shadow3 = saturate(4 * diff3); float3 Reflect3 = normalize(2 * diff3 * bumpNormal - LightDir3); // R float4 spec3 = pow(saturate(dot(Reflect3, ViewDir)), 15); float4 Attenuation3 = saturate(dot(psInStruct.Att3, psInStruct.Att3)); //light4 float3 LightDir4 = normalize(psInStruct.Light4); float4 diff4 = saturate(dot(bumpNormal, LightDir4)); // diffuse component float shadow4 = saturate(4 * diff4); float3 Reflect4 = normalize(2 * diff4 * bumpNormal - LightDir4); // R float4 spec4 = pow(saturate(dot(Reflect4, ViewDir)), 15); float4 Attenuation4 = saturate(dot(psInStruct.Att4, psInStruct.Att4));
return ( ((shadow3 * (color * diff3 + (spec3*gloss.w)) * (1 -Attenuation3))*vecLightColor[2])+ ((shadow4 * (color * diff4 + (spec4*gloss.w)) * (1 -Attenuation4))*vecLightColor[3])
); }
struct VS_OUTPUT2 { float4 Pos : POSITION; float2 Tex : TEXCOORD0; float3 View : TEXCOORD1; float3 Light5 : TEXCOORD2; float Att5 : TEXCOORD3; float3 Light6 : TEXCOORD4; float Att6 : TEXCOORD5;
float Fog : FOG; };
VS_OUTPUT2 VS_PASS2(float4 Pos : POSITION, float2 texcoord0 : TEXCOORD0, float3 Normal : NORMAL, float3 Tangent : TEXCOORD0 ) { VS_OUTPUT2 Out = (VS_OUTPUT2)0; Out.Pos = mul(Pos, matWorldViewProj); // transform Position // compute the 3x3 tranform matrix // to transform from world space to tangent space float3x3 worldToTangentSpace; worldToTangentSpace[0] = mul(Tangent, matWorld); worldToTangentSpace[1] = mul(cross(Tangent, Normal), matWorld); worldToTangentSpace[2] = mul(Normal, matWorld); Out.Tex = texcoord0.xy;
float3 PosWorld = mul(Pos, matWorld);
float3 Viewer = PosWorld - vecViewPos; Out.View = mul(worldToTangentSpace, -Viewer); // V
//light 5 float3 Light5 = PosWorld - vecLightPos[4] ; Out.Light5.xyz = mul(worldToTangentSpace, -Light5); // L Out.Att5 = distance(PosWorld,vecLightPos[4])/vecLightPos[4].w; // Point light //light 6 float3 Light6 = PosWorld - vecLightPos[5] ; Out.Light6.xyz = mul(worldToTangentSpace, -Light6); // L Out.Att6 = distance(PosWorld,vecLightPos[5])/vecLightPos[5].w; // Point light
float ofog = 1 - (distance(PosWorld, vecViewPos) - vecFog.x) * (vecFog.z); Out.Fog = ofog;
return Out; }
struct PS_INPUT2 { float2 Tex : TEXCOORD0; float3 View : TEXCOORD1; float3 Light5 : TEXCOORD2; float Att5 : TEXCOORD3; float3 Light6 : TEXCOORD4; float Att6 : TEXCOORD5; };
float4 PS_PASS2( PS_INPUT2 psInStruct ):COLOR { float4 color = tex2D(ColorMapSampler, psInStruct.Tex); // fetch color map float3 bumpNormal = 2 * (tex2D(BumpMapSampler, psInStruct.Tex) - 0.5); // fetch bump map float4 gloss = tex2D( BumpMapSampler, psInStruct.Tex ); float3 ViewDir = normalize(psInStruct.View);
//light5 float3 LightDir5 = normalize(psInStruct.Light5); float4 diff5 = saturate(dot(bumpNormal, LightDir5)); // diffuse component float shadow5 = saturate(4 * diff5); float3 Reflect5 = normalize(2 * diff5 * bumpNormal - LightDir5); // R float4 spec5 = pow(saturate(dot(Reflect5, ViewDir)), 15); float4 Attenuation5 = saturate(dot(psInStruct.Att5, psInStruct.Att5)); //light2 float3 LightDir6 = normalize(psInStruct.Light6); float4 diff6 = saturate(dot(bumpNormal, LightDir6)); // diffuse component float shadow6 = saturate(4 * diff6); float3 Reflect6 = normalize(2 * diff6 * bumpNormal - LightDir6); // R float4 spec6 = pow(saturate(dot(Reflect6, ViewDir)), 15); float4 Attenuation6 = saturate(dot(psInStruct.Att6, psInStruct.Att6));
return ( ((shadow5 * (color * diff5 + (spec5*gloss.w)) * (1 -Attenuation5))*vecLightColor[4])+ ((shadow6 * (color * diff6 + (spec6*gloss.w)) * (1 -Attenuation6))*vecLightColor[5]) ); }
// ------------------------------------------------------------- // 1.1 // -------------------------------------------------------------
float3x3 matTangent; float4x4 matWorldView; float4 vecSunDir;
float4 DoTransform(float4 Pos) { return mul(Pos,matWorldViewProj); }
float DoFog(float4 Pos) { float3 P = mul(Pos,matWorldView); // convert vector to view space to get it's depth (.z) return saturate((vecFog.y-P.z) * vecFog.z); // apply the linear fog formula }
float4 DoPos(float4 Pos) { return (mul(Pos,matWorld)); } float3 DoPos(float3 Pos) { return (mul(Pos,matWorld)); }
void CreateTangents(float3 inNormal,float3 inTangent) { matTangent[0] = DoPos(inTangent); matTangent[1] = DoPos(cross(inTangent,inNormal)); // binormal matTangent[2] = DoPos(inNormal); }
float3 DoTangent(float3 inVector) { return normalize(mul(matTangent,inVector)); }
struct out_bump { float4 Pos: POSITION; float Fog: FOG; float4 Color: COLOR; float2 Tex: TEXCOORD0; float2 Bump: TEXCOORD1; float3 Normal: TEXCOORD2; float3 Light: TEXCOORD3; };
out_bump vs_bump( in float4 inPos: POSITION, in float3 inNormal: NORMAL, in float2 inTex: TEXCOORD0, in float3 inTangent: TEXCOORD2) { out_bump Out;
Out.Pos = DoTransform(inPos); Out.Tex = inTex; Out.Bump = inTex; // different coordinates required for ps_1_1 Out.Color = float4(1.0,1.0,1.0,1.0); Out.Fog = DoFog(inPos); CreateTangents(inNormal,inTangent); float3 N = matTangent[2]; // transform the output values into the 0..1 range Out.Light = DoTangent(-vecSunDir) * 0.5 + 0.5; Out.Normal = DoTangent(N) * 0.5 + 0.5;
return Out; }
float4 ps_bump(out_bump In): COLOR { float4 base = tex2D(ColorMapSampler,In.Tex); float3 bumpNormal = tex2D(BumpMapSampler,In.Bump); float diffuse = saturate(dot(In.Light*2 - 1,bumpNormal*2 - 1)); diffuse *= saturate(4 * dot(In.Light*2 - 1,In.Normal*2 - 1));
return base * diffuse; }
// ------------------------------------------------------------- // techniques// // -------------------------------------------------------------
// 2.0 technique SpecularNormalMapping_20 { pass P0 { CULLMODE=none; alphablendenable=false; srcblend=zero; // compile shaders VertexShader = compile vs_2_0 VS_PASS0(); PixelShader = compile ps_2_0 PS_PASS0(); } pass P1 { CULLMODE=CW; vertexShaderConstant[0]=<matWorldViewProj>; vertexShaderConstant[16]=0.05; // outline_thickness, def0.001 << CHANGE THIS TO CHANGE OUTLINE THICKNESS vertexShader=asm { vs.1.1 dcl_position v0 dcl_normal v3 dcl_texcoord v7 mov r0,v0 mul r1,c16.x,v3 // Scale the normal add r0.xyz,r0.xyz,r1.xyz // Shell offset (vertex pos + Scaled Normal) m4x4 oPos,r0,c0 // Transorm position to clip space }; pixelShader=asm { ps.1.1 def c0,0,0,0,1 // outline rgba << CHANGE THIS TO CHANGE OUTLINE COLOUR mov r0,c0 }; } pass P2 { //blend second pass additively with first alphablendenable=true; srcblend=one; destblend=one; // compile shaders VertexShader = compile vs_2_0 VS_PASS1(); PixelShader = compile ps_2_0 PS_PASS1(); } pass P3 { //blend second pass additively with first and second alphablendenable=true; srcblend=one; destblend=one; // compile shaders VertexShader = compile vs_2_0 VS_PASS2(); PixelShader = compile ps_2_0 PS_PASS2(); }
}
// 1.1 technique SpecularNormalMapping_11 { pass P0 { VertexShader = compile vs_1_1 vs_bump(); PixelShader = compile ps_1_1 ps_bump(); } }
// Fallback; If nothing works technique fallback { pass one { } }
|
|
|
Re: NM not working in ATI
[Re: ACKNEX007]
#227327
09/13/08 20:19
09/13/08 20:19
|
Joined: Mar 2006
Posts: 2,758 Antwerp,Belgium
frazzle
Expert
|
Expert
Joined: Mar 2006
Posts: 2,758
Antwerp,Belgium
|
I'll answer the question in the other topic you started Btw, you didn't need to make a new topic about it, I could have answered it right here ^^ Cheers Frazzle
Antec® Case Intel® X58 Chipset Intel® i7 975 Quad Core 8 GB RAM DDR3 SSD OCZ®-VERTEX2 3.5 x4 ; HD 600 GB NVIDIA® GeForce GTX 295 Memory 1795GB
|
|
|
|