0 registered members (),
1,459
guests, and 9
spiders. |
Key:
Admin,
Global Mod,
Mod
|
|
|
[Supply] Matt's NormalMapping shader with 3 lights
#117980
03/18/07 11:02
03/18/07 11:02
|
Joined: Jan 2006
Posts: 1,829 Neustadt, Germany
TWO
OP
Serious User
|
OP
Serious User
Joined: Jan 2006
Posts: 1,829
Neustadt, Germany
|
Frank_G wanted to have matt's normalmapping shader with more than 2 lights, so here is it. I added the 3rd light and an ambient parameter you can change to prevent a total black modell. I also fixed that the shader ignored the first light (because matt used vecLighPos[1] instead of vecLightPos[0] as first) Because of the additional registers I had the change the shader version target from 2.0 to 3.0; Maybe a guru can remove some registers, then it would be possible to have even more lights. Anyone could post this shader in the wiki. Code:
// ------------------------------------------------------------- // Diffuse and specular shader for models // ------------------------------------------------------------- // [18/3/06 Bloodline] - Added ambient and a 3rd light
float4x4 matWorldViewProj; float4x4 matWorld; float4 vecLightPos[8]; //light position float4 vecLightColor[8]; //light color float4 vecViewPos;
// Change ambient here float4 Ambient = { 0.6f, 0.6f, 0.6f, 1.0f };
texture entSkin1; //this is the color map texture entSkin2; //this is the normal map
sampler sColorMap = sampler_state { Texture = <entSkin1>; MinFilter = Linear; MagFilter = Linear; MipFilter = Linear; AddressU = wrap; AddressV = wrap; };
sampler sBumpMap = sampler_state { Texture = <entSkin2>; MinFilter = Linear; MagFilter = Linear; MipFilter = Linear; AddressU = wrap; AddressV = wrap; };
/////////////////////////////////////////////////////////////////////////////////////////////////////////////// //first pass /////////////////////////////////////////////////////////////////////////////////////////////////////////////// // ------------------------------------------------------------- // Output channels // ------------------------------------------------------------- struct VS_OUTPUT0 { float4 Pos : POSITION; float2 Tex : TEXCOORD0;
float3 Light1 : TEXCOORD2; float3 View1 : TEXCOORD3; float3 Att1 : TEXCOORD4;
float3 Light2 : TEXCOORD5; float3 View2 : TEXCOORD6; float3 Att2 : TEXCOORD7;
float3 Light3 : TEXCOORD8; float3 View3 : TEXCOORD9; float3 Att3 : TEXCOORD10;
};
// ------------------------------------------------------------- // vertex shader function (input channels) // ------------------------------------------------------------- VS_OUTPUT0 VS_PASS0(float4 Pos : POSITION, float2 texcoord0 : TEXCOORD0, float3 Normal : NORMAL, float3 Tangent : TEXCOORD2 ) { 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);
float LightRange = 1/vecLightPos[0].w; float LightRange2 = 1/vecLightPos[1].w; float LightRange3 = 1/vecLightPos[2].w;
//light 1 float3 Light1 = PosWorld - vecLightPos[0] ; Out.Light1.xyz = mul(worldToTangentSpace, -Light1); // L
float3 Viewer1 = PosWorld - vecViewPos; Out.View1 = mul(worldToTangentSpace, -Viewer1); // V
Out.Att1 = Light1 * LightRange; // Point light
//light 2 float3 Light2 = PosWorld - vecLightPos[1] ; Out.Light2.xyz = mul(worldToTangentSpace, -Light2); // L
float3 Viewer2 = PosWorld - vecViewPos; Out.View2 = mul(worldToTangentSpace, -Viewer2); // V
Out.Att2 = Light2 * LightRange2; // Point light
//light 3 float3 Light3 = PosWorld - vecLightPos[2] ; Out.Light3.xyz = mul(worldToTangentSpace, -Light3); // L
float3 Viewer3 = PosWorld - vecViewPos; Out.View3 = mul(worldToTangentSpace, -Viewer3); // V
Out.Att3 = Light3 * LightRange3; // Point light
return Out; }
struct PS_INPUT0 { float2 Tex : TEXCOORD0;
float3 Light1 : TEXCOORD2; float3 View1 : TEXCOORD3; float3 Att1 : TEXCOORD4;
float3 Light2 : TEXCOORD5; float3 View2 : TEXCOORD6; float3 Att2 : TEXCOORD7;
float3 Light3 : TEXCOORD8; float3 View3 : TEXCOORD9; float3 Att3 : TEXCOORD10;
};
float4 PS_PASS0( PS_INPUT0 psInStruct ):COLOR
{
float4 color = tex2D(sColorMap, psInStruct.Tex); // fetch color map float3 bumpNormal = 2 * (tex2D(sBumpMap, psInStruct.Tex) - 0.5); // fetch bump map float4 gloss = tex2D( sBumpMap, psInStruct.Tex );
//light1 float3 LightDir1 = normalize(psInStruct.Light1); float3 ViewDir1 = normalize(psInStruct.View1); 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, ViewDir1)), 15); float4 Attenuation1 = saturate(dot(psInStruct.Att1, psInStruct.Att1));
//light2 float3 LightDir2 = normalize(psInStruct.Light2); float3 ViewDir2 = normalize(psInStruct.View2); 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, ViewDir2)), 15); float4 Attenuation2 = saturate(dot(psInStruct.Att2, psInStruct.Att2));
//light3 float3 LightDir3 = normalize(psInStruct.Light3); float3 ViewDir3 = normalize(psInStruct.View3); 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, ViewDir3)), 15); float4 Attenuation3 = saturate(dot(psInStruct.Att3, psInStruct.Att3));
return ( (0.1 * color + 0.2 * Ambient) + ((shadow1 * (color * diff1 + (spec1*gloss.w)) * (1 -Attenuation1))*vecLightColor[0])+ ((shadow2 * (color * diff2 + (spec2*gloss.w)) * (1 -Attenuation2))*vecLightColor[1])+ ((shadow3 * (color * diff3 + (spec3*gloss.w)) * (1 -Attenuation3))*vecLightColor[2]) ); }
// ------------------------------------------------------------- // techniques// // ------------------------------------------------------------- technique two_pass { pass P0 { alphablendenable=false; srcblend=zero;
VertexShader = compile vs_3_0 VS_PASS0(); PixelShader = compile ps_3_0 PS_PASS0(); }
}
|
|
|
Re: [Supply] Matt's NormalMapping shader with 3 lights
[Re: TWO]
#117981
03/18/07 13:11
03/18/07 13:11
|
Joined: Nov 2004
Posts: 7,121 Potsdam, Brandenburg, Germany
Machinery_Frank
Senior Expert
|
Senior Expert
Joined: Nov 2004
Posts: 7,121
Potsdam, Brandenburg, Germany
|
That is a fantastic contribution. Thank you very much. I will rate you 5 stars for that (ups, I already rated you, nevermind, you are the man of the day)
Last edited by Frank_G; 03/18/07 13:12.
Models, Textures and Games from Dexsoft
|
|
|
Re: [Supply] Matt's NormalMapping shader with 3 lights
[Re: Machinery_Frank]
#117982
03/18/07 14:04
03/18/07 14:04
|
Joined: Mar 2006
Posts: 2,758 Antwerp,Belgium
frazzle
Expert
|
Expert
Joined: Mar 2006
Posts: 2,758
Antwerp,Belgium
|
This is indeed a nice effort resulted in a great shader Great work Bloodline Btw, shouldn't there be HLSL too in the list of your occupation ^^ ?? Cheers Frazzle
|
|
|
Re: [Supply] Matt's NormalMapping shader with 3 li
[Re: frazzle]
#117986
03/19/07 14:53
03/19/07 14:53
|
Joined: Mar 2006
Posts: 2,503 SC, United States
xXxGuitar511
Expert
|
Expert
Joined: Mar 2006
Posts: 2,503
SC, United States
|
I've messed with this shader several times. There are many things that can be optimized. 1) The vec_light[] array needs to start with 0, not 1. But you already caught that 2) You only need one Out.View in the vertex shader. Matt used multiple wiew texcoords, but they all return the same values. 3) Your Ambience is incorrectlt implemented. Change the ambient value to a simple float (instead of float4), and multiply the color by the ambient factor. [ex: 0.1 * color + 0.2 * Ambient becomes color.rgb * Ambient4) While I did not have success, the way the lighting is calculated, and the attenuation could be optimized to run faster (use less math)...
xXxGuitar511 - Programmer
|
|
|
Re: [Supply] Matt's NormalMapping shader with 3 li
[Re: Machinery_Frank]
#117988
03/19/07 18:56
03/19/07 18:56
|
Joined: Jan 2006
Posts: 1,829 Neustadt, Germany
TWO
OP
Serious User
|
OP
Serious User
Joined: Jan 2006
Posts: 1,829
Neustadt, Germany
|
Ok, here is my super monster shader. It's a Normal Diffuse Specular Shader which handles 6 Lights in 3 passes with shader target version 2.o. Thanks to xXxGuitar for the view trick, I made the corrections. Now the shader could use even more lights, but I think it would be to slow (and you need the beta for the new light managerment). As additional feature I made a 1.1 fallback (the shader JCL postet). Again, I'm not really skilled with HLSL, even after studying the shaderx2 series. Code:
//-------------------------------------------------------------- // 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 { alphablendenable=false; srcblend=zero; // compile shaders VertexShader = compile vs_2_0 VS_PASS0(); PixelShader = compile ps_2_0 PS_PASS0(); } pass P1 { //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 P2 { //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 { } }
|
|
|
|