//////////////////////////////////////////////////////////////////////
// Blinn / Phong bump mapping
// (c) oP group 2010 Version 2.3
//////////////////////////////////////////////////////////////////////
#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.ViewDir);
float fLight = dot(In.LightDir1.xyz,Normal);
float3 R = reflect(In.LightDir1.xyz,Normal);
float3 Diffuse = DoPhong(In.Diffuse1,fLight,dot(R,viewDir),fSpecular);
fLight = dot(In.LightDir2.xyz,Normal);
R = reflect(In.LightDir2.xyz,Normal);
Diffuse += DoPhong(In.Diffuse2,fLight,dot(R,viewDir),fSpecular);
fLight = dot(In.LightDir3.xyz,Normal);
R = reflect(In.LightDir3.xyz,Normal);
Diffuse += DoPhong(In.Diffuse3,fLight,dot(R,viewDir),fSpecular);
#else // PHONG
float fLight = dot(In.LightDir1.xyz,Normal);
float3 Diffuse = DoPhong(In.Diffuse1,fLight,fLight,fSpecular);
fLight = dot(In.LightDir2.xyz,Normal);
Diffuse += DoPhong(In.Diffuse2,fLight,fLight,fSpecular);
fLight = dot(In.LightDir3.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 { } }
// Tweakables:
static const float AmbientIntensity = 1.0f; // The intensity of the ambient light.
static const float DiffuseIntensity = 1.0f; // The intensity of the diffuse light.
static const float SpecularIntensity = 1.0f; // The intensity of the specular light.
static const float SpecularPower = 8.0f; // The specular power. Used as 'glossyness' factor.
static const float4 SunColor = {0.9f, 0.9f, 0.5f, 1.0f}; // Color vector of the sunlight.
float water_height_var;
// Application fed data:
const float4x4 matWorldViewProj; // World*view*projection matrix.
const float4x4 matWorld; // World matrix.
const float4 vecAmbient; // Ambient color.
const float4 vecSunDir; // Sun light direction vector.
const float4 vecViewPos; // View position.
float3x3 matTangent; // hint for the engine to create tangents in TEXCOORD2
texture mtlSkin1;
sampler ColorMapSampler = sampler_state // Color map sampler.
{
Texture = <mtlSkin1>;
MipFilter = Linear; // required for mipmapping
};
texture mtlSkin2; // Normal map.
sampler NormalMapSampler = sampler_state // Normal map sampler.
{
Texture = <mtlSkin2>;
MipFilter = None; // a normal map usually has no mipmaps
};
// Vertex Shader:
void NormalMapVS( in float4 InPos: POSITION,
in float3 InNormal: NORMAL,
in float3 InTex: TEXCOORD0,
in float4 InTangent: TEXCOORD2,
out float4 OutPos: POSITION,
out float3 OutTex: TEXCOORD0,
out float3 OutViewDir: TEXCOORD1,
out float3 OutSunDir: TEXCOORD2)
{
// Transform the vertex from object space to clip space:
OutPos = mul(InPos, matWorldViewProj);
// Pass the texture coordinate to the pixel shader:
OutTex = InTex;
OutTex.z = mul(InPos,matWorld).y;
// Compute 3x3 matrix to transform from world space to tangent space:
matTangent[0] = mul(InTangent.xyz, matWorld);
matTangent[1] = mul(cross(InTangent.xyz, InNormal)*InTangent.w, matWorld);
matTangent[2] = mul(InNormal, matWorld);
// Calculate the view direction vector in tangent space:
OutViewDir = normalize(mul(matTangent, (vecViewPos - mul(InPos,matWorld))));
// Calculate the light direction vector in tangent space:
OutSunDir = normalize(mul(matTangent, -vecSunDir));
}
// Pixel Shader:
float4 NormalMapPS(
in float3 InTex: TEXCOORD0,
in float3 InViewDir: TEXCOORD1,
in float3 InSunDir: TEXCOORD2): COLOR
{
clip(InTex.z-water_height_var);
// Read the normal from the normal map and convert from [0..1] to [-1..1] range
float3 BumpNormal = tex2D(NormalMapSampler, InTex)*2 - 1;
// Calculate the ambient term:
float4 Ambient = AmbientIntensity * vecAmbient;
// Calculate the diffuse term:
float4 Diffuse = DiffuseIntensity * SunColor * saturate(dot(InSunDir, BumpNormal));
// Calculate the reflection vector:
float3 R = normalize(2 * dot(BumpNormal, InSunDir) * BumpNormal - InSunDir);
// Calculate the specular term:
InViewDir = normalize(InViewDir);
float Specular = pow(saturate(dot(R, InViewDir)), SpecularPower) * SpecularIntensity;
// Fetch the pixel color from the color map:
float4 Color = tex2D(ColorMapSampler, InTex);
// Calculate final color:
return (Ambient + Diffuse + Specular) * Color;
}
// Technique:
technique NormalMapTechnique
{
pass P0
{
VertexShader = compile vs_2_0 NormalMapVS();
PixelShader = compile ps_2_0 NormalMapPS();
}
}
VIEW* view_mirror = { layer = -1; } // render mirror view before camera view
BMAP* bmap_mirrortarget = NULL;
var mtlfx_mirrorvisible = 0;
function fx_mirror()
{
if (bmap_mirrortarget)
{
ptr_remove(bmap_mirrortarget);
bmap_mirrortarget = NULL;
}
bmap_mirrortarget = bmap_createblack(256,256,888);
my.material.skin2 = bmap_mirrortarget;
view_mirror.bmap = bmap_mirrortarget;
view_mirror.size_x = bmap_width(view_mirror.bmap);
view_mirror.size_y = bmap_height(view_mirror.bmap);
vec_set(view_mirror.pnormal_x,vector(0,0,1.0)); // reflect upwards
set(view_mirror,NOSHADOW|NOPARTICLE|NOCULL);
set(view_mirror,NOFLAG1);
while (bmap_mirrortarget)
{
proc_mode = PROC_LATE; // camera must be moved and mtlfx_mirrorvisible set before
if (mtlfx_mirrorvisible)
{
set(view_mirror,SHOW);
view_mirror.genius = camera.genius;
view_mirror.aspect = (screen_size.x/screen_size.y)*camera.aspect; // screen aspect, independent of render target
view_mirror.arc = camera.arc;
view_mirror.fog_start = camera.fog_start;
view_mirror.fog_end = camera.fog_end;
view_mirror.clip_far = camera.clip_far;
view_mirror.clip_near = camera.clip_near;
view_mirror.x = camera.x;
view_mirror.y = camera.y;
view_mirror.z = -camera.z; // view_mirror.z = 2*view_mirror.portal_z-camera.z;
view_mirror.pan = camera.pan;
view_mirror.tilt = -camera.tilt; // flip the vertical camera angle
view_mirror.roll = -camera.roll;
}
else
{
// switch rendering off when all mirror objects are outside the frustum
reset(view_mirror,SHOW);
}
mtlfx_mirrorvisible = 0;
wait(1);
}
}
BMAP* bmap_water_uv = NULL;
function mirror_init()
{
fx_mirror(); // create a mirror view, set mirror target to mtl.skin2
while (1)
{
if (!is(my,CLIPPED))
{
vec_for_max(view_mirror.portal_x,my);
vec_add(view_mirror.portal_x,my.x);
mtlfx_mirrorvisible = 1;
}
wait(1);
}
}
function mirror_water_init()
{
if (!bmap_water_uv)
{
bmap_water_uv = bmap_to_uv(bmap_create("water.dds"));
}
mtl.skin1 = bmap_water_uv;
mtl.flags |= TRANSLUCENT;
mirror_init(); // activate mirror view
}
MATERIAL* mtl_mirrorWater =
{
effect = "mirrorWater.fx";
event = mirror_water_init;
}
action fx_mirrorWater()
{
my.skill20 = 1;
set(my,PASSABLE);
set(my,FLAG1);
my.material = mtl_mirrorWater;
mtl_setup(80,80,80,80);//80
}
MATERIAL* mtl_specBumpymr22 =
{
diffuse_red = 255;
diffuse_blue = 255;
diffuse_green = 255;
specular_blue = 255; // bright specular component
specular_green = 255;
specular_red = 255;
ambient_red = 0;
ambient_blue = 0;
ambient_green = 0;
effect = "mirrorbump.fx";
flags = PASS_SOLID;
}
function mtl_event_render2()
{
if (render_view != camera)
{
mtl = mtl_specBumpymr22;
return(0);
}
}
MATERIAL* bump_mirror =
{
diffuse_red = 255;
diffuse_blue = 255;
diffuse_green = 255;
specular_blue = 255; // bright specular component
specular_green = 255;
specular_red = 255;
ambient_red = 0;
ambient_blue = 0;
ambient_green = 0;
event = mtl_event_render2;
flags = ENABLE_RENDER | PASS_SOLID;
effect = "specBump.fx";
}
// Tweakables:
static const float AmbientIntensity = 1.0f; // The intensity of the ambient light.
static const float DiffuseIntensity = 1.0f; // The intensity of the diffuse light.
static const float SpecularIntensity = 1.0f; // The intensity of the specular light.
static const float SpecularPower = 8.0f; // The specular power. Used as 'glossyness' factor.
static const float4 SunColor = {0.0f, 0.0f, 0.0f, 0.0f}; // Color vector of the sunlight.
float water_height;
// Application fed data:
const float4x4 matWorldViewProj; // World*view*projection matrix.
const float4x4 matWorld; // World matrix.
const float4 vecAmbient; // Ambient color.
const float4 vecSunDir; // Sun light direction vector.
const float4 vecViewPos; // View position.
float3x3 matTangent; // hint for the engine to create tangents in TEXCOORD2
texture mtlSkin1;
sampler ColorMapSampler = sampler_state // Color map sampler.
{
Texture = <mtlSkin1>;
MipFilter = Linear; // required for mipmapping
};
texture mtlSkin2; // Normal map.
sampler NormalMapSampler = sampler_state // Normal map sampler.
{
Texture = <mtlSkin2>;
MipFilter = None; // a normal map usually has no mipmaps
};
// Vertex Shader:
void NormalMapVS( in float4 InPos: POSITION,
in float3 InNormal: NORMAL,
in float3 InTex: TEXCOORD0,
in float4 InTangent: TEXCOORD2,
out float4 OutPos: POSITION,
out float3 OutTex: TEXCOORD0,
out float3 OutViewDir: TEXCOORD1,
out float3 OutSunDir: TEXCOORD2)
{
// Transform the vertex from object space to clip space:
OutPos = mul(InPos, matWorldViewProj);
// Pass the texture coordinate to the pixel shader:
OutTex = InTex;
OutTex.z = mul(InPos,matWorld).y;
// Compute 3x3 matrix to transform from world space to tangent space:
matTangent[0] = mul(InTangent.xyz, matWorld);
matTangent[1] = mul(cross(InTangent.xyz, InNormal)*InTangent.w, matWorld);
matTangent[2] = mul(InNormal, matWorld);
// Calculate the view direction vector in tangent space:
OutViewDir = normalize(mul(matTangent, (vecViewPos - mul(InPos,matWorld))));
// Calculate the light direction vector in tangent space:
OutSunDir = normalize(mul(matTangent, -vecSunDir));
}
// Pixel Shader:
float4 NormalMapPS(
in float3 InTex: TEXCOORD0,
in float3 InViewDir: TEXCOORD1,
in float3 InSunDir: TEXCOORD2): COLOR
{
clip(InTex.z);//water_height_var
// Read the normal from the normal map and convert from [0..1] to [-1..1] range
float3 BumpNormal = tex2D(NormalMapSampler, InTex)*2 - 1;
// Calculate the ambient term:
float4 Ambient = AmbientIntensity * vecAmbient;
// Calculate the diffuse term:
float4 Diffuse = DiffuseIntensity * SunColor * saturate(dot(InSunDir, BumpNormal));
// Calculate the reflection vector:
float3 R = normalize(2 * dot(BumpNormal, InSunDir) * BumpNormal - InSunDir);
// Calculate the specular term:
InViewDir = normalize(InViewDir);
float Specular = pow(saturate(dot(R, InViewDir)), SpecularPower) * SpecularIntensity;
// Fetch the pixel color from the color map:
float4 Color = tex2D(ColorMapSampler, InTex);
// Calculate final color:
return (Ambient + Diffuse + Specular) * Color;
}
// Technique:
technique NormalMapTechnique
{
pass P0
{
VertexShader = compile vs_2_0 NormalMapVS();
PixelShader = compile ps_2_0 NormalMapPS();
}
}
function level_switch(var* number)
{
trigger1 = 0;
trigger2 = 0;
trigger3 = 0;
trigger4 = 0;
trigger5 = 0;
mtl_hdr.skill4 = floatv(30); //set HDR values
mtl_hdr.skill1 = floatv(20);
mtl_hdr.skill2 = 20;
mtl_hdr.skill3 = floatv(20);
if(number == 0)
{
day_level = 1;
level_load("zero.wmb");
wait(1);
set_sky_lighting_suntomoon();
}
if(number == 1)
{
level_load("one.wmb");
wait(1);
set_sky_lighting_inside();
}
wait(3);
camera.arc = 90;
pp_set(camera,mtl_blur);//mtl_hdr
pp_add(mtl_hdr); mtl_blur.skill1 = floatv(0);
}