Sorry your browser is not supported!

   float4 PS_NormalMap(OUT_NormalMap IN)  : COLOR
     {
	float4 Texture=tex2D(Base,IN.Tex); 
	float3 NormalMap=tex2D(Normal,IN.Tex)*2-1; 
	float3 LightV=normalize(IN.LightVec);  	
	float3 ViewV=normalize(IN.ViewVec);
	NormalMap=normalize(NormalMap);
	float Normal=saturate(dot(reflect(-ViewV,NormalMap),LightV));
	Normal=pow(Normal,SpecularPow)+saturate(dot(NormalMap,LightV)); 
	float3 Projetlight=tex2Dproj(Projet,IN.Proj)*saturate(IN.Proj.z);
	float3 Light=LightColor*(1-saturate(dot(IN.Attenuation,IN.Attenuation)))*Projetlight;
	float Depth=(IN.Proj.xyz/LightRange); //MMM uses .xyz instead of .z
     	float shadowmap=1-(tex2Dproj(DepthMap,IN.Proj+float4(-0.8,-0.8,0,0)) < Depth ? 0.111f:0.0f);
        shadowmap=shadowmap-(tex2Dproj(DepthMap,IN.Proj+float4(0,-0.8,0,0)) < Depth ? 0.111f:0.0f);
        shadowmap=shadowmap-(tex2Dproj(DepthMap,IN.Proj+float4(0.8,-0.8,0,0)) < Depth ? 0.111f:0.0f);
        shadowmap=shadowmap-(tex2Dproj(DepthMap,IN.Proj+float4(-0.8,0,0,0)) < Depth ? 0.111f:0.0f);
        shadowmap=shadowmap-(tex2Dproj(DepthMap,IN.Proj+float4(0,0,0,0)) < Depth ? 0.111f:0.0f);
        shadowmap=shadowmap-(tex2Dproj(DepthMap,IN.Proj+float4(0.8,0,0,0)) < Depth ? 0.111f:0.0f);
        shadowmap=shadowmap-(tex2Dproj(DepthMap,IN.Proj+float4(-0.8,0.8,0,0)) < Depth ? 0.111f:0.0f);
        shadowmap=shadowmap-(tex2Dproj(DepthMap,IN.Proj+float4(0,0.8,0,0)) < Depth ? 0.111f:0.0f);
        shadowmap=shadowmap-(tex2Dproj(DepthMap,IN.Proj+float4(0.8,0.8,0,0)) < Depth ? 0.111f:0.0f);
	return float4(Texture*((Normal*Light*shadowmap)+Ambient),Texture.w);
     }

float Depth=(IN.Proj.xyz/LightRange); //MMM uses .xyz instead of .z

float Depth=(IN.Proj.x/LightRange);

/*********************************************************************NVMH3****
File: $Id: //sw/devrel/SDK/MEDIA_SRC/Shaders/templates/phong_bump_reflect.fx#2 $

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.

******************************************************************************/

float Script : STANDARDSGLOBAL <
    string UIWidget = "none";
    string ScriptClass = "object";
    string ScriptOrder = "standard";
    string ScriptOutput = "color";
    string Script = "Technique=Main;";
> = 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 ////////////////////

float4 LightSource : Position <
    string UIType = "Light Source";
> = {100.0f, 100.0f, -100.0f, 0.0f};

float3 Lamp0Color : Specular <
    string UIName =  "Lamp 0";
    string Object = "PointLight0";
    string UIWidget = "Color";
> = {1.0f, 1.0f, 1.0f};

float4 AmbiColor : Ambient <
    string UIName =  "Ambient Light Color";
    string UIWidget = "Color";
> = {0.01f, 0.01f, 0.01f, 1.0f};

float Ks <
    string UIWidget = "slider";
    float UIMin = 0.0;
    float UIMax = 1.0;
    float UIStep = 0.05;
    string UIName =  "Specular";
> = 1.0;

float SpecExpon : SpecularPower <
    string UIWidget = "slider";
    float UIMin = 1.0;
    float UIMax = 128.0;
    float UIStep = 1.0;
    string UIName =  "Specular Power";
> = 60.0;

float4 SurfColor : Diffuse
<
    string UIName =  "Surface Color";
    string UIType = "Color";
> = {0.5f, 0.5f, 0.5f, 1.0f};

float Bump <
    string UIWidget = "slider";
    float UIMin = 0.0;
    float UIMax = 3.0;
    float UIStep = 0.01;
    string UIName =  "Bumpiness";
> = 2.0; 

//////// COLOR & TEXTURE /////////////////////

texture ColorTexture : DIFFUSE <
    string ResourceName = "default_color.dds";
    string UIName =  "Diffuse Texture";
    string ResourceType = "2D";
>;

sampler2D ColorSampler = sampler_state {
    Texture = <ColorTexture>;
    MinFilter = Linear;
    MipFilter = Linear;
    MagFilter = 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>;
    MinFilter = Linear;
    MipFilter = Linear;
    MagFilter = Linear;
    AddressU = Wrap;
    AddressV = Wrap;
}; 

texture reflectMap <
    string ResourceName = "default_mask.dds";
    string UIName = "Specular Texture";
    string ResourceType = "2D";
>;

sampler2D reflectSampler = sampler_state {
    Texture = <reflectMap>;
    MinFilter = Linear;
    MipFilter = Linear;
    MagFilter = Linear;
    AddressU = Wrap;
    AddressV = Wrap;
};

//////// 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;
    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 = (LightSource - Pw);
    OUT.UV = IN.UV.xy;
    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 * SurfColor * LightColor;
    SpecularContrib = litV.y * litV.z * Ks * LightColor * SurfColor;
}

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);
	
	//(replace with local "Texture")
    float3 diffuseColor = tex2D(ColorSampler,IN.UV).rgb;
    float3 specColor = tex2D(reflectSampler,IN.UV).rgb; //scrap
    
    //(only use diffuse and apply it only to NORMAL)
    float3 result = specContrib*specColor+(diffuseColor*(diffContrib+AmbiColor));
    
    float3 R = reflect(Vn,Nn);
    return float4(result,1);
}

///// TECHNIQUES /////////////////////////////

technique Main <
	string Script = "Pass=p0;";
> {
    pass p0 <
	string Script = "Draw=geometry;";
    > {
        VertexShader = compile vs_2_0 std_VS();
		ZEnable = true;
		ZWriteEnable = true;
		CullMode = None;
        PixelShader = compile ps_2_0 std_PS();
    }
}

/////////////////////////////////////// eof //

	float Depth=(IN.Proj.z/LightRange); // Evolved's version
//	float Depth=(IN.Proj.xyz/LightRange); // your version

               if object=4 then make object sphere 1,75,5,5:scale object texture 1,0,2,1
`               if object=4 then make object sphere 1,75,40,40:scale object texture 1,0,2,1

   OUT_NormalMap VS_NormalMap(IN_NormalMap IN) 
     {
 	OUT_NormalMap OUT;
 	
 	
    	float3 netPosition = 0, netNormal = 0;
    	for (int i = 0; i < 4; i++)
    	 {
     	  float index = IN.Blendindices[i];
     	  float3x4 model = float3x4(boneMatrix[index][0], boneMatrix[index][1], boneMatrix[index][2]);
     	  float3 vec3 = mul(model,IN.Pos);
     	  vec3 = vec3 + boneMatrix[index][3].xyz;
     	  float3x3 rotate = float3x3(model[0].xyz, model[1].xyz, model[2].xyz); 
     	  float3 norm3 = mul(rotate, IN.Normal);
     	  netPosition += vec3.xyz * IN.Blendweight[i];
     	  netNormal += norm3.xyz * IN.Blendweight[i];
    	 }
    	float4 TempPos = float4(netPosition,1.0);
    	float3 TempNormal = normalize(netNormal);
        //OUT.OPos=mul(mul(TempPos,World),WorldVP);
 	
	OUT.OPos=mul(TempPos,WorldVP);
    	OUT.Tex=IN.UV;

	// Adjust tangents and binormals - GG quick fix for unwelded models
	float3 n = normalize(IN.Normal);
	float3 b = normalize(cross(n, IN.Tangent));
	float3 t = normalize(cross(b, n));
	float3x3 TBN={t,b,n};
	//float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
		
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(TempPos,World);  
	float3 LightPos=LightPosition-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-(LightPos/LightRange); 
 	OUT.ViewVec=mul(ViewPos,TBN);
    	float4 Wpos = mul(IN.Pos,World); //<<<need TempPos instead of IN.Pos but causes problem as displayed in attached image.
    	float4 Proj = mul(Wpos,LightProjMatrix);
    	OUT.Proj = mul(ViewMat,Proj);
	OUT.Fog=1-saturate(dot(ViewPos/FogRange,ViewPos/FogRange));	
	return OUT;
     }

   OUT_NormalMap VS_NormalMap(IN_NormalMap IN) 
     {
 	OUT_NormalMap OUT;
 	
 	
    	float3 netPosition = 0, netNormal = 0;
    	for (int i = 0; i < 4; i++)
    	 {
     	  float index = IN.Blendindices[i];
     	  float3x4 model = float3x4(boneMatrix[index][0], boneMatrix[index][1], boneMatrix[index][2]);
     	  float3 vec3 = mul(model,IN.Pos);
     	  vec3 = vec3 + boneMatrix[index][3].xyz;
     	  float3x3 rotate = float3x3(model[0].xyz, model[1].xyz, model[2].xyz); 
     	  float3 norm3 = mul(rotate, IN.Normal);
     	  netPosition += vec3.xyz * IN.Blendweight[i];
     	  netNormal += norm3.xyz * IN.Blendweight[i];
    	 }
    	float4 TempPos = float4(netPosition,1.0);
    	float3 TempNormal = normalize(netNormal);
        //OUT.OPos=mul(mul(TempPos,World),WorldVP);
 	
	OUT.OPos=mul(TempPos,WorldVP);
    	OUT.Tex=IN.UV;

	// Adjust tangents and binormals - GG quick fix for unwelded models
	float3 n = normalize(IN.Normal);
	float3 b = normalize(cross(n, IN.Tangent));
	float3 t = normalize(cross(b, n));
	float3x3 TBN={t,b,n};
	//float3x3 TBN={IN.Tangent,IN.Binormal,IN.Normal};
		
	TBN=transpose(mul(TBN,World));
	float3 WPos=mul(TempPos,World);  
	float3 LightPos=LightPosition-WPos; 
	float3 ViewPos=ViewInv[3].xyz-WPos;
	OUT.LightVec=mul(LightPos,TBN);
	OUT.Attenuation=-(LightPos/LightRange); 
 	OUT.ViewVec=mul(ViewPos,TBN);
    	float4 Wpos = mul(IN.Pos,World); //<<<-------------------PROBLEM BIT
    	float4 Proj = mul(Wpos,LightProjMatrix);
    	OUT.Proj = mul(ViewMat,Proj);
	OUT.Fog=1-saturate(dot(ViewPos/FogRange,ViewPos/FogRange));	
	return OUT;
     }

    	float4 Wpos = mul(IN.Pos,World); //<<<-------------------PROBLEM BIT

    	float4 Wpos = mul(TempPos,World); //<<<-------------------PROBLEM BIT

make object sphere 1, 100
make mesh from object 1, 1
make memblock from mesh 1, 1
delete mesh 1
make mesh from memblock 1, 1
make object 2, 1, 0
set object normals 2
delete object 1
wait key