new matrix functions - GameCreators Forum

Author

Message

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 7th Jun 2004 06:24 Edited at: 8th Nov 2012 16:36

Link

Default matrix too slow for you? Then try mine!

You can now texture the matrix with various tiles. That alone I think was the biggest pain in the butt! Recently added "pick_matrix()". Code demonstrates use of this function. It gets the x,y,z coordinates on the matrix given 2d screen coordinates.(such as your mouse cursor)

Functions include:
prepare_matrix_data()
create_matrix()
prepare_matrix_texture()
set_matrix_height()
set_matrix_tile()
update_matrix()
position_matrix()
get_ground_height()
pick_matrix()

With the demo code below, I get between 460 and 500 fps.

http://www.dannywartnaby.co.uk/rgt/attachments/matrix_functions.zip

[edited: 10-14-2005]
code posted due to LLRGT server being down for an extended period

`set display mode 800,600,32

load image "terrainsand.bmp", 1
load image "terrainheightmap.bmp", 2
load image "terraincolormap.bmp", 3
load image "terrainalphamap.bmp", 4

randomize timer()
sync on
`sync rate 100
autocam off
hide mouse

REM INCLUDE THIS AT START OF YOUR PROGRAM
REM internal matrix data used by matrix functions
type matriks
   ix as integer
   iy as integer
   xsegs as integer
   zsegs as integer
   width as float
   depth as float
   mem_numb as integer
   obj as integer
   image as integer
   mesh as integer
   prepared as boolean
   x as float
   y as float
   z as float
   cull as integer
   light as integer
   specular as integer
endtype

REM INCLUDE THIS AT START OF YOUR PROGRAM
REM dim array size by maximum number of matrices you'll have
dim matrix(1) as matriks
mx = 128
mz = 128
sizex# = 4000
sizez# = 4000
REM must be called before you can create a matrix
prepare_matrix_data(1,1,1,1)
REM Make a new matrix
create_matrix(1,sizex#, sizez#,mx,mz)
REM prepare a texture for use with the matrix
`prepare_matrix_texture(1,1,2,2)
prepare_matrix_texture(1,1,1,1)

set_matrix_from_heightmap(1,2,500.0)

set_matrix_from_colormap(1,3)

set_matrix_from_alphamap(1,4)

configure_matrix_normals(1)

set_matrix_light(1,0)

set_matrix_specular(1,0)

scale_matrix_texture(1,8,8)

REM update the matrix
update_matrix(1)

`set alpha mapping on 1, 100

load object "terrainskybox.x", 2
set object texture 2,2,0
position object 2, 2000,0,2000
scale object 2, 100000,100000,100000
set object fog 2, 0
set object light 2, 0
set object ambient 2, 0

set camera range 1, 65000

DO

gosub camera_stuff

text 2,2,str$(screen fps())

sync
LOOP

REM ==========================================================================
REM Parameters:
REM matrix number
REM object used to create matrix
REM memblock number used to create matrix
REM mesh number used to create object from memblock
function prepare_matrix_data(number as integer, object as integer, mb as integer, mesh as integer)
   matrix(number).obj = object
   matrix(number).mem_numb = mb
   matrix(number).mesh = mesh
endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM number of image tiles across
REM number of image tiles down
function scale_matrix_texture(number as integer, across as integer, down as integer)
   matrix(number).ix = across
   matrix(number).iy = down
   matrix(number).prepared = 1

tile = 1
   ln = 0
   for z = matrix(number).zsegs to 1 step -1
      for x = 1 to matrix(number).xsegs
         tl = ln*across + tile
         set_matrix_tile(number, x, z, tl)
         inc tile, 1
         if tile > across then tile = 1
      next x
      inc ln, 1
      if ln > down-1 then ln = 0
   next z
endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM image number
REM number of image tiles across
REM number of image tiles down
function prepare_matrix_texture(number as integer, image as integer, across as integer, down as integer)
   matrix(number).ix = across
   matrix(number).iy = down
   matrix(number).image = image
   matrix(number).prepared = 1
   `texture object matrix(number).obj, matrix(number).image

for z = 1 to matrix(number).zsegs
      for x = 1 to matrix(number).xsegs
         set_matrix_tile(number, x, z, 1)
      next x
   next z

endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM width of matrix
REM depth of matrix
REM number of X segments
REM number of Z segments
function create_matrix(number as integer, width as float, depth as float, xsegs as integer, zsegs as integer)
   fvf = 338
   size = 36
   matrix(number).width = width
   matrix(number).depth = depth
   matrix(number).xsegs = xsegs
   matrix(number).zsegs = zsegs
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = depth/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb

make memblock mem_numb, total_size
   write memblock dword mem_numb, 0, fvf
   write memblock dword mem_numb, 4, size
   write memblock dword mem_numb, 8, numb_verts

tile = 0
   for z = 1 to zsegs
      for x = 1 to xsegs
         location = tile*size*6 + 12

x1# = tile_size_x# * (x-1)
         y1# = 0
         z1# = tile_size_z# * (z-1)

x2# = tile_size_x# * (x-1)
         y2# = 0
         z2# = tile_size_z# * z

x3# = tile_size_x# * x
         y3# = 0
         z3# = tile_size_z# * z

x4# = x1#
         y4# = y1#
         z4# = z1#

x5# = x3#
         y5# = y3#
         z5# = z3#

x6# = x3#
         y6# = 0
         z6# = z1#

rem vert 1 - x,y,z, normals x,y,z, diffuse color
         write memblock float mem_numb, location, x1#
         write memblock float mem_numb, location+4, y1#
         write memblock float mem_numb, location+8, z1#
         write memblock float mem_numb, location+12, 0
         write memblock float mem_numb, location+16, 1
         write memblock float mem_numb, location+20, 0
         write memblock dword mem_numb, location+24, rgb(255,255,255)

rem vert 2 - x,y,z
         temp_size = size
         write memblock float mem_numb, location+temp_size, x2#
         write memblock float mem_numb, location+temp_size+4, y2#
         write memblock float mem_numb, location+temp_size+8, z2#
         write memblock float mem_numb, location+temp_size+12, 0
         write memblock float mem_numb, location+temp_size+16, 1
         write memblock float mem_numb, location+temp_size+20, 0
         write memblock dword mem_numb, location+temp_size+24, rgb(255,255,255)

rem vert 3 - x,y,z
         temp_size = size*2
         write memblock float mem_numb, location+temp_size, x3#
         write memblock float mem_numb, location+temp_size+4, y3#
         write memblock float mem_numb, location+temp_size+8, z3#
         write memblock float mem_numb, location+temp_size+12, 0
         write memblock float mem_numb, location+temp_size+16, 1
         write memblock float mem_numb, location+temp_size+20, 0
         write memblock dword mem_numb, location+temp_size+24, rgb(255,255,255)

rem vert 4 - x,y,z
         temp_size = size*3
         write memblock float mem_numb, location+temp_size, x4#
         write memblock float mem_numb, location+temp_size+4, y4#
         write memblock float mem_numb, location+temp_size+8, z4#
         write memblock float mem_numb, location+temp_size+12, 0
         write memblock float mem_numb, location+temp_size+16, 1
         write memblock float mem_numb, location+temp_size+20, 0
         write memblock dword mem_numb, location+temp_size+24, rgb(255,255,255)

rem vert 5 - x,y,z
         temp_size = size*4
         write memblock float mem_numb, location+temp_size, x5#
         write memblock float mem_numb, location+temp_size+4, y5#
         write memblock float mem_numb, location+temp_size+8, z5#
         write memblock float mem_numb, location+temp_size+12, 0
         write memblock float mem_numb, location+temp_size+16, 1
         write memblock float mem_numb, location+temp_size+20, 0
         write memblock dword mem_numb, location+temp_size+24, rgb(255,255,255)

rem vert 6 - x,y,z
         temp_size = size*5
         write memblock float mem_numb, location+temp_size, x6#
         write memblock float mem_numb, location+temp_size+4, y6#
         write memblock float mem_numb, location+temp_size+8, z6#
         write memblock float mem_numb, location+temp_size+12, 0
         write memblock float mem_numb, location+temp_size+16, 1
         write memblock float mem_numb, location+temp_size+20, 0
         write memblock dword mem_numb, location+temp_size+24, rgb(255,255,255)

inc tile, 1

next x
   next z

make mesh from memblock  1, mem_numb
   make object matrix(number).obj,1,0

endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
REM tile is an image tile number (from prepare_matrix_texture())
function set_matrix_tile(number as integer, tileX as integer, tileZ as integer, tile as integer)

if tileX < 0 OR tileX > matrix(number).xsegs OR tileX < 0 OR tileZ > matrix(number).zsegs OR matrix(number).prepared = 0
      exitfunction
   endif

if matrix(number).ix = 0 then matrix(number).ix = 1
   if matrix(number).iy = 0 then matrix(number).iy = 1

mem_numb = matrix(number).mem_numb
   size = 36
   boffset = size*6

location = 12 + ((tileZ-1)*matrix(number).xsegs*boffset + (tileX-1)*boffset)

x_temp = wrap(tile, matrix(number).ix)

mix# = matrix(number).ix
   x_max# = x_temp/mix#
   x_min# = (x_temp-1)/mix#

y_temp = int((tile - x_temp) / mix#) + 1.0

miy# = matrix(number).iy
   y_max# = y_temp/miy#
   y_min# = (y_temp-1)/miy#

if y_min# > 0 then y_min# = y_min# + 0.01
   if x_min# > 0 then x_min# = x_min# + 0.01

rem vert 1 - UV coordinates
   write memblock float mem_numb, location+28, x_min#
   write memblock float mem_numb, location+32, y_max#

rem vert 2
   write memblock float mem_numb, location+64, x_min#
   write memblock float mem_numb, location+68, y_min#

rem vert 3
   write memblock float mem_numb, location+100, x_max#
   write memblock float mem_numb, location+104, y_min#

rem vert 4
   write memblock float mem_numb, location+136, x_min#
   write memblock float mem_numb, location+140, y_max#

rem vert 5
   write memblock float mem_numb, location+172, x_max#
   write memblock float mem_numb, location+176, y_min#

rem vert 6
   write memblock float mem_numb, location+208, x_max#
   write memblock float mem_numb, location+212, y_max#

endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
REM diffuse color

function set_matrix_diffuse(number as integer, tile_x as integer, tile_z as integer, color as dword)

if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif
   size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

REM verts 3 and 5
   if tile_x > 0 and tile_z > 0
      gx = tile_x - 1
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+96, color
      write memblock dword mem_numb, location+168, color
   endif

REM vert 2
   if tile_z > 0 and tile_x < matrix(number).xsegs
      gx = tile_x
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+60, color
   endif

rem vert 6
   if tile_x > 0 and tile_z < matrix(number).zsegs
     gx = tile_x - 1
     gz = tile_z
     location = gz*lensize + gx*boffset + 12
     write memblock dword mem_numb, location+204, color
   endif

rem verts 1 and 4
   if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      gx = tile_x
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+24, color
      write memblock dword mem_numb, location+132, color
   endif

endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
REM alpha value
function set_matrix_alpha(number as integer, tile_x as integer, tile_z as integer, alpha as integer)

if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif
   size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

REM verts 3 and 5
   if tile_x > 0 and tile_z > 0
      gx = tile_x - 1
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+99, alpha
      write memblock dword mem_numb, location+171, alpha
   endif

REM vert 2
   if tile_z > 0 and tile_x < matrix(number).xsegs
      gx = tile_x
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+63, alpha
   endif

rem vert 6
   if tile_x > 0 and tile_z < matrix(number).zsegs
     gx = tile_x - 1
     gz = tile_z
     location = gz*lensize + gx*boffset + 12
     write memblock dword mem_numb, location+207, alpha
   endif

rem verts 1 and 4
   if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      gx = tile_x
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+27, alpha
      write memblock dword mem_numb, location+135, alpha
   endif
endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
REM height (height of tile you're setting)

function set_matrix_height(number as integer, tile_x as integer, tile_z as integer, height# as float)

if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif

size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

REM verts 3 and 5
   if tile_x > 0 and tile_z > 0
      gx = tile_x - 1
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+76, height#
      write memblock float mem_numb, location+148, height#
   endif

REM vert 2
   if tile_z > 0 and tile_x < matrix(number).xsegs
      gx = tile_x
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+40, height#
   endif

rem vert 6
   if tile_x > 0 and tile_z < matrix(number).zsegs
   `and tile_z < matrix(number).zsegs
     gx = tile_x - 1
     gz = tile_z
     location = gz*lensize + gx*boffset + 12
     write memblock float mem_numb, location+184, height#
   endif

rem verts 1 and 4
   if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      gx = tile_x
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+4, height#
      write memblock float mem_numb, location+112, height#
   endif

endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
REM nx,ny,nz - normal
function set_matrix_normal(number as integer, tile_x as integer, tile_z as integer, nx as float, ny as float, nz as float)

if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif
   size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

REM verts 3 and 5
   if tile_x > 0 and tile_z > 0
      gx = tile_x - 1
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+84, nx
      write memblock float mem_numb, location+88, ny
      write memblock float mem_numb, location+92, nz

write memblock float mem_numb, location+156, nx
      write memblock float mem_numb, location+160, ny
      write memblock float mem_numb, location+164, nz
   endif

REM vert 2
   if tile_z > 0 and tile_x < matrix(number).xsegs
      gx = tile_x
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+48, nx
      write memblock float mem_numb, location+52, ny
      write memblock float mem_numb, location+56, nz
   endif

rem vert 6
   if tile_x > 0 and tile_z < matrix(number).zsegs
      gx = tile_x - 1
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+192, nx
      write memblock float mem_numb, location+196, ny
      write memblock float mem_numb, location+200, nz
   endif

rem verts 1 and 4
   if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      gx = tile_x
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+12, nx
      write memblock float mem_numb, location+16, ny
      write memblock float mem_numb, location+20, nz

write memblock float mem_numb, location+120, nx
      write memblock float mem_numb, location+124, ny
      write memblock float mem_numb, location+128, nz
   endif
endfunction

remstart
REM ==========================================================================
REM Parameters:
REM matrix number
REM X coordinate
REM Z coordinate
function get_ground_height(number as integer, x#, z#)
   h# = intersect object(matrix(number).obj,x#,0,z#,x#,10000,z#)
endfunction h#
remend

function get_ground_height(number as integer, x#, z#)
   tileSizeX# = matrix(number).width / matrix(number).xsegs
   tileSizeZ# = matrix(number).depth / matrix(number).zsegs

row = (z# / tileSizeZ#)
   column = (x# / tileSizeX#)

if row < 0 OR row > matrix(number).xsegs OR column < 0 or column > matrix(number).zsegs
      exitfunction 0.0
   endif

h1# = get_matrix_height(number, row, column)
   h2# = get_matrix_height(number, row, column+1)
   h3# = get_matrix_height(number, row+1, column+1)
   h4# = get_matrix_height(number, row+1, column)

ahx# = ((h4#-h1#)+(h3#-h2#)) / 2.0
   ahz# = ((h2#-h1#)+(h3#-h4#)) / 2.0
   avg# = (ahx# + ahz#) / 2.0

xx# = x# mod tileSizeX#
   zz# = z# mod tileSizeZ#

ax# = (xx# * ahx#) / tileSizeX#
   az# = (zz# * ahz#) / tileSizeZ#

height# = (ax# + az#) / 2.0

endfunction height#

REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
function get_matrix_height(number as integer, tile_x as integer, tile_z as integer)
   if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif

size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      location = tile_z*lensize + tile_x*boffset + 12
      yheight# = memblock float (mem_numb, location+4)
   else
      location = (tile_z-1)*lensize + (tile_x-1)*boffset + 12
      yheight# = memblock float (mem_numb, location+76)
   endif

endfunction yheight#

REM ==========================================================================
REM Parameters:
REM matrix number
REM image number
REM maximum height
function set_matrix_from_heightmap(number as integer, img as integer, max as float)
   make memblock from image 256, img
   width# = memblock dword(256, 0)
   height# = memblock dword(256, 4)

ox# = width#/(matrix(number).xsegs+1)
   oz# = height#/(matrix(number).zsegs+1)

for z = 0 to matrix(number).zsegs
      for x = 0 to matrix(number).xsegs
         location = (int(z*oz#)*width# + int(x*ox#))*4 + 12
         c = memblock byte(256, location)
         rem convert color value into height value
         h# = (c*max)/255.0
         set_matrix_height(number,x,z,h#)
      next x
   next z

delete memblock 256
endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM image number
function set_matrix_from_colormap(number as integer, img as integer)
   make memblock from image 256, img
   width# = memblock dword(256, 0)
   height# = memblock dword(256, 4)

ox# = width#/(matrix(number).xsegs+1)
   oz# = height#/(matrix(number).zsegs+1)

for z = 0 to matrix(number).zsegs
      for x = 0 to matrix(number).xsegs
         location = (int(z*oz#)*width# + int(x*ox#))*4 + 12
         b = memblock byte(256, location)
         g = memblock byte(256, location+1)
         r = memblock byte(256, location+2)
         c = rgb(r,g,b)
         set_matrix_diffuse(number,x,z,c)
      next x
   next z

delete memblock 256
endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM image number
function set_matrix_from_alphamap(number as integer, img as integer)
   make memblock from image 256, img
   width# = memblock dword(256, 0)
   height# = memblock dword(256, 4)

ox# = width#/(matrix(number).xsegs+1)
   oz# = height#/(matrix(number).zsegs+1)

for z = 0 to matrix(number).zsegs
      for x = 0 to matrix(number).xsegs
         location = (int(z*oz#)*width# + int(x*ox#))*4 + 12
         a = memblock byte(256, location+3)
         set_matrix_alpha(number,x,z,a)
      next x
   next z

delete memblock 256
endfunction

REM ==========================================================================
REM Parameters:
REM X,Y,Z coordinates
function position_matrix(number as integer, x as float, y as float, z as float)
   matrix(number).x = x
   matrix(number).y = y
   matrix(number).z = z
   position object matrix(number).obj, x, y, z
endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
function update_matrix(number as integer)
   change mesh from memblock matrix(number).mesh, matrix(number).mem_numb
   delete object matrix(number).obj
   make object matrix(number).obj, matrix(number).mesh, matrix(number).image
   set object cull matrix(number).obj, matrix(number).cull
   set object light matrix(number).obj, matrix(number).light
   set object specular matrix(number).obj, matrix(number).specular
   position object matrix(number).obj, matrix(number).x, matrix(number).y, matrix(number).z
   if matrix(number).prepared = 0
      set object wireframe matrix(number).obj, 1
   endif
endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM flag, on or off
function set_matrix_cull(number as integer, flag as integer)
   matrix(number).cull = flag
   set object cull matrix(number).obj, flag
endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM flag, on or off
function set_matrix_light(number as integer, flag as integer)
   matrix(number).light = flag
   set object light matrix(number).obj, flag
endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM flag, on or off
function set_matrix_specular(number as integer, flag as integer)
   matrix(number).specular = flag
   set object specular matrix(number).obj, flag
endfunction

REM ==========================================================================
REM Coded by Dr. DB himself, Lee Bamber
REM Parameters:
REM matrix number
function configure_matrix_normals(number as integer)
   for z=1 to matrix(number).zsegs-1
      for x=1 to matrix(number).xsegs-1

rem Get matrix heights
         h8#=get_matrix_height(number,x,z-1)
         h4#=get_matrix_height(number,x-1,z)
         h#=get_matrix_height(number,x,z)
         h2#=get_matrix_height(number,x,z)

rem Calculate projected angle X using heights
         x1#=(x-1)*25.0 : y1#=h#
         x2#=(x+0)*25.0 : y2#=h4#
         dx#=x2#-x1#
         dy#=y2#-y1#
         ax#=atanfull(dx#,dy#)
         ax#=wrapvalue(90-ax#)

rem Calculate projected angle Z using heights
         z1#=(z-1)*25.0 : y1#=h2#
         z2#=(z+0)*25.0 : y2#=h8#
         dz#=z2#-z1#
         dy#=y2#-y1#
         az#=atanfull(dz#,dy#)
         az#=wrapvalue(90-az#)

rem Make normal from projected angle
         nx#=sin(ax#)
         ny#=cos(ax#)
         nz#=sin(az#)

rem Setting matrix normal for smoothness
         set_matrix_normal(number,x,z,nx#,ny#,nz#)
      next x
   next z
endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM max height
function randomize_matrix(number as integer, height as float)
   for z = 0 to matrix(number).zsegs
      for x = 0 to matrix(number).xsegs
         set_matrix_height(number, x, z, rnd(height*100.0)/100.0)
      next x
   next z
endfunction

REM ==========================================================================
REM Parameters:
REM matrix number
REM X,Y screen coordinates
REM vector number to store results in
function pick_matrix(number as integer, x as integer, y as integer, vector as integer)
   if matrix(number).obj = 0 then exitfunction

t = pick object(x,y,matrix(number).obj,matrix(number).obj)
   vx# = camera position X()+get pick vector x()
   vy# = camera position y()+get pick vector y()
   vz# = camera position z()+get pick vector z()
   set vector3 vector, vx#, vy#, vz#
endfunction

REM wrapvalue function
REM Wraps n1# to n2#
function wrap(n1#,n2#)

while (n1# > n2#)
      n1# = n1# - n2#
   endwhile

endfunction n1#

camera_stuff:
  oldcx#=cx#
  oldcz#=cz#
  speed# = 5
  if upkey()=1
    cx#=newxvalue(cx#,a#,speed#)
    cz#=newzvalue(cz#,a#,speed#)
  endif
  if downkey()=1
    cx#=newxvalue(cx#,a#,-speed#)
    cz#=newzvalue(cz#,a#,-speed#)
  endif
  if leftkey()=1
    cx#=newxvalue(cx#,wrapvalue(a#-90.0),speed#)
    cz#=newzvalue(cz#,wrapvalue(a#-90.0),speed#)
  endif
  if rightkey()=1
    cx#=newxvalue(cx#,wrapvalue(a#+90.0),speed#)
    cz#=newzvalue(cz#,wrapvalue(a#+90.0),speed#)
  endif

if shiftkey() then inc cy#, 2
   if controlkey() then dec cy#, 2

a#=wrapvalue(a#+(mousemovex()/3.0))
  cxa#=cxa#+(mousemovey()/3.0)
  if cxa#<-90.0 then cxa#=-90.0
  if cxa#>90.0 then cxa#=90.0
  cy# = get_ground_height(1,cx#,cz#)
  position camera cx#,cy#+100,cz#
  rotate camera wrapvalue(cxa#),a#,0
RETURN

+ Code Snippet

`set display mode 800,600,32

load image "terrainsand.bmp", 1
load image "terrainheightmap.bmp", 2
load image "terraincolormap.bmp", 3
load image "terrainalphamap.bmp", 4


randomize timer()
sync on
`sync rate 100
autocam off
hide mouse

REM INCLUDE THIS AT START OF YOUR PROGRAM
REM internal matrix data used by matrix functions
type matriks
   ix as integer
   iy as integer
   xsegs as integer
   zsegs as integer
   width as float
   depth as float
   mem_numb as integer
   obj as integer
   image as integer
   mesh as integer
   prepared as boolean
   x as float
   y as float
   z as float
   cull as integer
   light as integer
   specular as integer
endtype

REM INCLUDE THIS AT START OF YOUR PROGRAM
REM dim array size by maximum number of matrices you'll have
dim matrix(1) as matriks
mx = 128
mz = 128
sizex# = 4000
sizez# = 4000
REM must be called before you can create a matrix
prepare_matrix_data(1,1,1,1)
REM Make a new matrix
create_matrix(1,sizex#, sizez#,mx,mz)
REM prepare a texture for use with the matrix
`prepare_matrix_texture(1,1,2,2)
prepare_matrix_texture(1,1,1,1)


set_matrix_from_heightmap(1,2,500.0)

set_matrix_from_colormap(1,3)

set_matrix_from_alphamap(1,4)

configure_matrix_normals(1)

set_matrix_light(1,0)

set_matrix_specular(1,0)

scale_matrix_texture(1,8,8)

REM update the matrix
update_matrix(1)

`set alpha mapping on 1, 100

load object "terrainskybox.x", 2
set object texture 2,2,0
position object 2, 2000,0,2000
scale object 2, 100000,100000,100000
set object fog 2, 0
set object light 2, 0
set object ambient 2, 0

set camera range 1, 65000


DO



   gosub camera_stuff


   text 2,2,str$(screen fps())

   sync
LOOP



REM ==========================================================================
REM Parameters:
REM matrix number
REM object used to create matrix
REM memblock number used to create matrix
REM mesh number used to create object from memblock
function prepare_matrix_data(number as integer, object as integer, mb as integer, mesh as integer)
   matrix(number).obj = object
   matrix(number).mem_numb = mb
   matrix(number).mesh = mesh
endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM number of image tiles across
REM number of image tiles down
function scale_matrix_texture(number as integer, across as integer, down as integer)
   matrix(number).ix = across
   matrix(number).iy = down
   matrix(number).prepared = 1

   tile = 1
   ln = 0
   for z = matrix(number).zsegs to 1 step -1
      for x = 1 to matrix(number).xsegs
         tl = ln*across + tile
         set_matrix_tile(number, x, z, tl)
         inc tile, 1
         if tile > across then tile = 1
      next x
      inc ln, 1
      if ln > down-1 then ln = 0
   next z
endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM image number
REM number of image tiles across
REM number of image tiles down
function prepare_matrix_texture(number as integer, image as integer, across as integer, down as integer)
   matrix(number).ix = across
   matrix(number).iy = down
   matrix(number).image = image
   matrix(number).prepared = 1
   `texture object matrix(number).obj, matrix(number).image

   for z = 1 to matrix(number).zsegs
      for x = 1 to matrix(number).xsegs
         set_matrix_tile(number, x, z, 1)
      next x
   next z

endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM width of matrix
REM depth of matrix
REM number of X segments
REM number of Z segments
function create_matrix(number as integer, width as float, depth as float, xsegs as integer, zsegs as integer)
   fvf = 338
   size = 36
   matrix(number).width = width
   matrix(number).depth = depth
   matrix(number).xsegs = xsegs
   matrix(number).zsegs = zsegs
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = depth/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb

   make memblock mem_numb, total_size
   write memblock dword mem_numb, 0, fvf
   write memblock dword mem_numb, 4, size
   write memblock dword mem_numb, 8, numb_verts

   tile = 0
   for z = 1 to zsegs
      for x = 1 to xsegs
         location = tile*size*6 + 12

         x1# = tile_size_x# * (x-1)
         y1# = 0
         z1# = tile_size_z# * (z-1)

         x2# = tile_size_x# * (x-1)
         y2# = 0
         z2# = tile_size_z# * z

         x3# = tile_size_x# * x
         y3# = 0
         z3# = tile_size_z# * z

         x4# = x1#
         y4# = y1#
         z4# = z1#

         x5# = x3#
         y5# = y3#
         z5# = z3#

         x6# = x3#
         y6# = 0
         z6# = z1#

         rem vert 1 - x,y,z, normals x,y,z, diffuse color
         write memblock float mem_numb, location, x1#
         write memblock float mem_numb, location+4, y1#
         write memblock float mem_numb, location+8, z1#
         write memblock float mem_numb, location+12, 0
         write memblock float mem_numb, location+16, 1
         write memblock float mem_numb, location+20, 0
         write memblock dword mem_numb, location+24, rgb(255,255,255)

         rem vert 2 - x,y,z
         temp_size = size
         write memblock float mem_numb, location+temp_size, x2#
         write memblock float mem_numb, location+temp_size+4, y2#
         write memblock float mem_numb, location+temp_size+8, z2#
         write memblock float mem_numb, location+temp_size+12, 0
         write memblock float mem_numb, location+temp_size+16, 1
         write memblock float mem_numb, location+temp_size+20, 0
         write memblock dword mem_numb, location+temp_size+24, rgb(255,255,255)

         rem vert 3 - x,y,z
         temp_size = size*2
         write memblock float mem_numb, location+temp_size, x3#
         write memblock float mem_numb, location+temp_size+4, y3#
         write memblock float mem_numb, location+temp_size+8, z3#
         write memblock float mem_numb, location+temp_size+12, 0
         write memblock float mem_numb, location+temp_size+16, 1
         write memblock float mem_numb, location+temp_size+20, 0
         write memblock dword mem_numb, location+temp_size+24, rgb(255,255,255)

         rem vert 4 - x,y,z
         temp_size = size*3
         write memblock float mem_numb, location+temp_size, x4#
         write memblock float mem_numb, location+temp_size+4, y4#
         write memblock float mem_numb, location+temp_size+8, z4#
         write memblock float mem_numb, location+temp_size+12, 0
         write memblock float mem_numb, location+temp_size+16, 1
         write memblock float mem_numb, location+temp_size+20, 0
         write memblock dword mem_numb, location+temp_size+24, rgb(255,255,255)

         rem vert 5 - x,y,z
         temp_size = size*4
         write memblock float mem_numb, location+temp_size, x5#
         write memblock float mem_numb, location+temp_size+4, y5#
         write memblock float mem_numb, location+temp_size+8, z5#
         write memblock float mem_numb, location+temp_size+12, 0
         write memblock float mem_numb, location+temp_size+16, 1
         write memblock float mem_numb, location+temp_size+20, 0
         write memblock dword mem_numb, location+temp_size+24, rgb(255,255,255)

         rem vert 6 - x,y,z
         temp_size = size*5
         write memblock float mem_numb, location+temp_size, x6#
         write memblock float mem_numb, location+temp_size+4, y6#
         write memblock float mem_numb, location+temp_size+8, z6#
         write memblock float mem_numb, location+temp_size+12, 0
         write memblock float mem_numb, location+temp_size+16, 1
         write memblock float mem_numb, location+temp_size+20, 0
         write memblock dword mem_numb, location+temp_size+24, rgb(255,255,255)

         inc tile, 1

      next x
   next z

   make mesh from memblock  1, mem_numb
   make object matrix(number).obj,1,0

endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
REM tile is an image tile number (from prepare_matrix_texture())
function set_matrix_tile(number as integer, tileX as integer, tileZ as integer, tile as integer)

   if tileX < 0 OR tileX > matrix(number).xsegs OR tileX < 0 OR tileZ > matrix(number).zsegs OR matrix(number).prepared = 0
      exitfunction
   endif

   if matrix(number).ix = 0 then matrix(number).ix = 1
   if matrix(number).iy = 0 then matrix(number).iy = 1


   mem_numb = matrix(number).mem_numb
   size = 36
   boffset = size*6

   location = 12 + ((tileZ-1)*matrix(number).xsegs*boffset + (tileX-1)*boffset)

   x_temp = wrap(tile, matrix(number).ix)

   mix# = matrix(number).ix
   x_max# = x_temp/mix#
   x_min# = (x_temp-1)/mix#

   y_temp = int((tile - x_temp) / mix#) + 1.0

   miy# = matrix(number).iy
   y_max# = y_temp/miy#
   y_min# = (y_temp-1)/miy#


   if y_min# > 0 then y_min# = y_min# + 0.01
   if x_min# > 0 then x_min# = x_min# + 0.01


   rem vert 1 - UV coordinates
   write memblock float mem_numb, location+28, x_min#
   write memblock float mem_numb, location+32, y_max#

   rem vert 2
   write memblock float mem_numb, location+64, x_min#
   write memblock float mem_numb, location+68, y_min#

   rem vert 3
   write memblock float mem_numb, location+100, x_max#
   write memblock float mem_numb, location+104, y_min#

   rem vert 4
   write memblock float mem_numb, location+136, x_min#
   write memblock float mem_numb, location+140, y_max#

   rem vert 5
   write memblock float mem_numb, location+172, x_max#
   write memblock float mem_numb, location+176, y_min#

   rem vert 6
   write memblock float mem_numb, location+208, x_max#
   write memblock float mem_numb, location+212, y_max#

endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
REM diffuse color

function set_matrix_diffuse(number as integer, tile_x as integer, tile_z as integer, color as dword)

   if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif
   size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

   REM verts 3 and 5
   if tile_x > 0 and tile_z > 0
      gx = tile_x - 1
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+96, color
      write memblock dword mem_numb, location+168, color
   endif

   REM vert 2
   if tile_z > 0 and tile_x < matrix(number).xsegs
      gx = tile_x
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+60, color
   endif

   rem vert 6
   if tile_x > 0 and tile_z < matrix(number).zsegs
     gx = tile_x - 1
     gz = tile_z
     location = gz*lensize + gx*boffset + 12
     write memblock dword mem_numb, location+204, color
   endif

   rem verts 1 and 4
   if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      gx = tile_x
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+24, color
      write memblock dword mem_numb, location+132, color
   endif

endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
REM alpha value
function set_matrix_alpha(number as integer, tile_x as integer, tile_z as integer, alpha as integer)

   if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif
   size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

   REM verts 3 and 5
   if tile_x > 0 and tile_z > 0
      gx = tile_x - 1
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+99, alpha
      write memblock dword mem_numb, location+171, alpha
   endif

   REM vert 2
   if tile_z > 0 and tile_x < matrix(number).xsegs
      gx = tile_x
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+63, alpha
   endif

   rem vert 6
   if tile_x > 0 and tile_z < matrix(number).zsegs
     gx = tile_x - 1
     gz = tile_z
     location = gz*lensize + gx*boffset + 12
     write memblock dword mem_numb, location+207, alpha
   endif

   rem verts 1 and 4
   if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      gx = tile_x
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock dword mem_numb, location+27, alpha
      write memblock dword mem_numb, location+135, alpha
   endif
endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
REM height (height of tile you're setting)

function set_matrix_height(number as integer, tile_x as integer, tile_z as integer, height# as float)

   if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif

   size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

   REM verts 3 and 5
   if tile_x > 0 and tile_z > 0
      gx = tile_x - 1
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+76, height#
      write memblock float mem_numb, location+148, height#
   endif

   REM vert 2
   if tile_z > 0 and tile_x < matrix(number).xsegs
      gx = tile_x
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+40, height#
   endif

   rem vert 6
   if tile_x > 0 and tile_z < matrix(number).zsegs
   `and tile_z < matrix(number).zsegs
     gx = tile_x - 1
     gz = tile_z
     location = gz*lensize + gx*boffset + 12
     write memblock float mem_numb, location+184, height#
   endif

   rem verts 1 and 4
   if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      gx = tile_x
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+4, height#
      write memblock float mem_numb, location+112, height#
   endif

endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
REM nx,ny,nz - normal
function set_matrix_normal(number as integer, tile_x as integer, tile_z as integer, nx as float, ny as float, nz as float)

   if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif
   size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

   REM verts 3 and 5
   if tile_x > 0 and tile_z > 0
      gx = tile_x - 1
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+84, nx
      write memblock float mem_numb, location+88, ny
      write memblock float mem_numb, location+92, nz

      write memblock float mem_numb, location+156, nx
      write memblock float mem_numb, location+160, ny
      write memblock float mem_numb, location+164, nz
   endif

   REM vert 2
   if tile_z > 0 and tile_x < matrix(number).xsegs
      gx = tile_x
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+48, nx
      write memblock float mem_numb, location+52, ny
      write memblock float mem_numb, location+56, nz
   endif

   rem vert 6
   if tile_x > 0 and tile_z < matrix(number).zsegs
      gx = tile_x - 1
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+192, nx
      write memblock float mem_numb, location+196, ny
      write memblock float mem_numb, location+200, nz
   endif

   rem verts 1 and 4
   if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      gx = tile_x
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+12, nx
      write memblock float mem_numb, location+16, ny
      write memblock float mem_numb, location+20, nz

      write memblock float mem_numb, location+120, nx
      write memblock float mem_numb, location+124, ny
      write memblock float mem_numb, location+128, nz
   endif
endfunction

remstart
REM ==========================================================================
REM Parameters:
REM matrix number
REM X coordinate
REM Z coordinate
function get_ground_height(number as integer, x#, z#)
   h# = intersect object(matrix(number).obj,x#,0,z#,x#,10000,z#)
endfunction h#
remend

function get_ground_height(number as integer, x#, z#)
   tileSizeX# = matrix(number).width / matrix(number).xsegs
   tileSizeZ# = matrix(number).depth / matrix(number).zsegs

   row = (z# / tileSizeZ#)
   column = (x# / tileSizeX#)

   if row < 0 OR row > matrix(number).xsegs OR column < 0 or column > matrix(number).zsegs
      exitfunction 0.0
   endif

   h1# = get_matrix_height(number, row, column)
   h2# = get_matrix_height(number, row, column+1)
   h3# = get_matrix_height(number, row+1, column+1)
   h4# = get_matrix_height(number, row+1, column)

   ahx# = ((h4#-h1#)+(h3#-h2#)) / 2.0
   ahz# = ((h2#-h1#)+(h3#-h4#)) / 2.0
   avg# = (ahx# + ahz#) / 2.0

   xx# = x# mod tileSizeX#
   zz# = z# mod tileSizeZ#

   ax# = (xx# * ahx#) / tileSizeX#
   az# = (zz# * ahz#) / tileSizeZ#

   height# = (ax# + az#) / 2.0

endfunction height#



REM ==========================================================================
REM Parameters:
REM matrix number
REM tile X (grid-based coordinate)
REM tile Z (grid-based coordinate)
function get_matrix_height(number as integer, tile_x as integer, tile_z as integer)
   if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif

   size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

   if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      location = tile_z*lensize + tile_x*boffset + 12
      yheight# = memblock float (mem_numb, location+4)
   else
      location = (tile_z-1)*lensize + (tile_x-1)*boffset + 12
      yheight# = memblock float (mem_numb, location+76)
   endif

endfunction yheight#


REM ==========================================================================
REM Parameters:
REM matrix number
REM image number
REM maximum height
function set_matrix_from_heightmap(number as integer, img as integer, max as float)
   make memblock from image 256, img
   width# = memblock dword(256, 0)
   height# = memblock dword(256, 4)

   ox# = width#/(matrix(number).xsegs+1)
   oz# = height#/(matrix(number).zsegs+1)

   for z = 0 to matrix(number).zsegs
      for x = 0 to matrix(number).xsegs
         location = (int(z*oz#)*width# + int(x*ox#))*4 + 12
         c = memblock byte(256, location)
         rem convert color value into height value
         h# = (c*max)/255.0
         set_matrix_height(number,x,z,h#)
      next x
   next z

   delete memblock 256
endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM image number
function set_matrix_from_colormap(number as integer, img as integer)
   make memblock from image 256, img
   width# = memblock dword(256, 0)
   height# = memblock dword(256, 4)

   ox# = width#/(matrix(number).xsegs+1)
   oz# = height#/(matrix(number).zsegs+1)

   for z = 0 to matrix(number).zsegs
      for x = 0 to matrix(number).xsegs
         location = (int(z*oz#)*width# + int(x*ox#))*4 + 12
         b = memblock byte(256, location)
         g = memblock byte(256, location+1)
         r = memblock byte(256, location+2)
         c = rgb(r,g,b)
         set_matrix_diffuse(number,x,z,c)
      next x
   next z

   delete memblock 256
endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM image number
function set_matrix_from_alphamap(number as integer, img as integer)
   make memblock from image 256, img
   width# = memblock dword(256, 0)
   height# = memblock dword(256, 4)

   ox# = width#/(matrix(number).xsegs+1)
   oz# = height#/(matrix(number).zsegs+1)

   for z = 0 to matrix(number).zsegs
      for x = 0 to matrix(number).xsegs
         location = (int(z*oz#)*width# + int(x*ox#))*4 + 12
         a = memblock byte(256, location+3)
         set_matrix_alpha(number,x,z,a)
      next x
   next z

   delete memblock 256
endfunction


REM ==========================================================================
REM Parameters:
REM X,Y,Z coordinates
function position_matrix(number as integer, x as float, y as float, z as float)
   matrix(number).x = x
   matrix(number).y = y
   matrix(number).z = z
   position object matrix(number).obj, x, y, z
endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
function update_matrix(number as integer)
   change mesh from memblock matrix(number).mesh, matrix(number).mem_numb
   delete object matrix(number).obj
   make object matrix(number).obj, matrix(number).mesh, matrix(number).image
   set object cull matrix(number).obj, matrix(number).cull
   set object light matrix(number).obj, matrix(number).light
   set object specular matrix(number).obj, matrix(number).specular
   position object matrix(number).obj, matrix(number).x, matrix(number).y, matrix(number).z
   if matrix(number).prepared = 0
      set object wireframe matrix(number).obj, 1
   endif
endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM flag, on or off
function set_matrix_cull(number as integer, flag as integer)
   matrix(number).cull = flag
   set object cull matrix(number).obj, flag
endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM flag, on or off
function set_matrix_light(number as integer, flag as integer)
   matrix(number).light = flag
   set object light matrix(number).obj, flag
endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM flag, on or off
function set_matrix_specular(number as integer, flag as integer)
   matrix(number).specular = flag
   set object specular matrix(number).obj, flag
endfunction


REM ==========================================================================
REM Coded by Dr. DB himself, Lee Bamber
REM Parameters:
REM matrix number
function configure_matrix_normals(number as integer)
   for z=1 to matrix(number).zsegs-1
      for x=1 to matrix(number).xsegs-1

         rem Get matrix heights
         h8#=get_matrix_height(number,x,z-1)
         h4#=get_matrix_height(number,x-1,z)
         h#=get_matrix_height(number,x,z)
         h2#=get_matrix_height(number,x,z)

         rem Calculate projected angle X using heights
         x1#=(x-1)*25.0 : y1#=h#
         x2#=(x+0)*25.0 : y2#=h4#
         dx#=x2#-x1#
         dy#=y2#-y1#
         ax#=atanfull(dx#,dy#)
         ax#=wrapvalue(90-ax#)

         rem Calculate projected angle Z using heights
         z1#=(z-1)*25.0 : y1#=h2#
         z2#=(z+0)*25.0 : y2#=h8#
         dz#=z2#-z1#
         dy#=y2#-y1#
         az#=atanfull(dz#,dy#)
         az#=wrapvalue(90-az#)

         rem Make normal from projected angle
         nx#=sin(ax#)
         ny#=cos(ax#)
         nz#=sin(az#)

         rem Setting matrix normal for smoothness
         set_matrix_normal(number,x,z,nx#,ny#,nz#)
      next x
   next z
endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM max height
function randomize_matrix(number as integer, height as float)
   for z = 0 to matrix(number).zsegs
      for x = 0 to matrix(number).xsegs
         set_matrix_height(number, x, z, rnd(height*100.0)/100.0)
      next x
   next z
endfunction


REM ==========================================================================
REM Parameters:
REM matrix number
REM X,Y screen coordinates
REM vector number to store results in
function pick_matrix(number as integer, x as integer, y as integer, vector as integer)
   if matrix(number).obj = 0 then exitfunction

   t = pick object(x,y,matrix(number).obj,matrix(number).obj)
   vx# = camera position X()+get pick vector x()
   vy# = camera position y()+get pick vector y()
   vz# = camera position z()+get pick vector z()
   set vector3 vector, vx#, vy#, vz#
endfunction


REM wrapvalue function
REM Wraps n1# to n2#
function wrap(n1#,n2#)

   while (n1# > n2#)
      n1# = n1# - n2#
   endwhile

endfunction n1#



camera_stuff:
  oldcx#=cx#
  oldcz#=cz#
  speed# = 5
  if upkey()=1
    cx#=newxvalue(cx#,a#,speed#)
    cz#=newzvalue(cz#,a#,speed#)
  endif
  if downkey()=1
    cx#=newxvalue(cx#,a#,-speed#)
    cz#=newzvalue(cz#,a#,-speed#)
  endif
  if leftkey()=1
    cx#=newxvalue(cx#,wrapvalue(a#-90.0),speed#)
    cz#=newzvalue(cz#,wrapvalue(a#-90.0),speed#)
  endif
  if rightkey()=1
    cx#=newxvalue(cx#,wrapvalue(a#+90.0),speed#)
    cz#=newzvalue(cz#,wrapvalue(a#+90.0),speed#)
  endif

   if shiftkey() then inc cy#, 2
   if controlkey() then dec cy#, 2



  a#=wrapvalue(a#+(mousemovex()/3.0))
  cxa#=cxa#+(mousemovey()/3.0)
  if cxa#<-90.0 then cxa#=-90.0
  if cxa#>90.0 then cxa#=90.0
  cy# = get_ground_height(1,cx#,cz#)
  position camera cx#,cy#+100,cz#
  rotate camera wrapvalue(cxa#),a#,0
RETURN

"You're not going crazy. You're going sane in a crazy world!" ~Tick

Back to top

Profile PM Email Website

MikeS

Retired Moderator

21

Years of Service

User Offline

Joined: 2nd Dec 2002

Location: United States

Posted: 7th Jun 2004 19:18

Link

Very nice Phaelax. Have been working on memblock matrices myself as well. People should really start switching to memblock matrices for speed and the ability to manipulate landscapes as objects.

It's just great!

A book? I hate book. Book is stupid.
(Formerly known as Yellow)

Back to top

Profile PM Email

PantheR RIP

21

Years of Service

User Offline

Joined: 7th Jul 2003

Location:

Posted: 7th Jun 2004 20:54

Link

WOW... It's realy awesome! I'll try to use this one in my project - it takes a lot of work to rid off that matrices but i want to see the result =) FPS problem is most annoying problem in DBPRO. BTW it will be good to add SET_MATRIX function to your sources to have an availability to change objects options...

Back to top

Profile PM

PantheR RIP

21

Years of Service

User Offline

Joined: 7th Jul 2003

Location:

Posted: 7th Jun 2004 21:07

Link

ooops! I can't see that matrix... =(( Strange. Have no idea what is this!!! Just unseen... Also PICK_MATRIX function isn't optimal for FREE rotation and sizing...

Back to top

Profile PM

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 8th Jun 2004 02:36

Link

pick matrix should work with any rotation, camera or object. but it could be optimized further.

"eureka" - Archimedes

Back to top

Profile PM Email Website

PantheR RIP

21

Years of Service

User Offline

Joined: 7th Jul 2003

Location:

Posted: 8th Jun 2004 07:50

Link

Hmmm... does PICK MATRIX function work with FOV change? Strange... Pointer sphere spawns at the camera coordinates.

Back to top

Profile PM

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 8th Jun 2004 09:35

Link

works perfectly find for me. same method i use for my rts.

"eureka" - Archimedes

Back to top

Profile PM Email Website

Cian Rice

20

Years of Service

User Offline

Joined: 8th Jun 2004

Location:

Posted: 12th Jun 2004 05:22

Link

Does this only work in Pro or will it work in Classic Enhanced too, since that supports memblocks...
Please answer, I'd love to know so I can download it...

Got anime?
I do.

Back to top

Profile PM Email Website

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 12th Jun 2004 22:16

Link

pro only. someone is trying to convert it to classic though

"eureka" - Archimedes

Back to top

Profile PM Email Website

David T

Retired Moderator

22

Years of Service

User Offline

Joined: 27th Aug 2002

Location: England

Posted: 14th Jun 2004 20:53 Edited at: 14th Jun 2004 20:56

Link

I might just make the switch after these functions

It'd mean proper ghosting at least!

Now all we needs is for some clever soul to write a routine that smoothly textures then depending upon height. Hmm.

(ps - might want to change your .dbpro file to read "main=verts.dba")

Two strings walk into a bar. I'll have a pint says the first$%ASLDJ09920D"$"$D. Excuse my friend says the second, he isn't null terminated.

Back to top

Profile PM Email Website

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 15th Jun 2004 02:13

Link

Quote: "ps - might want to change your .dbpro file to read "main=verts.dba")"

Why's that?

Quote: "a routine that smoothly textures then depending upon height"

Started working on it last night. Van-B used the same method in his holiday tech demo that I'm currently working on. All I gotta do is add the correct normals code, and it's basically complete.

"eureka" - Archimedes

Back to top

Profile PM Email Website

David T

Retired Moderator

22

Years of Service

User Offline

Joined: 27th Aug 2002

Location: England

Posted: 16th Jun 2004 20:29 Edited at: 16th Jun 2004 20:30

Link

Quote: "Quote: "ps - might want to change your .dbpro file to read "main=verts.dba")"
Why's that?"

Because on my PC d:/whatever/verts.dba doesn't exist

you get an error.

Started working on it last night. Van-B used the same method in his holiday tech demo that I'm currently working on. All I gotta do is add the correct normals code, and it's basically complete.

Looking forward to it! After that, I might finally make the switch to memblock matrices. I have an idea for a game once I finish MiS, which is currently being polished

Two strings walk into a bar. I'll have a pint says the first$%ASLDJ09920D"$"$D. Excuse my friend says the second, he isn't null terminated.

Back to top

Profile PM Email Website

Marthik

20

Years of Service

User Offline

Joined: 25th Jan 2004

Location: Washington State, USA

Posted: 16th Jun 2004 23:03 Edited at: 17th Jun 2004 00:02

Link

Quote: ""a routine that smoothly textures then depending upon height""

also, a routine that will do slope as well, which is more imortant in my option.

Back to top

Profile PM Email

Marthik

20

Years of Service

User Offline

Joined: 25th Jan 2004

Location: Washington State, USA

Posted: 16th Jun 2004 23:13 Edited at: 17th Jun 2004 00:02

Link

good job, on the matrix, it's really nice, i think i'll use it in my mini game i am making for the community.

[edit]
you seem to have forgotten, a very important function Randomize Matrix, so i won't be able to use it after all.

Back to top

Profile PM Email

David T

Retired Moderator

22

Years of Service

User Offline

Joined: 27th Aug 2002

Location: England

Posted: 17th Jun 2004 00:08 Edited at: 17th Jun 2004 00:09

Link

Quote: "you seem to have forgotten, a very important function Randomize Matrix, so i won't be able to use it after all. "

That's easy!

+ Code Snippet

rem Dunno if this works, it's only guessswork
function randomize_matrix(m,maxheight,xw,zw)
for x = 1 to xw
  for y = 1 to zw
    randomize timer()*x*y
    set_matrix_height m,rnd(matheight)
  next y
next x

Two strings walk into a bar. I'll have a pint says the first$%ASLDJ09920D"$"$D. Excuse my friend says the second, he isn't null terminated.

Back to top

Profile PM Email Website

jwurmz

21

Years of Service

User Offline

Joined: 6th Oct 2003

Location: Arizona, USA

Posted: 17th Jun 2004 04:01 Edited at: 17th Jun 2004 22:26

Link

David T:
i think just one "randomize timer()" at the beginning of the program will suffice. it'll free up a little cpu if you didn't reseed every time you set the height. but good job otherwise

"Creativity is knowing how to hide your sources" - Einstein

Back to top

Profile PM Website

jwurmz

21

Years of Service

User Offline

Joined: 6th Oct 2003

Location: Arizona, USA

Posted: 17th Jun 2004 22:29

Link

Phaelax, one quick question about your code...
what does "get pick vector x()" refer to? it looks like a command, but the GUI editor doesn't change its color. i thought it might be a function, but i didn't see it. nice code btw, very fast!

"Creativity is knowing how to hide your sources" - Einstein

Back to top

Profile PM Website

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 18th Jun 2004 10:30

Link

After calling pick object(), the data from that method call is stored in a vector. You retrieve that data from the get pick vector commands. Basically, its a vector of the distance from the camera to where the intersecting coordinates are.

"eureka" - Archimedes

Back to top

Profile PM Email Website

Marthik

20

Years of Service

User Offline

Joined: 25th Jan 2004

Location: Washington State, USA

Posted: 18th Jun 2004 11:30

Link

Quote: "That's easy!"

i know, just didn't feel like thinking about it, for some reason...

Back to top

Profile PM Email

David T

Retired Moderator

22

Years of Service

User Offline

Joined: 27th Aug 2002

Location: England

Posted: 18th Jun 2004 19:51

Link

Quote: "David T:
i think just one "randomize timer()" at the beginning of the program will suffice. it'll free up a little cpu if you didn't reseed every time you set the height. but good job otherwise "

I always thought that calling multiple rnd() commands with the same seed returned the same results...

may just have been me. If I was wrong then yes just put randomize timer() at the beginning.

But, if rnd(constant) always returned different results, then what's point for randomize()?

Two strings walk into a bar. I'll have a pint says the first$%ASLDJ09920D"$"$D. Excuse my friend says the second, he isn't null terminated.

Back to top

Profile PM Email Website

Marthik

20

Years of Service

User Offline

Joined: 25th Jan 2004

Location: Washington State, USA

Posted: 19th Jun 2004 08:55 Edited at: 19th Jun 2004 08:57

Link

no, it just does the same sequence, so if did randomize 101 then every time i ran the program, it would be the same.

+ Code Snippet

randomize 101
print rnd(4)
print rnd(5)
print rnd(6000)
wait key

/edit

btw there is a topic around here somewhere on random numbers, and randomize, it explains it a little bit.

Back to top

Profile PM Email

Marthik

20

Years of Service

User Offline

Joined: 25th Jan 2004

Location: Washington State, USA

Posted: 20th Jun 2004 01:18

Link

mmm your get ground height function doesn't seem to work, it keeps puting the building at the same height no matter, what the height of the ground is.

Back to top

Profile PM Email

David T

Retired Moderator

22

Years of Service

User Offline

Joined: 27th Aug 2002

Location: England

Posted: 20th Jun 2004 01:38

Link

I know that rnd(whatever) will produce the same result without randomize [whatever] being called - however does anybody know if you do this:

randomize timer()
print rnd(10)
print rnd(10)
print rnd(10)

then will all the results be the same?

Lol, I suppose it's easy enough to find out; don't feel like going on DB now though

Two strings walk into a bar. I'll have a pint says the first$%ASLDJ09920D"$"$D. Excuse my friend says the second, he isn't null terminated.

Back to top

Profile PM Email Website

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 20th Jun 2004 02:09

Link

anyone else have problems with get ground height()? Cause its working fine here.

"eureka" - Archimedes

Back to top

Profile PM Email Website

jwurmz

21

Years of Service

User Offline

Joined: 6th Oct 2003

Location: Arizona, USA

Posted: 20th Jun 2004 05:04

Link

David T:
i have no idea what the chances of all three being the same (7,7,7) are, probably like 1 in 1,000,000,000 or something.
the chances of those commands yielding the same results on different occasions (7,2,4 and 7,2,4 again) is 1 in 1000. reason - the random number generator is seeded by TIMER() which is always the system times' millisecond reading. so the only time the numbers will be the same on two different occasions would be if the program seeded the RNG at the same exact millisecond-time each time. i think...

"Creativity is knowing how to hide your sources" - Einstein

Back to top

Profile PM Website

David T

Retired Moderator

22

Years of Service

User Offline

Joined: 27th Aug 2002

Location: England

Posted: 20th Jun 2004 19:56

Link

Okay - the only reason I asked is that I read somewhere once that in order to get different results for the same value you need to radnomze each time. Silly person

Two strings walk into a bar. I'll have a pint says the first$%ASLDJ09920D"$"$D. Excuse my friend says the second, he isn't null terminated.

Back to top

Profile PM Email Website

jwurmz

21

Years of Service

User Offline

Joined: 6th Oct 2003

Location: Arizona, USA

Posted: 21st Jun 2004 06:49

Link

actually, after further testing the timer() function returned a 7-digit number so the chances are more like 1 in 9999999. don't take my word for it though. just know that a single "randomize timer()" command is enough to get random results, no matter where or when you use a "rnd(whatever)" function thereafter.

"Creativity is knowing how to hide your sources" - Einstein

Back to top

Profile PM Website

Jetmech

22

Years of Service

User Offline

Joined: 25th Oct 2002

Location: Dayton Ohio

Posted: 21st Jun 2004 07:04

Link

Just out of curiosity, ( your functions are great) but.... Kevil made all these same functions and several more, months ago... aren't you kind of reinventing the wheel here?

Back to top

Profile PM

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 21st Jun 2004 11:15

Link

I didn't know he made them until i started making them. besides, i wanted to know how to use memblocks. dont like it, dont use it.

"eureka" - Archimedes

Back to top

Profile PM Email Website

Marthik

20

Years of Service

User Offline

Joined: 25th Jan 2004

Location: Washington State, USA

Posted: 21st Jun 2004 11:53

Link

mmm i am not sure y it's not setting the object to the currect height, but i lowered the amound my landscape is randized by, so now it's smaller, and can't be noticed, or maybe it just works now...

Back to top

Profile PM Email

David T

Retired Moderator

22

Years of Service

User Offline

Joined: 27th Aug 2002

Location: England

Posted: 21st Jun 2004 11:53

Link

I could never get results with Kevil's functions. These look a lot more like normal matrix commands

Two strings walk into a bar. I'll have a pint says the first$%ASLDJ09920D"$"$D. Excuse my friend says the second, he isn't null terminated.

Back to top

Profile PM Email Website

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 22nd Jun 2004 09:06

Link

well technically they are. but the matrix is an object now.
Just so you know, the get ground height() doesn't work for heights lower than 0.

"eureka" - Archimedes

Back to top

Profile PM Email Website

Jetmech

22

Years of Service

User Offline

Joined: 25th Oct 2002

Location: Dayton Ohio

Posted: 22nd Jun 2004 14:33

Link

phaelax,

wasn't trying to put down your work in any way, as I stated in my previous post, your functions work great and its obvious that that a lot of work went into them!

Sorry if I came off the wrong way!

please keep up the good work!

Jet

Back to top

Profile PM

Steele

21

Years of Service

User Offline

Joined: 25th Oct 2003

Location: Somewhere over the rainbow

Posted: 22nd Jun 2004 18:42

Link

Something that might be beneficial would be "set_matrix_normal" as I am using a small routine which uses it.

Just something to think about, maybe for version two.

Good job!

Steele

-- I straddle the line between genius and insanity. Guess which side I am on now? --

Back to top

Profile PM Email

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 22nd Jun 2004 19:53 Edited at: 22nd Jun 2004 19:56

Link

Well, alright. Until I get the DLL completed, and fully functional, here's the DBP source for all commands. Includes matrix normals, and an auto configure routine.(not sure how well it works) A revised version of get ground height is in the works. It should replace the current method and increase frame rates by over 100. At least it does on my machine, as intersect object is slooow. Randomize matrix added.
Yes, maybe some ppl have made programs like this before. But has anyone made it into an easy to use set of functions?
Check source button below for full source code including new functions.

"eureka" - Archimedes

Back to top

Profile PM Email Website

David T

Retired Moderator

22

Years of Service

User Offline

Joined: 27th Aug 2002

Location: England

Posted: 22nd Jun 2004 21:16

Link

Automatic normal calculation'd be nice

Two strings walk into a bar. I'll have a pint says the first$%ASLDJ09920D"$"$D. Excuse my friend says the second, he isn't null terminated.

Back to top

Profile PM Email Website

Jetmech

22

Years of Service

User Offline

Joined: 25th Oct 2002

Location: Dayton Ohio

Posted: 23rd Jun 2004 06:18 Edited at: 23rd Jun 2004 06:28

Link

disregard this post

Back to top

Profile PM

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 23rd Jun 2004 09:39

Link

Quote: "Automatic normal calculation'd be nice "

from my post just above yours:

Quote: "Includes matrix normals, and an auto configure routine"

so umm, yes its there.

"eureka" - Archimedes

Back to top

Profile PM Email Website

jwurmz

21

Years of Service

User Offline

Joined: 6th Oct 2003

Location: Arizona, USA

Posted: 26th Jun 2004 10:28

Link

Phaelax:
just wanted to thank you for the memblock matrix code. it works splendidly!!! i'll be sure and give credit in the event that i finish my project... the very first "old west" RPG. your method will allow me to make my landscapes MUCH larger. if you improve on it any more (than you already have), don't hesitate to update the code snippets section. thanks again

"Creativity is knowing how to hide your sources" - Einstein

Back to top

Profile PM Website

David T

Retired Moderator

22

Years of Service

User Offline

Joined: 27th Aug 2002

Location: England

Posted: 26th Jun 2004 12:52

Link

Quote: "from my post just above yours:

Quote: "Includes matrix normals, and an auto configure routine"

so umm, yes its there"

Hmm, well, I had a quick scan through and couldn't see anything

Two strings walk into a bar. I'll have a pint says the first$%ASLDJ09920D"$"$D. Excuse my friend says the second, he isn't null terminated.

Back to top

Profile PM Email Website

jwurmz

21

Years of Service

User Offline

Joined: 6th Oct 2003

Location: Arizona, USA

Posted: 26th Jun 2004 15:28 Edited at: 26th Jun 2004 18:19

Link

it's there

function configure_matrix_normals(number as integer)
   for z=1 to matrix(number).zsegs-1
      for x=1 to matrix(number).xsegs-1

rem Get matrix heights
         h8#=get_matrix_height(number,x,z-1)
         h4#=get_matrix_height(number,x-1,z)
         h#=get_matrix_height(number,x,z)
         h2#=get_matrix_height(number,x,z)

rem Calculate projected angle X using heights
         x1#=(x-1)*25.0 : y1#=h#
         x2#=(x+0)*25.0 : y2#=h4#
         dx#=x2#-x1#
         dy#=y2#-y1#
         ax#=atanfull(dx#,dy#)
         ax#=wrapvalue(90-ax#)

rem Calculate projected angle Z using heights
         z1#=(z-1)*25.0 : y1#=h2#
         z2#=(z+0)*25.0 : y2#=h8#
         dz#=z2#-z1#
         dy#=y2#-y1#
         az#=atanfull(dz#,dy#)
         az#=wrapvalue(90-az#)

rem Make normal from projected angle
         nx#=sin(ax#)
         ny#=cos(ax#)
         nz#=sin(az#)

rem Setting matrix normal for smoothness
         set_matrix_normal(number,x,z,nx#,ny#,nz#)
      next x
   next z
endfunction

+ Code Snippet

function configure_matrix_normals(number as integer)
   for z=1 to matrix(number).zsegs-1
      for x=1 to matrix(number).xsegs-1

         rem Get matrix heights
         h8#=get_matrix_height(number,x,z-1)
         h4#=get_matrix_height(number,x-1,z)
         h#=get_matrix_height(number,x,z)
         h2#=get_matrix_height(number,x,z)

         rem Calculate projected angle X using heights
         x1#=(x-1)*25.0 : y1#=h#
         x2#=(x+0)*25.0 : y2#=h4#
         dx#=x2#-x1#
         dy#=y2#-y1#
         ax#=atanfull(dx#,dy#)
         ax#=wrapvalue(90-ax#)

         rem Calculate projected angle Z using heights
         z1#=(z-1)*25.0 : y1#=h2#
         z2#=(z+0)*25.0 : y2#=h8#
         dz#=z2#-z1#
         dy#=y2#-y1#
         az#=atanfull(dz#,dy#)
         az#=wrapvalue(90-az#)

         rem Make normal from projected angle
         nx#=sin(ax#)
         ny#=cos(ax#)
         nz#=sin(az#)

         rem Setting matrix normal for smoothness
         set_matrix_normal(number,x,z,nx#,ny#,nz#)
      next x
   next z
endfunction

function set_matrix_normal(number as integer, tile_x as integer, tile_z as integer, nx as float, ny as float, nz as float)

if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif
   size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

REM verts 3 and 5
   if tile_x > 0 and tile_z > 0
      gx = tile_x - 1
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+84, nx
      write memblock float mem_numb, location+88, ny
      write memblock float mem_numb, location+92, nz

write memblock float mem_numb, location+156, nx
      write memblock float mem_numb, location+160, ny
      write memblock float mem_numb, location+164, nz
   endif

REM vert 2
   if tile_z > 0 and tile_x < matrix(number).xsegs
      gx = tile_x
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+48, nx
      write memblock float mem_numb, location+52, ny
      write memblock float mem_numb, location+56, nz
   endif

rem vert 6
   if tile_x > 0 and tile_z < matrix(number).zsegs
      gx = tile_x - 1
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+192, nx
      write memblock float mem_numb, location+196, ny
      write memblock float mem_numb, location+200, nz
   endif

rem verts 1 and 4
   if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      gx = tile_x
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+12, nx
      write memblock float mem_numb, location+16, ny
      write memblock float mem_numb, location+20, nz

write memblock float mem_numb, location+120, nx
      write memblock float mem_numb, location+124, ny
      write memblock float mem_numb, location+128, nz
   endif
endfunction

+ Code Snippet

function set_matrix_normal(number as integer, tile_x as integer, tile_z as integer, nx as float, ny as float, nz as float)

   if tile_x < 0 OR tile_x > matrix(number).xsegs OR tile_z < 0 OR tile_z > matrix(number).zsegs
      exitfunction
   endif
   size = 36
   boffset = size*6
   numb_verts = matrix(number).xsegs * matrix(number).zsegs * 6
   total_size = numb_verts*size + 12
   tile_size_x# = width/matrix(number).xsegs
   tile_size_z# = height/matrix(number).zsegs
   mem_numb = matrix(number).mem_numb
   lensize = matrix(number).xsegs*boffset

   REM verts 3 and 5
   if tile_x > 0 and tile_z > 0
      gx = tile_x - 1
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+84, nx
      write memblock float mem_numb, location+88, ny
      write memblock float mem_numb, location+92, nz

      write memblock float mem_numb, location+156, nx
      write memblock float mem_numb, location+160, ny
      write memblock float mem_numb, location+164, nz
   endif

   REM vert 2
   if tile_z > 0 and tile_x < matrix(number).xsegs
      gx = tile_x
      gz = tile_z - 1
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+48, nx
      write memblock float mem_numb, location+52, ny
      write memblock float mem_numb, location+56, nz
   endif

   rem vert 6
   if tile_x > 0 and tile_z < matrix(number).zsegs
      gx = tile_x - 1
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+192, nx
      write memblock float mem_numb, location+196, ny
      write memblock float mem_numb, location+200, nz
   endif

   rem verts 1 and 4
   if tile_x < matrix(number).xsegs and tile_z < matrix(number).zsegs
      gx = tile_x
      gz = tile_z
      location = gz*lensize + gx*boffset + 12
      write memblock float mem_numb, location+12, nx
      write memblock float mem_numb, location+16, ny
      write memblock float mem_numb, location+20, nz

      write memblock float mem_numb, location+120, nx
      write memblock float mem_numb, location+124, ny
      write memblock float mem_numb, location+128, nz
   endif
endfunction

"Creativity is knowing how to hide your sources" - Einstein

Back to top

Profile PM Website

Sorry your browser is not supported!

Code Snippets / new matrix functions