Sorry your browser is not supported!

rem Initialise
sync on
sync rate 0

rem Load model and shader effect
load object "cube.dbo",1
autocam off
load effect "Normal Mapping.dbs",1,1
set object effect 1,1

x# = 3000
y# = 5000
z# = -1000
range# = 8000
red = 120
green = 100
blue = 90


` -------------------------
` Set the ambienct light
null = Make Vector4(1)
Set Vector4 1, 0.2, 0.2, 0.2, 1.0
Set Effect Constant Vector 1, "AmbientColor", 1

` -------------------------
` Set the technique based on number of lights
numberOfLights = 1

` Limit the old fashion way
If numberOfLights < 0
	numberOfLights = 0
Else
	If numberOfLights > 9
		numberOfLights = 9
	Endif
Endif

` Or with matrix1, limit the values this way
` numberOfLights = Clamp( numberOfLights, 0, 8)

If numberOfLights > 0
	Set Effect Technique 1, "DBLight" + Str$(numberOfLights)
Endif

` -------------------------
` Sets a lights properties and returns true if successful
` The shader and object must exist and the shader must be on to the object
` The function requests the shader ID for comfirmation, but uses the shader applied on the object
lightNumber = 0
If SetShaderLightEx(lightNumber, 1, 1, x#, y#, z#, range#, red, green, blue) = 0
	`Show Message "Failed to set light position"
Endif

` -------------------------
` This version request vector4 colour and position parameters
`SetShaderLight(lightNumber, effect, object,  v4LightPosition, v4Color)

do
	rem Draw main camera
	sync mask %001 : sync
loop

//============================================================
Function SetShaderLight(lightNumber, effect, object,  v4LightPosition, v4Color)
	If effect > 0
		If object > 0
			
			` Do not set anything if the object or effect is non existant
			If Not Effect Exist(effect) = 0 Then ExitFunction 0
			If Not Object Exist(object) = 0 Then ExitFunction 0			
			
			` Get the effect pointer
			null = Get Object Effect( object, -1 )
			
			` Apply
			Set Effect Constant Vector Element "LightPos", lightNumber, v4LightPosition		
			Set Effect Constant Vector Element "LightColor", lightNumber, v4Color
			
			Release Effect Pointer
		Endif
	Endif
Endfunction 1
//============================================================
Function SetShaderLightEx(lightNumber, effect, object, x#, y#, z#, range#, red, green, blue)

	Local red# : red# = red * 0.0039215
	Local green# : green# = green * 0.0039215
	Local blue# : blue# = blue * 0.0039215
	
	Local v4position
	Local v4color
	Local outcome
	
	remstart
	` Matrix1 code
	v4position = New Vector4(x#, y#, z#, range#)
	v4color = New Vector4(red#, green#, blue#, 1.0)
	remend
	
	` Code for DBP without Matrix1
	v4position = 999998
	v4color = 999999
	null = Make Vector4(v4position)
	null = Make Vector4(v4color)
	Set Vector4 v4position, x#, y#, z#, range#
	Set Vector4 v4color, red#, green#, blue#, 1.0

	` Apply
	outcome = SetShaderLight(lightNumber, effect, object,  v4position, v4Color)
	
	Delete Vector4 v4position
	Delete Vector4 v4color
	
Endfunction outcome

string Description = "This shader uses preview lights to produce per pixel normal mapped lighting. This shader requires lights.";
string Thumbnail = "Normal Mapping.png";

//--------------
//Untweakables
//--------------
float4x4 WorldViewProj : WorldViewProjection;
float4x4 World : World;
float4x4 WorldT : WorldTranspose;
float4x4 WorldIT : WorldInverseTranspose;

float4 LightPos[8] : LIGHTPOSITION;
float3 LightColor[8] : LIGHTCOLOR;
float3 AmbientColor : AMBIENTCOLOR;

float3 eyepos : CameraPosition;
float time : TIME;

//--------------
//Tweakables
//--------------

float SpecularPower1 
<
	string UIWidget = "slider";
	float UIMax = 30;
	float UIMin = 1;
> = 15.000000;

texture BaseTex
<
	string ResourceName = "door1.jpg";
>;

sampler diffuse_smp = sampler_state 
{
	Texture = <BaseTex>;
	MinFilter = Anisotropic;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};

texture NormalMap
<
	string ResourceName = "cobbles_R.DDS";
>;

sampler normalmap_smp = sampler_state 
{
	Texture = <NormalMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};

struct app_in
{
	float4 pos : POSITION;
	float3 normal : NORMAL0;
	float3 tangent : TANGENT0;
	float3 binormal : BINORMAL0;
	float2 uv : TEXCOORD0;
};

struct vs_out
{
	float4 pos : POSITION;
	float2 uv : TEXCOORD0;
	float3 normal : TEXCOORD1;
	float3 tangent : TEXCOORD2;
	float3 binormal : TEXCOORD3;
	float4 wpos : TEXCOORD4;
};

vs_out VS( app_in IN )
{
	vs_out OUT;
	
	float4 pos = mul( IN.pos, WorldViewProj );
	OUT.pos = pos;
	OUT.wpos = mul( IN.pos, World );
	OUT.uv = IN.uv;
	float3 normal = normalize(mul(IN.normal.xyz,(float3x3)World ));
	float3 tangent = normalize(mul(IN.tangent.xyz,(float3x3)World ));
	float3 binormal = normalize(mul(IN.binormal.xyz,(float3x3)World ));
	
	//smooth out the tangents and binormals with the normals
	float3 b = normalize(cross( normal,tangent ));
	b *= sign(dot(b,binormal));
	
	float3 t = normalize(cross( normal,b ));
	t *= sign(dot(t,tangent));
	
	float3 t2 = normalize(cross( normal,binormal ));
	t2 *= sign(dot(t2,tangent));
	
	float3 b2 = normalize(cross( normal,t2 ));
	b2 *= sign(dot(b2,binormal));
	
	//pass normal, tangent, and binormal to pixel shader
	OUT.normal = normal;
	OUT.tangent = normalize((t+t2)*0.5);
	OUT.binormal = normalize((b+b2)*0.5);
	
	return OUT;
}

float luminance ( float3 rgb )
{
	return rgb.r*0.3 + rgb.g*0.59 + rgb.b*0.11;
}

float4 PS( vs_out IN, uniform int numLights ) : COLOR
{
	float3 color = AmbientColor;
	
	float3 n = normalize(IN.normal);
	float3 t = normalize(IN.tangent);
	float3 b = normalize(IN.binormal);
	
	//build transpose matrix
	float3x3 TangentSpace = {t,b,n};
	TangentSpace = transpose(TangentSpace);
	
	n = normalize(tex2D(normalmap_smp, IN.uv)*2 - 1);
	
	float3 e = normalize(eyepos - IN.wpos);
	float eyeDist = length(eyepos - IN.wpos);
	
	e = mul(e,TangentSpace);
	
	float4 texColor = tex2D( diffuse_smp, IN.uv );
	
	//cycle through all lights, number depending on technique chosen
	for ( int i = 0; i < numLights; i++ )
	{
		float range = LightPos[i].w;
		
		if ( range > 0 )
		{
			float3 l = (LightPos[i].xyz - IN.wpos.xyz);
			l = mul(l,TangentSpace);
			
			//calculate attenuation
			float dist = length(l);
			float att = saturate((range-dist) / range);
			
			//calculate diffuse lighting
			l = normalize(l);
			float diffuse = saturate(dot(n,l));
			
			//caculate specular lighting
			float3 h = normalize(l+e);
			float spec = pow( saturate(dot(n,h)), SpecularPower1 )*(1-pow(1-diffuse,10));
			
			//add to final color
			color += (diffuse * att * LightColor[i]) + (spec * att * LightColor[i] * smoothstep(0.3,0.6,luminance(texColor.xyz)));
		}
	}
	
	return float4(color,1.0) * texColor;
}

//choose the technique corresponding to the number of lights in your application
technique PerPixelLighting
{
	pass p0
	{
		VertexShader = compile vs_2_0 VS( );
		PixelShader = compile ps_2_0 PS( 0 );
	}
}

technique DBLight1
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 1 );
	}
}

technique DBLight2
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 2 );
	}
}

technique DBLight3
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 3 );
	}
}

technique DBLight4
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 4 );
	}
}

technique DBLight5
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 5 );
	}
}

technique DBLight6
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 6 );
	}
}

technique DBLight7
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 7 );
	}
}

technique DBLight8
{
	pass p0
	{
		VertexShader = compile vs_1_1 VS( );
		PixelShader = compile ps_2_a PS( 8 );
	}
}

texture texture_name
<
	string ResourceName = "texture_file";
>;

sampler sampler_name = sampler_state 
{
	Texture = <texture_name>;
	MinFilter = Anisotropic;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = Wrap;
	AddressV = Wrap;
};