Sorry your browser is not supported!

/******************************************************************************
simple normal map shader
by Ben Cloward
bsmji@hotmail.com
http://www.monitorstudios.com/bcloward

This shader uses a normal map to give the illusion that the model surface
contains more detail than is really there.  It's based on several shaders
written by Kevin Bjorke of Nvidia and included with the Cg plugin for 
3DS Max.

I created it for use with the tutorial I wrote on creating normal maps:
http://www.monitorstudios.com/bcloward/tutorials_normal_maps1.html
******************************************************************************/

/************* TWEAKABLES **************/

float4x4 world : World;
float4x4 WorldIMatrix : WorldI;
float4x4 wvp : WorldViewProjection;

float4 lightPos : Position
<
	string Object = "PointLight";
	string Space = "World";
> = {100.0f, 100.0f, 100.0f, 0.0f};

float4 lightColor : Diffuse
<
	string Object = "PointLight";
> = { 0.8f, 0.8f, 0.8f, 0.0f };

float4 ambiColor : Ambient = {0.1f, 0.1f, 0.1f, 1.0f};

texture colorTexture : DiffuseMap
<
	string Name = "colourmap.dds";
    string TextureType = "2D";
>;

texture normalMap : NormalMap
<
	string Name  = "normalmap.dds";
    string TextureType = "2D";
>;

sampler2D cmap = sampler_state
{
	Texture = <colorTexture>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

sampler2D normalSampler = sampler_state 
{
	Texture = <normalMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};
/*************/


/************* STRUCTS **************/

// vertex input
struct VertexIn {
    float4 Position	: POSITION; //in object space
    float4 UV		: TEXCOORD0; //in object space
    float4 Normal	: NORMAL; //in object space
    float3 T 		: TEXCOORD1; //in object space
	float3 B 		: TEXCOORD2; //in object space
};

//vertex output
struct VertexOut {
    float4 HPosition	: POSITION;
	float4 texCoord0	: TEXCOORD0;
	float4 texCoord1 	: TEXCOORD1;
	float4 LightVector	: TEXCOORD2;
};

//pixel output
struct PixelOut {
  float4 col : COLOR;
};
/*************/


//vertex shader*************************************
VertexOut DiffuseBumpVS(VertexIn IN, 
	uniform float4x4 WorldViewProj, 
	uniform float4x4 WorldIMatrix, 
	uniform float4x4 World, 
	uniform float4 LightPos)
{
	//create the vertex out struct
	VertexOut OUT;
	
	OUT.texCoord0 = IN.UV; //pass coords for diffuse map
	OUT.texCoord1 = IN.UV; //pass coords for normal map
	
	// transform position to projection space
	OUT.HPosition = mul(WorldViewProj, IN.Position);
	
	// compute the 3x3 tranform from tangent space to object space
	float3x3 objToTangentSpace;
	objToTangentSpace[0] = IN.T;
	objToTangentSpace[1] = -IN.B;
	objToTangentSpace[2] = IN.Normal;
	
	//put the vert position in world space
	float4 worldSpacePos = mul(World, IN.Position);
	
	//cast a ray to the light
	float4 normLightVec = normalize(LightPos - worldSpacePos);

	//transform the light vector to object space
    float4 objnormLightVec = mul(WorldIMatrix, normLightVec);
    
	// transform light vector from object space to tangent space and pass it as a color 
	OUT.LightVector.xyz = 0.5 * mul(objToTangentSpace, objnormLightVec.xyz) + 0.5.xxx;

	return OUT;
}


//pixel shader*************************************
PixelOut myps(VertexOut IN,
	uniform sampler2D colorMap,
	uniform sampler2D NormalMap,
	uniform float4 LightColor,
	uniform float4 AmbientColor) 
{
    PixelOut OUT; 
    
    //get the color from the diffuse texture
    float4 texColor = tex2D(colorMap);
    
    //get the color (normal) from the normal map
	float4 bumpNormal = expand(tex2D(NormalMap));
	
	//expand iterated light vector to [-1,1]
	float4 lightVector = expand(passthrough(IN.LightVector));
    
	//compute final color (diffuse + ambient)
	float4 bump = uclamp(dot3_rgba(bumpNormal.xyz,lightVector.xyz));
	OUT.col = texColor * bump * LightColor + AmbientColor;
    
    return OUT;
}


//MAIN*************************************
technique diffuseBump
{
	pass p0 
	{	
		VertexShader = compile vs_1_1 DiffuseBumpVS(wvp,WorldIMatrix,world,lightPos,lightColor);

		ZEnable = true;
		ZWriteEnable = true;
		CullMode = None;	

		PixelShader = compile ps_1_1 myps(cmap,normalSampler,lightColor,ambiColor);
	}
}

/***************************** eof ***/

//  Normalmap Shader - 1.0
//      by Ninja Matt
//------------------------------------
float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : WorldIT;
float4x4 ViewPos : ViewIT;

//------------------------------------
float4 LightPos : Position
<
	string Object = "PointLight";
    string Space = "World";
> = {1.0f, -1.0f, 1.0f, 0.0f};

texture TexMap
<
	string name = "Fieldstone.tga";
>;

texture NormMap
<
	string name = "FieldstoneNormal.tga";
>;

//------------------------------------
technique Bumpmap
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;
		VertexShaderConstant[4] = <World>;
		VertexShaderConstant[8] = <ViewPos>;
		VertexShaderConstant[12] = <LightPos>;

		VertexShader = asm
		{
			// Initilise Shader
			vs.1.1
			dcl_position	v0
			dcl_normal		v1
			dcl_texcoord	v2
			dcl_tangent		v3
			dcl_binormal	v4
			
			// Scale and Bias Value
			def c20, 1.0f, 0.5f, 0.0f, 0.0f
			
			// Transform Position to Clip
			m4x4 oPos, v0, c0
			
			// Output Texture Coordinates
			mov oT0, v2
			mov oT1, v2
			
			// Move Light to Object Space
			mov r1, c12
			m4x4 r0, r1, c4
			
			// Find Light Vector: L
			add r0, r0, -v0
			
			// Normalise Light Vector: L
			dp3 r1.w, r0, r0
			rsq r1.w, r1.w
			mul r0, r0, r1.w
			
			// Move Light Vector to Texture Space
			dp3 r1.x, r0, v3
			dp3 r1.y, r0, v4
			dp3 r1.z, r0, v1

			// Scale and Bias
			add r1, r1, c20.x
			mul r1, r1, c20.y
			
			// Output Light Vector
			mov oT2, r1
		};
		
		PixelShader = asm
		{
			// Initialise Shader
			ps.1.4
			
			// Read Texture Data
			texld r0, t0	
			texld r1, t1
			
			// Get Per-Pixel Light Vector
			texcrd r2.xyz, t2
			
			// DP3 Light Vector with Surface Normal
			dp3_sat r3, r1_bx2, r2_bx2
			
			// Multiply Diffuse with Lighting
			mul r0, r0, r3
		};

		Texture[0] = <TexMap>;
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Linear;

		Texture[1] = <NormMap>;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Linear;
	}
}

//  Terrain Shader for Zeal - 1.0
//      by Ninja Matt
//------------------------------------
float4x4 WorldViewProj : WorldViewProjection;
float4x4 ViewPos : ViewIT;

//------------------------------------
texture BaseMap
<
	string name = "TerrainBase.tga";
>;

texture BlendMap
<
	string name = "TerrainBlend.tga";
>;

texture DetailMap
<
	string name = "TerrainDetail.tga";
>;

//------------------------------------
technique Terrain
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;
		VertexShaderConstant[4] = <ViewPos>;

		VertexShader = asm
		{
			// Initilise Shader
			vs.1.1
			dcl_position	v0
			dcl_normal		v1
			dcl_texcoord	v2
			
			// TWEAKABLE - Detail Texture Scale
			def c20, 4.0f, 4.0f, 4.0f, 4.0f
			
			// TWEAKABLE - Detail Texture Strength
			def c21, 0.5f, 0.5f, 0.5f, 0.5f
			
			// Transform Position to Clip
			m4x4 oPos, v0, c0
			
			// Base and Blend Map Tex Coords
			mov oT0, v2
			mov oT1, v2
			
			// Scale and Output Detail Map Coords
			mul oT2, v2, c20
			
			mov oT3, c21
		};
		
		PixelShader = asm
		{
			// Initialise Shader
			ps.1.4
			
			// Load Textures
			texld r0, t0
			texld r1, t1
			texld r2, t2
			
			// Load Detail Fade
			texcrd r3.rgb, t3
			
			// 'Fix' the Texcrd Function
			mov_sat r3.rgb, r3
			+mov_sat r3.a, r3.r
			
			// Multiply Detail Map by Fade and Strength
			mul r2, r2_bias, r3
			
			// Multiply Blend by Detail for each Channel
			mad r0.rgb, r1.r, r2.r, r0
			mad r0.rgb, r1.g, r2.g, r0
			mad r0.rgb, r1.b, r2.b, r0
			mad r0.rgb, r1.a, r2.a, r0
		};

		Texture[0] = <BaseMap>;
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Linear;

		Texture[1] = <BlendMap>;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Linear;

		Texture[2] = <DetailMap>;
		MinFilter[2] = Linear;
		MagFilter[2] = Linear;
		MipFilter[2] = Linear;
	}
}

//	Terrain Shader for Zeal - 1.1
//------------------------------------
float4x4 WorldViewProj : WorldViewProjection;
float4x4 ViewPos : ViewIT;

//------------------------------------
texture BaseMap
<
	string name = "TerrainBase.tga";
>;

texture BlendMap
<
	string name = "TerrainBlend.tga";
>;

texture DetailMap
<
	string name = "TerrainDetail.tga";
>;

//------------------------------------
technique Terrain
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;
		VertexShaderConstant[4] = <ViewPos>;

		VertexShader = asm
		{
			// Initilise Shader
			vs.1.1
			dcl_position	v0
			dcl_normal		v1
			dcl_texcoord	v2
			
			// TWEAKABLE - Detail Texture Scale
			def c20, 4.0f, 4.0f, 4.0f, 4.0f

			// TWEAKABLE - Detail Texture Strength
			def c21, 0.5f, 0.5f, 0.5f, 0.5f
			
			// Transform Position to Clip
			m4x4 oPos, v0, c0
			
			// Base and Blend Map Tex Coords
			mov oT0, v2
			mov oT1, v2
			
			// Scale and Output Detail Map Coords
			mul oT2, v2, c20
			
			// Output Detail Strength Multiplier
			mov oT3, c21
		};
		
		PixelShader = asm
		{
			// Initialise Shader
			ps.1.1
			
			// Create RGB Masks
			def c0, 1.0f, 0.0f, 0.0f, 0.0f
			def c1, 0.0f, 1.0f, 0.0f, 0.0f
			def c2, 0.0f, 0.0f, 1.0f, 0.0f
			
			// Load Main Textures
			tex t0
			tex t1
			tex t2
			
			// Load Detail Map Strength
			texcoord t3
			
			// Multiply Blend Map by Detail
			mul r0, t1, t2_bias
			
			// Combine Red-Channel Detail
			dp3 r1, r0, c0
			mad t0, r1, t3, t0
			
			// Combine Green-Channel Detail
			dp3 r1, r0, c1
			mad t0, r1, t3, t0
			
			// Combine Blue-Channel Detail
			dp3 r1, r0, c2
			mad t0, r1, t3, t0
			
			// Combine Alpha-Channel and then Output
			mad r0, r0.a, t3, t0
		};

		Texture[0] = <BaseMap>;
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Linear;

		Texture[1] = <BlendMap>;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Linear;

		Texture[2] = <DetailMap>;
		MinFilter[2] = Linear;
		MagFilter[2] = Linear;
		MipFilter[2] = Linear;
	}
}

Make Object Sphere 1,10
Set Effect On 1,[.fx File Name],1 
Do
Loop

//  Normalmap Shader - 1.1
//      by Ninja Matt
//------------------------------------
float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : WorldIT;
float4x4 ViewPos : ViewIT;

//------------------------------------
float4 LightPos : Position
<
	string Object = "PointLight";
    string Space = "World";
> = {1.0f, -1.0f, 1.0f, 0.0f};

texture TexMap
<
	string name = "Fieldstone.tga";
>;

texture NormMap
<
	string name = "FieldstoneNormal.tga";
>;

//------------------------------------
technique Bumpmap
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;
		VertexShaderConstant[4] = <World>;
		VertexShaderConstant[8] = <ViewPos>;
		VertexShaderConstant[12] = <LightPos>;

		VertexShader = asm
		{
			// Initilise Shader
			vs.1.1
			dcl_position	v0
			dcl_normal		v1
			dcl_texcoord	v2
			dcl_tangent		v3
			dcl_binormal	v4
			
			// Scale and Bias Value
			def c20, 1.0f, 0.5f, 0.0f, 0.0f
			
			// Transform Position to Clip
			m4x4 oPos, v0, c0
			
			// Output Texture Coordinates
			mov oT0, v2
			mov oT1, v2
			
			// Move Light to Object Space
			mov r1, c12
			m4x4 r0, r1, c4
			
			// Find Light Vector: L
			add r0, r0, -v0
			
			// Normalise Light Vector: L
			dp3 r1.w, r0, r0
			rsq r1.w, r1.w
			mul r0, r0, r1.w
			
			// Move Light Vector to Texture Space
			dp3 r1.x, r0, v3
			dp3 r1.y, r0, v4
			dp3 r1.z, r0, v1

			// Scale and Bias
			add r1, r1, c20.x
			mul r1, r1, c20.y
			
			// Output Light Vector
			mov oT2, r1
		};
		
		PixelShader = asm
		{
			// Initialise Shader
			ps.1.1
			
			// Read Texture Data
			tex t0
			tex t1
			
			// Get Per-Pixel Light Vector
			texcoord t2
			
			// DP3 Light Vector with Surface Normal
			dp3_sat r0, t1_bx2, t2_bx2
			
			// Multiply Diffuse with Lighting
			mul r0, r0, t0
		};

		Texture[0] = <TexMap>;
		MinFilter[0] = Linear;
		MagFilter[0] = Linear;
		MipFilter[0] = Linear;

		Texture[1] = <NormMap>;
		MinFilter[1] = Linear;
		MagFilter[1] = Linear;
		MipFilter[1] = Linear;
	}
}

//  Hologram Shader - 1.1
//      by Ninja Matt
//------------------------------------
float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : WorldIT;
float4 EyePos <> = {0.0f, 0.0f, 0.0f, 0.0f};

//------------------------------------
texture HoloMap
<
	string name = "Hologram.tga";
>;

//------------------------------------
technique Hologram
{
	pass p0 
	{		
		VertexShaderConstant[0] = <WorldViewProj>;
		VertexShaderConstant[4] = <World>;
		VertexShaderConstant[8] = <EyePos>;

		VertexShader = asm
		{
			// Initilise Shader
			vs.1.1
			dcl_position	v0
			dcl_normal	v1

			// Clamp Values
			def c20, 1.0f, 0.0f, 0.0f, 0.0f

			// Transform Position to Clip
			m4x4 oPos, v0, c0
			
			// Move Eye Position to Object Space
			mov r0, c8
			m4x4 r1, r0, c4
			
			// Compute Eye Vector
			add r1, r1, -v0

			// Normalise Eye Vector
			dp3 r1.w, r1, r1
			rsq r1.w, r1.w
			mul r1, r1, r1.w

			// Compute N-dot-E
			dp3 r0, v1, r1

			// Clamp to [0..1]
			min r0, r0, c20.x
			max r0, r0, c20.y

			// Output Tex Coords
			mov oT0.x, r0
		};

		Texture[0] = <HoloMap>;
		MinFilter[0] = Point;
		MagFilter[0] = Point;
		MipFilter[0] = Point;
	}
}