// Blinn / Phong bump mapping
// (c) oP group 2009  Version 2.2

#include <bump_vs>
#include <phong>

bool REQUIRE_NORMAL;

texture entSkin1;	// texture
texture entSkin2;	// normal map or lightmap
texture entSkin3;	// normal map on blocks

sampler sBaseTex = sampler_state { Texture = <entSkin1>; MipFilter = Linear;	};
sampler sSkin2 = sampler_state { Texture = <entSkin2>; MipFilter = None;	};
sampler sSkin3 = sampler_state { Texture = <entSkin3>; MipFilter = None;	};

float3 DoSpecular(bumpOut In,float3 Normal,float fSpecular)
{
#ifdef BLINN
	float3 viewDir = normalize(In.PosView);	
			
	float fLight = DoShine(In.Light1.xyz,Normal);
	float fHalfway = DoShine(In.Light1.xyz+viewDir,Normal);
	float3 Diffuse = DoPhong(In.Diffuse1,fLight,fHalfway,fSpecular);

	fLight = DoShine(In.Light2.xyz,Normal);
	fHalfway = DoShine(In.Light2.xyz+viewDir,Normal);
	Diffuse += DoPhong(In.Diffuse2,fLight,fHalfway,fSpecular);

	fLight = DoShine(In.Light3.xyz,Normal);
	fHalfway = DoShine(In.Light3.xyz+viewDir,Normal);
	Diffuse += DoPhong(In.Diffuse3,fLight,fHalfway,fSpecular);
#else // PHONG			
	float fLight = DoShine(In.Light1.xyz,Normal);
	float3 Diffuse = DoPhong(In.Diffuse1,fLight,fLight,fSpecular);		

	fLight = DoShine(In.Light2.xyz,Normal);
	Diffuse += DoPhong(In.Diffuse2,fLight,fLight,fSpecular);		

	fLight = DoShine(In.Light3.xyz,Normal);
	Diffuse += DoPhong(In.Diffuse3,fLight,fLight,fSpecular);
#endif

	return Diffuse;
}

float4 specBump_PS(bumpOut In): COLOR
{
	float4 Base = tex2D(sBaseTex,In.Tex12.xy);
	float3 Normalmap = tex2D(sSkin2,In.Tex12.xy)*2-1;
   float3 Diffuse = DoSpecular(In,Normalmap,Base.w);	
	return Base * DoColor(Diffuse,In.Ambient);
}

float4 specBumpLM_PS(bumpOut In): COLOR
{
	float4 Base = tex2D(sBaseTex,In.Tex12.xy);
	float4 Lightmap = tex2D(sSkin2,In.Tex12.zw);
	float3 Normalmap = tex2D(sSkin3,In.Tex12.xy)*2-1;
   float3 Diffuse = DoSpecular(In,Normalmap,Base.w);	
	return Base * DoLightmap(Diffuse,Lightmap,In.Ambient);
}


technique spec
{
	pass one
	{		
      ZWriteEnable = True;
      AlphaBlendEnable = False;

		VertexShader = compile vs_2_0 bump_VS();
		PixelShader = compile ps_2_0 specBump_PS();
	}
}

technique spec_lm
{
	pass one
	{		
      ZWriteEnable = True;
      AlphaBlendEnable = False;

		VertexShader = compile vs_2_0 bump_VS();
		PixelShader = compile ps_2_0 specBumpLM_PS();
	}
}

technique fallback { pass one { } }

technique spec_trans // a new name for the new shader 
{
	pass one
	{		
		ZWriteEnable = True;
		AlphaBlendEnable = True; // Enable alpha blending

		VertexShader = compile vs_2_0 bump_VS();
		PixelShader = compile ps_2_0 specBumpTrans_PS(); // A new pixel shader function
	}
}

MATERIAL *mtlSpecBumpTrans = {
   effect = "specBump.fx"; // the shader file
   technique = "spec_trans"; // the new technique
   flags = TRANSLUCENT; // not neccesary but you can ensure the entity is rendered by the translucent pass
}

float4 specBumpTrans_PS(bumpOut In): COLOR
{
	float4 Base = tex2D(sBaseTex,In.Tex12.xy);
	float4 Normalmap = tex2D(sSkin2,In.Tex12.xy);
	Normalmap.xyz = Normalmap.xyz*2-1;
	float3 Diffuse = DoSpecular(In,Normalmap.xyz,Normalmap.w);	
	Base.xyz *= DoColor(Diffuse,In.Ambient);
	return Base;
}

Normalmap.xyz = Normalmap.xyz*2-1;

float3 Diffuse = DoSpecular(In,Normalmap.xyz,Normalmap.w);

AlphaTestEnable = True;

float3x3 matTangent;

float4x4 matWorldViewProj;
float4x4 matWorld;
float4 vecViewDir;
float4 vecLight;

int iLights;
float4 vecLightPos[8];
float4 vecLightColor[8];

texture entSkin1;
sampler TexSampler = sampler_state { Texture = <entSkin1>; Mipfilter = Linear; Minfilter = Linear; Magfilter = Linear; };
texture entSkin2;
sampler TNSampler = sampler_state { Texture = <entSkin2>; Mipfilter = Linear; Minfilter = Linear; Magfilter = Linear; };

void VS (
	in float4 inPos: POSITION,
	in float3 inNormal: NORMAL,
	in float2 inTex: TEXCOORD0,
	in float3 inTangent: TEXCOORD2,
	out float4 outPos: POSITION,
	out float3 outNormal: TEXCOORD0,
	out float3 outWorld: TEXCOORD1,
	out float2 outTex: TEXCOORD2,
	out float3 outTangent: TEXCOORD3) {
		outPos = mul(inPos, matWorldViewProj);
		outNormal = mul(inNormal, (float3x3)matWorld);
		outWorld = mul(inPos, matWorld).xyz;
		outTex.xy = inTex.xy;
		outTangent = mul( inTangent.xyz, (float3x3)matWorld );
	}
	
float4 PS (
	in float3 inNormal: TEXCOORD0,
	in float3 inWorld: TEXCOORD1,
	in float2 inTex: TEXCOORD2,
	in float3 inTangent: TEXCOORD3) : COLOR0 {
		float4 Color = tex2D(TexSampler, inTex);
		float4 TNormalTex = tex2D(TNSampler, inTex);
		float3 bumpNormal = (TNormalTex.xyz * 2.0f) - 1.0f;
		inTangent = normalize(inTangent);
		inNormal = normalize(inNormal);
		float3 binormal = cross(inNormal, inTangent);
		float3 worldNormal = bumpNormal.x * inTangent + bumpNormal.y * binormal + bumpNormal.z * inNormal;
		
		float3 fDiffuse = vecLight.rgb;
		float3 fSpecular = 0;
		for(float i=0; i<iLights; i+=1) {
			float3 fDir = inWorld.xyz - vecLightPos[i].xyz;
			float3 fReflect = normalize((2.0f * dot(worldNormal, fDir) * worldNormal) - fDir);
			float fRadiance = saturate((vecLightPos[i].w - length(fDir)) / vecLightPos[i].w);
		   fSpecular += vecLightColor[i].rgb * pow(saturate(dot(fReflect, vecViewDir.xyz)), 8.0f) * TNormalTex.a;
			fDiffuse += vecLightColor[i].rgb * saturate(dot(normalize(-fDir), worldNormal.xyz)) * fRadiance;
		}
		
		float4 FinalColor;
		FinalColor.rgb = Color.rgb * fDiffuse;
		FinalColor.rgb += fSpecular;
		FinalColor.a = Color.a;
		
		return FinalColor;
	}

technique SpecTrans
{
	pass p0
	{
		ZWriteEnable = True;
		AlphaBlendEnable = True;
		AlphaTestEnable = True;
		
		VertexShader = compile vs_3_0 VS();
		PixelShader  = compile ps_3_0 PS();
	}
}

///////////////////////////////
#include <acknex.h>
#include <default.c>
//#include <mtlFX.c>
#include <shadows.c>
///////////////////////////////
var shadow_flag = 1; 	// Einfacher Schatten



MATERIAL *mtlSpecTrans = {
   effect = "SpecTrans.fx";
}

MATERIAL *mtlSpecBumpTrans = {
   effect = "specBump.fx";
   technique = "spec_trans";
}


// Startet Schatten bei dem der Schatten einer Entity
// auch auf sich selber geworfen werden kann.
function setShadow() 
{
	if (shadow_flag == 1) // Schatten: Stancil mit Eigenschatten	
	{	
		//		stencil_blur(0);
		pssm_run(0);
		shadow_stencil = 1;
		
		for(you = ent_next(NULL); you; you = ent_next(you)) 
		{
			reset(you, CAST);
			set(you, SHADOW);
			you.shadow = NULL;
		}
	}
	
	if (shadow_flag == 2)
	{
		// Dieser Schatten kann nur aktiviert werden, wenn die
		// Grafikkarte Shadermodel 3 oder höher unterstützt.
		if (d3d_shaderversion >= 3)
		{			
			// Deaktivieren des PSSM um dessen Parameter ändern zu können.
			pssm_run(0);
			//			stencil_blur(0);
			for(you = ent_next(NULL); you; you = ent_next(you)) {
				reset(you, CAST);
				set(you, SHADOW);
				you.shadow = NULL;
			}
			shadow_stencil = 8;	
			// Clip-Werte so nah wie möglich zusammenlegen.
			camera.clip_near = 30;
			camera.clip_far = 3000;
			// Fehlerquotienten setzen, dieser Wert wird durch ausprobieren
			// optimiert.
			pssm_fbias = 0.0005;
			pssm_run(3);		
		}
		else
		{
			printf("Ihre Grafikkarte unterstützt Shader Model 3 nicht!");
		}		
	}	
}







void main () {
	video_mode = 10;
	wait(3);
	sun_light = 0;
	level_load("spec.wmb");
	
	setShadow();
	
	def_move();	
	
	while(!key_esc) {
		
		wait(1);
	}
	
	sys_exit(NULL);
}

float fFog = saturate((camDist - vecFog.x) * vecFog.z) * vecFogColor.w;

MATERIAL* mtl_specBump =
{
   effect = "specBump.fx";
   specular_blue = 255;
   specular_green = 255;
   specular_red = 255;
   power = 10;
   flags = PASS_SOLID;
}

MATERIAL* mtl_specBump =
{
   effect = "specBump.fx";
   specular_blue = 255;
   specular_green = 255;
   specular_red = 255;
   power = 0.5;
   flags = PASS_SOLID;
}