//------------------------------------------------------------------------------
//----- USER INPUT -------------------------------------------------------------
//------------------------------------------------------------------------------

//assign skins
#define SKIN_ALBEDO (skin1.xyz) //diffusemap
#define SKIN_ALPHA (skin1.w) //alphamap
#define SKIN_NORMAL (skin2.xyz) //normalmap
#define SKIN_GLOSS (skin2.w) //glossmap
//...

#define NORMALMAPPING //do normalmapping?

#define GLOSSMAP //entity has glossmap?

#define ALPHA //entity has alphamap?
#define TRANSPARENT //entity alpha should be interpreted as transparent/translucent?

//------------------------------------------------------------------------------
// ! END OF USER INPUT !
//------------------------------------------------------------------------------

#include <scHeaderObject>

//custom code goes here

#include <scObject>

//------------------------------------------------------------------------------
//----- USER INPUT -------------------------------------------------------------
//------------------------------------------------------------------------------

//assign skins
#define SKIN_ALBEDO (skin1.xyz) //diffusemap
#define SKIN_ALPHA (skin1.w) //alpha
#define SKIN_NORMAL (skin2.xyz) //normalmap
#define SKIN_GLOSS (skin2.w) //glossmap
#define SKIN_EMISSIVEMASK (skin3.y) //emissive mask
#define SKIN_COLOR (skin3.w) //(team)color mask

//...

#define NORMALMAPPING //do normalmapping?

#define GLOSSMAP //entity has glossmap?
#define GLOSSSTRENGTH 0 //glossmap channel will be set to this value if GLOSSMAP is not defined

//#define EMISSIVEMASK //use emissive mask? (formula: emissive_color = SKIN_EMISSIVEMASK * SKIN_ALBEDO)
//#define EMISSIVE_A7 // (optional EMISSIVEMASK addon) use emissive_red/green/blue for as emissive color? (formula: emissive_color = SKIN_EMISSIVEMASK * vecEmissive)
//#define EMISSIVE_SHADEC // (optional EMISSIVEMASK addon) OR use SC_OBJECT_EMISSIVE as emissive color? (formula: emissive_color = SKIN_EMISSIVEMASK * SC_OBJECT_EMISSIVE)

//#define OBJECTCOLOR_A7 // use diffuse_red/green/blue as (team)color using the colormask?
//#define OBJECTCOLOR_SHADEC // OR use SC_OBJECT_COLOR as (team)color using the colormask?

//#define ALPHACLIP //do alphatesting/alphacutout?

//#define USE_VEC_DIFFUSE //use diffuse_red/green/blue? (note: don't use with OBJECTCOLOR_A7 at the same time)

//#define ZPREPASS //do an early zbuffer prepass? Only makes sense for heavy ALU

//------------------------------------------------------------------------------
// ! END OF USER INPUT !
//------------------------------------------------------------------------------

#include <scHeaderObject>
// <-
// insert custom code here
// ->
#include <scObject>

sc_screen_default.settings.forward.enabled = 1;

#define ALPHACLIP //do alphatesting/alphacutout?

ENTITY* sc_ent_softSprite(ENTITY* ent, VECTOR* color, int inFadeDist, int inSoftness, int pType)

EXAMPLE:
sc_ent_softSprite(me, vector(128,128,128), 1, 1, 0);

action Grass_WED(){
	set (my, PASSABLE);
	//my.material = mtl_carWindow;
	sc_ent_softSprite(me, vector(128,128,128), 1, 1, 0);
	reset (my, DYNAMIC);
}

sc_screen_default.settings.forward.enabled = 1;

BMAP* sc_bmap_terrainColor = "terrain_color.dds";

MATERIAL* sc_ent_Terrain =
{
	skin1 = sc_bmap_terrainColor;
	effect = "terr.fx";
}

/******************************************************************************************************
Terrain-Shader by Wolfgang "BoH_Havoc" Reichardt

Entity Textures:
	Skin1 = Global Colormap
	Skin2 = Tile-Colormask  (RGB) + Shadow (A)
	Skin3 = Global Normalmap
	Skin4 = Tile-Normalmap (RGB) + Specularmap (A) (Quad-Texture)

Material Textures:
	Skin1 = Tile-Color (Quad-Texture)

Usage:

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

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

float shadowAlpha = 0.25; //shadowalpha of bumpmapping
float texShadowAlpha = 0.25; //shadowalpha of shadowtexture



/***************************************SHADER*CODE****************************************************/

texture entSkin1; //colormap
texture entSkin2; //global normalmap + Shadow
texture entSkin3; //colormask
texture entSkin4; //normalmaps
texture mtlSkin1; //colormaps

matrix matWorld;
matrix matWorldInv;
matrix matViewInv;
matrix matWorldViewProj;

float4 vecSunPos;
float4 vecSunColor;
float4 vecLightPos[8];
float4 vecViewPos;
float4 vecFog;

#define DOSUN

sampler colorSampler = sampler_state 
{ 
   Texture = <entSkin1>; 
   MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

sampler maskSampler = sampler_state 
{ 
   Texture = <entSkin2>; 
   MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
}; 

sampler globalNormSampler = sampler_state 
{ 
   Texture = <entSkin3>; 
   MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
}; 

sampler normSampler = sampler_state 
{ 
   Texture = <entSkin4>; 
   MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
}; 

sampler tileColorSampler = sampler_state 
{ 
   Texture = <mtlSkin1>; 
   MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
};

void terrain_VS( 
   in float4 InPos: POSITION, 
   in float3 InNormal: NORMAL, 
   in float2 InTex: TEXCOORD0,
   in float3 InTangent : TEXCOORD0,
   in float2 InShadow : TEXCOORD1,
   out float4 OutPos: POSITION, 
   out float2 OutTex: TEXCOORD0, 
   out float4 OutLight: TEXCOORD1,
   out float3 OutViewDir: TEXCOORD2,
   out float3 OutWorldNormal	: TEXCOORD3,
	out float3 OutWorldTangent	: TEXCOORD4,
	out float3 OutWorldBinorm	: TEXCOORD5,
	out float3 OutWorldPos	: TEXCOORD6,
   out float OutFog : FOG) 
{ 
	// Transform the vertex from object space to clip space: 
   OutPos = mul(InPos, matWorldViewProj); 
	// Pass the texture coordinate to the pixel shader: 
   OutTex.xy = InTex;
   
   float3 PosWorld = mul(InPos, matWorld);
  	
   //Light
   #ifdef DOSUN
   OutLight.xyz = vecSunPos - PosWorld;;
   OutLight.w = 100000;//distance(PosWorld,vecLightPos[0])/vecLightPos[0].w;
   #else
   OutLight.xyz = vecLightPos[0] - PosWorld;
   OutLight.w = 0;
   if(vecLightPos[0].w < 100000) OutLight.w = 1-distance(PosWorld,vecLightPos[0])/vecLightPos[0].w;
   #endif
  	//

	//Specular Lighting
	#ifdef DOSUN
	OutViewDir = (vecSunPos) - mul(InPos, matWorld);
	#else
	OutViewDir = (vecLightPos[0]) - mul(InPos, matWorld); 
	#endif
	//
	
	//Misc Output
	float3 Binormal = cross(InNormal,InTangent);
	OutWorldNormal.xyz = mul(InNormal, matWorld).xyz;
	OutWorldTangent.xyz = mul(InTangent, matWorld).xyz;
	OutWorldBinorm.xyz = mul(Binormal, matWorldInv).xyz;
	OutWorldPos = PosWorld;
	//
	
	//Fog
	OutFog = 1 - (distance(PosWorld, vecViewPos) - vecFog.x) * (vecFog.z);
   //
}

float4 terrain_PS(
	float2 Tex : TEXCOORD0,
	float4 InLight: TEXCOORD1,
	float3 InViewDir: TEXCOORD2,
	float3 InWorldNormal	: TEXCOORD3,
	float3 InWorldTangent	: TEXCOORD4,
	float3 InWorldBinorm	: TEXCOORD5,
	float3 InWorldPos	: TEXCOORD6
):COLOR0
{
	float4 Color = tex2D(colorSampler, Tex);
	
	float4 colorMask = tex2D(maskSampler, Tex);
	
	float2 Tile = Tex*40;
	Tile = frac(Tile)*(0.5-2*0.004)+0.004;
	
	float4 color = tex2D(colorSampler, Tex);
	
	float4 color1 = tex2D(tileColorSampler, Tile)*colorMask.r;
	float4 color2 = tex2D(tileColorSampler, Tile+float2(0.5, 0.0))*colorMask.g;
	float4 color3 = tex2D(tileColorSampler, Tile+float2(0.0, 0.5))*colorMask.b;
		
	float4 normal1 = tex2D(normSampler, Tile)*colorMask.r;
	float4 normal2 = tex2D(normSampler, Tile+float2(0.5, 0.0))*colorMask.g;
	float4 normal3 = tex2D(normSampler, Tile+float2(0.0, 0.5))*colorMask.b;
		
	float3 Ln = normalize(InLight.xyz);
   float3 Nn = normalize(InWorldNormal);
   float3 Tn = normalize(InWorldTangent);
   float3 Bn = normalize(InWorldBinorm);
   float3 Nb = 0;
   float3 Vn = 0;
   float3 Hn = 0;
   float4 lighting = 0;
	
	float gloss = normal1.a + normal2.a + normal3.a;	
	
	float3 bumpNormal = (normal1.rgb+normal2.rgb+normal3.rgb);
	//bumpNormal += tex2D(globalNormSampler, Tex).xyz;
	bumpNormal = lerp(bumpNormal, tex2D(globalNormSampler, Tex).xyz, 0.5);
	Nb = Nn + (bumpNormal.x * Tn + bumpNormal.y * Bn);
   Nb = normalize(Nb);
   Vn = normalize(InViewDir);
   Hn = normalize(Vn + Ln);
   lighting = lit(dot(Ln,Nb),dot(Hn,Nb),1);
   
	Color.rgb = saturate(clamp(lighting.y, shadowAlpha, 1)*vecSunColor*2);
	//Color.rgb = lighting.y+lighting.z;
	
	Color.rgb *= lerp(color, (color1+color2+color3), 0.5);
	//Color.rgb *= color;
	//Color.rgb *= color*(color1+color2+color3);
	//Color.rgb *= 2;
	//Color.rgb = clamp(Color.rgb,0,1);
	Color.rgb += lighting.z*gloss*Color.rgb;
	Color.rgb = clamp(Color.rgb, 0, 1);
	Color.rgb *= clamp(colorMask.a,texShadowAlpha,1);

	Color.a = 1;
	//Color.rgb = (color1+color2+color3);
	/*
	//VELVETY
	Vn = normalize(matViewInv[3].xyz - InWorldPos);
	half3 velvety1;
   float vdn = 0.4-dot(Vn,Nn);
   float3 vecColor = float4(vdn.xxx,1.0);
   velvety1 = float4((vecColor).xyz,1);
   velvety1 = clamp(velvety1,0,1);
   Color.rgb += velvety1*gloss;
	//
	*/
	
	return float4(Color.rgb,1);
}

technique terrain
{
	pass p0
	{
		//cullmode = none;
		//zwriteenable = true;
		//alphablendenable = true;
		VertexShader = compile vs_2_0 terrain_VS();
		PixelShader = compile ps_2_a terrain_PS();
	}
}

LPDIRECT3DVOLUMETEXTURE9 sc_volumeTexture_create(STRING *filename)
{
	LPDIRECT3DVOLUMETEXTURE9 temptex;
	HRESULT res = D3DXCreateVolumeTextureFromFile((LPDIRECT3DDEVICE9)pd3ddev, _chr(filename), &temptex);
	if(res != S_OK)
	{
		printf("error: %x", res);
		return NULL;
	}
	return temptex;
}

STRING* sc_deferredLighting_sBRDFLUT = "shadec/tex/sc_deferredLighting_LUT.dds";

STRING* sc_deferredLighting_sBRDFLUT = "shadec/tex/sc_deferredLighting_LUT.dds";

STRING* sc_deferredLighting_sBRDFLUT = "sc_deferredLighting_LUT.dds";

STRING* sc_deferredLighting_sBRDFLUT = "shadec/tex/sc_deferredLighting_LUT.dds";

STRING* sc_deferredLighting_sBRDFLUT = "sc_deferredLighting_LUT.dds";

/// YOUR MAIN C

// #define FINAL_PUBLISH  // COMMENT OUT TILL FINAL PUBLISH
#include xxxxx

function main(){
... BLA BLA
}
//////////

// Modified script
#ifndef FINAL_PUBLISH
STRING* sc_deferredLighting_sBRDFLUT = "shadec/tex/sc_deferredLighting_LUT.dds";
#else
STRING* sc_deferredLighting_sBRDFLUT = "sc_deferredLighting_LUT.dds";
#endif

//------------------------------------------------------------------------------
//----- USER INPUT -------------------------------------------------------------
//------------------------------------------------------------------------------

//assign skins
#define SKIN_ALBEDO (skin1.xyz) //diffusemap
#define SKIN_ALPHA (skin1.w) //alpha
#define SKIN_NORMAL (skin2.xyz) //normalmap
#define SKIN_GLOSS (skin2.w) //glossmap
#define SKIN_EMISSIVEMASK (skin3.xyz) //emissive mask
//#define SKIN_COLOR (skin3.w) //(team)color mask

//...

#define NORMALMAPPING //do normalmapping?

#define GLOSSMAP //entity has glossmap?
#define GLOSSSTRENGTH 0 //glossmap channel will be set to this value if GLOSSMAP is not defined

#define EMISSIVEMASK //use emissive mask? (formula: emissive_color = SKIN_EMISSIVEMASK * SKIN_ALBEDO)
//#define EMISSIVE_A7 // (optional EMISSIVEMASK addon) use emissive_red/green/blue for as emissive color? (formula: emissive_color = SKIN_EMISSIVEMASK * vecEmissive)
//#define EMISSIVE_SHADEC // (optional EMISSIVEMASK addon) OR use SC_OBJECT_EMISSIVE as emissive color? (formula: emissive_color = SKIN_EMISSIVEMASK * SC_OBJECT_EMISSIVE)

//#define OBJECTCOLOR_A7 // use diffuse_red/green/blue as (team)color using the colormask?
//#define OBJECTCOLOR_SHADEC // OR use SC_OBJECT_COLOR as (team)color using the colormask?

//#define ALPHACLIP //do alphatesting/alphacutout?

//#define USE_VEC_DIFFUSE //use diffuse_red/green/blue? (note: don't use with OBJECTCOLOR_A7 at the same time)

//#define ZPREPASS //do an early zbuffer prepass? Only makes sense for heavy ALU

//------------------------------------------------------------------------------
// ! END OF USER INPUT !
//------------------------------------------------------------------------------

#include <scHeaderObject>
// <-
// insert custom code here
// ->
#include <scObject>

#ifdef ALPHA
			#ifdef TRANSPARENT
				
				SKIN_ALPHA *= tex2D(stipplingMaskSampler, projCoord*vecViewPort.xy*0.5).g * fAlpha;
				#ifdef TRANSPARENTALPHACLIP
					clip(SKIN_ALPHA - fAlpha);
				#else
					clip(SKIN_ALPHA - ALPHACLIP);
				#endif
			#else
				#ifdef CUSTOM_PS_ALPHA
					clip(Custom_PS_Alpha(In, SKIN_ALPHA));
				#else
					clip(SKIN_ALPHA-(1-fAlpha));
				#endif
			#endif
		#endif

#ifdef TRANSPARENT
				alphablendenable = true;
				BlendOp = Add;
				//SrcBlend = InvDestColor;
				//DestBlend = One;
				//SrcBlendAlpha = InvDestAlpha;//InvDestAlpha;
				//DestBlendAlpha = One;
			#endif

sc_screen_default.settings.lights.sunShadowResolution = 512; //reduce shadow resolution as we are manually setting the shadow range to 5000 and can therefor get away with a small shadowmap
	sc_screen_default.settings.lights.sunPssmSplitWeight = 0.7; //high res near splits, low res far splits
	sc_screen_default.settings.lights.sunShadowRange = 5000; //manually set the shadow range...we don't need realtime shadows in the far distant! If set to 0 (default) shadow range will be set to camera.clip_far
	sc_screen_default.settings.lights.sunShadowBias = 0.001; //set the shadow bias

BMAP* blood_smear_map1 = "blood1.tga"; // 32bit with alpha channel
...
c_trace
...
if (HIT_TARGET && you){
   if (!ent_getdecal (you, 0, 35)){     // dont place too much decals ( performance )
      PARTICLE* p = ent_decal (you, blood_smear_map1, 1 + random (2), random (360)); 
      if (p){
         p.alpha    = 50 + random (30);
       //p.lifespan = 5000;
         p.material = mtl_blood;
         set (p, TRANSLUCENT); //|PASSABLE
      }
   }
}
...
..
.

MATERIAL* mtl_blood = {
	effect = "myblood.fx";
	flags  = ENABLE_RENDER;
	event  = sc_materials_event;	
	power  = 200;
}

#define SKIN_ALBEDO (skin1.xyz)
#define SKIN_ALPHA  (skin1.w)
#define ALPHA
#include <scHeaderObject>
#include <scObject>

BMAP* blood_smear_map1 = "blood1.tga"; // 32bit with alpha channel
...
c_trace
...
if (HIT_TARGET && you){
   if (!ent_getdecal (you, 0, 35)){
      PARTICLE* p = ent_decal (you, blood_smear_map1, 1, random (360));
      if (p){
         p.lifespan  = 5000;
         p.material  = mtl_translucent;
      }
   }
}
...
..
.

MATERIAL* mtl_translucent = {
	effect = "simpTran.fx";
	flags  = ENABLE_RENDER;
	event  = sc_materials_event;
	power  = 200;
}

#define SKIN_ALBEDO       (skin1.xyz)
#define SKIN_ALPHA        (skin1.w)
#define ALPHA
#define TRANSPARENT
#include <scHeaderObject>
#include <scObject>