Shade-C v0.91 BETA S1 RELEASED

#define PRAGMA_PATH "shade-c"

#include <litec.h>
#include <d3d9.h> // <--- THIS IS IMPORTANT!
#include <acknex.h>
#include <default.c>
#include "sc_core.c"

BMAP* map_normal_fisheye = "normalmap_fisheye.bmp";
void v_fisheye()
{
	sc_mtl_pp_refract.skill1 = floatv(2.5); //this is the refract/bump strength
	sc_mtl_pp_refract.skill2 = floatv(0); //normalmap shifting speed. we don't want the normalmap to move, so set it to 0
	sc_mtl_pp_refract.skill3 = floatv(0); //refractmask factor. (Only) makes sense when using the depthmap as refractmask
	sc_mtl_pp_refract.skin1 = map_normal_fisheye; // assign the normalmap to the refraction shader
	
	sc_ppAdd(sc_mtl_pp_refract,camera,0); //apply refraction shader to screen
}

BMAP* map_normal_fisheye = "normalmap_fisheye.bmp";
void v_fisheye()
{
	sc_mtl_pp_refract.skill1 = floatv(0.8); //this is the refract/bump strength
	sc_mtl_pp_refract.skill2 = floatv(0); //normalmap shifting speed. we don't want the normalmap to move, so set it to 0
	sc_mtl_pp_refract.skill3 = floatv(0); //refractmask factor. (Only) makes sense when using the depthmap as refractmask
	sc_mtl_pp_refract.skin1 = map_normal_fisheye; // assign the normalmap to the refraction shader
	
	sc_ppAdd(sc_mtl_pp_refract,camera,0); //apply refraction shader to screen
}

camera.arc = 110;

/*
Terrain-Shader by Wolfgang "BoH_Havoc" Reichardt
Automatically uses A7 lightmap if its a .hmp file instead of a .mdl

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 @ DDS)

Usage:

	
*/

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

float bumpStr = 2; //bump strength
float numTiles = 60; // number of tiles
float shadowAlpha = 0.5; //shadowalpha of bumpmapping
float texShadowAlpha = 0.25; //shadowalpha of shadowtexture
float velvStr = 0.4; //velvety strength
float specStr = 1.0; //specular Strength
float4 specPower = 10; //specular Sharpness, higher value = sharper specular lighting

//active dynamic shadows (shadowType = 0)
//#define DYNSHADOW

//activate velvety backlight
#define VELVETY

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

texture entSkin1; //colormap
texture entSkin2; //global normalmap + Shadow
texture entSkin3; //colormask
texture entSkin4; //normalmaps
texture mtlSkin1; //colormaps
texture LightMap; //lightmap passed by engine

matrix matWorld;
matrix matWorldInv;
matrix matViewInv;
matrix matWorldViewProj;
float4x4 matEffect1;
float4x4 matEffect2;
float4x4 matEffect3;

float4 vecSunDir;
float4 vecSunColor;
float4 vecLightPos[8];
float4 vecLightColor[8];
float4 vecViewPos;
float4 vecAmbient;
float fAmbient;



//do sunlight
#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;
};

sampler2D lightmapSampler = sampler_state
{
	Texture = <LightMap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = WRAP;
	AddressV = WRAP;
};



#ifdef DYNSHADOW
// ShadowDepth map sampler
texture sc_map_shadowDepthSun_bmap;

sampler ShadowMapSampler = sampler_state
{
	Texture = <sc_map_shadowDepthSun_bmap>;
	MinFilter = Linear;
	MagFilter = Linear;
	MipFilter = Linear;
	AddressU = CLAMP;
	AddressV = CLAMP;
};

Texture sc_map_shadowAlpha_bmap;

sampler ShadowAlphaSampler = sampler_state
{
	texture = <sc_map_shadowAlpha_bmap>;
	magfilter = LINEAR;
	minfilter = LINEAR;
	mipfilter=LINEAR;
	AddressU = clamp;
	AddressV = clamp;
};
#endif

///////////////////////HELPER FUNCTIONS///////////////////////////////////////
// calculate the light attenuation factor
float DoLightFactor(float4 Light,float3 Pos)
{
   float fac = 0.f;
   if (Light.w > 0.f) {    
      float LD = length(Light.xyz-Pos)/Light.w;
      if (LD < 1.f)
         fac = saturate(1.f - LD);

   }
   return fac; // get the distance factor
}

// calculate the light attenuation factor on the front side
float DoLightFactor(float4 Light,float3 P,float3 N)
{
	float3 D = Light.xyz-P; // ray pointing from the light to the surface
	float NdotL = dot(N,normalize(D));   // angle between surface and light ray
	
	if (NdotL >= 0.f) 
	   return saturate(NdotL*8)*DoLightFactor(Light,P);
	else
	   return 0.f;
}

float DoLightFactorN(float4 Light,float3 P,float3 N)
{
	float3 D = Light.xyz-P; // ray pointing from the light to the surface
	float NdotL = dot(N,normalize(D));   // angle between surface and light ray
	
	if (NdotL >= 0.f) 
	   return 2 * NdotL * DoLightFactor(Light,P);
	else
	   return 0.f;
}

float4 DoPointLight(float3 P, float3 N, float4 Light, float4 LightColor)
{
	return LightColor * DoLightFactorN(Light,P,N);
}

float4 DoLight(float3 P, float3 N, int i)
{
	
	if(vecLightPos[i].w < 100000) return DoPointLight(P,N,vecLightPos[i],vecLightColor[i]);
	else return 0;
}


float4 doLighting(float3 P, float3 N, int i)
{
	if(vecLightPos[i].w < 100000)
	{
		float4 lighting = 1;
		lighting.xyz = clamp(1-distance(vecLightPos[i].xyz,P)/vecLightPos[i].w,0,1);
		lighting.xyz *= dot(N,normalize(vecLightPos[i]-P))*vecLightColor[i].xyz;
		return lighting;
	}
	else
	{ 
		return 0;
	}
	
}

float light_vsm_epsilon = 0.00003;
float light_shadow_bias = 0.0025;

float doVSM(float2 depthmap, float lightDepth)
{
     	//depthmap.y = (depthmap.x * depthmap.x);
     	float lit_factor = (lightDepth <= depthmap.x);
    	
    	// Variance shadow mapping
    	float E_x2 = depthmap.y;
    	float Ex_2 = depthmap.x * depthmap.x;
    	float variance = min(max(E_x2 - Ex_2, 0.0) + light_vsm_epsilon, 1.0);
    	float m_d = (depthmap.x - lightDepth);
    	float p = variance / (variance + m_d * m_d);
    	
    	// Adjust the light color based on the shadow attenuation
    	return 1-max(lit_factor, p);
}

void terrain_VS( 
   in float4 InPos: POSITION, 
   in float3 InNormal: NORMAL, 
   in float2 InTex: TEXCOORD0,
   in float3 InTangent : TEXCOORD0,
   out float4 OutPos: POSITION,
   out float4 OutColor : COLOR0,
   out float2 OutTex: TEXCOORD0, 
   out float4 OutLight: TEXCOORD1,
   out float3 OutViewDir: TEXCOORD2,
   out float3 OutWorldNormal	: TEXCOORD3,
	out float3 OutWorldTangent	: TEXCOORD4,
	out float3 OutWorldBinorm	: TEXCOORD5,
	#ifdef DYNSHADOW
		out float3 OutWorldPos	: TEXCOORD6,
		out float4 OutShadow	: TEXCOORD7
	#else
		out float3 OutWorldPos	: TEXCOORD6
	#endif
	) 
{ 
	// Transform the vertex from object space to clip space: 
   OutPos = mul(InPos, matWorldViewProj); 
	// Pass the texture coordinate to the pixel shader: 
   OutTex.xy = InTex.xy;
   
   float3 PosWorld = mul(InPos, matWorld);
  	
   //Light
   #ifdef DOSUN
	   OutLight.xyz = -vecSunDir.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
	OutViewDir = matViewInv[3].xyz - PosWorld;
	//
	
	//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;
	//
	
	#ifdef DYNSHADOW
	   //Shadowmapping
		float4 ShadowMapSamplingPos = mul(mul(InPos,matWorld), mul(matEffect3,matEffect1));
		float4 RealDistance = mul(mul(InPos,matWorld), matEffect3).z/matEffect2[0].w;
		
		OutShadow.x = ShadowMapSamplingPos.x;
		OutShadow.y = ShadowMapSamplingPos.y;
		OutShadow.z = ShadowMapSamplingPos.w;
		OutShadow.w = RealDistance.x;
		//
	#endif
	
	OutColor = fAmbient; // Add ambient and sun light
   #ifdef DOSUN
	for (int i=0; i<8; i++)  // Add 8 dynamic lights
		OutColor += DoLight(PosWorld,OutWorldNormal.xyz,i);
	#else
	for (int i=1; i<8; i++)  // Add 7 dynamic lights
		OutColor += DoLight(PosWorld,OutWorldNormal.xyz,i);
	#endif
	
	
}

float4 terrain_PS(
	uniform int inLM,
	in float4 InColor : COLOR0,
	float2 Tex : TEXCOORD0,
	float4 InLight: TEXCOORD1,
	float3 InViewDir: TEXCOORD2,
	float3 InWorldNormal	: TEXCOORD3,
	float3 InWorldTangent	: TEXCOORD4,
	float3 InWorldBinorm	: TEXCOORD5,
	float3 InWorldPos	: TEXCOORD6,
	in float4 InShadow	: TEXCOORD7
):COLOR0
{
	float4 Color = tex2D(colorSampler, Tex.xy);
	
	float4 colorMask = tex2D(maskSampler, Tex.xy);
	
	float2 Tile = Tex.xy*numTiles;
	Tile = frac(Tile)*(0.5-2*0.004)+0.004;
	
	float4 color = tex2D(colorSampler, Tex.xy);
	
	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.xy).xyz), 0.5);
	bumpNormal = (bumpNormal-(0.5).xxx)*bumpStr;
	
	//bumpNormal *= 2;
	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),10);
   
   
   
   
   #ifdef DYNSHADOW
	   float2 ProjectedTexCoords;
	   ProjectedTexCoords[0] = InShadow.x/InShadow.z/2.0f +0.5f;
	   ProjectedTexCoords[1] = -InShadow.y/InShadow.z/2.0f +0.5f;
	
		float blurStr = matEffect2[1].x;
		float shadowDepth = tex2D(ShadowMapSampler, ProjectedTexCoords).x;
		
		float shadow1 = doVSM(float2(shadowDepth,shadowDepth*shadowDepth),InShadow.w);
	   shadow1 = (1-shadow1);
	   
	   shadow1 *=(1-tex2D(ShadowAlphaSampler, ProjectedTexCoords));
	   shadow1 += tex2D(ShadowAlphaSampler, ProjectedTexCoords);
	   //shadow1 *= lighting.y;
	   shadow1 = clamp(shadow1,0,1);
   #else
   	float shadow1 = 1;
   #endif
   lighting.y *= shadow1;
   
   
   #ifdef VELVETY
   	float velvety1 = clamp(velvStr-dot(Vn,Nb),0,1);
   #else
   	float velvety1 = 0;
   #endif
   
   
   
	Color.rgb = saturate(clamp(lighting.y, shadowAlpha, 1)*vecSunColor*2)+(InColor.rgb);
	
	Color.rgb *= lerp(color, (color1+color2+color3), 0.5);
	Color.rgb += (lighting.z+velvety1)*specStr*gloss*Color.rgb;
	Color.rgb = clamp(Color.rgb, 0, 1);
	//Color.rgb *= clamp(colorMask.a,texShadowAlpha,1);
	if(inLM == 0)	Color.rgb *= clamp(colorMask.a,texShadowAlpha,1);
	else Color.rgb *= tex2D(lightmapSampler,Tex.xy).rgb;
	
	Color.a = 1;
	
	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(int(0));
	}
}

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

#define PRAGMA_PATH "shadec"
#define SC_A7 //activate A7 mode
#include "shade-c.h"

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

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

#define NORMALMAPPING //do normalmapping?

#define GLOSSMAP //entity has glossmap?

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

#include <scHeaderObject>


#define CUSTOM_PS_EXTEND
#ifndef VECSKILL1
	#define VECSKILL1
	float4 vecSkill1;
#endif
psOut Custom_PS_Extend(vsOut InPs, psOut OutPs)
{
	//fetch output color and calculate clip value from it
	half clipValue = (dot(OutPs.AlbedoAndEmissiveMask.xyz,1)*vecSkill1.x)-1;
	//apply clipping
	clip(clipValue);
	
	//output clipvalue to emissive buffer for some nice glow one edges where clipping will occur in the near future
	OutPs.AlbedoAndEmissiveMask.w = (1-saturate(clipValue))*0.05;
	//set emissive color
	OutPs.AlbedoAndEmissiveMask.xyz = lerp(OutPs.AlbedoAndEmissiveMask.xyz, vecSkill1.yzw, pow(1-saturate(clipValue),2));
	
	return OutPs;
}

#include <scObject>

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

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

#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

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

#include <scHeaderObject>


#define CUSTOM_VS_POSITION
#ifndef MATWORLD
#define MATWORLD
	float4x4 matWorld;
#endif
#ifndef MATWORLDVIEWPROJ
#define MATWORLDVIEWPROJ
	float4x4 matWorldViewProj;
#endif
#ifndef VECTIME
#define VECTIME
	float4 vecTime;
#endif
#ifndef VECSKILL1
#define VECSKILL1
	float4 vecSkill1;
#endif
float4 Custom_VS_Position(vsIn In)
{
	float3 P = mul(In.Pos, matWorld);
	float force_x = vecSkill1.x; 
	float force_y = vecSkill1.y;
	float speed = sin((vecTime.w+0.2*(P.x+P.y+P.z)) * vecSkill1.z);
	
	if (In.Pos.y > 0 ) // move only upper part of tree
	{
		In.Pos.x += speed * force_x * In.Pos.y;
		In.Pos.z += speed * force_y * In.Pos.y;
		In.Pos.y -= 0.1*abs(speed*(force_x+force_y)) * In.Pos.y;
	}
	
	return mul(In.Pos,matWorldViewProj);
}

#define CUSTOM_PS_EMISSIVEMASK
float Custom_PS_EmissiveMask(vsOut In, float emissive)
{
	return vecSkill1.w;
}


#include <scObject>

effect_load(mtl_shaded, "shadercode.fx");
mtl_shaded.flags = ENABLE_RENDER;
mtl_shaded.event = sc_materials_event;

effect_load(mtl_model, "shadercode.fx");
mtl_model.flags = ENABLE_RENDER;
mtl_model.event = sc_materials_event;

//activate sunlight
vec_set(sun_color, vector(128,128,128));

//set camera as main view of sc_screen_default
sc_screen_default = sc_screen_create(camera);

/activate sun shadows
sc_screen_default.settings.lights.sunShadows = 1;

//setup Shade-C
sc_setup(sc_screen_default);

//simple day night cycle
while(1)
{

	//move the sun around the scene
	sun_angle.pan += time_frame; 
	sun_angle.pan %= 360; 
   	sun_angle.tilt = fsin(sun_angle.pan, 45) + 45;
   	//set the sunlight brightness
   	sun_light = sun_angle.tilt;
        wait(1);
}

VIEW *scopeRefView = 
{
	size_x = 2048;
	size_y = 1024;
	aspect = 1.4;
	clip_near = 1;
	flags = SHOW;
}

while(screen.views.hdr)
{
   screen.materials.hdr.skill5 = floatv(random(1)); // Update video grain tex-coords
   screen.materials.hdr.skill6 = floatv(random(1)); // (same as above)
   wait(1);
}

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

#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 CUSTOM_VS_POSITION
float4 Custom_VS_Position(vsIn In)
{
	float3 P = mul(In.Pos, matWorld);
	float force_x = vecSkill1.x; 
	float force_y = vecSkill1.y;
	
	float speed = sin(vecTime.w * vecSkill1.z);
	
	In.Pos.z += speed * force_x;
	
	return mul(In.Pos,matWorldViewProj);
}