Sorry your browser is not supported!

// Green Gandalf's Blending Shader v4 EDITED SPECIALLY FOR ROXAS and PS1.4
//
//  [Only supports three terrain textures at the moment
//   - but PS2.0 supports the fourth texture easily. ]
//
// designed for advanced terrain with roads
//
// Created 19 April 2007, edited 24 April 2007.
//
// Blends four terrain textures and also blends these with a road map and texture.
// Uses a single directional light source and ambient lighting.
//
// Uses VS normalisation.

matrix wvp : WorldViewProjection;
matrix mw : World;
matrix winv: WorldInverse;

float4 lightDir   = {0.0, -1.0, 0.0, 1.0};
float4 ambiColor  = {0.2, 0.2, 0.2, 1.0};
float4 lightColor = {1.0, 1.0, 1.0, 1.0};
float2 UVTiling = {4, 4};
float  vertScale = 0.01; // reciprocal of maximum height of terrain
float contrast = 1.0;  // higher values increase the contrast between textures

texture detailMap1   < string ResourceName = ""; >;
texture detailMap2   < string ResourceName = ""; >;
texture detailMap3   < string ResourceName = ""; >;
texture detailMap4   < string ResourceName = ""; >;
texture roadMap      < string ResourceName = ""; >;
texture roadTexture  < string ResourceName = ""; >;
sampler2D detail1 = sampler_state 
{  texture = <detailMap1>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
   AddressU  = Wrap;
   AddressV  = Wrap;
};
sampler2D detail2 = sampler_state 
{  texture = <detailMap2>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
   AddressU  = Wrap;
   AddressV  = Wrap;
};
sampler2D detail3 = sampler_state 
{  texture = <detailMap3>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
   AddressU  = Wrap;
   AddressV  = Wrap;
};
sampler2D detail4 = sampler_state 
{  texture = <detailMap4>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
   AddressU  = Wrap;
   AddressV  = Wrap;
};
sampler2D roadMap1 = sampler_state 
{  texture = <roadMap>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
   AddressU  = Wrap;
   AddressV  = Wrap;
};
sampler2D roadTex = sampler_state 
{  texture = <roadTexture>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
   AddressU  = Wrap;
   AddressV  = Wrap;
};

struct VS_INPUT
{   float4 Pos          : POSITION;
//    float3 Tangent      : TANGENT;
//    float3 Binormal     : BINORMAL;
    float3 Normal       : NORMAL;
    float2 Tex          : TEXCOORD0;
};

struct VS_OUTPUT3
{   float4 Pos          : POSITION;
    float2 TexXY        : TEXCOORD0;
    float2 TexZW        : TEXCOORD1;
    float  Diffuse      : TEXCOORD2;
    float2 BlendXY      : TEXCOORD3;
    float2 BlendZW      : TEXCOORD4;
};

VS_OUTPUT3 GGBlendRoadVShader(VS_INPUT In, VS_OUTPUT3 Out)
{   float4 tempPos = mul(In.Pos, mw);
    Out.Pos = mul(In.Pos, wvp);
    Out.TexXY = In.Tex * UVTiling.xy;
    Out.TexZW = In.Tex;
    Out.Diffuse  = saturate(dot(normalize(In.Normal), -normalize(lightDir.xyz)));
    float2 hn = float2 (tempPos.y * vertScale, In.Normal.y);
    hn = saturate(0.5.xx + contrast * (hn - 0.5.xx));
    Out.BlendXY = float2 (hn.x * hn.y, hn.x * (1 - hn.y));
    Out.BlendZW = float2 ((1 - hn.x) * hn.y, (1 - hn.x) * (1 - hn.y));
    // e.g. blends = grass, rock, sand, gravel
    return Out;
}

struct PS_INPUT3
{   float2 TexXY     : TEXCOORD0;
    float2 TexZW     : TEXCOORD1;
    float  Diffuse   : TEXCOORD2;
    float2 BlendXY   : TEXCOORD3;
    float2 BlendZW   : TEXCOORD4;
};

struct PS_OUTPUT
{  float4 col : COLOR;
};

PS_OUTPUT GGBlendRoadPShader(PS_INPUT3 In, PS_OUTPUT Out)
{  float4 base1 = tex2D(detail1, In.TexXY) * In.BlendXY.x;
   float4 base2 = tex2D(detail2, In.TexXY) * In.BlendXY.y;
   float4 base3 = tex2D(detail3, In.TexXY) * In.BlendZW.x;
//   float4 base4 = tex2D(detail4, In.TexXY) * In.BlendZW.y;
   float4 base  = base1 + base2 + base3;// + base4;
   float  roadPos = tex2D(roadMap1, In.TexZW).x;
   float4 roadTex = tex2D(roadTex, In.TexXY);
   Out.col = lerp(base, roadTex, roadPos) * (ambiColor + In.Diffuse * lightColor);
   return Out;
}

technique t2 // use this for blending plus roads only
{   pass p0
    {  VertexShader = compile vs_1_1 GGBlendRoadVShader();
       PixelShader = compile ps_1_4 GGBlendRoadPShader();
    }
}

ny = .2

ny# = .2

// Green Gandalf's Terrain Shader v2.0
//   blends three images together using a fourth texture
//   to give a detailed terrain
// Created 12 October 2006, modified 18 January 2007.

float4x4 wvp : WorldViewProjection;

float2 repeatScale = {4.0, 4.0};

float Cmapsat = 0.1;

texture lmap <string ResourceName = "lightmap.bmp";>;
sampler2D lmap = sampler_state
{texture = (lmap);
 minfilter = linear;
 magfilter = linear;
 mipfilter = linear;
 addressU  = wrap;
 addressV  = wrap;
};


texture Cmap <string ResourceName = "Cmap.bmp";>;
sampler2D Cmap = sampler_state
{texture = (lmap);
 minfilter = linear;
 magfilter = linear;
 mipfilter = linear;
 addressU  = wrap;
 addressV  = wrap;
};

texture detailMap1 <string ResourceName = "lightmap.bmp";>;
sampler2D lmap = sampler_state
{texture = (lmap);
 minfilter = linear;
 magfilter = linear;
 mipfilter = linear;
 addressU  = wrap;
 addressV  = wrap;
};

texture detailMap1 <string ResourceName = "grass.png";>;
sampler2D detailSample1 = sampler_state
{texture = (detailMap1);
 minfilter = linear;
 magfilter = linear;
 mipfilter = linear;
 addressU  = wrap;
 addressV  = wrap;
};

texture detailMap2 <string ResourceName = "gravel.png";>;
sampler2D detailSample2 = sampler_state
{texture = (detailMap2);
 minfilter = linear;
 magfilter = linear;
 mipfilter = linear;
 addressU  = wrap;
 addressV  = wrap;
};

texture detailMap3 <string ResourceName = "rock.png";>;
sampler2D detailSample3 = sampler_state
{texture = (detailMap3);
 minfilter = linear;
 magfilter = linear;
 mipfilter = linear;
 addressU  = wrap;
 addressV  = wrap;
};

texture rgbaMap <string ResourceName = "rgba.dds";>;
sampler2D rgbaSample = sampler_state
{texture = (rgbaMap);
 minfilter = linear;
 magfilter = linear;
 mipfilter = linear;
 addressU  = wrap;
 addressV  = wrap;
};
struct VS_Input
{ float4 pos    : position;
  float4 UV     : texcoord0;
};
struct VS_Output
{ float4 pos    : position;
  float4 UV     : texcoord0;
};
struct PS_Input
{ float4 UV     : texcoord0;
};
struct PS_Output { float4 colour : color; };

VS_Output V_Shader(VS_Input In, VS_Output Out)
{ Out.pos = mul(In.pos,wvp);
  Out.UV = In.UV;
  return Out;
};

PS_Output P_Shader(PS_Input In, PS_Output Out)
{ float4 rgbaColours = tex2D(rgbaSample, In.UV);
  float4 baseColour = tex2D(detailSample1, repeatScale * In.UV) * rgbaColours.r;
  float4 lmap = tex2D(lmap, In.UV);
  baseColour += tex2D(detailSample2, repeatScale * In.UV)  *rgbaColours.g;
  baseColour += tex2D(detailSample3, repeatScale * In.UV) * rgbaColours.b;
  basecolour = lerp(basecolour,Cmap,Cmapsat);
  basecolour = basecolour * lmap;
  Out.colour = baseColour;
  return Out;
};

technique terrainBlendv3
{
   pass p0
   {  VertexShader = compile vs_1_1 V_Shader();
      PixelShader = compile ps_2_0 P_Shader();
   }

}

Function Make_SkyDome(Obj,Pla,Atm,XDi,ZDi)
 `Obj = Object Number
 `Pla = Planet Radius
 `Atm = Atmosphere Radius
 `XDi = X Divisions
 `ZDi = Y Divisions
 Cld = Pla+((Atm-Pla)/2) ` Cloud Radius
 Size = 2*Sqrt(Atm^2-Pla^2)
 `*note the object will contain three meshes
 `Limb 1 is a Mesh Obj,Size,Size,XDi,ZDi for the Ocean
 `Every Vertex Y position will be 0, sea level
 `Limb 2 is a Mesh Obj,Size,Size,XDi,ZDi for the Cloud
 `Every Vertex Y position will be calculated from equation using cloud radius.
 `Limb 3 is a Mesh Obj,Size,Size,XDi,ZDi for the Atmosphere
 `Every Vertex Y position will be calculated from equation using Atmospheric radius.
EndFunction

`*******************************************************************************
`    Filename : Main.dba                                                       `
`     Version : 1.0a                                                           `
`        Date : June 2007                                                      `
` Description : Procedural Terrain Project                                     `
`       Author: Tintin                                                         `
`                    Copyright © 2007, all rights reserved.                    `
`*******************************************************************************
` Constants.
`*******************************************************************************
#Constant False 0
#Constant True not False
#Constant cBar (128<<24)||(0<<16)||(0<<8)||(255)
#Constant WinTitle "Procedural Terrain Demo v1.0a"
Type tDisp
   hWnd as dWord
   hDC as dWord
   Width as dWord
   Height as dWord
   Depth as dWord
EndType
Global Desktop as tDisp
Type tP3D
   X as float
   Y as float
   Z as float
EndType
Global Cam as tP3D
`*******************************************************************************
` Main Loop.
`*******************************************************************************
If Initialised(800,600,32)
   A$=" Auto Resolution Set To "+Str$(Screen Width())+" x "+Str$(Screen Height())+" x "+Str$(Screen Depth())+" "
   Center text Screen Width()/2,(Screen Height()-Text Height("|"))/4,A$ : FastSync
   Make_Environment()
   Cls : Position Mouse Screen Width()/2, Screen Height()/2
   Do
      `Camera Movement
      If KeyState(17) or UpKey() Then Position Camera Camera Position X()+(Sin(Camera Angle Y())*.0318),Camera Position Y(),Camera Position Z()+(Cos(Camera Angle Y())*.0318) `MF
      If KeyState(31) or DownKey() Then Position Camera Camera Position X()-(Sin(Camera Angle Y())*.0318),Camera Position Y(),Camera Position Z()-(Cos(Camera Angle Y())*.0318) `MB
      If KeyState(30) or LeftKey() Then YRotate Camera WrapValue(Camera Angle Y()-0.5)`TL
      If KeyState(32) or RightKey() Then YRotate Camera WrapValue(Camera Angle Y()+0.5)`TR
      YRotate Camera (WrapValue(MouseMoveX()+Camera Angle Y()))
`     XRotate needs to be limited to +- 90 degrees
      XRotate Camera (WrapValue(MouseMoveY()+Camera Angle X()))
      `Move Matrix
      XM=0 : If (Camera Position X()-Cam.X) >= 4 Then XM=1
      If (Camera Position X()-Cam.X) <= -4 Then XM=-1
      ZM=0 : If (Camera Position Z()-Cam.Z) >= 4 Then ZM=1
      If (Camera Position Z()-Cam.Z) <= -4 Then ZM=-1
      If XM<>0 Then Cam.X = Camera Position X()
      If ZM<>0 Then Cam.Z = Camera Position Z()
      Update_Matrix(XM,ZM)
      `Show Information
      Information()
   Loop
   Clearup()
EndIf
End
`*******************************************************************************
` Initialised() Function.
`*******************************************************************************
Function Initialised(W,H,D)
   Flush Video Memory
   ` Get Current Desktop Resolution
   Load Dll "User32.dll",1
   Load Dll "GDI32.dll",2
   Desktop.hWnd      = Call Dll(1,"GetDesktopWindow")
   Desktop.hDC       = Call Dll(1,"GetDC",0)
   Desktop.Width     = Call Dll(1,"GetSystemMetrics",0)
   Desktop.Height    = Call Dll(1,"GetSystemMetrics",1)
   Desktop.Depth     = Call Dll(2,"GetDeviceCaps",Desktop.hDC,12)
   Call Dll 1,"ReleaseDC",0,Desktop.hDC
   Delete Dll 2
   Delete Dll 1
   `Find nearest supported resolution to requirements
   Empty Checklist : Perform Checklist For Display Modes
   P=(Desktop.Width*Desktop.Height)^2 : Q=0
   For I=1 to Checklist Quantity()
      If ((Checklist Value B(I)*1.0)/(Checklist Value A(I)*1.0)) = ((Desktop.Height*1.0)/(Desktop.Width*1.0)) and Checklist Value C(I) = D
         If ABS((Checklist Value A(I)*Checklist Value B(I))-(W*H))<= P Then P = ABS((Checklist Value A(I)*Checklist Value B(I))-(W*H)): Q=I
      EndIf
   Next
   If Q>0 Then W = Checklist Value A(Q) : H = Checklist Value B(Q)
   ` Check resolution
   If Check Display Mode(W,H,D)
      Set Display Mode W,H,D :  Set Window Off : Set Window Title WinTitle
      Sync Rate 0 : Sync On : FastSync : Color Backdrop RGB(192,192,255)
      Hide Mouse : Position Mouse Screen Width()/2, Screen Height()/2
      AutoCam Off : Position Camera 0,2,0 : Set Camera Aspect ((Screen Width()*1.0)/(Screen Height()*1.0))
      Center Text Screen Width()/2,(Screen Height()-Text Height("|"))/2,"Loading Data..."
      Show Window
      bRet = True
   EndIf
EndFunction bRet
`*******************************************************************************
` Information() Function.
`*******************************************************************************
Function Information()
   Ink RGB(255,255,255),0
   Box 0,0,Screen Width(),Text Height("|"),cBar,cBar,cBar,cBar
   Text 0,0,Str$(Screen FPS())+" FPS "
   Center Text Screen Width()/2,0,WinTitle
   A$=" "+Str$(Statistic(1))+" Polys" : Text Screen Width()-Text Width(A$),0,A$
   A$="By TinTin"
   Text Screen Width()-Text Width(A$),Screen Height()-Text Height(A$),A$
   `
   `Text 0,14," Desktop : "+Str$(Desktop.Width)+" x "+Str$(Desktop.Height)+" x "+Str$(Desktop.Depth)+" @ "+Str$((Desktop.Height*1.0)/(Desktop.Width*1.0),2)+":1 "
   `A$=" Window : "+Str$(Screen Width())+" x "+Str$(Screen Height())+" x "+Str$(Screen Depth())+" @ "+Str$((Screen Height()*1.0)/(Screen Width()*1.0),2)+":1 "
   `Text Screen Width()-Text Width(A$),14,A$
   `
   `If ScanCode()>0 then Text 0,14,Str$(ScanCode())+"   "
   Sync
EndFunction
`*******************************************************************************
` Clearup() Function
`*******************************************************************************
Function Clearup()
   For I=1 to 1000
      If Bitmap Exist(I) Then Delete Bitmap I
      If Image Exist(I) Then Delete Image I
      If Object Exist(I) Then Delete Object I
      If Matrix Exist(I) Then Delete Matrix I
   Next
   Flush Video Memory
EndFunction
`*******************************************************************************
` Make_Environment() Function.
`*******************************************************************************
Function Make_Environment()
   T=Timer()+500
   Create Bitmap 1,128,128
   Set Current Bitmap 1
   Cls RGB(0,64,0)
   For I=1 to 128*128
      Dot Rnd(128),Rnd(128),RGB(Rnd(64),Rnd(64)+32,Rnd(16))
   Next
   Ink RGB(0,32,0),0
   Line 0,0,128,0
   Line 0,0,0,128
   Get Image 1,0,0,128,128
   Cls
   Set Current Bitmap 0
   `
   Make Matrix 1,128,128,32,32 : Position Matrix 1,-64,0,-64
   Prepare Matrix Texture 1,1,1,1 : Update Matrix 1
   `
   Fog On : Fog Distance 64*.66 : Fog Color RGB(192,192,255)
   Set Camera Range .5,64*.66
   Repeat : Until T<Timer()
EndFunction
`*******************************************************************************
` Update_Matrix() Function.
`*******************************************************************************
Function Update_Matrix(XM,ZM)
   IF XM<>0 or ZM<>0
      Set Current Bitmap 1
      Get Image 2,0,0,32,32
      Lock Pixels
      Cls
      Paste Image 2,XM,ZM
      For P=0 to 32
         If XM>0 Then Dot  0, P,RMF( 0, P)
         If XM<0 Then Dot 32, P,RMF(32, P)
         If ZM>0 Then Dot  P, 0,RMF( P, 0)
         If ZM<0 Then Dot  P,32,RMF( P,32)
      Next
      For X=0 to 32
         For Z=0 to 32
            CV = Point(X,Z)
            Set Matrix Height 1,X,Z,RGBR(CV)
         Next
      Next
      Unlock Pixels
      Set Current Bitmap 0
   EndIf
   Position Matrix 1,-64+Cam.X,0,-64+Cam.Z
   Update Matrix 1
EndFunction
`*******************************************************************************
` RMF() Function.
`*******************************************************************************
Function RMF(X,Z)
   `Dummy Function...
   `This will be used to call the RigidMultiFractal function
   `X & Z need to be scaled along with the Cam. position to fit the RigidMultifractal
   dwRet as dWord
   dwRet = RGB(0,0,0)
EndFunction dwRet
`*******************************************************************************
` End
`*******************************************************************************