Thanks.
Just tested it in the FX Browser but don't see any errors - but then it doesn't work either.
I then tested it in DarkShader and that gives the FX compiler errors you were probably talking about.
I think the shader is using some DirectX10 Shader Model 4 (SM4) commands or possibly some FX Composer specific functions. Using that assumption I commented out all the SM4 stuff plus anything else DarkShader objected to, i.e. lines such as
FILTER = MIN_MAG_MIP_LINEAR;
which you can reinstate if you wish using the usual SM2 syntax
minFilter = linear;
magFilter = linear;
mipFilter = linear;
I don't know enough about Shader Model 4 to tell whether the problem is with FX Composer specific stuff or just the use of SM4 itself.
Anyway, with those changes the shader compiles and runs in both FX Browser and DarkShader.
Here's the final code I tested:
/*********************************************************************NVMH3****
$Revision$
Copyright NVIDIA Corporation 2007
TO THE MAXIMUM EXTENT PERMITTED BY APPLICABLE LAW, THIS SOFTWARE IS PROVIDED
*AS IS* AND NVIDIA AND ITS SUPPLIERS DISCLAIM ALL WARRANTIES, EITHER EXPRESS
OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, IMPLIED WARRANTIES OF MERCHANTABILITY
AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL NVIDIA OR ITS SUPPLIERS
BE LIABLE FOR ANY SPECIAL, INCIDENTAL, INDIRECT, OR CONSEQUENTIAL DAMAGES
WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR ANY OTHER PECUNIARY
LOSS) ARISING OUT OF THE USE OF OR INABILITY TO USE THIS SOFTWARE, EVEN IF
NVIDIA HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
To learn more about shading, shaders, and to bounce ideas off other shader
authors and users, visit the NVIDIA Shader Library Forums at:
http://developer.nvidia.com/forums/
******************************************************************************/
#define FLIP_TEXTURE_Y
float Script : STANDARDSGLOBAL <
string UIWidget = "none";
string ScriptClass = "object";
string ScriptOrder = "standard";
string ScriptOutput = "color";
string Script = "Technique=Phong?Main:Main10;";
> = 0.8;
//// UN-TWEAKABLES - AUTOMATICALLY-TRACKED TRANSFORMS ////////////////
float4x4 WorldITXf : WorldInverseTranspose < string UIWidget="None"; >;
float4x4 WvpXf : WorldViewProjection < string UIWidget="None"; >;
float4x4 WorldXf : World < string UIWidget="None"; >;
float4x4 ViewIXf : ViewInverse < string UIWidget="None"; >;
//// TWEAKABLE PARAMETERS ////////////////////
/// Point Lamp 0 ////////////
float3 Lamp0Pos : Position <
string Object = "PointLight0";
string UIName = "Lamp 0 Position";
string Space = "World";
> = {-0.5f,2.0f,1.25f};
float3 Lamp0Color : Specular <
string UIName = "Lamp 0";
string Object = "Pointlight0";
string UIWidget = "Color";
> = {1.0f,1.0f,1.0f};
// Ambient Light
float3 AmbiColor : Ambient <
string UIName = "Ambient Light";
string UIWidget = "Color";
> = {0.07f,0.07f,0.07f};
float Ks <
string UIWidget = "slider";
float UIMin = 0.0;
float UIMax = 1.0;
float UIStep = 0.05;
string UIName = "Specular";
> = 0.4;
float SpecExpon : SpecularPower <
string UIWidget = "slider";
float UIMin = 1.0;
float UIMax = 128.0;
float UIStep = 1.0;
string UIName = "Specular Power";
> = 55.0;
float Bump <
string UIWidget = "slider";
float UIMin = 0.0;
float UIMax = 3.0;
float UIStep = 0.01;
string UIName = "Bumpiness";
> = 1.0;
float Kr <
string UIWidget = "slider";
float UIMin = 0.0;
float UIMax = 1.0;
float UIStep = 0.01;
string UIName = "Reflection Strength";
> = 0.5;
//////// COLOR & TEXTURE /////////////////////
texture ColorTexture : DIFFUSE <
string ResourceName = "default_color.dds";
string UIName = "Diffuse Texture";
string ResourceType = "2D";
>;
sampler2D ColorSampler = sampler_state {
Texture = <ColorTexture>;
// FILTER = MIN_MAG_MIP_LINEAR;
AddressU = Wrap;
AddressV = Wrap;
};
texture NormalTexture <
string ResourceName = "default_bump_normal.dds";
string UIName = "Normal-Map Texture";
string ResourceType = "2D";
>;
sampler2D NormalSampler = sampler_state {
Texture = <NormalTexture>;
// FILTER = MIN_MAG_MIP_LINEAR;
AddressU = Wrap;
AddressV = Wrap;
};
texture EnvTexture : ENVIRONMENT <
string ResourceName = "default_reflection.dds";
string UIName = "Environment";
string ResourceType = "Cube";
>;
samplerCUBE EnvSampler = sampler_state {
Texture = <EnvTexture>;
// FILTER = MIN_MAG_MIP_LINEAR;
AddressU = Clamp;
AddressV = Clamp;
AddressW = Clamp;
};
// shared shadow mapping supported in Cg version
//////// CONNECTOR DATA STRUCTURES ///////////
/* data from application vertex buffer */
struct appdata {
float3 Position : POSITION;
float4 UV : TEXCOORD0;
float4 Normal : NORMAL;
float4 Tangent : TANGENT0;
float4 Binormal : BINORMAL0;
};
/* data passed from vertex shader to pixel shader */
struct vertexOutput {
float4 HPosition : POSITION;
float2 UV : TEXCOORD0;
// The following values are passed in "World" coordinates since
// it tends to be the most flexible and easy for handling
// reflections, sky lighting, and other "global" effects.
float3 LightVec : TEXCOORD1;
float3 WorldNormal : TEXCOORD2;
float3 WorldTangent : TEXCOORD3;
float3 WorldBinormal : TEXCOORD4;
float3 WorldView : TEXCOORD5;
};
///////// VERTEX SHADING /////////////////////
/*********** Generic Vertex Shader ******/
vertexOutput std_VS(appdata IN) {
vertexOutput OUT = (vertexOutput)0;
OUT.WorldNormal = mul(IN.Normal,WorldITXf).xyz;
OUT.WorldTangent = mul(IN.Tangent,WorldITXf).xyz;
OUT.WorldBinormal = mul(IN.Binormal,WorldITXf).xyz;
float4 Po = float4(IN.Position.xyz,1);
float3 Pw = mul(Po,WorldXf).xyz;
OUT.LightVec = (Lamp0Pos - Pw);
#ifdef FLIP_TEXTURE_Y
OUT.UV = float2(IN.UV.x,(1.0-IN.UV.y));
#else /* !FLIP_TEXTURE_Y */
OUT.UV = IN.UV.xy;
#endif /* !FLIP_TEXTURE_Y */
OUT.WorldView = normalize(ViewIXf[3].xyz - Pw);
OUT.HPosition = mul(Po,WvpXf);
return OUT;
}
///////// PIXEL SHADING //////////////////////
// Utility function for phong shading
void phong_shading(vertexOutput IN,
float3 LightColor,
float3 Nn,
float3 Ln,
float3 Vn,
out float3 DiffuseContrib,
out float3 SpecularContrib)
{
float3 Hn = normalize(Vn + Ln);
float4 litV = lit(dot(Ln,Nn),dot(Hn,Nn),SpecExpon);
DiffuseContrib = litV.y * LightColor;
SpecularContrib = litV.y * litV.z * Ks * LightColor;
}
float4 std_PS(vertexOutput IN) : COLOR {
float3 diffContrib;
float3 specContrib;
float3 Ln = normalize(IN.LightVec);
float3 Vn = normalize(IN.WorldView);
float3 Nn = normalize(IN.WorldNormal);
float3 Tn = normalize(IN.WorldTangent);
float3 Bn = normalize(IN.WorldBinormal);
float3 bump = Bump * (tex2D(NormalSampler,IN.UV).rgb - float3(0.5,0.5,0.5));
Nn = Nn + bump.x*Tn + bump.y*Bn;
Nn = normalize(Nn);
phong_shading(IN,Lamp0Color,Nn,Ln,Vn,diffContrib,specContrib);
float3 diffuseColor = tex2D(ColorSampler,IN.UV).rgb;
float3 result = specContrib+(diffuseColor*(diffContrib+AmbiColor));
float3 R = -reflect(Vn,Nn);
float3 reflColor = Kr * texCUBE(EnvSampler,R.xyz).rgb;
result += diffuseColor*reflColor;
return float4(result,1);
}
///// TECHNIQUES /////////////////////////////
/*
RasterizerState DisableCulling
{
CullMode = NONE;
};
DepthStencilState DepthEnabling
{
DepthEnable = TRUE;
};
BlendState DisableBlend
{
BlendEnable[0] = FALSE;
};
*/
technique Main <
string Script = "Pass=p0;";
> {
pass p0 <
string Script = "Draw=geometry;";
> {
VertexShader = compile vs_2_0 std_VS();
ZEnable = true;
ZWriteEnable = true;
ZFunc = LessEqual;
AlphaBlendEnable = false;
CullMode = None;
PixelShader = compile ps_2_a std_PS();
}
}
/*
technique10 Main10 <
string Script = "Pass=p0;";
> {
pass p0 <
string Script = "Draw=geometry;";
> {
SetVertexShader( CompileShader( vs_4_0, std_VS() ) );
SetGeometryShader( NULL );
SetPixelShader( CompileShader( ps_4_0, std_PS() ) );
SetRasterizerState(DisableCulling);
SetDepthStencilState(DepthEnabling, 0);
SetBlendState(DisableBlend, float4( 0.0f, 0.0f, 0.0f, 0.0f ), 0xFFFFFFFF);
}
}
*/
/////////////////////////////////////// eof //
I very rarely use FX Composer shaders in their original form. The first thing I do is prune out everything I don't need (or don't understand
). Then edit the rest into a form I find more readable.
I mainly find FXC useful as a source of ideas.
