;   ;Read Terragen Data
;   SeekFile(file,20) : QTS_Size=ReadInt(file)
;   SeekFile(file,28) : QTS_XPTS=ReadInt(file)
;   SeekFile(file,44) : QTS_XSCALE=ReadFloat(file) : QTS_YSCALE=ReadFloat(file)
;   SeekFile(file,60) : QTS_HSCALE=ReadShort(file) : QTS_HBASE=ReadShort(file)
;   
   ;-- Die ersten 100 Bytes in einen String einlesen als Suchbasis
   SeekFile(file,0)
   For xpt%=1 To 100
      ypt%=ReadByte(file)
      tmp$=tmp$+Chr$(ypt%)
   Next
   
   ;-- Angabe "SIZE" ist zwingend notwendig und steht immer an der gleichen Stelle im Header,
   ;-- daher keine Suche notwendig
   SeekFile(file,20): QTS_Size=ReadInt(file)
   
   ;-- Default-Werte für XPTS/YPTS und SCALE, da einige Programme nicht alle optionalen Angaben in
   ;-- den Header schreiben und interne Defaultwerte verwenden
   ;-- Vorbelegung mit Default-Werten
   QTS_XPTS=QTS_Size+1
   QTS_XSCALE=30
   QTS_YSCALE=30
   
   ;-- Suche nach "XPTS" (opt.), normalerweise ist YPTS=XPTS, daher nur "XPTS" auslesen
   xpt%=Instr(tmp$,"XPTS")
   If xpt% Then
      SeekFile(file,xpt%+3) : QTS_XPTS=ReadInt(file)
   End If
   
   ;-- Suche nach "SCAL" (opt.), 3 Floatwerte für X/Y/Z-Skalierung, verwendet werden hier nur 2 Werte,
   ;-- da X- u. Z-Skalierung identisch sind
   xpt%=Instr(tmp$,"SCAL", xpt%+4)
   If xpt% Then
      SeekFile(file,xpt%+3) : QTS_XSCALE=ReadFloat(file) : QTS_YSCALE=ReadFloat(file)
   End If
   
   ;-- Suche nach "ALTW", 2 Floatwerte (Angabe ist zwingend notwendig)
   ;-- Die Position von "ALTW" ist sehr variabel, da es davor 5 optionale Angaben im .TER-Datei-Header
   ;-- gibt und "ALTW" immer der letzte Eintrag im Header ist
   xpt%=Instr(tmp$,"ALTW", xpt%+4)
   SeekFile(file,xpt%+3) : QTS_HSCALE=ReadShort(file) : QTS_HBASE=ReadShort(file)

; -------------------------------------------------------------------------------------------------
; Project Title   : QTS : Quadtree Terrain System
; -------------------------------------------------------------------------------------------------
;
; Author      : Poursin Nicolas
; Email         : Nicolas.poursin(at)3dgametool.com
;
; Version      : 1.1.1         
; Date         : 23.05.2009
;
; -------------------------------------------------------------------------------------------------
;
; Updated by Krischan on 23.05.2009 for use with "BlitzTiles"
;
; - cleaned out unnecessary functions
; - fixed some errors
; - added Terragen loader
; - added tilebased UV-Coordinates, Vertexcolors and Vertexnormals calculation
;
; -------------------------------------------------------------------------------------------------


; -------------------------------------------------------------------------------------------------
; Terms of Use License
; -------------------------------------------------------------------------------------------------
;
; This is a legal agreement ("License Agreement") between you And Poursin Nicolas.
;
;   You are permitted To:
;   - Create For free or commercial games
;   - Free Tool
;   
;   You are Not permitted To:
;   1) Sell, resell it
;   2) Use it, in commercial tool
;   3) Modify the products And sell it                   
;
; -------------------------------------------------------------------------------------------------


; -------------------------------------------------------------------------------------------------
; Types
; -------------------------------------------------------------------------------------------------
Type QTS_TPatch
   
   Field mesh%
   Field surf%
   Field x#
   Field y#
   Field z#
   Field xtab%
   Field ztab%
   
End Type


; -------------------------------------------------------------------------------------------------
; Globals
; -------------------------------------------------------------------------------------------------
Global QTS_Terrain%,QTS_QuadTree%,QTS_HeightMap%,QTS_Vertex%,QTS_Tile%,QTS_BlockSize%
Global QTS_Size%,QTS_XPTS%,QTS_XSCALE#,QTS_YSCALE#,QTS_HSCALE#,QTS_HBASE#
Global QTS_MinHeight#,QTS_MaxHeight#,QTS_HeightMapSize%


; -------------------------------------------------------------------------------------------------
; Initial Function
; -------------------------------------------------------------------------------------------------
Function QTS_CreateTerrain(filename$,tiles%,edgeerror#,calcnormals%,normalsfactor#,switchnormals%,usevertexcolors%,vertexintensity#,colormap%)
   
   QTS_LoadHeightMap(filename)
   QTS_BlockSize=(QTS_HeightMapSize-1)/16/tiles
   QTS_Terrain=CreateMesh()
   QTS_Tile=CreateBank(64*64*4)
   QTS_Roughness(edgeerror)
   QTS_CreatePatch(QTS_BlockSize)
   QTS_Texture(tiles,calcnormals,normalsfactor,switchnormals,usevertexcolors,vertexintensity,colormap)
   
   FreeBank QTS_QuadTree
   FreeBank QTS_HeightMap
   FreeBank QTS_Vertex
   
End Function


; -------------------------------------------------------------------------------------------------
; Terrain Roughness
; -------------------------------------------------------------------------------------------------
Function QTS_Roughness(error#=1.0)
   
   Local edgelength%=3,morph#
   Local x%,z%,node%,kill%
   Local edgeoffset%,childoffset%
   
   While edgelength<=17
      
      edgeoffset=(edgelength-1)/2
      childoffset=(edgelength-1)/4
      
      z=edgeoffset
      
      While z<QTS_HeightMapSize
         
         If edgelength=3 Then BT_UpdateBar("Calculating Quadtree",z,QTS_HeightMapSize,10,40)
         
         x= edgeoffset
         While x<QTS_HeightMapSize
            
            node = 0
            kill=0
            
            If edgelength>3 Then
               node=QTS_GetMV(x-childoffset,z-childoffset)
               node=QTS_Max(node,QTS_GetMV(x+childoffset,z-childoffset))
               node=QTS_Max(node,QTS_GetMV(x+childoffset,z+childoffset))
               node=QTS_Max(node,QTS_GetMV(x-childoffset,z+childoffset))
            EndIf
            
            If edgelength=3 Or node=0 Then
               
               QTS_SetMV(x-edgeoffset,z-edgeoffset,1)
               QTS_SetMV(x+edgeoffset,z-edgeoffset,1)
               QTS_SetMV(x+edgeoffset,z+edgeoffset,1)
               QTS_SetMV(x-edgeoffset,z+edgeoffset,1)
               
               morph=Abs(QTS_GetHeight(x,z-edgeoffset)-((QTS_GetHeight(x-edgeoffset,z-edgeoffset)+QTS_GetHeight(x+edgeoffset,z-edgeoffset))/2))
               
               If morph>error Then
                  QTS_SetMV(x,z-edgeoffset,1)
               Else
                  If edgelength>3 Then QTS_SetMV(x,z-edgeoffset,0)
                  kill=kill +1
               EndIf
               
               morph=Abs(QTS_GetHeight(x+edgeoffset,z)-((QTS_GetHeight(x+edgeoffset,z-edgeoffset)+QTS_GetHeight(x+edgeoffset,z+edgeoffset))/2))
               
               If morph>error Then
                  QTS_SetMV(x+edgeoffset,z,1)
               Else
                  If edgelength>3 Then QTS_SetMV(x+edgeoffset,z,0)
                  kill=kill +1
               EndIf
               
               morph=Abs(QTS_GetHeight(x,z+edgeoffset)-((QTS_GetHeight(x+edgeoffset,z+edgeoffset)+QTS_GetHeight(x-edgeoffset,z+edgeoffset))/2))
               
               If morph>error Then
                  QTS_SetMV(x,z+edgeoffset,1)
               Else
                  If edgelength>3 Then QTS_SetMV(x,z+edgeoffset,0)
                  kill=kill+1
               EndIf               
               
               morph=Abs(QTS_GetHeight(x-edgeoffset,z)-((QTS_GetHeight(x-edgeoffset,z+edgeoffset)+QTS_GetHeight(x-edgeoffset,z-edgeoffset))/2))
               
               If morph>error Then
                  QTS_SetMV(x-edgeoffset,z,1)
               Else
                  If edgelength>3 Then QTS_SetMV(x-edgeoffset,z,0)
                  kill = kill +1
               EndIf
               
               QTS_SetMV(x,z,1)
               
               If kill=4 Then   
                  morph=Abs(QTS_GetHeight(x,z)-((QTS_GetHeight(x-edgeoffset,z-edgeoffset)+QTS_GetHeight(x+edgeoffset,z+edgeoffset))/2))
                  If morph<=error Then
                     morph=Abs(QTS_GetHeight(x,z)-((QTS_GetHeight(x+edgeoffset,z-edgeoffset)+QTS_GetHeight(x-edgeoffset,z+edgeoffset))/2))
                     If morph<=error Then QTS_SetMV(x,z,0)
                  EndIf
               EndIf
               
            Else If edgelength>3
               
               QTS_SetMV(x,z-edgeoffset,1)
               QTS_SetMV(x+edgeoffset,z,1)
               QTS_SetMV(x,z+edgeoffset,1)
               QTS_SetMV(x-edgeoffset,z,1)   
               
            EndIf
            
            x=x+edgelength-1
            
         Wend
         
         z=z+edgelength-1
         
      Wend
      
      edgelength=(edgelength Shl 1 )-1
      
   Wend
   
   For z=16 To QTS_HeightMapSize-1 Step 32
      For x=16 To QTS_HeightMapSize-1 Step 32
         QTS_ProcessNode(x,z,33,False,False)
      Next
   Next
   
End Function


; -------------------------------------------------------------------------------------------------
; Renders a node
; -------------------------------------------------------------------------------------------------
Function QTS_RenderNode(x%,z%,edgelength%,edgeoffset%,surf%,brender%)
   
   Local VC%,V1%,V2%,VE%
   Local xx%,xstart%,xend%
   Local zz%,zstart%,zend%
   
   If brender Then
      VC = QTS_AddVertex( x,z,surf)
      V1 = QTS_AddVertex( x-edgeoffset , z-edgeoffset ,surf)
      VE = QTS_AddVertex( x+edgeoffset , z-edgeoffset , surf)
   Else
      QTS_SetMV( x-edgeoffset , z-edgeoffset)
      QTS_SetMV( x+edgeoffset , z-edgeoffset )
   EndIf
   
   zz=z-edgeoffset
   xstart=x-edgeoffset+1
   xend=x-edgeoffset+edgelength-2
   
   For xx=xstart To xend
      
      If QTS_GetMV(xx,zz)>0 Then
         
         If brender Then
            V2=QTS_AddVertex(xx,zz,surf)
            AddTriangle surf,V1,V2,VC
         Else
            QTS_SetMV(xx,zz)
         EndIf
         
         V1=V2
         
      EndIf
      
   Next
   
   If brender Then
      AddTriangle surf,V1,VE,VC
      VC=QTS_AddVertex(x,z,surf)
      V1=QTS_AddVertex(x-edgeoffset,z+edgeoffset,surf)
      VE=QTS_AddVertex(x+edgeoffset,z+edgeoffset,surf)
   Else
      QTS_SetMV(x-edgeoffset,z+edgeoffset)
      QTS_SetMV(x+edgeoffset,z+edgeoffset)
   EndIf
   
   zz=z+edgeoffset
   xstart=x-edgeoffset+1
   xend=x-edgeoffset+edgelength-2
   
   For xx=xstart To xend
      
      If QTS_GetMV(xx,zz)>0 Then
         
         If brender Then
            V2=QTS_AddVertex(xx,zz,surf)
            AddTriangle surf,V2,V1,VC
         Else
            QTS_SetMV(xx,zz)
         EndIf
         
         V1=V2
         
      EndIf
      
   Next
   
   If brender Then
      AddTriangle surf,VE,V1,VC
      VC=QTS_AddVertex(x,z,surf)
      V1=QTS_AddVertex(x+edgeoffset,z-edgeoffset,surf)
      VE=QTS_AddVertex(x+edgeoffset,z+edgeoffset,surf)
   Else
      QTS_SetMV(x+edgeoffset,z-edgeoffset)
      QTS_SetMV(x+edgeoffset,z+edgeoffset)
   EndIf
   
   xx=x+edgeoffset
   zstart=z-edgeoffset+1
   zend=z-edgeoffset+edgelength-2
   
   For zz=zstart To zend
      
      If QTS_GetMV(xx,zz)>0 Then
         
         If brender Then
            V2=QTS_AddVertex(xx,zz,surf)
            AddTriangle surf,V1,V2,VC
         Else
            QTS_SetMV(xx,zz)
         EndIf
         
         V1=V2
         
      EndIf
      
   Next
   
   If brender Then
      AddTriangle surf,V1,VE,VC
      VC=QTS_AddVertex(x,z,surf)
      V1=QTS_AddVertex(x-edgeoffset,z-edgeoffset,surf)
      VE=QTS_AddVertex(x-edgeoffset,z+edgeoffset,surf)
   Else
      QTS_SetMV(x-edgeoffset,z-edgeoffset)
      QTS_SetMV(x-edgeoffset,z+edgeoffset)
   EndIf
   
   xx=x-edgeoffset
   zstart=z-edgeoffset+1
   zend=z-edgeoffset+edgelength-2
   
   For zz=zstart To zend
      
      If QTS_GetMV(xx,zz)>0 Then
         
         If brender Then
            V2=QTS_AddVertex(xx,zz,surf)
            AddTriangle surf,V2,V1,VC
         Else
            QTS_SetMV(xx,zz)
         EndIf
         
         V1=V2
         
      EndIf
      
   Next
   
   If brender Then AddTriangle surf,VE,V1,VC
   
End Function


; -------------------------------------------------------------------------------------------------
; Creates a Tile patch
; -------------------------------------------------------------------------------------------------
Function QTS_CreatePatch(blocksize%)
   
   Local x%,z%
   Local xtab%,ztab%
   Local xx#,zz#
   Local mesh%,surf%
   Local bx%,bz%,cx%,cz%
   
   While z<=QTS_HeightMapSize
      
      BT_UpdateBar("Creating Terrain Patches",z,QTS_HeightMapSize,40,50)
      
      x=0
      xtab=0
      
      While x<=QTS_HeightMapSize
         
         xx=x+(blocksize*16/2)
         zz=z+(blocksize*16/2)
         
         mesh=CreateMesh()
         surf=CreateSurface(mesh)
         
         ; make tile pickable
         EntityPickMode mesh,2
         
         QTS_Vertex=CreateBank((QTS_HeightMapSize)*(QTS_HeightMapSize)*4)
         
         For bz=8 To blocksize*16 Step 16
            
            For bx=8 To blocksize*16 Step 16
               
               cx=x+bx
               cz=z+bz
               If cx<QTS_HeightMapSize And cz<QTS_HeightMapSize Then QTS_ProcessNode(cx,cz,17,surf,True)
               
            Next
            
         Next
         
         FreeBank QTS_Vertex
         
         EntityParent mesh,QTS_Terrain
         
         t.QTS_TPatch = New QTS_TPatch
         t\mesh=mesh
         t\surf=surf
         t\x=xtab*(blocksize*16/2)*2
         t\y=MeshHeight(mesh)/2
         t\z=-ztab*(blocksize*16/2)*2
          t\xtab=xtab
         t\ztab=ztab
         
         PokeInt QTS_Tile,((ztab*64+xtab)*4),Handle(t)
         
         x=x+(blocksize*16)
         
         xtab=xtab+1
         
      Wend
      
      z=z+(blocksize*16)
      ztab=ztab+1
      
   Wend
   
End Function


; -------------------------------------------------------------------------------------------------
; Processes a Node
; -------------------------------------------------------------------------------------------------
Function QTS_ProcessNode(x,z,edgelength%,surf%,brender%)
   
   Local edgeoffset%=(edgelength-1)/2
   Local childoffset=(edgelength-1)/4
   Local node%=QTS_GetMV(x,z)
   
   If node=1 Then
      
      If  edgelength=3 Then
         
         QTS_RenderNode(x,z,edgelength,edgeoffset,surf,brender)
         
      Else
         
         If QTS_GetMV(x-childoffset,z-childoffset)>0 Then
            
            QTS_ProcessNode(x-childoffset,z-childoffset,edgelength-(edgelength/2),surf,brender)
            
         Else
            
            QTS_RenderNode(x-childoffset,z-childoffset,edgelength-(edgelength/2),edgeoffset-(edgeoffset/2),surf,brender)
            
         EndIf
         
         If QTS_GetMV(x+childoffset,z-childoffset)>0 Then
            
            QTS_ProcessNode(x+childoffset,z-childoffset,edgelength-(edgelength/2),surf,brender)
            
         Else
            
            QTS_RenderNode(x+childoffset,z-childoffset,edgelength-(edgelength/2),edgeoffset-(edgeoffset/2),surf,brender)
            
         EndIf
         
         If QTS_GetMV(x-childoffset,z+childoffset)>0 Then
            
            QTS_ProcessNode(x-childoffset,z+childoffset,edgelength-(edgelength/2),surf,brender)
            
         Else
            
            QTS_RenderNode(x-childoffset,z+childoffset,edgelength-(edgelength/2),edgeoffset-(edgeoffset/2),surf,brender)
            
         EndIf
         
         If QTS_GetMV(x+childoffset,z+childoffset)>0 Then
            
            QTS_ProcessNode(x+childoffset,z+childoffset,edgelength-(edgelength/2),surf,brender)
            
         Else
            
            QTS_RenderNode(x+childoffset,z+childoffset,edgelength-(edgelength/2),edgeoffset-(edgeoffset/2),surf,brender)
            
         EndIf
         
      EndIf
      
   Else
      
      QTS_RenderNode(x,z,edgelength,edgeoffset,surf,brender)
      
   EndIf
   
End Function


; -------------------------------------------------------------------------------------------------
; Central Addvertex function
; -------------------------------------------------------------------------------------------------
Function QTS_AddVertex(x%,z%,surf%)
   
   Local y#,v%
   
   If PeekInt(QTS_Vertex,QTS_MatrixIndex(x,z)*4)=0 Then
      
      y=QTS_GetHeight(x,z)
      v=AddVertex(surf,(-QTS_HeightMapSize/2.0)+x,y,(QTS_HeightMapSize/2.0)-z,0,0)
      PokeInt QTS_Vertex, QTS_MatrixIndex(x,z)*4,v+1
      
   Else
      
      v=PeekInt(QTS_Vertex,QTS_MatrixIndex(x,z)*4)-1
      
   EndIf
   
   Return v
   
End Function


; -------------------------------------------------------------------------------------------------
; Loads a Terragen File and its according RAW Colormap / Normalmap
; -------------------------------------------------------------------------------------------------
Function QTS_LoadHeightMap(filename$)
   
   Local xpt%,ypt%,h#
   Local file%=ReadFile(filename)
   
   ; read Terragen data
   SeekFile(file,20) : QTS_Size=ReadInt(file)
   SeekFile(file,28) : QTS_XPTS=ReadInt(file)
   SeekFile(file,44) : QTS_XSCALE=ReadFloat(file) : QTS_YSCALE=ReadFloat(file)
   SeekFile(file,60) : QTS_HSCALE=ReadShort(file) : QTS_HBASE=ReadShort(file)
   
   ; get the size of the map and create heightmap and quadtree banks
   QTS_HeightMapSize=QTS_XPTS
   QTS_HeightMap=CreateBank(QTS_XPTS*QTS_XPTS*2)
   QTS_QuadTree=CreateBank((QTS_HeightMapSize)*(QTS_HeightMapSize))
   
   ; write data to bank
   For ypt=QTS_XPTS To 1 Step -1
      
      If ypt Mod 32=0 Then BT_UpdateBar("Loading Terragen Data",(QTS_XPTS-ypt+1),QTS_XPTS,0,10)
      
      For xpt=1 To QTS_XPTS Step 1
         PokeShort QTS_HeightMap,((xpt-1)+(ypt-1)*QTS_XPTS)*2,ReadShort(file)-32768
         h=QTS_GetHeight(xpt-1,ypt-1)
         If h<QTS_MinHeight Then QTS_MinHeight=h
         If h>QTS_MaxHeight Then QTS_MaxHeight=h
      Next
   Next
   
   CloseFile(file)
   
End Function


; -------------------------------------------------------------------------------------------------
; Prepares UV-Coordinates, Vertexcolors and Vertexnormals of a tile
; -------------------------------------------------------------------------------------------------
Function QTS_Texture(tiles%,calcnormals%,normalsfactor#,switchnormals%,usevertexcolors%,vertexintensity#,colormap%)
   
   Local x%,z%,obj%,vx#,vz#
   Local surf%,vertices%,v%,rgb%,r%,g%,b%
   Local cbuf%=ImageBuffer(colormap)
   Local cfactor#=ImageWidth(colormap)*1.0/QTS_HeightMapSize
   
   LockBuffer cbuf
   
   For z=0 To tiles-1
      
      If z Mod 2=0 Then BT_UpdateBar("Calculating Vertex Normals",z,tiles-1,50,70)
      
      For x=0 To tiles-1
         
         obj=PeekInt(QTS_Tile,(z*64+x)*4)
         
         If obj>0 Then
            
            t.QTS_TPatch=Object.QTS_TPatch(obj)
            
            If t\mesh<>-1 Then
               
               surf = GetSurface(t\mesh,1)
               vertices = CountVertices(surf)
               
               For v=0 To vertices-1
                  
                  ; calculate map position from vertex position
                  vx=VertexX(surf,v)+(QTS_HeightMapSize/2.0)
                  vz=-VertexZ(surf,v)+(QTS_HeightMapSize/2.0)
                  
                  ; Calculate Vertexcolors
                  If usevertexcolors Then
                     rgb=ReadPixelFast(Int(Floor(vx*cfactor)),Int(Floor(vz*cfactor)),cbuf)
                     r=Int(Floor(((rgb And $ff0000)/$10000)*vertexintensity))
                     g=Int(Floor(((rgb And $ff00)/$100)*vertexintensity))
                     b=Int(Floor(((rgb And $ff))*vertexintensity))
                  Else
                     r=255*vertexintensity
                     g=255*vertexintensity
                     b=255*vertexintensity
                  EndIf
                  r=Int(Floor(r)) : If r<0 Then r=0 Else If r>255 Then r=255
                  g=Int(Floor(g)) : If g<0 Then g=0 Else If g>255 Then g=255
                  b=Int(Floor(b)) : If b<0 Then b=0 Else If b>255 Then b=255
                  
                  ; Color the vertex
                  VertexColor surf,v,r,g,b,1
                  
                  ; calculate Normals by height and vertex
                  If calcnormals Then QTS_CalcNormal(surf,v,vx,vz,normalsfactor,switchnormals)
                  
                  ; Calculate UV-Coordinates
                  vx#=(vx/((QTS_HeightMapSize-1*1.0)/tiles))-t\xtab
                  vz#=(vz/((QTS_HeightMapSize-1*1.0)/tiles))-t\ztab
                  VertexTexCoords surf,v,vx,vz
                  
               Next
               
            EndIf
            
         EndIf
         
      Next
      
   Next
   
   UnlockBuffer cbuf
   
End Function


; -----------------------------------------------------------------------------
; Calculates the Vertex Normal at a given position
; -----------------------------------------------------------------------------
Function QTS_CalcNormal(surf%,v%,x%,y%,normalsfactor#,switchnormals%)
   
   Local xm1%,xp1%,ym1%,yp1%
   Local tl%,tm%,tr%,ml%,mm%,mr%,bl%,bm%,br%
   Local vx#,vy#,vz#
   Local isq2#,sum#
   Local al#,ar#,at#,ab#
   Local m#
   
   ; limit heightmap
   If x>0 Then xm1=x-1 Else xm1=0
   If x<QTS_HeightMapSize-1 Then xp1=x+1 Else xp1=QTS_HeightMapSize-1
   If y>0 Then ym1=y-1 Else ym1=0
   If y<QTS_HeightMapSize-1 Then yp1=y+1 Else yp1=QTS_HeightMapSize-1
   
   ; get the middle and the surrounding heights
   tl=QTS_Normalize(QTS_GetHeight(xm1,ym1),QTS_MinHeight,QTS_MaxHeight,0,65535)
   tm=QTS_Normalize(QTS_GetHeight(x  ,ym1),QTS_MinHeight,QTS_MaxHeight,0,65535)
   tr=QTS_Normalize(QTS_GetHeight(xp1,ym1),QTS_MinHeight,QTS_MaxHeight,0,65535)
   ml=QTS_Normalize(QTS_GetHeight(xm1,y  ),QTS_MinHeight,QTS_MaxHeight,0,65535)
   mm=QTS_Normalize(QTS_GetHeight(x  ,y  ),QTS_MinHeight,QTS_MaxHeight,0,65535)
   mr=QTS_Normalize(QTS_GetHeight(xp1,y  ),QTS_MinHeight,QTS_MaxHeight,0,65535)
   bl=QTS_Normalize(QTS_GetHeight(xm1,yp1),QTS_MinHeight,QTS_MaxHeight,0,65535)
   bm=QTS_Normalize(QTS_GetHeight(x  ,yp1),QTS_MinHeight,QTS_MaxHeight,0,65535)
   br=QTS_Normalize(QTS_GetHeight(xp1,yp1),QTS_MinHeight,QTS_MaxHeight,0,65535)
   
   vx=0.0
   vy=0.0
   vz=1.0
   
   isq2=1.0/Sqr(2.0)
   sum=1.0+isq2+isq2
   
   al=(tl*isq2+ml+bl*isq2)/sum
   ar=(tr*isq2+mr+br*isq2)/sum
   at=(tl*isq2+tm+tr*isq2)/sum
   ab=(bl*isq2+bm+br*isq2)/sum
   
   vx=(al-ar)/(65535.0)
   vy=(at-ab)/(65535.0)
   
   m=QTS_Max(0,vx*vx+vy*vy)
   m=QTS_Min(m,1.0)
   
   vz=Sqr(1.0-m)
   
   If normalsfactor<>0.0
      vz=vz/normalsfactor
      m#=Sqr(vx*vx+vy*vy+vz*vz)
      vx=vx/m
      vy=vy/m
      vz=vz/m
   EndIf
   
   If switchnormals Then VertexNormal surf,v,vx,vz,vy Else VertexNormal surf,v,vx,vy,vz
   
End Function


; -----------------------------------------------------------------------------
; Normalize a value
; -----------------------------------------------------------------------------
Function QTS_Normalize#(value#=128.0,value_min#=0.0,value_max#=255.0,norm_min#=0.0,norm_max#=1.0)
   
   Return ((value#-value_min#)/(value_max#-value_min#))*(norm_max#-norm_min#)+norm_min#
   
End Function


; -------------------------------------------------------------------------------------------------
; Gets a Matrix Value
; -------------------------------------------------------------------------------------------------
Function QTS_GetMV(x%,z%)
   
   Return PeekByte(QTS_QuadTree,QTS_MatrixIndex(x,z))
   
End Function


; -------------------------------------------------------------------------------------------------
; Sets a Matrix Value
; -------------------------------------------------------------------------------------------------
Function QTS_SetMV(x%,z%,value%=1)
   
   PokeByte QTS_QuadTree,QTS_MatrixIndex(x,z),value
   
End Function


; -------------------------------------------------------------------------------------------------
; Gets a Matrix Index
; -------------------------------------------------------------------------------------------------
Function QTS_MatrixIndex(x%,z%)
   
   Return ((z*QTS_HeightMapSize)+x)
   
End Function


; -------------------------------------------------------------------------------------------------
; Returns the minimum value of two values
; -------------------------------------------------------------------------------------------------
Function QTS_Min#(v1#,v2#)
   
   If v1<v2 Then Return v1 Else Return v2
   
End Function


; -------------------------------------------------------------------------------------------------
; Returns the maximum value of two values
; -------------------------------------------------------------------------------------------------
Function QTS_Max#(v1#,v2#)
   
   If v1>v2 Then Return v1 Else Return v2
   
End Function


; -------------------------------------------------------------------------------------------------
; Calculates the exact height at a given position
; -------------------------------------------------------------------------------------------------
Function QTS_GetHeight#(x#,z#)
   
   Local short%=PeekShort(QTS_HeightMap,((Int(Floor(z*QTS_HeightMapSize)))+Int(Floor(x)))*2)-32768
   Return QTS_HBASE+short*QTS_HSCALE/65536.0*QTS_YSCALE
   
End Function