Sorry your browser is not supported!

Vcount=GET VERTEXDATA VERTEX COUNT()
For Array=0 to Vcount

Vcount=GET VERTEXDATA VERTEX COUNT() - 1
For Array=0 to Vcount

TRANSFORM COORDS VECTOR3 vector, vector, World

tempX# = VerX# + OBJECT POSITION X(ObjectNumber2)
tempY# = VerY# + OBJECT POSITION Y(ObjectNumber2)
tempZ# = VerZ# + OBJECT POSITION Z(ObjectNumber2)

Dist#=Distance#(length, tempX#, tempY#, tempZ#, PickX#, PickY#, PickZ#)

SET DISPLAY MODE DESKTOP WIDTH(), DESKTOP HEIGHT(), 32, 1
sync on : sync rate 60 : sync
`object:
Scale=5
ObjSize=250
Seg=50

LOAD IMAGE "Shaders\Grass.jpg", 4, 1
LOAD IMAGE "Shaders\Grassy Rock.jpg", 3, 1
LOAD IMAGE "Shaders\Ice Cliff.jpg", 2, 1
LOAD IMAGE "Shaders\Snow.jpg", 1, 1

LOAD EFFECT "Shaders\TerrainTexture.fx", 1, 1

`vertex editing (averaging)

For ObX=1 to ObjSize*Scale step ObjSize
  For ObY=1 to ObjSize*Scale step ObjSize
    inc ObjectNumber, 1
    MAKE OBJECT PLAIN ObjectNumber, ObjSize, ObjSize, Seg, Seg, 338
    POSITION OBJECT ObjectNumber, (ObjSize*(Scale/2.0))-(ObX-1)-(ObjSize/2.0), 0, (ObjSize*(Scale/2.0))-(ObY-1)-(ObjSize/2.0)
    SET OBJECT EFFECT ObjectNumber, 1
    TEXTURE OBJECT ObjectNumber, 0, 1
    TEXTURE OBJECT ObjectNumber, 1, 2
    TEXTURE OBJECT ObjectNumber, 2, 3
    TEXTURE OBJECT ObjectNumber, 3, 4
    SET OBJECT WIREFRAME ObjectNumber, 0
  next ObY
next ObX

LOCK VERTEXDATA FOR LIMB 1, 0
  Vcount=GET VERTEXDATA VERTEX COUNT()-1
  Dim PickX(Vcount)
  Dim PickZ(Vcount)
  Dim PickXB(Vcount)
  Dim PickZB(Vcount)
UNLOCK VERTEXDATA

dim objNums(8) ` this stores the object IDs for the 9 objects around and including the pick object

COLOR BACKDROP 0, RGB(87,192,255)
set camera range 0,1, 1250000.0

`Make a 3d cursor
righttop=FIND FREE OBJECT()
MouseRTop=righttop
MAKE OBJECT plain MouseRTop, 5,5

lefttop=FIND FREE OBJECT()
MouseLTop=lefttop
MAKE OBJECT plain MouseLTop, 5,5

RightBottom=FIND FREE OBJECT()
MouseRBottom=RightBottom
MAKE OBJECT plain MouseRBottom, 5,5

LeftBottom=FIND FREE OBJECT()
MouseLBottom=LeftBottom
MAKE OBJECT plain MouseLBottom, 5,5

CenterTop=FIND FREE OBJECT()
MouseCT=CenterTop
MAKE OBJECT plain MouseCT, 5,5

CenterBottom=FIND FREE OBJECT()
MouseCB=CenterBottom
MAKE OBJECT plain MouseCB, 5,5

Center=FIND FREE OBJECT()
MouseC=Center
MAKE OBJECT plain MouseC, 4,4
SET TEXT FONT "Arial"
SET TEXT SIZE 16

autocam off
Cdist#=(ObjSize*scale)/2

vector=1
length=2
Wld=MAKE VECTOR3(vector)
lgth=MAKE VECTOR3(length)

do
ObjectNumber2=PICK OBJECT(MouseX(), MouseY(),1,ObjectNumber)
PickD#=GET PICK DISTANCE()
PickX#=GET PICK VECTOR X()+CAMERA POSITION x(0)
PickY#=GET PICK VECTOR Y()+CAMERA POSITION y(0)
PickZ#=GET PICK VECTOR Z()+CAMERA POSITION Z(0)
`set the cursor's lines
POSITION OBJECT MouseRTop, PickX#-5, PickY#, PickZ#
MRX=int(OBJECT SCREEN X(MouseRTop))
MRY= int(OBJECT SCREEN Y(MouseRTop))
POSITION OBJECT MouseLTop, PickX#+5, PickY#, PickZ#
MLX=int(OBJECT SCREEN X(MouseLTop))
MLY=int(OBJECT SCREEN Y(MouseLTop))
POSITION OBJECT MouseRBottom, PickX#, PickY#, PickZ#-5
MRBX=int(OBJECT SCREEN X(MouseRBottom))
MRBY= int(OBJECT SCREEN Y(MouseRBottom))
POSITION OBJECT MouseLBottom, PickX#, PickY#, PickZ#+5
MLBX=int(OBJECT SCREEN X(MouseLBottom))
MLBY=int(OBJECT SCREEN Y(MouseLBottom))
POSITION OBJECT MouseCB, PickX#, PickY#-10, PickZ#
MCBX=int(OBJECT SCREEN X(MouseCB))
MCBY=int(OBJECT SCREEN Y(MouseCB))
POSITION OBJECT MouseCT, PickX#, PickY#+10, PickZ#
MCTX=int(OBJECT SCREEN X(MouseCT))
MCTY=int(OBJECT SCREEN Y(MouseCT))
POSITION OBJECT MouseC, PickX#, PickY#, PickZ#
MCX=int(OBJECT SCREEN X(MouseC))
MCY=int(OBJECT SCREEN Y(MouseC))
SET TEXT TO BOLD
ink RGB(128,128,128),RGB(0,0,0)
Text MouseX()+10, MouseY()+25, "Pick X: "+Str$(PickX#)+", Pick Y: "+Str$(PickY#)+", Pick Z: "+Str$(PickZ#)
Text 10, 10, "Selected Object: "+Str$(ObjectNumber2) +"  Vcount = "+str$(Vcount)+"  FPS = "+str$(screen fps())
SET TEXT TO NORMAL


ink RGB(0, 128, 255), RGB(0,0,0,0)
FILL CIRCLE MCX, MCY, 10, RGB(96,255,20,0)
Line MRX, MRY, MLX, MLY
Line MRBX, MRBY, MLBX, MLBY
Line MCBX, MCBY, MCTX, MCTY
CamX#=NewXValue(0, CAng#, CDist#)
CamZ#=NewZValue(0, CAng#, CDist#)
inc CAng#, 0.0
Position camera 0,CamX#,CDist#,CamZ#
CAng#=Wrapvalue(CAng#)
POINT CAMERA 0,0,0,0


Newmousez = MousemoveZ()
If oldmousez <> newmousez
  If oldmousez < newmousez
    mousezz=-(CDist#/5)
  else
    mousezz=(CDist#/5)
  endif
  Oldmousez = newmousez
  CDist#=CDist#+MouseZz
  Position camera 0,CamX#,CDist#,CamZ#
  POINT CAMERA 0,0,0,0
  Mousezz=0
endif

If mouseclick()=2 and shiftkey()=0
Newang#=MousemoveX()
If oldang# <> NEWANG#
   If Oldang# < Newang# then Mousexx#=10
   If oldang# > Newang# then Mousexx#=-10
   Oldang#=MousemoveX()
Cang#=Cang#+Mousexx#
Position camera 0,CamX#,CDist#,CamZ#
POINT CAMERA 0,0,0,0
else
MouseXX#=0
endif
endif

If MouseClick()=1

  If ObjectNumber2>0
    `now we determine the objects around the pick object and update their positions in the same way
    ` these formulae are not correct on the edges
    objNums(0) = ObjectNumber2
    objNums(1) = ObjectNumber2 + 1
    objNums(2) = ObjectNumber2 - 1
    objNums(3) = ObjectNumber2 + scale
    objNums(4) = ObjectNumber2 + scale + 1
    objNums(5) = ObjectNumber2 + Scale - 1
    objNums(6) = ObjectNumber2 - Scale
    objNums(7) = ObjectNumber2 - Scale + 1
    objNums(8) = ObjectNumber2 - Scale - 1

    PickX#=GET PICK VECTOR X()+CAMERA POSITION x(0)
    PickY#=GET PICK VECTOR Y()+CAMERA POSITION y(0)
    PickZ#=GET PICK VECTOR Z()+CAMERA POSITION Z(0)
    
    ` now make the changes for all 9 objects if necessary
    for obj = 0 to 8
      if objNums(obj) > 0 and objNums(obj) <= ObjectNumber
      LOCK VERTEXDATA FOR LIMB objNums(obj), 0
        For Array=0 to Vcount
          VerX#=GET VERTEXDATA POSITION X(Array)
          VerY#=GET VERTEXDATA POSITION Y(Array)
          VerZ#=GET VERTEXDATA POSITION Z(Array)


          `calculate the correct vertices on the object to check against the others
          tempX# = VerX# + OBJECT POSITION X(objNums(obj))
          tempY# = VerY# + OBJECT POSITION Y(objNums(obj))
          tempZ# = VerZ# + OBJECT POSITION Z(objNums(obj))

          Dist#=Distance#(length, TempX#, TempY#, TempZ#, PickX#, PickY#, PickZ#)

          if dist# < 3.0
            incAmount# = 1.0
          else
          if dist# < 6.0
            incAmount# =  3.0
          else
          if dist# < 12.0
            incAmount# =  6.0
          else
          if dist# < 17.5
            incAmount# =  10.0
          else
          if dist# < 35.0
            incAmount# =  15.0
          else
            incAmount# = 0.0
          endif
          endif
          endif
          endif
          endif

         if incAmount# > 0.0 then SET VERTEXDATA POSITION Array, VerX#, VerY# + incAmount#, VerZ#
       NEXT ARRAY
     UNLOCK VERTEXDATA
     endif
   next obj
 endif
 endif
text 10,25, "Top Object= "+Str$(Otop)
PickX#=int(PickX#)/(Seg/scale)*(Seg/scale)
PickY#=int(PickY#)/(Seg/scale)*(Seg/scale)
PickZ#=int(PickZ#)/(Seg/scale)*(Seg/scale)

sync
loop

end

Function Distance#(VecNum, x1#, y1#, z1#, x2#,  y2#, z2#)
set vector3 VecNum, x2# - x1#, y2# - y1#, z2# - z1#
dist# = length vector3(VecNum)
EndFunction dist#

// Based on Green Gandalf's B. N. M. Shader
//1) technique, normal mapping and self shadowing included - uses the overall height of an object and four textures.
//2) additions are by Daryn Alsup.
//3) Fog based on various methods
matrix wvp : WorldViewProjection;
matrix w : World;
matrix wi: WorldInverse;
vector EyePosition : EyePosition;

float UVTilingX <
string UIWidget = "slider";
	float UIMax = 50.0;
	float UIMin = 1.0;
	float UIStep = 1.0;
> = 50.0;
float UVTilingY <
string UIWidget = "slider";
	float UIMax = 50.0;
	float UIMin = 1.0;
	float UIStep = 1;
> = 50.0;

float  Height1 <
string UIWidget = "slider";
	float UIMax = 0.50;
	float UIMin = 0.01;
	float UIStep = 0.01;
> = 0.5; // reciprocal of maximum height of terrain
float  Height2 <
string UIWidget = "slider";
	float UIMax = 0.50;
	float UIMin = 0.01;
	float UIStep = 0.01;
> = 0.24; // reciprocal of maximum height of terrain
float  Height3 <
string UIWidget = "slider";
	float UIMax = 0.50;
	float UIMin = 0.01;
	float UIStep = 0.01;
> = 0.19; // reciprocal of maximum height of terrain
float  Height4 <
string UIWidget = "slider";
	float UIMax = 0.50;
	float UIMin = 0.01;
	float UIStep = 0.01;
> = 0.01; // reciprocal of maximum height of terrain
float lightposX<
string UIWidget = "slider";
	float UIMax = 5.0;
	float UIMin = 0.05;
	float UIStep = 0.05;
> = 0.35;
float lightposY<
string UIWidget = "slider";
	float UIMax = 10.0;
	float UIMin = 0.05;
	float UIStep = 0.05;
> = 0.05;
float lightposZ<
string UIWidget = "slider";
	float UIMax = 5.0;
	float UIMin = 0.05;
	float UIStep = 0.05;
> = 3.25;
float brightness <
string UIWidget = "slider";
	float UIMax = 10.0;
	float UIMin = 0.5;
	float UIStep = 0.05;
> = 3.0;
float contrast <
string UIWidget = "slider";
	float UIMax = 15.0;
	float UIMin = 0.0;
	float UIStep = 0.01;
> = 4.0;  // higher values increase the contrast between textures
float Gscale <
string UIWidget = "slider";
	float UIMax = 100.0;
	float UIMin = 0.0;
	float UIStep = 1.0;
> = 50.0;  // higher values increase the contrast between textures
float GOpacity <
string UIWidget = "slider";
	float UIMax = 2.0;
	float UIMin = 0.0;
	float UIStep = 0.01;
> = 0.0;  // higher values increase the contrast between textures
float FogRed <
string UIWidget = "slider";
	float UIMax = 1.0;
	float UIMin = 0.0;
	float UIStep = 0.01;
> = 0.45;
float FogGreen <
string UIWidget = "slider";
	float UIMax = 1.0;
	float UIMin = 0.0;
	float UIStep = 0.01;
> = 0.75;
float FogBlue <
string UIWidget = "slider";
	float UIMax = 1.0;
	float UIMin = 0.0;
	float UIStep = 0.01;
> = 1.0;
float fogHeight <
string UIWidget = "slider";
	float UIMax = 100.0;
	float UIMin = -100.0;
	float UIStep = 0.01;
> = 10.0;
float fogDensity <
string UIWidget = "slider";
	float UIMax = 100.0;
	float UIMin = 0.0;
	float UIStep = 0.01;
> = 100.0;
float fogClearing <
string UIWidget = "slider";
	float UIMax = 100.0;
	float UIMin = 0.0;
	float UIStep = 0.01;
> = 75.0;
float fogMode <
string UIWidget = "slider";
	int UIMax = 1;
	int UIMin = 0;
	int UIStep = 1;
> = 0;

texture detailMap1 < string ResourceName = ""; >;
texture detailMap2 < string ResourceName = ""; >;
texture detailMap3 < string ResourceName = ""; >;
texture detailMap4 < string ResourceName = ""; >;
texture grid < string ResourceName = ""; >;
sampler2D d1 = sampler_state 
{  texture = <detailMap1>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};
sampler2D d2 = sampler_state 
{  texture = <detailMap2>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};
sampler2D d3 = sampler_state 
{  texture = <detailMap3>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};
sampler2D d4 = sampler_state 
{  texture = <detailMap4>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};
sampler2D GridMap = sampler_state 
{  texture = <grid>;
   MinFilter = Linear;
   MagFilter = Linear;
   MipFilter = Linear;
};

struct app_in
{
float4 pos : POSITION;
float4 normal : NORMAL;
float2 uv : TEXCOORD;
//float Fog : FOG;
};

struct vs_out
{
float4 pos : POSITION;
float4 normal : TEXCOORD0;
float2 uv : TEXCOORD1;
float4 wpos : TEXCOORD2;
float4 Blender : TEXCOORD3;
float Fog : FOG;
};

vs_out TerrainVS(app_in IN)
{
vs_out OUT;
float4 tempPos = mul(IN.pos, w);
Height1=Height1*0.01;
Height2=Height2*0.01;
Height3=Height3*0.01;
Height4=Height4*0.01;
OUT.pos=mul(IN.pos, wvp);
OUT.uv.x=IN.uv.x*UVTilingX;
OUT.uv.y=IN.uv.y*UVTilingY;
OUT.wpos=mul(IN.pos, w);
float2 d1h = float2 (OUT.wpos.y * Height1-0.65, IN.normal.y);
float2 d2h = float2 (OUT.wpos.y * Height2-0.39, IN.normal.y);
float2 d3h = float2 (OUT.wpos.y * Height3-0.32, IN.normal.y);
float2 d4h = float2 (OUT.wpos.y * Height4-0.0, IN.normal.y);
d1h = saturate(0.8 + contrast * (d1h + 0.0));
d2h = saturate(0.7 + contrast * (d2h + 0.07));
d3h = saturate(0.5 + contrast * (d3h + 0.2));
d4h = saturate(0.2 + contrast * (d4h + 0.4));
OUT.Blender = float4( (d1h.x)*(d1h.y), (d2h.x)*(d2h.y), (d3h.x)*(d3h.y), (0.01+d4h.x) * (d4h.y) );
OUT.normal=mul(IN.normal, w);
OUT.Fog = 1.0f - ((fogHeight - tempPos.y) / (fogDensity));
	if (fogMode == 0.0)
	{
		OUT.Fog = 1.0f - ((fogHeight - tempPos.y) / (fogDensity));
	}
	if (fogMode == 1.0)
	{
		OUT.Fog = ((fogHeight - tempPos.y) / (fogDensity))-1.0f; 
	}
      if (OUT.Fog < 1.0)
	{		
		OUT.Fog = OUT.Fog + (fogClearing / length(IN.pos - EyePosition)) ; 	
	} 
return OUT;
}

float4 TerrainPS(vs_out IN) : COLOR
{
float2 Tiling={UVTilingX, UVTilingY};
float3 lightpos={lightposX, lightposY, lightposZ};
   float4 base1 = tex2D(d1, IN.uv*5) * IN.Blender.x/Height1;
   base1=base1*25;
   float4 base2 = tex2D(d2, IN.uv.xy/((Tiling.x/5))) * IN.Blender.y/(Height2);
   base2=base2*7.5;
   float4 base3 = tex2D(d3, IN.uv.xy/((Tiling.x/15))) * IN.Blender.z;
   base3=base3*2;
   float4 base4 = tex2D(d4, IN.uv) * IN.Blender.w;
   float diffuse1 = saturate(tex2D(d1, IN.uv).xyz - 1.0);
   float diffuse2 = saturate(tex2D(d2, IN.uv).xyz - 1.5);
   float diffuse3 = saturate(tex2D(d3, IN.uv).xyz - 2.0);
   float diffuse4 = saturate(tex2D(d4, IN.uv).xyz - 2.5);
   float4 base  = base1 + base2 + base3 + base4;
   float4 detail1=(tex2D(d1, IN.uv)*tex2D(d2, IN.uv)*tex2D(d3, IN.uv)*tex2D(d4, IN.uv))*brightness;
   brightness=brightness*100000;
   float4 bmapped=detail1+brightness;
   bmapped=bmapped*10;
   float4 diffuse  = base + diffuse1;
   diffuse  += base + diffuse2;
   diffuse  += base + diffuse3;
   diffuse  += base + diffuse4;
   float4 ComboColor=(normalize(diffuse*bmapped));
   float4 Shadow=tex2D(d1, normalize(lightpos)*IN.normal.y);
   brightness=saturate(brightness);
   ComboColor=saturate(ComboColor)*brightness/Shadow;
   //GOpacity=saturate(GOpacity);
   Gscale=Gscale*0.01;
   float4 GridDetail=tex2D(GridMap, IN.uv*Gscale );
 GridDetail=GridDetail*GOpacity;
float4 OutputColor=ComboColor+GridDetail;
return OutputColor;
}

technique Terrain3_0
{
	pass p0
	{	FOGENABLE = (3);	 	
	FOGVERTEXMODE = LINEAR;
	FOGCOLOR = (float4(FogRed, FogGreen, FogBlue, 1.0f));
	VertexShader= compile vs_2_0 TerrainVS();
	PixelShader= compile ps_2_0 TerrainPS();
	}
}

OUT.Fog = 1.0f - ((fogHeight - tempPos.y) / (fogDensity));
	if (fogMode == 0.0)
	{
		OUT.Fog = 1.0f - ((fogHeight - tempPos.y) / (fogDensity));
	}
	if (fogMode == 1.0)
	{
		OUT.Fog = ((fogHeight - tempPos.y) / (fogDensity))-1.0f; 
	}
      if (OUT.Fog < 1.0)
	{		
		OUT.Fog = OUT.Fog + (fogClearing / length(IN.pos - EyePosition)) ; 	
	} 

SET DISPLAY MODE DESKTOP WIDTH(), DESKTOP HEIGHT(), 32, 1
autocam off
sync on : sync rate 0 : sync

`Color for fog and bg
BGColor as DWord
LightColor As Dword
BGColor=RGB(50+sin(Timer()/1000)*43,100+(sin(Timer()/1000)*96),130+Sin(Timer()/1000)*125)
LightColor=RGB(252,239,211)
COLOR LIGHT 0, LightColor
`rotation and randomizer
Randomize Timer()

`object:
Scale=20
ObjSize=100
Seg=50

LOAD IMAGE "Shaders\Grass.jpg", 4, 1
LOAD IMAGE "Shaders\Grassy Rock.jpg", 3, 1
LOAD IMAGE "Shaders\Ice Cliff.jpg", 2, 1
LOAD IMAGE "Shaders\Snow.jpg", 1, 1
LOAD IMAGE "Shaders\Grid2.bmp", 5, 1
COLOR BACKDROP 0, BGColor
set camera range 0,1, 1250000.0
LOAD EFFECT "Shaders\TerrainTexture.fx", 1, 1

`vertex editing (averaging)
For ObX=1 to ObjSize*Scale step ObjSize
  For ObY=1 to ObjSize*Scale step ObjSize
    inc ObjectNumber, 1
    MAKE OBJECT PLAIN ObjectNumber, ObjSize, ObjSize, Seg, Seg
    POSITION OBJECT ObjectNumber, (ObjSize*(Scale/2.0))-(ObX-1)-(ObjSize/2.0), 0, (ObjSize*(Scale/2.0))-(ObY-1)-(ObjSize/2.0)
    SET OBJECT EFFECT ObjectNumber, 1
    TEXTURE OBJECT ObjectNumber, 0, 1
    TEXTURE OBJECT ObjectNumber, 1, 2
    TEXTURE OBJECT ObjectNumber, 2, 3
    TEXTURE OBJECT ObjectNumber, 3, 4
    TEXTURE OBJECT ObjectNumber, 4, 5
    SET OBJECT NORMALS ObjectNumber
  next ObY
next ObX

LOCK VERTEXDATA FOR LIMB 1, 0
  Vcount=GET VERTEXDATA VERTEX COUNT()-1
  Dim PickX(Vcount)
  Dim PickZ(Vcount)
  Dim PickXB(Vcount)
  Dim PickZB(Vcount)
UNLOCK VERTEXDATA
dim objNums(8) ` this stores the object IDs for the 9 objects around and including the pick object

`Make a 3d cursor
righttop=FIND FREE OBJECT()
MouseRTop=righttop
MAKE OBJECT plain MouseRTop, 5,5

lefttop=FIND FREE OBJECT()
MouseLTop=lefttop
MAKE OBJECT plain MouseLTop, 5,5

RightBottom=FIND FREE OBJECT()
MouseRBottom=RightBottom
MAKE OBJECT plain MouseRBottom, 5,5

LeftBottom=FIND FREE OBJECT()
MouseLBottom=LeftBottom
MAKE OBJECT plain MouseLBottom, 5,5

CenterTop=FIND FREE OBJECT()
MouseCT=CenterTop
MAKE OBJECT plain MouseCT, 5,5

CenterBottom=FIND FREE OBJECT()
MouseCB=CenterBottom
MAKE OBJECT plain MouseCB, 5,5

Center=FIND FREE OBJECT()
MouseC=Center
MAKE OBJECT plain MouseC, 4,4
SET TEXT FONT "Arial"
SET TEXT SIZE 16

`Hide the cursor objects
Hide object MouseC
HIDE OBJECT MouseCB
HIDE OBJECT MouseCT
Hide object MouseLBottom
Hide object MouseRBottom
Hide object MouseLTop
Hide object MouseRTop

Cdist#=(ObjSize)

vector=1
length=2
Cam=3
Light=4
Wld=MAKE VECTOR3(vector)
lgth=MAKE VECTOR3(length)
Camera=MAKE VECTOR4(cam)
lite=MAKE VECTOR4(light)
r=make vector3(5)
r=make vector3(6)
r=make vector3(7)
r=make vector3(8)
r=make vector3(9)
r=make vector3(10)
R=MAKE MATRIX4(11)


`Pre-edited effect values
Density#=100.0
FHeight#=10.0
Clearing#=75.0

do
World MATRIX4 11
POSITION LIGHT 0, 1000, 1000, 0
`night and day
BGColor=RGB(50+sin(Timer()/1000)*43,100+(sin(Timer()/1000)*96),130+Sin(Timer()/1000)*125)
COLOR BACKDROP 0, BGColor
SET AMBIENT LIGHT 50+(sin(Timer()/1000)*20)
SET EFFECT CONSTANT FLOAT 1, "FogRed", RGBR(BGColor)
SET EFFECT CONSTANT FLOAT 1, "FogGreen", RGBG(BGColor)
SET EFFECT CONSTANT FLOAT 1, "FogBlue", RGBB(BGColor)
SET VECTOR4 Light, light POSITION X(0), light POSITION Y(0), light POSITION Z(0), 0
SET VECTOR3 6, light POSITION X(0), light POSITION Y(0), light POSITION Z(0)
SET EFFECT CONSTANT vector 1, "lightpos", light

`create a shortcut for showing the grid and assoc. values (via shader) ALSO set the view area
if keystate(34)=1 and ControlKEY()=0
SET EFFECT CONSTANT FLOAT 1, "GOpacity", 0.2
endif

if keystate(34)=1 and ControlKey()=1
SET EFFECT CONSTANT FLOAT 1, "GOpacity", 0.0
endif

If Keystate(32)=1 and ControlKEY()=0
Inc Density#, 3.0
SET EFFECT CONSTANT FLOAT 1, "fogDensity", Density#
endif

If Keystate(32)=1 and ControlKey()=1
dec Density#, 3.0
SET EFFECT CONSTANT FLOAT 1, "fogDensity", Density#
endif

If Keystate(35)=1 and ControlKEY()=0
Inc FHeight#, 3.0
SET EFFECT CONSTANT FLOAT 1, "fogHeight", FHeight#
endif

If Keystate(35)=1 and ControlKey()=1
Dec FHeight#, 3.0
SET EFFECT CONSTANT FLOAT 1, "fogHeight", FHeight#
endif

If Keystate(46)=1 and ControlKEY()=0
Inc Clearing#, 3.0
SET EFFECT CONSTANT FLOAT 1, "fogClearing", Clearing#
endif

If Keystate(46)=1 and ControlKey()=1
Dec Clearing#, 3.0
SET EFFECT CONSTANT FLOAT 1, "fogClearing", Clearing#
endif

`Calculate cam dist from object
For A=1 to ObjectNumber
CamToOb#=Distance#(length, Camera Position X(0), Camera Position Y(0), Camera Position Z(0), OBJECT POSITION X(A), Object Position Y(A), Object Position Z(A))
If CamToOb#>ObjSize*(2) or OBJECT IN SCREEN(A)=0
HIDE OBJECT A
endif
If CamToOb#<ObjSize*(2) then SHOW OBJECT A
Next A


ObjectNumber2=PICK OBJECT(MouseX(), MouseY(),1,ObjectNumber)
PickD#=GET PICK DISTANCE()
PickX#=GET PICK VECTOR X()+CAMERA POSITION x(0)
PickY#=GET PICK VECTOR Y()+CAMERA POSITION y(0)
PickZ#=GET PICK VECTOR Z()+CAMERA POSITION Z(0)
`set the cursor's lines
POSITION OBJECT MouseRTop, PickX#-5, PickY#, PickZ#
MRX=int(OBJECT SCREEN X(MouseRTop))
MRY= int(OBJECT SCREEN Y(MouseRTop))
POSITION OBJECT MouseLTop, PickX#+5, PickY#, PickZ#
MLX=int(OBJECT SCREEN X(MouseLTop))
MLY=int(OBJECT SCREEN Y(MouseLTop))
POSITION OBJECT MouseRBottom, PickX#, PickY#, PickZ#-5
MRBX=int(OBJECT SCREEN X(MouseRBottom))
MRBY= int(OBJECT SCREEN Y(MouseRBottom))
POSITION OBJECT MouseLBottom, PickX#, PickY#, PickZ#+5
MLBX=int(OBJECT SCREEN X(MouseLBottom))
MLBY=int(OBJECT SCREEN Y(MouseLBottom))
POSITION OBJECT MouseCB, PickX#, PickY#-10, PickZ#
MCBX=int(OBJECT SCREEN X(MouseCB))
MCBY=int(OBJECT SCREEN Y(MouseCB))
POSITION OBJECT MouseCT, PickX#, PickY#+10, PickZ#
MCTX=int(OBJECT SCREEN X(MouseCT))
MCTY=int(OBJECT SCREEN Y(MouseCT))
POSITION OBJECT MouseC, PickX#, PickY#, PickZ#
MCX=int(OBJECT SCREEN X(MouseC))
MCY=int(OBJECT SCREEN Y(MouseC))

ink RGB(255,255,255),RGB(0,0,0)
Text 10, 10, "Total Objects: "+Str$(ObjectNumber)+"  Selected Object: "+Str$(ObjectNumber2) +"  Vcount = "+str$(Vcount)+"  FPS = "+str$(screen fps())
text 10, 25, "Wait Left: "+Str$(Waiting)
Text 10, 40, "Fog Density: "+Str$(Density#)+"  Press D to increase (unthinken) and Ctrl+D to decrease"
Text 10, 55, "Fog Height: "+Str$(FHeight#)+"  Press H to increase and Ctrl+H to decrease"
Text 10, 70, "Fog Clearing: "+Str$(Clearing#)+"  Press C to increase and Ctrl+C to decrease"
Text 10, 85, "To show grid press G. To hide press Ctrl+G."


ink RGB(0, 128, 255), RGB(0,0,0,0)
FILL CIRCLE MCX, MCY, 10, RGB(96,255,20,0)
Line MRX, MRY, MLX, MLY
Line MRBX, MRBY, MLBX, MLBY
Line MCBX, MCBY, MCTX, MCTY
CamX#=NewXValue(0, CAng#, CDist#)
CamZ#=NewZValue(0, CAng#, CDist#)
inc CAng#, 0.0
Position camera 0,CamX#,CDist#,CamZ#
CAng#=Wrapvalue(CAng#)
POINT CAMERA 0,0,0+yLocation#,0
`POSITION OBJECT FogObj, CAMERA POSITION X(0), CAMERA POSITION Y(0), CAMERA POSITION Z(0)

Newmousez = MousemoveZ()
If oldmousez <> newmousez
If oldmousez < newmousez
mousezz=-(CDist#/5)
Ylocation#=Ylocation#+0.75
If Ylocation#>100 then Ylocation#=100
endif

If oldmousez > newmousez
mousezz=(CDist#/5)
Ylocation#=Ylocation#-0.75
If Ylocation#<0 then Ylocation#=0
endif

Oldmousez =Mousemovez()
CDist#=CDist#+MouseZz
Position camera 0,CamX#,CDist#,CamZ#
POINT CAMERA 0, 0, 0+yLocation#, 0

Mousezz=0
endif

If mouseclick()=2
Newang#=MousemoveX()
If oldang# <> NEWANG#
   If Oldang# < Newang# then Mousexx#=10
   If oldang# > Newang# then Mousexx#=-10
   Oldang#=MousemoveX()
Cang#=Cang#+Mousexx#
Position camera 0,CamX#,CDist#,CamZ#
POINT CAMERA 0,0,0+yLocation#,0
else
MouseXX#=0
endif
endif

If MouseClick()=1
`general multiplier for terraforming
  If ObjectNumber2>0
    `now we determine the objects around the pick object and update their positions in the same way
    ` these formulae are not correct on the edges
    objNums(0) = ObjectNumber2
    objNums(1) = ObjectNumber2 + 1
    objNums(2) = ObjectNumber2 - 1
    objNums(3) = ObjectNumber2 + scale
    objNums(4) = ObjectNumber2 + scale + 1
    objNums(5) = ObjectNumber2 + Scale - 1
    objNums(6) = ObjectNumber2 - Scale
    objNums(7) = ObjectNumber2 - Scale + 1
    objNums(8) = ObjectNumber2 - Scale - 1

    PickX#=GET PICK VECTOR X()+CAMERA POSITION x(0)
    PickY#=GET PICK VECTOR Y()+CAMERA POSITION y(0)
    PickZ#=GET PICK VECTOR Z()+CAMERA POSITION Z(0)
    PickX#=int(PickX#)/(Seg/scale)*(Seg/scale)
PickY#=int(PickY#)/(Seg/scale)*(Seg/scale)
PickZ#=int(PickZ#)/(Seg/scale)*(Seg/scale)
    
    ` now make the changes for all 9 objects if necessary
    for obj = 0 to 8
      if objNums(obj) > 0 and objNums(obj) <= ObjectNumber
      reCalculateNormals = 0
      LOCK VERTEXDATA FOR LIMB objNums(obj), 0
        For Array=0 to Vcount
          VerX#=GET VERTEXDATA POSITION X(Array)
          VerY#=GET VERTEXDATA POSITION Y(Array)
          VerZ#=GET VERTEXDATA POSITION Z(Array)
			
          `calculate the correct vertices on the object to check against the others
          tempX# = VerX# + OBJECT POSITION X(objNums(obj))
          tempY# = VerY# + OBJECT POSITION Y(objNums(obj))
          tempZ# = VerZ# + OBJECT POSITION Z(objNums(obj))
          
          `SET VECTOR3 5, VerX#, VerY#, VerZ#





`NORMALIZE VECTOR3 5, 5
`Lighting#=DOT PRODUCT VECTOR3(5,6)
`SET VECTOR3 5, Lighting#, Lighting#, Lighting#
`CROSS PRODUCT VECTOR3 5, 5, 6
`TRANSFORM NORMALS VECTOR3 5, 5, 11
`NORMALIZE VECTOR3 5, 5

`SET VERTEXDATA NORMALS Array, sin(X VECTOR3(5)), cos(Y VECTOR3(5)), sin(Z VECTOR3(5))
`SET VERTEXDATA NORMALS Array, Lighting#, Lighting#, Lighting#

          Dist#=Distance#(length, TempX#, TempY#, TempZ#, PickX#, PickY#, PickZ#)
If ShiftKey()=1
Multiplier#=10000.0
endif
If Shiftkey()=0
Multiplier#=1.0
endif
          if dist# < (35.0*Multiplier#)
            incAmount# = 0.25
          endif
          if dist# < (30.0*Multiplier#)
            incAmount# =  0.5
          endif
          if dist# < (25.0*Multiplier#)
            incAmount# =  0.75
          endif
          if dist# < (20.0*Multiplier#)
            incAmount# =  1.0
          endif
          if dist# < (15.0*Multiplier#)
            incAmount# =  1.25
          endif
          if dist# < (10.0*Multiplier#)
            incAmount# =  1.5
          endif
          if dist# < (5.0*Multiplier#)
            incAmount# =  1.75
          endif
          If Dist#>35.0 or Dist#<0.2
            incAmount# = 0.0
          endif

         if incAmount# > 0.0 then SET VERTEXDATA POSITION Array, VerX#, VerY# + incAmount#, VerZ# : reCalculateNormals = 1
       NEXT ARRAY
       
       `for the normals
       remstart
For normal=0 to Vcount step 3
          VerX#=GET VERTEXDATA POSITION X(normal)
          VerY#=GET VERTEXDATA POSITION Y(normal)
          VerZ#=GET VERTEXDATA POSITION Z(normal)
          Ver1X#=GET VERTEXDATA POSITION X(normal+1)
          Ver1Y#=GET VERTEXDATA POSITION Y(normal+1)
          Ver1Z#=GET VERTEXDATA POSITION Z(normal+1)
          Ver2X#=GET VERTEXDATA POSITION X(normal+2)
          Ver2Y#=GET VERTEXDATA POSITION Y(normal+2)
          Ver2Z#=GET VERTEXDATA POSITION Z(normal+2)          

set vector3 5,VerX#, VerY#, VerZ#
set vector3 6,Ver1X#, Ver1Y#, Ver1Z#
set vector3 7,Ver2X#, Ver2Y#, Ver2Z#
subtract vector3 9,5,6
subtract vector3 10,5,7
cross product vector3 8,10,9
`SET VECTOR3 8, Float#,Float#,Float#
NORMALIZE VECTOR3 8,8

set vertexdata normals normal, X vector3(8), Y vector3(8), Z Vector3(8)

next normal
remend
     UNLOCK VERTEXDATA
     if reCalculateNormals = 1 thenSET OBJECT NORMALS objNums(obj)
     endif
   next obj
 endif
 endif

`make an idle rotation
If mouseclick()=0 and MouseMoveX()=0 and MouseMoveY()=0 and mousemoveZ()=0 and scancode()=0
Waiting=Waiting+250
If Waiting=11000
`whether the cam will rotate left or right
RotationRandom=Rnd(1)

repeat
`right/left
If RotationRandom=0
CAng#=Cang#-0.125
endif

If RotationRandom=1
CAng#=Cang#+0.125
endif

`positioning the cam idlely
Cang#=Wrapvalue(CAng#)
CamX#=NewXValue(0, CAng#, CDist#)
CamZ#=NewZValue(0, CAng#, CDist#)
Position camera 0,CamX#,CDist#,CamZ#
POINT CAMERA 0,0,0+yLocation#,0
BGColor=RGB(50+sin(Timer()/1000)*43,100+(sin(Timer()/1000)*96),130+Sin(Timer()/1000)*125)
COLOR BACKDROP 0, BGColor
SET AMBIENT LIGHT 50+(sin(Timer()/1000)*20)
SET EFFECT CONSTANT FLOAT 1, "FogRed", RGBR(BGColor)
SET EFFECT CONSTANT FLOAT 1, "FogGreen", RGBG(BGColor)
SET EFFECT CONSTANT FLOAT 1, "FogBlue", RGBB(BGColor)

ink RGB(255,255,255),RGB(0,0,0)
Text 10, 10, "Total Objects: "+Str$(ObjectNumber)+"  Selected Object: "+Str$(ObjectNumber2) +"  Vcount = "+str$(Vcount)+"  FPS = "+str$(screen fps())
text 10, 25, "Wait Left: "+Str$(Waiting)
Text 10, 40, "Fog Density: "+Str$(Density#)+"  Press D to increase (unthinken) and Ctrl+D to decrease"
Text 10, 55, "Fog Height: "+Str$(FHeight#)+"  Press H to increase and Ctrl+H to decrease"
Text 10, 70, "Fog Clearing: "+Str$(Clearing#)+"  Press C to increase and Ctrl+C to decrease"
Text 10, 85, "To show grid press G. To hide press Ctrl+G."

`Update the fog/object hiding
For A=1 to ObjectNumber
CamToOb#=Distance#(length, Camera Position X(0), Camera Position Y(0), Camera Position Z(0), OBJECT POSITION X(A), Object Position Y(A), Object Position Z(A))
If CamToOb#>ObjSize*(2) or OBJECT IN SCREEN(A)=0
HIDE OBJECT A
endif
If CamToOb#<ObjSize*(2) then SHOW OBJECT A
Next A

sync
until mouseclick()>0 or MouseMoveX()<>0 or MouseMoveY()<>0 or mousemoveZ()<>0 or scancode()>0
endif
endif

`if mouse is used (and keystate), remove the waiting time and reset it.
If mouseclick()>0
Waiting=0
endif

If MouseMoveX() <>0
Waiting=0
endif

If MouseMoveY() <>0
Waiting=0
endif

If mousemoveZ() <> 0
waiting=0
endif

If scancode() > 0
waiting=0
endif

if Waiting=11000
Waiting=0
endif

SET CAMERA EFFECT CONSTANT VECTOR 1,"EyePosition",0
sync
loop

end
Function Distance#(VecNum, x1#, y1#, z1#, x2#,  y2#, z2#)
set vector3 VecNum, x2# - x1#, y2# - y1#, z2# - z1#
dist# = length vector3(VecNum)
EndFunction dist#

          VerX#=GET VERTEXDATA POSITION X(normal)
          VerY#=GET VERTEXDATA POSITION Y(normal)
          VerZ#=GET VERTEXDATA POSITION Z(normal)
          Ver1X#=GET VERTEXDATA POSITION X(normal+1)
          Ver1Y#=GET VERTEXDATA POSITION Y(normal+1)
          Ver1Z#=GET VERTEXDATA POSITION Z(normal+1)
          Ver2X#=GET VERTEXDATA POSITION X(normal+2)
          Ver2Y#=GET VERTEXDATA POSITION Y(normal+2)
          Ver2Z#=GET VERTEXDATA POSITION Z(normal+2)          

set vector3 5,VerX#, VerY#, VerZ#
set vector3 6,Ver1X#, Ver1Y#, Ver1Z#
set vector3 7,Ver2X#, Ver2Y#, Ver2Z#
subtract vector3 9,5,6
subtract vector3 10,5,7
cross product vector3 8,10,9
`SET VECTOR3 8, Float#,Float#,Float#
NORMALIZE VECTOR3 8,8

set vertexdata normals normal, X vector3(8), Y vector3(8), Z Vector3(8)

type lod
VerX as float
VerY '
VerZ '
NormX '
NormY'
NormZ '
Diffuse as Dword
TexU as float
TexV '
endtype

Lock vertexdata for limb 1,0 `remember that this will either be after or following the making of objectnumber(1)
Vcount=Get Vertexdata Vertex Count()-1

Global dim ObNumber(Vcount) as Lod

...

In the area that also terraforms the objects via vertexdata, all of the values are edited in a function - it is done while the vertexdata is locked for the current pick object... thus updating the array for the object(s) in question.

(f) MemObject(Object, VertexNumber, X,Y,Z,NX,NY,NZ,Diffuse,U,V)

next array...

...

Function MemObject(Object, VertexNumber, X,Y,Z,NX,NY,NZ,Diffuse,U,V)
{Update the array}
endfunction

(((Then we make a memblock and use it to create a simplified mesh)))
Function MemLOD(Obnumber, LODStep, Memnumber, vTotal)
If memblock exist(memNumber)=0
Lock VertexData for Limb Obnumber, 0
Make MemBlock Memnumber, ((Vtotal/LODStep)-1)*36
Write memblock Dword memnumber, 0, 338
Write Memblock Dword memnumber, 4, 36
Write memblock Dword memnumber, 8, ((vTotal/LodStep)-1)*36
LODSkip=0
For A= 1 to ((Vtotal/LodStep)-1)*36 step 36
(((Using the array, we write to the memblock)))
Write memblock float MemNumber, A, ObNumber(LodSkip).VerX
...
Inc LodSkip, LodStep
Next A
Make mesh from memblock MemNumber, MeshNum (This is currently a random number... need to fix this :))
Change mesh ObNumber, MeshNum
Delete Memblock MemNumber
Endif
EndFunction

make object plain objId0, 100, 100, 64, 64

make object plain objId0, 100, 100, 32, 32

make object plain objId0, 100, 100, 16, 16

IF ez=1
     EZRO_FINDNORMAL x1#,y1#,z1#,x2#,y2#,z2#,x3#,y3#,z3#
     xn#=EZRO_GETNORMALX()
     yn#=EZRO_GETNORMALY()
     zn#=EZRO_GETNORMALZ()
ENDIF

`LAND MAP LOD 2
`======================
`©Paul Parkinson
`======================
`Main Source File
`############################################################## SYSTEM SETUP
SYNC ON
SYNC RATE 60
AUTOCAM OFF
COLOR BACKDROP 0,0
SET CAMERA RANGE 1,20000`set at long range to test LOD,Routines Shorten range for speed
SET TEXT FONT "Arial"
SET TEXT SIZE 24
SET TEXT TRANSPARENT

`###################################################################### LIGHTS & CAMERA
`set up camera and lights
POSITION CAMERA -1000,3000,-1000
POINT CAMERA 3000,0,3000
MAKE LIGHT 1
SET POINT LIGHT 1,5000,5000,5000
SET LIGHT RANGE 1,50000
HIDE LIGHT 0
SET AMBIENT LIGHT 0
MAKE OBJECT SPHERE 10000,-100
COLOR OBJECT 10000,RGB(255,255,0)
TEXT 0,0,"Please Wait - Starting Up"
SYNC
SYNC

`############################################################## NORMAL CREATION
GLOBAL ez=1`change to 1 if you have ez_rotate installed to speed up the build process or 0 to use vector maths method
`remember to comment out the ez_rotate commands as well if you dont have it
`there located in the 'make_normals()' function
IF ez=0
	GLOBAL avx#:GLOBAL avy#:GLOBAL avz#
	null = MAKE VECTOR3(0)
	null = MAKE VECTOR3(1)
	null = MAKE VECTOR3(2)
	null = MAKE VECTOR3(5)
	null = MAKE VECTOR3(6)
	null = MAKE VECTOR3(9)
	null = MAKE VECTOR3(10)
ENDIF

`############################################################## SAVE DIRECTORIES
GLOBAL save=1`change this to 0 if you dont want save the dbo's and bmp's that are created
`if you do then change the folder names to suit your self
GLOBAL bmp$="bmp"`base folder to store textures in
GLOBAL dbo$="dbo"`base folder to store objects in
`make folders if not present
IF save=1
	IF NOT PATH EXIST(bmp$)
		MAKE DIRECTORY bmp$`this folder also holds base textures
	ENDIF
	IF NOT PATH EXIST(dbo$)
		MAKE DIRECTORY dbo$
	ENDIF
	IF NOT PATH EXIST(dbo$+"lod1")
		MAKE DIRECTORY dbo$+"lod1"
	ENDIF
	IF NOT PATH EXIST(dbo$+"lod2")
		MAKE DIRECTORY dbo$+"lod2"
	ENDIF
ENDIF

`############################################################## TEXTURE SETUP
`global texture variables used if *.raw data file is inported,otherwise these will be set up in the fractal routine but need initialising first
GLOBAL sand1#:sand1#=45
GLOBAL sand2#:sand2#=70
GLOBAL sand3#:sand3#=90
GLOBAL grass1#:grass1#=120
GLOBAL grass2#:grass2#=170
GLOBAL grass3#:grass3#=190
GLOBAL rock1#:rock1#=220
GLOBAL rock2#:rock2#=240
GLOBAL rock3#:rock3#=270
GLOBAL rock4#:rock4#=310
GLOBAL rock5#:rock5#=360

`############################################################## WORLD SETUP
`random variation based on this value
GLOBAL hmv#:hmv#=15.0
GLOBAL blend:blend=64

`total size of world
TEXT 0,0,"Please Wait - Building World Data"
SYNC
GLOBAL grid_x#:GLOBAL grid_z#
grid_x#=512:grid_z#=512`do not adjust
DIM map_data(grid_x#,grid_z#,8) AS FLOAT `you have to setup the main map_data array before you can build the terrain

`uv set up
GLOBAL near_lod AS FLOAT:GLOBAL mid_lod AS FLOAT :GLOBAL far_lod AS FLOAT
near_lod=64.0:mid_lod=32.0:far_lod=16.0
GLOBAL u# AS DOUBLE FLOAT:GLOBAL v# AS DOUBLE FLOAT

`grid_size# is the size of each polygon used,this will scale the whole world but only the x,z plane so the hills will be more abrupt
`make the changes in the fractal generator function to smooth this out
GLOBAL grid_size#
grid_size#=32.0

`bitmap size for texture
GLOBAL bitmap_size#

`make a random hight map or read in a data file
RANDOMIZE TIMER()
GLOBAL scale AS FLOAT
scale=2.2

`read_hmap()`reads in a 512x512 teragen raw data height map these are not tileable
hmap_fractal()`make random fractal height map these are tileable

`map_data(xpos,zpos,8) array is used like this
`(1)=height (2),(3),(4)=normal x,y,z this is the total for all the normals at that vertex (5)=number of vertex sharing that point
`devides (2),(3),(4) by (5) to get the averaged normal 
`(6),(7),(8) can be used for diffuse color if needed
make_normals()

`turn on wire frame
GLOBAL wf=0`1 is on 0 is off,this will also turn off the texturing process if wire frame is selected

`#################################################################### LOD OBJECT CREATION
`near LOD objects
GLOBAL num_objects_in_landscape AS INTEGER
TEXT 0,0,"Please Wait - Creating Objects"
SYNC
u#=1.0/near_lod
v#=1.0/near_lod
create_memblockobject(1,(near_lod*near_lod*2*3))
`build the near LOD objects
obj=1000
FOR z=0 TO grid_z#/near_lod-1
	FOR x=0 TO grid_x#/near_lod-1
		build_memblockobject(obj,x*near_lod,z*near_lod,x*near_lod+near_lod,z*near_lod+near_lod)
		IF wf=1 THEN SET OBJECT WIREFRAME obj,1
		SYNC
		INC obj
		INC num_objects_in_landscape
	NEXT x
NEXT z

`mid LOD objects
u#=1.0/mid_lod
v#=1.0/mid_lod
DIM map_data_lod1(grid_x#/2,grid_z#/2,8) AS FLOAT
create_memblockobject(2,(mid_lod*mid_lod*2*3))
FOR z=0 TO grid_x#/2
	FOR x=0 TO grid_z#/2
		FOR l=1 TO 8
			map_data_lod1(x,z,l)=map_data(x*2,z*2,l)
		NEXT l
	NEXT x
NEXT z
`build the mid LOD objects
obj=2000
FOR z=0 TO grid_z#/near_lod-1
	FOR x=0 TO grid_x#/near_lod-1
		build_memblockobject_lod1(obj,x*mid_lod,z*mid_lod,x*mid_lod+mid_lod,z*mid_lod+mid_lod)
		IF wf=1 THEN SET OBJECT WIREFRAME obj,1
		INC obj
	NEXT x
NEXT z

`far LOD objects
u#=1.0/far_lod
v#=1.0/far_lod
DIM map_data_lod2(grid_x#/4,grid_z#/4,8) AS FLOAT
create_memblockobject(3,(far_lod*far_lod*2*3))
FOR z=0 TO grid_z#/4
	FOR x=0 TO grid_x#/4
		FOR l=1 TO 8
			map_data_lod2(x,z,l)=map_data(x*4,z*4,l)
		NEXT l
	NEXT x
NEXT z
`build the far LOD objects
obj=3000
FOR z=0 TO grid_z#/near_lod-1
	FOR x=0 TO grid_x#/near_lod-1
		build_memblockobject_lod2(obj,x*far_lod,z*far_lod,x*far_lod+far_lod,z*far_lod+far_lod)
		IF wf=1 THEN SET OBJECT WIREFRAME obj,1
		INC obj
	NEXT x
NEXT z

`######################################################################### TEXTURE CREATION
IF wf=0
	TEXT 0,0,"Please Wait - Creating Textures Samples"
	SYNC
	`make tiles
	`sand grass rock
	make_sprite(235,180,50,4000):SPRITE 1,-128,-128,4000
	make_sprite(205,128,50,4001):SPRITE 2,-128,-128,4001
	make_sprite(128,64,50,4002):SPRITE 3,-128,-128,4002
	make_sprite(0,200,0,4003):SPRITE 4,-128,-128,4003
	make_sprite(0,128,0,4004):SPRITE 5,-128,-128,4004
	make_sprite(0,64,0,4005):SPRITE 6,-128,-128,4005
	make_sprite(30,30,30,4006):SPRITE 7,-128,-128,4006
	make_sprite(70,70,70,4007):SPRITE 8,-128,-128,4007
	make_sprite(120,120,120,4008):SPRITE 9,-128,-128,4008
	make_sprite(170,170,170,4009):SPRITE 10,-128,-128,4009
	make_sprite(220,220,220,4010):SPRITE 11,-128,-128,4010
ENDIF
IF wf=0
	TEXT 0,0,"Please Wait - Applying Textures To Near LOD"
	SYNC
	bitmap_size#=512
	preview_texture(bmp$,1000)
ENDIF

`######################################################################### ADD LOD OBJECTS
`set up the LOD data if textures are needed then call this after they have been set up as once this is called no changes can be made
FOR l=1000 TO (grid_x#/near_lod)*(grid_z#/near_lod)+999
	ADD LOD TO OBJECT l,l+1000,0,near_lod*grid_size#*2
	ADD LOD TO OBJECT l,l+2000,1,near_lod*grid_size#*3
	DELETE OBJECT l+1000
	DELETE OBJECT l+2000
NEXT l
	
`reset uv to main texture size
u#=1.0/near_lod
v#=1.0/near_lod

`###################################################################### MAIN LOOP
CLS
SYNC

DO
	mov#=(2000.0-SCREEN FPS())/500.0
	mousecontrol(8)
	IF INKEY$()="z"
		POSITION CAMERA -1000,3000,-1000
		POINT CAMERA 3000,0,3000
		SET POINT LIGHT 1,5000,5000,5000
		SET LIGHT RANGE 1,50000
	ENDIF
	
	lx=LIGHT POSITION X(1)
	ly=LIGHT POSITION Y(1)
	lz=LIGHT POSITION Z(1)
	`control light
	IF UPKEY()
		POSITION LIGHT 1,lx,ly,lz+10
	ENDIF
	IF DOWNKEY()
		POSITION LIGHT 1,lx,ly,lz-10
	ENDIF
	IF LEFTKEY()
		POSITION LIGHT 1,lx-10,ly,lz
	ENDIF
	IF RIGHTKEY()
		POSITION LIGHT 1,lx+10,ly,lz
	ENDIF
	POSITION OBJECT 10000,lx,ly,lz
	IF INKEY$()="-"
		SET LIGHT RANGE 1,LIGHT RANGE(1)-100
	ENDIF
	IF INKEY$()="+"
		SET LIGHT RANGE 1,LIGHT RANGE(1)+100
	ENDIF
	TEXT 0,0,"press 'z' to reset view point"
	TEXT 0,30,"mouse to look around"
	TEXT 0,60,"arrows to move light,'+','-' to change range - position x"+STR$(lx)+" y"+STR$(ly)+" z"+STR$(lz)+" range "+STR$(INT(LIGHT RANGE(1)))
	TEXT 0,90,"screen fps "+STR$(SCREEN FPS())
//	text 0,120,"'w' to turn wire frame test mode on (puts closest LOD into wire frame only)"
	TEXT 0,150,"Polygons on screen "+STR$(STATISTIC(1))+" mov "+STR$(mov#)
	SYNC
	
//	IF INKEY$()="w"
//		INC wf
//		if wf>1 then wf=0
//		FOR l=1000 TO 1000+num_objects_in_landscape-1
//			SET OBJECT WIREFRAME l,wf
//		NEXT l
//		FOR w=0 TO 100000
//			``wait
//		NEXT w
//	ENDIF
LOOP

`###################################################################### FUNCTIONS

FUNCTION read_hmap()
	IF FILE OPEN(1) THEN CLOSE FILE 1
	OPEN TO READ 1,"hmap.raw"
	DIM dat(512,512)
	FOR z=0 TO 512
		FOR x=0 TO 512
			READ BYTE 1,bt1
			
			dat(x,z)=bt1
			DOT x,z,RGB(bt1,bt1,bt1)
			IF x<=grid_x# AND z<=grid_z#
				map_data(x,z,1)=bt1*scale
			ENDIF
		NEXT x
	NEXT z
	CLOSE FILE 1
	SYNC
ENDFUNCTION

FUNCTION hmap_fractal()
`thanks to who ever did this code,had it so long,and it never fails to work for me
av AS FLOAT
rn AS FLOAT
s=grid_x#  ` units and array size; must be a power of 2
rn=0.06  ` bigger numbers = smoother, smaller = spikier
smt=1  ` how many times to smooth matrix
DIM a(s,s,1) AS FLOAT
` do the diamond square algorithm
` paying special attention to wrapping around
c=s
REPEAT
   FOR z=0 TO (s-c) STEP c
      FOR x=0 TO (s-c) STEP c
         av=(a(x,z)+a(x+c,z)+a(x,z+c)+a(x+c,z+c))/4.0
         av=av+((-50+RND(100))/rn)
         a(x+(c/2),z+(c/2))=av
      NEXT x
   NEXT z
   w=1
   FOR z=0 TO (s-(c/2)) STEP (c/2)
      FOR x=0 TO (s-c) STEP c
         x2=x+(w*(c/2))
         av=a(x2,z+(c/2))+a(x2+(c/2),z)
         IF x2=0
            av=av+a(s-(c/2),z)
         ELSE
            av=av+a(x2-(c/2),z)
         ENDIF
         IF z=0
            av=av+a(x2,s-(c/2))
         ELSE
            av=av+a(x2,z-(c/2))
         ENDIF
         av=av/4.0
         av=av+((-50+RND(100))/rn)
         a(x2,z,0)=av
         IF x2=0 THEN a(s,z,0)=av
         IF z=0 THEN a(x2,s,0)=av
      NEXT x
      w=1-w
   NEXT z
   c=c/2
   rn=rn*2.0
UNTIL c < 2

` smooth the result
FOR multiple=1 TO smt
   FOR x=0 TO s-1
      x2=x-1 : IF x2 < 0 THEN x2=s-1
      FOR z=0 TO s-1
         z2=z-1 : IF z2 < 0 THEN z2=s-1
         v1#=a(x2,z+1,0)
         v2#=a(x,z+1,0)
         v3#=a(x+1,z+1,0)
         v4#=a(x+1,z,0)
         v5#=a(x+1,z2,0)
         v6#=a(x,z2,0)
         v7#=a(x2,z2,0)
         v8#=a(x2,z,0)
         av#=(v1#+v2#+v3#+v4#+v5#+v6#+v7#+v8#)/8.0
         a(x,z,0)=av#
      NEXT z
   NEXT x
   FOR f=0 TO s
      a(s,f,0)=a(0,f,0)
      a(f,s,0)=a(f,0,0)
   NEXT f
NEXT multiple

`find min/max height
minh#=5000:maxh#=-5000
FOR z=0 TO grid_z#
   FOR x=0 TO grid_x#
   	a(x,z,0)=a(x,z,0)*scale
      IF a(x,z,0)<minh# THEN minh#=a(x,z,0)
      IF a(x,z,0)>maxh# THEN maxh#=a(x,z,0)
   NEXT x
NEXT z

` update data array and make it raise up so the lowest point is>=0
FOR z=0 TO grid_z#
   FOR x=0 TO grid_x#
      av=a(x,z,0)
      IF minh#<0 THEN map_data(x,z,1)=av+ABS(minh#)
      IF minh#>=0 THEN map_data(x,z,1)=av-minh#
      `resets the normals
      map_data(x,z,2)=0
      map_data(x,z,3)=0
      map_data(x,z,4)=0
      map_data(x,z,5)=0
	NEXT x
NEXT z

`set up texture heights to suit terrain created
diff#=maxh#-minh#
diff#=diff#/100.0

`sand grass rock
sand1#=(diff#*10)
sand2#=(diff#*15)
sand3#=(diff#*20)
grass1#=(diff#*30)
grass2#=(diff#*50)
grass3#=(diff#*70)
rock1#=(diff#*75)
rock2#=(diff#*80)
rock3#=(diff#*85)
rock4#=(diff#*90)
rock5#=(diff#*95)
`random variation based on this value
hmv#=diff#*10`blend between textures so its not striped
blend=64

ENDFUNCTION

FUNCTION create_memblockobject(memnum,v)
	MAKE MEMBLOCK memnum,12+(32*v)
   WRITE MEMBLOCK DWORD memnum,0,274
   WRITE MEMBLOCK DWORD memnum,4,32
   WRITE MEMBLOCK DWORD memnum,8,v
ENDFUNCTION

FUNCTION create_vertex(memnum,v,vposx#,vposy#,vposz#,color AS DWORD,u#,v#)
	WRITE MEMBLOCK FLOAT memnum,v*32+12,vposx#
  	WRITE MEMBLOCK FLOAT memnum,v*32+16,vposy#
  	WRITE MEMBLOCK FLOAT memnum,v*32+20,vposz#
  `write memblock dword memnum,v*36+36,color `not needed in 274fvf format diffuse color seems to mess up some shader code
  	WRITE MEMBLOCK FLOAT memnum,v*32+36,u#
  	WRITE MEMBLOCK FLOAT memnum,v*32+40,v#
ENDFUNCTION

FUNCTION set_normal(memnum,v,normalx#,normaly#,normalz#)
	WRITE MEMBLOCK FLOAT memnum,v*32+24,normalx#
   WRITE MEMBLOCK FLOAT memnum,v*32+28,normaly#
   WRITE MEMBLOCK FLOAT memnum,v*32+32,normalz#
ENDFUNCTION

FUNCTION make_object(objnum,meshnum,memnum,imgnum)
	IF OBJECT EXIST (objnum) THEN DELETE OBJECT objnum
	IF MESH EXIST (meshnum) THEN DELETE MESH meshnum
   MAKE MESH FROM MEMBLOCK meshnum,memnum
   MAKE OBJECT objnum,meshnum,imgnum
ENDFUNCTION

FUNCTION make_normals()
	FOR z=0 TO grid_z#-1
		FOR x=0 TO grid_x#-1
			x1#=x*grid_size#:y1#=map_data(x,z,1):z1#=z*grid_size#
			x2#=x*grid_size#:y2#=map_data(x,z+1,1):z2#=(z+1)*grid_size#
			x3#=(x+1)*grid_size#:y3#=map_data(x+1,z,1):z3#=z*grid_size#
			`find the surface normal of the polygon
			IF ez=1
				EZRO_FINDNORMAL x1#,y1#,z1#,x2#,y2#,z2#,x3#,y3#,z3#
				xn#=EZRO_GETNORMALX()
				yn#=EZRO_GETNORMALY()
				zn#=EZRO_GETNORMALZ()
			ENDIF
			IF ez=0
				normals(x1#,y1#,z1#,x2#,y2#,z2#,x3#,y3#,z3#)
				xn#=avx#
				yn#=avy#
				zn#=avz#
			ENDIF
			`add it to any others at that vertex and increment the number of times that vertex has been used
			map_data(x,z,2)=map_data(x,z,2)+xn#
			map_data(x,z,3)=map_data(x,z,3)+yn#
			map_data(x,z,4)=map_data(x,z,4)+zn#
			INC map_data(x,z,5)
			map_data(x,z+1,2)=map_data(x,z+1,2)+xn#
			map_data(x,z+1,3)=map_data(x,z+1,3)+yn#
			map_data(x,z+1,4)=map_data(x,z+1,4)+zn#
			INC map_data(x,z+1,5)
			map_data(x+1,z,2)=map_data(x+1,z,2)+xn#
			map_data(x+1,z,3)=map_data(x+1,z,3)+yn#
			map_data(x+1,z,4)=map_data(x+1,z,4)+zn#
			INC map_data(x+1,z,5)
			
			x1#=(x+1)*grid_size#:y1#=map_data(x+1,z+1,1):z1#=(z+1)*grid_size#
			x2#=(x+1)*grid_size#:y2#=map_data(x+1,z,1):z2#=z*grid_size#
			x3#=x*grid_size#:y3#=map_data(x,z+1,1):z3#=(z+1)*grid_size#
			`find the surface normal of the polygon
			IF ez=1
				EZRO_FINDNORMAL x1#,y1#,z1#,x2#,y2#,z2#,x3#,y3#,z3#
				xn#=EZRO_GETNORMALX()
				yn#=EZRO_GETNORMALY()
				zn#=EZRO_GETNORMALZ()
			ENDIF
			IF ez=0
				normals(x1#,y1#,z1#,x2#,y2#,z2#,x3#,y3#,z3#)
				xn#=avx#
				yn#=avy#
				zn#=avz#
			ENDIF
			`add it to any others at that vertex and increment the number of times that vertex has been used
			map_data(x+1,z+1,2)=map_data(x+1,z+1,2)+xn#
			map_data(x+1,z+1,3)=map_data(x+1,z+1,3)+yn#
			map_data(x+1,z+1,4)=map_data(x+1,z+1,4)+zn#
			INC map_data(x+1,z+1,5)
			map_data(x+1,z,2)=map_data(x+1,z,2)+xn#
			map_data(x+1,z,3)=map_data(x+1,z,3)+yn#
			map_data(x+1,z,4)=map_data(x+1,z,4)+zn#
			INC map_data(x,z+1,5)
			map_data(x,z+1,2)=map_data(x,z+1,2)+xn#
			map_data(x,z+1,3)=map_data(x,z+1,3)+yn#
			map_data(x,z+1,4)=map_data(x,z+1,4)+zn#
			INC map_data(x+1,z,5)
			
		NEXT x
	NEXT z
	`average the normals at each point
	FOR z=0 TO grid_z#
		FOR x=0 TO grid_x#
			dumx#=map_data(x,z,2)/map_data(x,z,5)
			dumy#=map_data(x,z,3)/map_data(x,z,5)
			dumz#=map_data(x,z,4)/map_data(x,z,5)
			`dumx#=4.0
			`dumy#=4.0
			`dumz#=4.0
			map_data(x,z,2)=dumx#
			map_data(x,z,3)=dumy#
			map_data(x,z,4)=dumz#
			
		NEXT x
	NEXT z
ENDFUNCTION

FUNCTION normals(vertex_px1#,vertex_py1#,vertex_pz1#,vertex_px2#,vertex_py2#,vertex_pz2#,vertex_px3#,vertex_py3#,vertex_pz3#)
`zero globals
	avx#=0
	avy#=0
	avz#=0
`vertex 1
   SET VECTOR3 0,vertex_px1#, vertex_py1#, vertex_pz1#
`vertex 2
   SET VECTOR3 1,vertex_px2#, vertex_py2#, vertex_pz2#
`vertex 3
   SET VECTOR3 2,vertex_px3#, vertex_py3#, vertex_pz3#
`find normals
  	SUBTRACT VECTOR3 5, 0,2       ` -- direction v1
	SUBTRACT VECTOR3 6, 1,2       ` -- direction v2
	CROSS PRODUCT VECTOR3 9, 5,6  ` -- normal
	NORMALIZE VECTOR3 10, 9       ` -- normalized normal 
`set globals to vector results
	avx#=X VECTOR3(10)
  	avy#=Y VECTOR3(10)
  	avz#=Z VECTOR3(10)
ENDFUNCTION

FUNCTION build_memblockobject(obj,start_x,start_z,end_x,end_z)
	vertex=0
	FOR z=start_z TO end_z-1
		FOR x=start_x TO end_x-1
			x1#=x*grid_size#:y1#=map_data(x,z,1):z1#=z*grid_size#
			x2#=x*grid_size#:y2#=map_data(x,z+1,1):z2#=(z+1)*grid_size#
			x3#=(x+1)*grid_size#:y3#=map_data(x+1,z,1):z3#=z*grid_size#
			x1#=x1#-(start_x*grid_size#):x2#=x2#-(start_x*grid_size#):x3#=x3#-(start_x*grid_size#)
			z1#=z1#-(start_z*grid_size#):z2#=z2#-(start_z*grid_size#):z3#=z3#-(start_z*grid_size#)
			create_vertex(1,vertex,x1#,y1#,z1#,RGB(map_data(x,z,6),map_data(x,z,7),map_data(x,z,8)),u#*(x-start_x),v#*(z-start_z))
			set_normal(1,vertex,map_data(x,z,2),map_data(x,z,3),map_data(x,z,4))
			INC vertex
			create_vertex(1,vertex,x2#,y2#,z2#,RGB(map_data(x,z,6),map_data(x,z,7),map_data(x,z,8)),u#*(x-start_x),v#*(z+1-start_z))
			set_normal(1,vertex,map_data(x,z+1,2),map_data(x,z+1,3),map_data(x,z+1,4))
			INC vertex
			create_vertex(1,vertex,x3#,y3#,z3#,RGB(map_data(x,z,6),map_data(x,z,7),map_data(x,z,8)),u#*(x+1-start_x),v#*(z-start_z))
			set_normal(1,vertex,map_data(x+1,z,2),map_data(x+1,z,3),map_data(x+1,z,4))
			INC vertex
			
			x1#=(x+1)*grid_size#:y1#=map_data(x+1,z+1,1):z1#=(z+1)*grid_size#
			x2#=(x+1)*grid_size#:y2#=map_data(x+1,z,1):z2#=z*grid_size#
			x3#=x*grid_size#:y3#=map_data(x,z+1,1):z3#=(z+1)*grid_size#
			x1#=x1#-(start_x*grid_size#):x2#=x2#-(start_x*grid_size#):x3#=x3#-(start_x*grid_size#)
			z1#=z1#-(start_z*grid_size#):z2#=z2#-(start_z*grid_size#):z3#=z3#-(start_z*grid_size#)
			create_vertex(1,vertex,x1#,y1#,z1#,RGB(map_data(x,z,6),map_data(x,z,7),map_data(x,z,8)),u#*(x+1-start_x),v#*(z+1-start_z))
			set_normal(1,vertex,map_data(x+1,z+1,2),map_data(x+1,z+1,3),map_data(x+1,z+1,4))
			INC vertex
			create_vertex(1,vertex,x2#,y2#,z2#,RGB(map_data(x,z,6),map_data(x,z,7),map_data(x,z,8)),u#*(x+1-start_x),v#*(z-start_z))
			set_normal(1,vertex,map_data(x+1,z,2),map_data(x+1,z,3),map_data(x+1,z,4))
			INC vertex
			create_vertex(1,vertex,x3#,y3#,z3#,RGB(map_data(x,z,6),map_data(x,z,7),map_data(x,z,8)),u#*(x-start_x),v#*(z+1-start_z))
			set_normal(1,vertex,map_data(x,z+1,2),map_data(x,z+1,3),map_data(x,z+1,4))
			INC vertex
		NEXT x
	NEXT z
	make_object(obj,1,1,0)
	POSITION OBJECT obj,start_x*grid_size#,OBJECT POSITION Y(obj),start_z*grid_size#
	IF save=1
		f$=dbo$+"\land mass"+STR$(obj)+".dbo"
		IF FILE EXIST(f$) THEN DELETE FILE f$
		SAVE OBJECT f$,obj
	ENDIF
ENDFUNCTION

FUNCTION build_memblockobject_lod1(obj,start_x,start_z,end_x,end_z)
	vertex=0
	FOR z=start_z TO end_z-1
		FOR x=start_x TO end_x-1
			x1#=x*grid_size#*2:y1#=map_data_lod1(x,z,1):z1#=z*grid_size#*2
			x2#=x*grid_size#*2:y2#=map_data_lod1(x,z+1,1):z2#=(z+1)*grid_size#*2
			x3#=(x+1)*grid_size#*2:y3#=map_data_lod1(x+1,z,1):z3#=z*grid_size#*2
			x1#=x1#-(start_x*grid_size#*2):x2#=x2#-(start_x*grid_size#*2):x3#=x3#-(start_x*grid_size#*2)
			z1#=z1#-(start_z*grid_size#*2):z2#=z2#-(start_z*grid_size#*2):z3#=z3#-(start_z*grid_size#*2)
			create_vertex(2,vertex,x1#,y1#,z1#,RGB(map_data_lod1(x,z,6),map_data_lod1(x,z,7),map_data_lod1(x,z,8)),u#*(x-start_x),v#*(z-start_z))
			set_normal(2,vertex,map_data_lod1(x,z,2),map_data_lod1(x,z,3),map_data_lod1(x,z,4))
			INC vertex
			create_vertex(2,vertex,x2#,y2#,z2#,RGB(map_data_lod1(x,z,6),map_data_lod1(x,z,7),map_data_lod1(x,z,8)),u#*(x-start_x),v#*(z+1-start_z))
			set_normal(2,vertex,map_data_lod1(x,z+1,2),map_data_lod1(x,z+1,3),map_data_lod1(x,z+1,4))
			INC vertex
			create_vertex(2,vertex,x3#,y3#,z3#,RGB(map_data_lod1(x,z,6),map_data_lod1(x,z,7),map_data_lod1(x,z,8)),u#*(x+1-start_x),v#*(z-start_z))
			set_normal(2,vertex,map_data_lod1(x+1,z,2),map_data_lod1(x+1,z,3),map_data_lod1(x+1,z,4))
			INC vertex
			
			x1#=(x+1)*grid_size#*2:y1#=map_data_lod1(x+1,z+1,1):z1#=(z+1)*grid_size#*2
			x2#=(x+1)*grid_size#*2:y2#=map_data_lod1(x+1,z,1):z2#=z*grid_size#*2
			x3#=x*grid_size#*2:y3#=map_data_lod1(x,z+1,1):z3#=(z+1)*grid_size#*2
			x1#=x1#-(start_x*grid_size#*2):x2#=x2#-(start_x*grid_size#*2):x3#=x3#-(start_x*grid_size#*2)
			z1#=z1#-(start_z*grid_size#*2):z2#=z2#-(start_z*grid_size#*2):z3#=z3#-(start_z*grid_size#*2)
			create_vertex(2,vertex,x1#,y1#,z1#,RGB(map_data_lod1(x,z,6),map_data_lod1(x,z,7),map_data_lod1(x,z,8)),u#*(x+1-start_x),v#*(z+1-start_z))
			set_normal(2,vertex,map_data_lod1(x+1,z+1,2),map_data_lod1(x+1,z+1,3),map_data_lod1(x+1,z+1,4))
			INC vertex
			create_vertex(2,vertex,x2#,y2#,z2#,RGB(map_data_lod1(x,z,6),map_data_lod1(x,z,7),map_data_lod1(x,z,8)),u#*(x+1-start_x),v#*(z-start_z))
			set_normal(2,vertex,map_data_lod1(x+1,z,2),map_data_lod1(x+1,z,3),map_data_lod1(x+1,z,4))
			INC vertex
			create_vertex(2,vertex,x3#,y3#,z3#,RGB(map_data_lod1(x,z,6),map_data_lod1(x,z,7),map_data_lod1(x,z,8)),u#*(x-start_x),v#*(z+1-start_z))
			set_normal(2,vertex,map_data_lod1(x,z+1,2),map_data_lod1(x,z+1,3),map_data_lod1(x,z+1,4))
			INC vertex
		NEXT x
	NEXT z
	make_object(obj,2,2,0)
	IF save=1
		f$=dbo$+"lod1"+"\land mass"+STR$(obj)+".dbo"
		IF FILE EXIST(f$) THEN DELETE FILE f$
		SAVE OBJECT f$,obj
	ENDIF
	POSITION OBJECT obj,-5000,-5000,-5000
ENDFUNCTION

FUNCTION build_memblockobject_lod2(obj,start_x,start_z,end_x,end_z)
	vertex=0
	FOR z=start_z TO end_z-1
		FOR x=start_x TO end_x-1
			x1#=x*grid_size#*4:y1#=map_data_lod2(x,z,1):z1#=z*grid_size#*4
			x2#=x*grid_size#*4:y2#=map_data_lod2(x,z+1,1):z2#=(z+1)*grid_size#*4
			x3#=(x+1)*grid_size#*4:y3#=map_data_lod2(x+1,z,1):z3#=z*grid_size#*4
			x1#=x1#-(start_x*grid_size#*4):x2#=x2#-(start_x*grid_size#*4):x3#=x3#-(start_x*grid_size#*4)
			z1#=z1#-(start_z*grid_size#*4):z2#=z2#-(start_z*grid_size#*4):z3#=z3#-(start_z*grid_size#*4)
			create_vertex(3,vertex,x1#,y1#,z1#,RGB(map_data_lod2(x,z,6),map_data_lod2(x,z,7),map_data_lod2(x,z,8)),u#*(x-start_x),v#*(z-start_z))
			set_normal(3,vertex,map_data_lod2(x,z,2),map_data_lod2(x,z,3),map_data_lod2(x,z,4))
			INC vertex
			create_vertex(3,vertex,x2#,y2#,z2#,RGB(map_data_lod2(x,z,6),map_data_lod2(x,z,7),map_data_lod2(x,z,8)),u#*(x-start_x),v#*(z+1-start_z))
			set_normal(3,vertex,map_data_lod2(x,z+1,2),map_data_lod2(x,z+1,3),map_data_lod2(x,z+1,4))
			INC vertex
			create_vertex(3,vertex,x3#,y3#,z3#,RGB(map_data_lod2(x,z,6),map_data_lod2(x,z,7),map_data_lod2(x,z,8)),u#*(x+1-start_x),v#*(z-start_z))
			set_normal(3,vertex,map_data_lod2(x+1,z,2),map_data_lod2(x+1,z,3),map_data_lod2(x+1,z,4))
			INC vertex
			
			x1#=(x+1)*grid_size#*4:y1#=map_data_lod2(x+1,z+1,1):z1#=(z+1)*grid_size#*4
			x2#=(x+1)*grid_size#*4:y2#=map_data_lod2(x+1,z,1):z2#=z*grid_size#*4
			x3#=x*grid_size#*4:y3#=map_data_lod2(x,z+1,1):z3#=(z+1)*grid_size#*4
			x1#=x1#-(start_x*grid_size#*4):x2#=x2#-(start_x*grid_size#*4):x3#=x3#-(start_x*grid_size#*4)
			z1#=z1#-(start_z*grid_size#*4):z2#=z2#-(start_z*grid_size#*4):z3#=z3#-(start_z*grid_size#*4)
			create_vertex(3,vertex,x1#,y1#,z1#,RGB(map_data_lod2(x,z,6),map_data_lod2(x,z,7),map_data_lod2(x,z,8)),u#*(x+1-start_x),v#*(z+1-start_z))
			set_normal(3,vertex,map_data_lod2(x+1,z+1,2),map_data_lod2(x+1,z+1,3),map_data_lod2(x+1,z+1,4))
			INC vertex
			create_vertex(3,vertex,x2#,y2#,z2#,RGB(map_data_lod2(x,z,6),map_data_lod2(x,z,7),map_data_lod2(x,z,8)),u#*(x+1-start_x),v#*(z-start_z))
			set_normal(3,vertex,map_data_lod2(x+1,z,2),map_data_lod2(x+1,z,3),map_data_lod2(x+1,z,4))
			INC vertex
			create_vertex(3,vertex,x3#,y3#,z3#,RGB(map_data_lod2(x,z,6),map_data_lod2(x,z,7),map_data_lod2(x,z,8)),u#*(x-start_x),v#*(z+1-start_z))
			set_normal(3,vertex,map_data_lod2(x,z+1,2),map_data_lod2(x,z+1,3),map_data_lod2(x,z+1,4))
			INC vertex
		NEXT x
	NEXT z
	make_object(obj,3,3,0)
	IF save=1
		f$=dbo$+"lod2"+"\land mass"+STR$(obj)+".dbo"
		IF FILE EXIST(f$) THEN DELETE FILE f$
		SAVE OBJECT f$,obj
		POSITION OBJECT obj,-5000,-5000,-5000
	ENDIF
ENDFUNCTION

FUNCTION mousecontrol(Speed AS FLOAT)
	XROTATE CAMERA CAMERA ANGLE X()+MOUSEMOVEY()
	YROTATE CAMERA CAMERA ANGLE Y()+MOUSEMOVEX()
	IF MOUSECLICK()=1 THEN MOVE CAMERA Speed
	IF MOUSECLICK()=2 THEN MOVE CAMERA (0-Speed)
	r=MOUSEMOVEX()
	r=MOUSEMOVEY()
ENDFUNCTION

`###################################################################### TEXTURE ROUTINES STAR HERE
FUNCTION make_sprite(r#,g#,b#,image_num)
	IF BITMAP EXIST(1) THEN DELETE BITMAP 1
	SET BITMAP FORMAT 21
	CREATE BITMAP 1,128,128
	SET CURRENT BITMAP 1
	SET IMAGE COLORKEY 0,0,0
	FOR l=1 TO 2000
		x=RND(128)
		z=RND(128)
		DOT x,z,RGB(r#,g#,b#)
	NEXT l
	FOR l=1 TO 2000
		x=RND(128)
		z=RND(128)
		col#=RND(30)
		r2#=r#+col#
		IF r2#>255 THEN r2#=255
		g2#=g#+col#
		IF g2#>255 THEN g2#=255
		b2#=b#+col#
		IF b2#>255 THEN b2#=255
		DOT x,z,RGB(r2#,g2#,b2#)
	NEXT l
	FOR l=1 TO 200
		x=RND(128)
		z=RND(128)
		col#=RND(50)+50
		r2#=col#
		g2#=col#
		b2#=col#
		DOT x,z,RGB(r2#,g2#,b2#)
	NEXT l
	IF IMAGE EXIST(image_num) THEN DELETE IMAGE image_num
	GET IMAGE image_num,0,0,128,128
	IF save=1
		f$=bmp$+"\sprite"+STR$(image_num)+".png"
		IF FILE EXIST(f$) THEN DELETE FILE f$
		SAVE IMAGE f$,image_num
	ENDIF
	SET CURRENT BITMAP 0
ENDFUNCTION


FUNCTION preview_texture(bf$,ob)
	obj=ob
	`make a bitmap big enough to cover the whole 8 x 8 grid
	IF BITMAP EXIST(1) THEN DELETE BITMAP 1
	SET BITMAP FORMAT 21
	bms#=bitmap_size#*(8)
	CREATE BITMAP 1,bms#,bms#
	SET CURRENT BITMAP 1
	mulx=bms#/(64*8)
	mulz=bms#/(64*8)
		FOR z=0 TO 64*8 `step 2
			FOR x=0 TO 64*8 `step 2
				IF INKEY$()="q" THEN GOTO jump3
					posx=(x*mulx)+RND(blend)-(blend/2)
					posz=(z*mulz)+RND(blend)-(blend/2)
					offset=RND(hmv#)
					IF map_data(x,z,1)<=sand1#-offset
						ROTATE SPRITE 1,RND(90)
						PASTE SPRITE 1,posx,posz
					ENDIF
					IF map_data(x,z,1)>sand1#-offset AND map_data(x,z,1)<=sand2#+offset
						ROTATE SPRITE 2,RND(90)
						PASTE SPRITE 2,posx,posz
					ENDIF
					IF map_data(x,z,1)>sand2#-offset AND map_data(x,z,1)<=sand3#+offset
						ROTATE SPRITE 3,RND(90)
						PASTE SPRITE 3,posx,posz
					ENDIF
					IF map_data(x,z,1)>sand3#-offset AND map_data(x,z,1)<=grass1#+offset
						ROTATE SPRITE 4,RND(90)
						PASTE SPRITE 4,posx,posz
					ENDIF
					IF map_data(x,z,1)>grass1#-offset AND map_data(x,z,1)<=grass2#+offset
						ROTATE SPRITE 5,RND(90)
						PASTE SPRITE 5,posx,posz
					ENDIF
					IF map_data(x,z,1)>grass2#-offset AND map_data(x,z,1)<=grass3#+offset
						ROTATE SPRITE 6,RND(90)
						PASTE SPRITE 6,posx,posz
					ENDIF
					IF map_data(x,z,1)>grass3#-offset AND map_data(x,z,1)<=rock1#+offset
						ROTATE SPRITE 7,RND(90)
						PASTE SPRITE 7,posx,posz
					ENDIF
					IF map_data(x,z,1)>rock1#-offset AND map_data(x,z,1)<=rock2#+offset
						ROTATE SPRITE 8,RND(90)
						PASTE SPRITE 8,posx,posz
					ENDIF
					IF map_data(x,z,1)>rock2#-offset AND map_data(x,z,1)<=rock3#+offset
						ROTATE SPRITE 9,RND(90)
						PASTE SPRITE 9,posx,posz
					ENDIF
					IF map_data(x,z,1)>rock3#-offset AND map_data(x,z,1)<=rock4#+offset
						ROTATE SPRITE 10,RND(90)
						PASTE SPRITE 10,posx,posz
					ENDIF
					IF map_data(x,z,1)>rock4#-offset
						ROTATE SPRITE 11,RND(90)
						PASTE SPRITE 11,posx,posz
					ENDIF
			NEXT x
		NEXT z
	`cut up the texture in to tile size pieces and apply to mesh
	FOR z=0 TO 7
		FOR x=0 TO 7
			IF INKEY$()="q" THEN GOTO jump3
			GET IMAGE obj,x*bitmap_size#+1,z*bitmap_size#+1,(x+1)*bitmap_size#,(z+1)*bitmap_size#
			TEXTURE OBJECT obj,0,obj
			SET OBJECT TEXTURE obj,2,1
			IF save=1
				f$=bf$
				f$=f$+"\land mass"+STR$(obj)+".bmp"
				IF FILE EXIST(f$) THEN DELETE FILE f$
				SAVE IMAGE f$,obj
			ENDIF
			SET CURRENT BITMAP 0
			SYNC
			SET CURRENT BITMAP 1
		INC obj
		NEXT x
	NEXT z
	SET CURRENT BITMAP 0
jump3:
	SET CURRENT BITMAP 0
	IF BITMAP EXIST(1) THEN DELETE BITMAP 1
ENDFUNCTION

`%ProjectTitle%
`======================
`©P.Parkinson
`======================
`Main Source File

`*********************************
`enviroment set up

IF CHECK DISPLAY MODE(1024,768,32) 
	SET DISPLAY MODE 1024,768,32
	h=DESKTOP HEIGHT()
	w=DESKTOP WIDTH()
	posx=w/2-512
	posy=h/2-384
ELSE
	SET DISPLAY MODE 640,480,32
	h=DESKTOP HEIGHT()
	w=DESKTOP WIDTH()
	posx=w/2-320
	posy=h/2-240
ENDIF
SET WINDOW POSITION posx,posy

SYNC ON
SYNC RATE 60
AUTOCAM OFF
HIDE MOUSE
COLOR BACKDROP 0,0
SET TEXT FONT "Arial"
SET TEXT SIZE 12
SET TEXT TRANSPARENT
SET CAMERA RANGE 1,1000
POSITION CAMERA 50,50,-50
POINT CAMERA 0,0,0
POSITION MOUSE SCREEN WIDTH()/2,SCREEN HEIGHT()/2
dummy=MOUSEMOVEX()
dummy=MOUSEMOVEY()
TEXT 0,0,"PLEASE WAIT DURING SET UP"
SYNC 
SYNC

`*********************************	
`declarations and setup starts here

`*********************************
`make the objects that make up the landscape and set up the size variables

`column and row size
GLOBAL sz AS INTEGER=64
`actual object size to be created centred at 0,0,0 when created
GLOBAL obj_sz AS FLOAT=128.0
`how many tiles per row/col
GLOBAL tile_sz AS INTEGER=8`change this to 256 and watch what happens
`first object
GLOBAL lod_first_obj AS INTEGER

col=128``used to make a checker board pattern
FOR y=0 TO tile_sz
	FOR x=0 TO tile_sz
		obj=free_object()
		IF x=0 AND y=0 THEN lod_first_obj=obj
		`ianm matrix1 command
		MAKE OBJECT PLAIN obj,obj_sz,obj_sz,sz,sz,338
		SET OBJECT WIREFRAME obj,1	
		POSITION OBJECT obj,x*obj_sz,0,y*obj_sz
		COLOR OBJECT obj,RGB(col,col,col)
		col=col+128
		IF col>256 THEN col=128
		SC_SETUPCOMPLEXOBJECT obj,0,2
	NEXT x
NEXT y


`make object to use for raycasting
GLOBAL ray_cast_obj_target
ray_cast_obj_target=free_object()
MAKE OBJECT CUBE ray_cast_obj_target,1
HIDE OBJECT ray_cast_obj_target

`make object to use for marker
GLOBAL ray_cast_obj_marker
ray_cast_obj_marker=free_object()
MAKE OBJECT CUBE ray_cast_obj_marker,2
COLOR OBJECT ray_cast_obj_marker,RGB(255,0,0)

GLOBAL cx AS FLOAT
GLOBAL cy AS FLOAT
GLOBAL cz AS FLOAT
GLOBAL col_obj AS INTEGER
GLOBAL nx AS FLOAT
GLOBAL ny AS FLOAT
GLOBAL nz AS FLOAT
GLOBAL face_hit AS INTEGER

`*********************************
`main loop starts here
DO
	`check for raycast to landscape and place marker
	raycast_landscape()
	
	`show or hide the marker depending on collision
	IF col_obj>0
		SHOW OBJECT ray_cast_obj_marker
	ELSE
		HIDE OBJECT ray_cast_obj_marker
	ENDIF
	
	`move the camera
	mouse_control(1.0)
	
	`display info
	TEXT 0,0,"marker on object "+STR$(col_obj)
	TEXT 0,20,"At Position x="+STR$(cx)+" y="+STR$(cy)+" z="+STR$(cz)
	TEXT 0,40,"screen fps="+STR$(SCREEN FPS())
	TEXT 0,60,"object face hit="+STR$(face_hit)
	
	
	SYNC
LOOP

`*********************************
`functions start here
FUNCTION mouse_control(speed AS FLOAT)
	XROTATE CAMERA CAMERA ANGLE X()+MOUSEMOVEY()
	YROTATE CAMERA CAMERA ANGLE Y()+MOUSEMOVEX()
	IF MOUSECLICK()=1 THEN MOVE CAMERA speed
	IF MOUSECLICK()=2 THEN MOVE CAMERA (0-speed)
	dummy=MOUSEMOVEX()
	dummy=MOUSEMOVEY()
ENDFUNCTION

//FUNCTION mouse_control(Speed AS FLOAT)
//	IF SPACEKEY()
//		XROTATE CAMERA CAMERA ANGLE X()+MOUSEMOVEY()
//		YROTATE CAMERA CAMERA ANGLE Y()+MOUSEMOVEX()
//	ENDIF
//	IF msz>MOUSEZ() THEN MOVE CAMERA Speed:msz=MOUSEZ()
//	IF msz<MOUSEZ() THEN MOVE CAMERA (0-Speed):msz=MOUSEZ()
//	r=MOUSEMOVEX()
//	r=MOUSEMOVEY()
//
//ENDFUNCTION 

FUNCTION free_object()
	REPEAT
		INC i 
		IF OBJECT EXIST(i)=0 THEN found=1
	UNTIL found
ENDFUNCTION i

FUNCTION raycast_landscape()
	POSITION OBJECT ray_cast_obj_target,CAMERA POSITION X(),CAMERA POSITION Y(),CAMERA POSITION Z()
	SET OBJECT TO CAMERA ORIENTATION ray_cast_obj_target
	MOVE OBJECT ray_cast_obj_target,10000
	col_obj=SC_RAYCAST(0,CAMERA POSITION X(),CAMERA POSITION Y(),CAMERA POSITION Z(),OBJECT POSITION X(ray_cast_obj_target),OBJECT POSITION Y(ray_cast_obj_target),OBJECT POSITION Z(ray_cast_obj_target),0)
	IF col_obj>0
		cx = SC_GETSTATICCOLLISIONX() : nx = SC_GETCOLLISIONNORMALX()
     	cy = SC_GETSTATICCOLLISIONY() : ny = SC_GETCOLLISIONNORMALY()
      cz = SC_GETSTATICCOLLISIONZ() : nz = SC_GETCOLLISIONNORMALZ()
		POSITION OBJECT ray_cast_obj_marker,cx,cy,cz
      POINT OBJECT ray_cast_obj_marker,cx+(nx*1000),cy+(ny*1000),cz+(nz*1000)
      face_hit=SC_GETFACEHIT()
	ELSE 
		cx=0.0
		cy=0.0
		cz=0.0
		nx=0.0
		ny=0.0
		nz=0.0
		face_hit=0
	ENDIF
ENDFUNCTION

FUNCTION needed_for_sparkys()
	IF MEMBLOCK EXIST(1)
		
	ENDIF
ENDFUNCTION