TheGameCreators - CodeBase - Memblock Matrix

Category: Matrix

Version: 1.0

Information

Uploaded: 9th Dec 2004 05:51

Modified: 1st Jan 1970 01:00

Author: Kelebrindae

Summary

Create a matrix that can be manipulated (ex:rotated) like a common object. Advanced functionality (heigtmaps, normals calculation, tile-texturing with rotated/mirrored tiles...) has been added. See ZIP in attachment for an example.

Full Description

Create a matrix that can be manipulated (ex:rotated) like a common object. Advanced functionality (heigtmaps, normals calculation, tile-texturing with rotated/mirrored tiles) has been added. Make intensive use of the memblocks.<br /> Please download the ZIP file in attachments to get some sample codes and a short "how to" file.

DarkBASIC Source Code

` This code was downloaded from The Game Creators

` It is reproduced here with full permission

` http://www.thegamecreators.com

rem *******************************************************************

rem * Create and manage a "matrix-like-object" built from a memblock  *

rem * Author: Kelebrindae                                             *

rem * November 2004                                                   *

rem *******************************************************************

rem Build a memblock containing the mesh of a "matrix-like" object.

rem This mesh will be [width#] by [depth#], divided in a grid of [tilesX] by [tilesZ] squares.

rem Each square has 4 vertices, so the mesh will contain [tilesX] * [tilesZ] * 4 vertices, numeroted from 0 to [Nb verteces - 1].

rem This means that a 2x2 grid will have 16 verteces, like shown here:

rem   09--10 13--14

rem   |     |     |

rem   08__11 12__15

rem   01  02 05  06

rem   |     |     |

rem   00--03 04--07

rem The mesh's pivot (0,0,0 coordinates) is located on vertex nÂ°0 (in the "lower-left" corner).

rem The UV coords 0,0 are located on the "upper left" corner of the matrix (in the 3x3 matrix, on vertex nÂ°12).

rem It is so because the Y axis in images is "inverted" (pixel 0,0 is in the upper left corner of the bitmap).

rem So, to avoid a "vertical mirror" effect on the texture, I had to invert the V axis of UVmapping...

rem Matrix number of tiles and dimensions are stored in memblock 255 for fast and easy access.

` Parameters:

` Memblock number, matrix width (pixels), matrix depth (pixels)

function makeMemMatrix(memNum,width#,depth#,tilesX,tilesZ)

if memblock exist(memNum) = 1 then  exitfunction

rem If memblock nÂ°255 doesn't exist yet, create it.

if memblock exist(255) = 0

make memblock 255,(memNum+1)*16

else

rem If it exists but is too small, copy its content, delete and re-create it, then copy its datas back

size=get memblock size(255)

if size<(memNum+1)*16

make memblock 254,size

copy memblock 255,254,0,0,size

delete memblock 255

make memblock 255,(memNum+1)*16

copy memblock 254,255,0,0,size

endif

rem Compute offsets and datas sizes

vertNum = tilesX*tilesZ*4

faceNum = (tilesX * tilesZ) * 2

vertOffset = 32

normNum = vertNum

normOffset = 32+(vertNum*12)

faceOffset = 32+(vertNum*12)+(normNum*12)

faceSize = 7*faceNum: rem this size is in "Dwords", not in "Bytes"! (1 Dword = 4 bytes)

UVOffset = 32+(vertNum*12)+(normNum*12)+(faceNum*28)

rem Create memblock

memSize = 32 + (12*vertNum) + (12*normNum) + (28*faceNum) + (8*vertNum)

make memblock memNum,memSize

rem Write mesh header

write memblock dword memNum,0,vertNum

write memblock dword memNum,4,vertOffset

write memblock dword memNum,8,normNum

write memblock dword memNum,12,normOffset

write memblock dword memNum,16,faceNum

write memblock dword memNum,20,faceOffset

write memblock dword memNum,24,faceSize

write memblock dword memNum,28,UVOffset

rem Size of matrix tile, Size of UV tile

tileWidth# = width#/(tilesX*1.0)

tileDepth# = depth#/(tilesZ*1.0)

UVtileWidth# = 1.00/(tilesX*1.0)

UVtileDepth# = 1.00/(tilesZ*1.0)

rem Store number of tiles and tiles size in memblock 255

write memblock Dword 255,memNum*16,tilesX

write memblock Dword 255,(memNum*16)+4,tilesZ

write memblock float 255,(memNum*16)+8,tileWidth#

write memblock float 255,(memNum*16)+12,tileDepth#

rem Create 4 vertex and 2 faces by tile

vertCtr=0:faceCtr=0

for cz = 0 to tilesZ-1

for cx = 0 to tilesX-1

rem Vertex 0 coords

write memblock float memNum,vertOffset+(vertCtr*12),cx*tileWidth#

write memblock float memNum,vertOffset+(vertCtr*12)+4,0.00

write memblock float memNum,vertOffset+(vertCtr*12)+8,cz*tileDepth#

rem Normals infos

write memblock float memNum,normOffset+(vertCtr*12),0.0

write memblock float memNum,normOffset+(vertCtr*12)+4,1.00

write memblock float memNum,normOffset+(vertCtr*12)+8,0.0

rem UV coords

write memblock float memNum,UVoffset+(vertCtr*8),cx*UVtileWidth#

write memblock float memNum,UVoffset+(vertCtr*8)+4,1.00-(cz*UVtileDepth#)

rem Store vertex number and go on

v0 = vertCtr

inc vertCtr

rem Vertex 1 coords

write memblock float memNum,vertOffset+(vertCtr*12),cx*tileWidth#

write memblock float memNum,vertOffset+(vertCtr*12)+4,0.00

write memblock float memNum,vertOffset+(vertCtr*12)+8,(cz+1)*tileDepth#

rem Normals infos

write memblock float memNum,normOffset+(vertCtr*12),0.0

write memblock float memNum,normOffset+(vertCtr*12)+4,1.00

write memblock float memNum,normOffset+(vertCtr*12)+8,0.0

rem UV coords

write memblock float memNum,UVoffset+(vertCtr*8),cx*UVtileWidth#

write memblock float memNum,UVoffset+(vertCtr*8)+4,1.00-((cz+1)*UVtileDepth#)

rem Store vertex number and go on

v1 = vertCtr

inc vertCtr

rem Vertex 2 coords

write memblock float memNum,vertOffset+(vertCtr*12),(cx+1)*tileWidth#

write memblock float memNum,vertOffset+(vertCtr*12)+4,0.00

write memblock float memNum,vertOffset+(vertCtr*12)+8,(cz+1)*tileDepth#

rem Normals infos

write memblock float memNum,normOffset+(vertCtr*12),0.0

write memblock float memNum,normOffset+(vertCtr*12)+4,1.00

write memblock float memNum,normOffset+(vertCtr*12)+8,0.0

rem UV coords

write memblock float memNum,UVoffset+(vertCtr*8),(cx+1)*UVtileWidth#

write memblock float memNum,UVoffset+(vertCtr*8)+4,1.00-((cz+1)*UVtileDepth#)

rem Store vertex number and go on

v2 = vertCtr

inc vertCtr

rem Vertex 3 coords

write memblock float memNum,vertOffset+(vertCtr*12),(cx+1)*tileWidth#

write memblock float memNum,vertOffset+(vertCtr*12)+4,0.00

write memblock float memNum,vertOffset+(vertCtr*12)+8,cz*tileDepth#

rem Normals infos

write memblock float memNum,normOffset+(vertCtr*12),0.0

write memblock float memNum,normOffset+(vertCtr*12)+4,1.00

write memblock float memNum,normOffset+(vertCtr*12)+8,0.0

rem UV coords

write memblock float memNum,UVoffset+(vertCtr*8),(cx+1)*UVtileWidth#

write memblock float memNum,UVoffset+(vertCtr*8)+4,1.00-(cz*UVtileDepth#)

rem Store vertex number and go on

v3 = vertCtr

inc vertCtr

rem First triangle of tile

write memblock dword memNum,faceOffset+(faceCtr*28),3

write memblock dword memNum,faceOffset+(faceCtr*28)+4,v1

write memblock dword memNum,faceOffset+(faceCtr*28)+8,v1

write memblock dword memNum,faceOffset+(faceCtr*28)+12,v2

write memblock dword memNum,faceOffset+(faceCtr*28)+16,v2

write memblock dword memNum,faceOffset+(faceCtr*28)+20,v0

write memblock dword memNum,faceOffset+(faceCtr*28)+24,v0

inc faceCtr

rem Second triangle

write memblock dword memNum,faceOffset+(faceCtr*28),3

write memblock dword memNum,faceOffset+(faceCtr*28)+4,v3

write memblock dword memNum,faceOffset+(faceCtr*28)+8,v3

write memblock dword memNum,faceOffset+(faceCtr*28)+12,v0

write memblock dword memNum,faceOffset+(faceCtr*28)+16,v0

write memblock dword memNum,faceOffset+(faceCtr*28)+20,v2

write memblock dword memNum,faceOffset+(faceCtr*28)+24,v2

inc faceCtr

next cx

next cz

endfunction

rem Set the height of a vertex in the matrix memblock

` Parameters:

` Memblock number, x coord of the vertex to move, Z coord, new height

function setMemMatrixHeight(memNum,cx,cz,height#)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

if cx>0 and cz>0 then vertCtr=((cz-1)*(4*tilesX)) + ((cx-1)*4) + 2:write memblock float memNum,32+(vertCtr*12)+4,height#

if cx>0 and cz<TilesZ then vertCtr=(cz*(4*tilesX)) + ((cx-1)*4) + 3:write memblock float memNum,32+(vertCtr*12)+4,height#

if cx<TilesX and cz<TilesZ then vertCtr=(cz*(4*tilesX)) + (cx*4):write memblock float memNum,32+(vertCtr*12)+4,height#

if cx<TilesX and cz>0 then vertCtr=((cz-1)*(4*tilesX)) + (cx*4)+1:write memblock float memNum,32+(vertCtr*12)+4,height#

endfunction

rem Get the height of a vertex in the matrix memblock

` Parameters:

` Memblock number, x coord of the vertex, Z coord

` Return: height of the vertex

function getMemMatrixHeight(memNum,cx,cz)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

height#=0

if cx>0 and cz>0 then vertCtr=((cz-1)*(4*tilesX)) + ((cx-1)*4) + 2:exitfunction memblock float(memNum,32+(vertCtr*12)+4)

if cx>0 and cz<TilesZ then vertCtr=(cz*(4*tilesX)) + ((cx-1)*4) + 3:exitfunction memblock float(memNum,32+(vertCtr*12)+4)

if cx<TilesX and cz<TilesZ then vertCtr=(cz*(4*tilesX)) + (cx*4):exitfunction memblock float(memNum,32+(vertCtr*12)+4)

if cx<TilesX and cz>0 then vertCtr=((cz-1)*(4*tilesX)) + (cx*4)+1:exitfunction memblock float(memNum,32+(vertCtr*12)+4)

endfunction height#

rem Get the height of a point in the matrix memblock

` Parameters:

` Memblock number, x coord, Z coord

` Return: height of the point

` (DBpro code by Phaelax, slightly adapted for DBC)

function getMemMatrixGroundHeight(memNum,x#,z#)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

rem retrieve tiles size

sizex#=memblock float(255,(memnum*16)+8)

sizez#=memblock float(255,(memnum*16)+12)

rem If the point is in the matrix, return its height

if x#>=0 and z#>=0 and x#<tilesX*sizex# and z#<tilesZ*sizez#

xt=int(x#/sizex#)

zt=int(z#/sizez#)

if (((xt+1)*sizex#)-x#)+(z#-(zt*sizez#))<=sizex#

dx#=getMemMatrixHeight(memNum,xt+1,zt)-getMemMatrixHeight(memNum,xt,zt)

dz#=getMemMatrixHeight(memNum,xt+1,zt+1)-getMemMatrixHeight(memNum,xt+1,zt)

else

dx#=getMemMatrixHeight(memNum,xt+1,zt+1)-getMemMatrixHeight(memNum,xt,zt+1)

dz#=getMemMatrixHeight(memNum,xt,zt+1)-getMemMatrixHeight(memNum,xt,zt)

endif

height#=(((x#-(xt*sizex#))/sizex#)*dx#)+(((z#-(zt*sizez#))/sizez#)*dz#)+getMemMatrixHeight(memNum,xt,zt)

endif

endfunction height#

rem Set the normal of a vertex in the matrix memblock

rem => called in the ConfigureMemMatrixNormal function

` Parameters:

` Memblock number, x coord of the vertex, Z coord, x,y,z of the new normal vector

function setMemMatrixNormal(memNum,cx,cz,nx#,ny#,nz#)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

vertNum=memblock dword(memNum,0)

normOffset = 32+(vertNum*12)

if cx>0 and cz>0

vertCtr=((cz-1)*(4*tilesX)) + ((cx-1)*4) + 2

write memblock float memNum,normOffset+(vertCtr*12),nx#

write memblock float memNum,normOffset+(vertCtr*12)+4,ny#

write memblock float memNum,normOffset+(vertCtr*12)+8,nz#

endif

if cx>0 and cz<TilesZ

vertCtr=(cz*(4*tilesX)) + ((cx-1)*4) + 3

write memblock float memNum,normOffset+(vertCtr*12),nx#

write memblock float memNum,normOffset+(vertCtr*12)+4,ny#

write memblock float memNum,normOffset+(vertCtr*12)+8,nz#

endif

if cx<TilesX and cz<TilesZ

vertCtr=(cz*(4*tilesX)) + (cx*4)

write memblock float memNum,normOffset+(vertCtr*12),nx#

write memblock float memNum,normOffset+(vertCtr*12)+4,ny#

write memblock float memNum,normOffset+(vertCtr*12)+8,nz#

endif

if cx<TilesX and cz>0

vertCtr=((cz-1)*(4*tilesX)) + (cx*4)+1

write memblock float memNum,normOffset+(vertCtr*12),nx#

write memblock float memNum,normOffset+(vertCtr*12)+4,ny#

write memblock float memNum,normOffset+(vertCtr*12)+8,nz#

endif

endfunction

rem Re-calculate the normal of each vertex of the matrix

` Parameters:

` Memblock number

function ConfigureMemMatrixNormals(memNum)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

rem retrieve tiles size

sizex#=memblock float(255,(memnum*16)+8)

sizez#=memblock float(255,(memnum*16)+12)

for z=1 to tilesZ-1

for x=1 to tilesX-1

rem Get matrix heights

h8#=getMemMatrixHeight(memNum,x,z-1)

h4#=getMemMatrixHeight(memNum,x-1,z)

h#=getMemMatrixHeight(memNum,x,z)

h2#=getMemMatrixHeight(memNum,x,z)

rem Calculate projected angle X using heights

x1#=(x-1)*sizex# : y1#=h#

x2#=x*sizex# : 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)*sizez# : y1#=h2#

z2#=z*sizez# : 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

setMemMatrixNormal(memNum,x,z,nx#,ny#,nz#)

next x

next z

endfunction

rem Re-calculate the normal of ONE vertex of the matrix

` Parameters:

` Memblock number, x coord of the vertex, Z coord

function ConfigureOneMemMatrixNormal(memNum,x,z)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

rem retrieve tiles size

sizex#=memblock float(255,(memnum*16)+8)

sizez#=memblock float(255,(memnum*16)+12)

rem Get matrix heights

h8#=getMemMatrixHeight(memNum,x,z-1)

h4#=getMemMatrixHeight(memNum,x-1,z)

h#=getMemMatrixHeight(memNum,x,z)

h2#=getMemMatrixHeight(memNum,x,z)

rem Calculate projected angle X using heights

x1#=(x-1)*sizex# : y1#=h#

x2#=x*sizex# : 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)*sizez# : y1#=h2#

z2#=z*sizez# : 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

setMemMatrixNormal(memNum,x,z,nx#,ny#,nz#)

endfunction

rem "Smooth" the matrix, giving it a more "round" look.

rem This smoothes the mesh; it does not affect the normals.

rem The more iterations you set, the more intense the smooth effect will be (it'll be slower, too).

` Parameters:

` Memblock number, nb iterations of smoothing

` (DBpro code by Phaelax, slightly adapted for DBC)

function smoothMemMatrix(memNum,iterations)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

rem store original heights

dim heights#(tilesX,tilesZ)

for z = 0 to tilesZ

for x = 0 to tilesX

heights#(x,z) = getMemMatrixHeight(memNum,x,z)

next x

next z

rem Smooth the matrix by "averaging" the height of each vertex with the height of its neighbours

for t = 1 to iterations

for z = 0 to tilesZ

for x = 0 to tilesX

count = 0

h1# = 0

h2# = 0

h3# = 0

h4# = 0

h5# = 0

h6# = 0

h7# = 0

h8# = 0

if z < tilesZ

if x > 0 then h1# = heights#(x-1,z+1) : inc count

h2# = heights#(x,z+1) : inc count

if x < tilesX then h3# = heights#(x+1,z+1) : inc count

endif

if x > 0 then h4# = heights#(x-1,z) : inc count

if x < tilesX then h5# = heights#(x+1,z) : inc count

if z > 0

if x > 0 then h6# = heights#(x-1,z-1) : inc count

h7# = heights#(x,z-1) : inc count

if x < tilesX then h8# = heights#(x+1,z-1) : inc count

endif

avg# = (h1#+h2#+h3#+h4#+h5#+h6#+h7#+h8#) / count

setMemMatrixHeight(memNum,x,z,avg#)

next x

next z

next t

rem delete array

undim heights#()

endfunction

rem Take a rectangle in the matrix (defined by x1,z1,x2,z2 parameters) and change its UVmapping

rem to show a certain area of the texture (defined by xtex1,ytex1,xtex2,ytex2 parameters).

` Parameters:

` memblock,image used to texture the matrix,

` width,depth of the matrix

` x1,z1,x2,z2 (in tiles coordinates, which define a rectangle wherein the mapping will be changed)

` xtex1,ytex1,xtex2,ytex2 (in pixels, which define a rectangle in the texture that will be mapped on the rectangle defined above)

` rotate (0 = no rotation; 1 = 90Â° ; 2 = 180Â° ; 3 = 270Â°. Rotation is trigonometric -> anti-clockwise)

` flip (0 = no flip; 1 = horizontal flip; 2 = vertical flip. You don't need "flip both" 'cos it's just like "rotate 180Â°")

` (Man, is it complicated! I must find a way to make it simplier...)

` Return: 0 - if you did everything right

`         1 - Memblock doesn't exist

`         2 - Texture image doesn't exist (did you load it before running this function?)

`         3 - Tiles coords given for mapping (x1,z1,x2,z2) exceed matrix limits

`         4 - Tiles coords are inverted (x1>x2 and/or z1>z2)

`         5 - Texture coords exceed texture limits (<0 or >texture size)

`         6 - Texture coords are inverted (xtex1>xtex2 and/or ytex1>ytex2)

`         7 - Rotate/flipping params exceeds limits (<0 or >3 for rotate or >2 for flipping)

function UVmapMemMatrix(memNum,imageNum,x1,z1,x2,z2,xtex1,ytex1,xtex2,ytex2,rotate,flip)

if memblock exist(memNum) = 0 then exitfunction 1

if image exist(ImageNum) = 0 then exitfunction 2

rem Control parameter integrity

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

if x1<0 or x2>tilesX or z1<0 or z2>tilesZ then exitfunction 3

if x1>x2 or z1>z2 then exitfunction 4

if rotate<0 or rotate>3 or flip<0 or flip>2 then exitfunction 7

rem Load texture into a memblock, to get its size

make memblock from image 254,imageNum

imageWidth#=memblock dword(254,0):imageHeight#=memblock dword(254,4)

delete memblock 254

if xtex2>imageWidth# or ytex2>imageHeight# or xtex1<0 or ytex1<0 then exitfunction 5

if xtex1>=xtex2 or ytex1>=ytex2 then exitfunction 6

rem Rotating and flipping

dim rotx(4):dim rotz(4)

rotx(1)=0:rotx(2)=0:rotx(3)=1:rotx(4)=1

rotz(1)=0:rotz(2)=1:rotz(3)=1:rotz(4)=0

nrotstart=1:mirrorboth=0

if rotate=1 then nrotstart=2

if rotate=2 then mirrorboth=1:rem 180Â° rotation = flip both axis

if rotate=3 then nrotstart=2:mirrorboth=1:rem 270Â° rotation = 90Â° rotation + flip both axis

if mirrorboth=1

select flip

case 0

newflip=3

endcase

case 1

newflip=2

endcase

case 2

newflip=1

endcase

endselect

flip=newflip

endif

rem Useful values: Nb Tiles to remap, size of UV tiles, etc...

UVOffset=memblock dword(memNum,28)

nbtilesX=abs(x2-x1):nbtilesZ=abs(z2-z1)

xtex1#=xtex1:xtex2#=xtex2:ytex1#=ytex1:ytex2#=ytex2

subImageRatiox#=((1.00+xtex2#-xtex1#)/imageWidth#)

subImageRatioy#=((1.00+ytex2#-ytex1#)/imageHeight#)

Ustart#=xtex1#/imageWidth#

Vstart#=(ytex2#+1.00)/imageHeight#

UVtileWidth# = subImageRatiox#/(abs(nbtilesX)+1)

UVtileDepth# = subImageRatioy#/(abs(nbtilesZ)+1)

rem Mirroring: U and/or V directions are inverted

if flip=1 or flip=3 then Ustart#=1.00-(subImageRatiox#+Ustart#):UVtileWidth#=UVtileWidth#*-1.00

if flip=2 or flip=3 then Vstart#=1.00-(subImageRatioy#-Vstart#):UVtileDepth#=UVtileDepth#*-1.00

rem remapping of the rectangle x1,z1 -> x2,z2

for cz=0 to nbtilesZ

for cx=0 to nbtilesX

rem UV coords

if rotate=1 or rotate=3

vertCtr=((x1+cx)*tilesZ*4)+((z2-cz)*4)

else

vertCtr=((z1+cz)*tilesX*4)+((x1+cx)*4)

endif

nrot=nrotstart

rem v0

write memblock float memNum,UVoffset+(vertCtr*8),Ustart#+((cx+rotx(nrot))*UVtileWidth#)

write memblock float memNum,UVoffset+(vertCtr*8)+4,Vstart#-((cz+rotz(nrot))*UVtileDepth#)

inc vertCtr

inc nrot:if nrot=5 then nrot=1

rem v1

write memblock float memNum,UVoffset+(vertCtr*8),Ustart#+((cx+rotx(nrot))*UVtileWidth#)

write memblock float memNum,UVoffset+(vertCtr*8)+4,Vstart#-((cz+rotz(nrot))*UVtileDepth#)

inc vertCtr

inc nrot:if nrot=5 then nrot=1

rem v2

write memblock float memNum,UVoffset+(vertCtr*8),Ustart#+((cx+rotx(nrot))*UVtileWidth#)

write memblock float memNum,UVoffset+(vertCtr*8)+4,Vstart#-((cz+rotz(nrot))*UVtileDepth#)

inc vertCtr

inc nrot:if nrot=5 then nrot=1

rem v3

write memblock float memNum,UVoffset+(vertCtr*8),Ustart#+((cx+rotx(nrot))*UVtileWidth#)

write memblock float memNum,UVoffset+(vertCtr*8)+4,Vstart#-((cz+rotz(nrot))*UVtileDepth#)

next cx

next cz

endfunction 0

rem Randomize the height of all vertices in the matrix, within the range of 0 to heightrange#

` Parameters:

` Memblock number, height range

function randomizeMemMatrix(memNum,heightrange#)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

for i=0 to tilesX

for j=0 to tilesZ

setMemMatrixHeight(memNum,i,j,(rnd(heightrange#*256.00)/256.00))

next j

next i

endfunction

rem Move the pivot point of the matrix (usually the lower left corner) to the x,z center of the object

function centerMemMatrixPivot(memnum)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

rem retrieve tiles size

sizex#=memblock float(255,(memnum*16)+8)

sizez#=memblock float(255,(memnum*16)+12)

rem Calculate x and z displacement we must apply to each vertex

vertOffset=memblock dword(memNum,4)

vertNum=memblock dword(memNum,0)

xmove#=( memblock float(memNum,vertOffset)-memblock float(memNum,vertOffset+((vertnum-2)*12)) )/2.00

zmove#=( memblock float(memNum,vertOffset+8)-memblock float(memNum,vertOffset+((vertnum-2)*12)+8) )/2.00

rem Move vertex to their new position

vertCtr=0

for cz = 0 to tilesZ-1

for cx = 0 to tilesX-1

rem Vertex 0 coords

write memblock float memNum,vertOffset+(vertCtr*12),xmove#+(cx*sizex#)

write memblock float memNum,vertOffset+(vertCtr*12)+8,zmove#+(cz*sizez#)

inc vertCtr

rem Vertex 1 coords

write memblock float memNum,vertOffset+(vertCtr*12),xmove#+(cx*sizex#)

write memblock float memNum,vertOffset+(vertCtr*12)+8,zmove#+((cz+1)*sizez#)

inc vertCtr

rem Vertex 2 coords

write memblock float memNum,vertOffset+(vertCtr*12),xmove#+((cx+1)*sizex#)

write memblock float memNum,vertOffset+(vertCtr*12)+8,zmove#+((cz+1)*sizez#)

inc vertCtr

rem Vertex 3 coords

write memblock float memNum,vertOffset+(vertCtr*12),xmove#+((cx+1)*sizex#)

write memblock float memNum,vertOffset+(vertCtr*12)+8,zmove#+(cz*sizez#)

inc vertCtr

next cx

next cz

endfunction

rem Move the pivot point of the matrix to its lower left corner (in case it has been centered before)

function restoreMemMatrixPivot(memnum)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

rem retrieve tiles size

sizex#=memblock float(255,(memnum*16)+8)

sizez#=memblock float(255,(memnum*16)+12)

rem Calculate x and z displacement we must apply to each vertex

vertOffset=memblock dword(memNum,4)

vertNum=memblock dword(memNum,0)

rem Move vertex to their new position

vertCtr=0

for cz = 0 to tilesZ-1

for cx = 0 to tilesX-1

rem Vertex 0 coords

write memblock float memNum,vertOffset+(vertCtr*12),cx*sizex#

write memblock float memNum,vertOffset+(vertCtr*12)+8,cz*sizez#

inc vertCtr

rem Vertex 1 coords

write memblock float memNum,vertOffset+(vertCtr*12),cx*sizex#

write memblock float memNum,vertOffset+(vertCtr*12)+8,(cz+1)*sizez#

inc vertCtr

rem Vertex 2 coords

write memblock float memNum,vertOffset+(vertCtr*12),(cx+1)*sizex#

write memblock float memNum,vertOffset+(vertCtr*12)+8,(cz+1)*sizez#

inc vertCtr

rem Vertex 3 coords

write memblock float memNum,vertOffset+(vertCtr*12),(cx+1)*sizex#

write memblock float memNum,vertOffset+(vertCtr*12)+8,cz*sizez#

inc vertCtr

next cx

next cz

endfunction

Rem Given a heightmap (greyscale image), this function will assign the height of each

rem vertex or the matrix. White pixels mean high vertex, black ones mean height=0

` Parameters:

` Memblock number, Image number,Nb tiles on X axis, Nb tiles on Z axis,maximum height

` NB: minimum height after function call is 0

` (DBpro code by Phaelax, slightly adapted for DBC)

function setMemMatrixFromHeightmap(memNum,ImageNum,maxheight#)

if image exist(ImageNum) = 0 then exitfunction

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

rem create a memblock from the image

make memblock from image 254, imageNum

rem get image dimensions

width = memblock dword(254, 0)

height = memblock dword(254, 4)

depth = memblock dword(254, 8)

rem pixel offset for configuring match between pixel and tile number

xsegs# = tilesX

zsegs# = tilesZ

ox# = width/(xsegs#+1.0)

oz# = height/(zsegs#+1.0)

rem 16 or 32

mode = depth

for z = 0 to tilesZ

for x = 0 to tilesX

if mode = 16

pos = (int((tilesZ-z)*oz#)*width + int(x*ox#))*2 + 12

c = memblock word(254, pos)

c = ((c/2048)&31)*8

endif

if mode = 32

pos = (int((tilesZ-z)z*oz#)*width + int(x*ox#))*4 + 12

c = memblock byte(254, pos)

endif

h# = (c*maxHeight#)/255.0

setMemMatrixHeight(memNum, x, z, h#)

next x

next z

delete memblock 254

endfunction

Rem Export the matrix heightmap to disk

` Parameters:

` Memblock number, file name of the heightmap

` (DBpro code by Phaelax, slightly adapted for DBC)

function saveMemMatrixHeightmap(memNum,filename$)

if file exist(filename$) then delete file filename$

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

highpt# = 0

lowpt# = 0

for x=0 to tilesX

for z=0 to tilesZ

h# = getMemMatrixHeight(memNum,x,z)

if h# > highpt# then highpt# = h#

if h# < lowpt# then lowpt# = h#

next z

next x

lowpt# = abs(lowpt#)

width = tilesX+1

height = tilesZ+1

size = width*height*4 + 12

make memblock 254, size

write memblock dword 254, 0, width

write memblock dword 254, 4, height

write memblock dword 254, 8, 32

for z=0 to tilesZ

for x=0 to tilesX

h# = getMemMatrixHeight(memNum,x,z) + lowpt#

color = (h# * 255) / highpt#

location = ((tilesZ-z)*width + x)*4 + 12

write memblock dword 254, location, rgb(color, color, color)

next x

next z

make image from memblock 254, 254

save image filename$, 254

delete memblock 254

delete image 254

endfunction

rem Move all tiles one step "down" (along the Z axis), with a wrapping effect

rem -> the first line of tiles become the last, the other lines go down.

` Parameters:

` Memblock number

function shiftMemMatrixDown(memNum)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

vertOffset=memblock dword(memNum,4)

lineSize=tilesX*48

otherLineSize=((tilesZ-1)*lineSize)

memsize=get memblock size(memNum)

vertCtr=vertOffset

rem Create a memblock and save the first line

make memblock 254,memsize

copy memblock 1,254,vertCtr,vertOffset,lineSize

rem For each tile (except those in the first line), copy the vertex height to the tile beneath

vertCtr2=vertOffset+4

vertCtr=vertCtr2+lineSize

numtiles=tilesX*(tilesZ-1)

for i=1 to numtiles

copy memblock memNum,memNum,vertCtr,vertCtr2,4

copy memblock memNum,memNum,vertCtr+12,vertCtr2+12,4

copy memblock memNum,memNum,vertCtr+24,vertCtr2+24,4

copy memblock memNum,memNum,vertCtr+36,vertCtr2+36,4

inc vertCtr,48

inc vertCtr2,48

next i

rem Restore the first line and put it to the top

vertCtr=vertOffset+4

vertCtr2=vertCtr+otherLineSize

for cx=1 to tilesX

copy memblock 254,memNum,vertCtr,vertCtr2,4

copy memblock 254,memNum,vertCtr+12,vertCtr2+12,4

copy memblock 254,memNum,vertCtr+24,vertCtr2+24,4

copy memblock 254,memNum,vertCtr+36,vertCtr2+36,4

inc vertCtr,48

inc vertCtr2,48

next cx

rem Data offsets and sizes for faces, normals, UV

normOffset=memblock dword(memNum,12)

faceOffset=memblock dword(memNum,20)

faceSize=memblock dword(memNum,24)

UVOffset=memblock dword(memNum,28)

UVlineSize = tilesX*32

rem copy the first line to the last of the new memblock

normdecal=normOffset+((tilesZ-1)*lineSize)

UVdecal=UVOffset+((tilesZ-1)*UVLineSize)

copy memblock memNum,254,normOffset,normdecal,lineSize

copy memblock memNum,254,UVoffset,UVdecal,UVLineSize

rem copy the rest of the lines

copy memblock memNum,254,normOffset+lineSize,normOffset,((tilesZ-1)*lineSize)

copy memblock memNum,254,UVoffset+UVLineSize,UVOffset,((tilesZ-1)*UVLineSize)

rem copy header and vertices infos

copy memblock memNum,254,0,0,normOffset

rem Copy faces

copy memblock memNum,254,faceOffset,faceOffset,faceSize*4

rem Copy the new memblock to the old one

copy memblock 254,memNum,0,0,memSize

delete memblock 254

endfunction

rem Move all tiles one step "up" (along the Z axis), with a wrapping effect

rem -> the last line of tiles become the first, the other lines go up.

` Parameters:

` Memblock number

function shiftMemMatrixUp(memNum)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

memsize=get memblock size(memNum)

vertOffset=memblock dword(memNum,4)

lineSize=tilesX*48

otherLineSize=((tilesZ-1)*lineSize)

vertCtr=vertOffset+otherLineSize

rem Create a memblock and save the last line

make memblock 254,memsize

copy memblock 1,254,vertCtr,vertCtr,lineSize

rem For each tile (except those in the last line), copy the vertex height to the tile above

numtiles=tilesX*(tilesZ-1)

vertCtr=vertOffset+4+otherLineSize-48

vertCtr2=vertCtr+lineSize

for i=1 to numtiles

copy memblock memNum,memNum,vertCtr,vertCtr2,4

copy memblock memNum,memNum,vertCtr+12,vertCtr2+12,4

copy memblock memNum,memNum,vertCtr+24,vertCtr2+24,4

copy memblock memNum,memNum,vertCtr+36,vertCtr2+36,4

dec vertCtr,48

dec vertCtr2,48

next i

rem Restore the last line and put it to the bottom

vertCtr2=vertOffset+4

vertCtr=vertCtr2+otherLineSize

for cx=1 to tilesX

copy memblock 254,memNum,vertCtr,vertCtr2,4

copy memblock 254,memNum,vertCtr+12,vertCtr2+12,4

copy memblock 254,memNum,vertCtr+24,vertCtr2+24,4

copy memblock 254,memNum,vertCtr+36,vertCtr2+36,4

inc vertCtr,48

inc vertCtr2,48

next cx

rem Data offsets and sizes for faces, normals, UV

normOffset=memblock dword(memNum,12)

faceOffset=memblock dword(memNum,20)

faceSize=memblock dword(memNum,24)

UVOffset=memblock dword(memNum,28)

UVlineSize = tilesX*32

rem copy the last line to the first of the new memblock

normdecal=normOffset+otherLineSize

UVdecal=UVOffset+((tilesZ-1)*UVLineSize)

copy memblock memNum,254,normdecal,normOffset,lineSize

copy memblock memNum,254,UVdecal,UVoffset,UVLineSize

rem copy the rest of the lines

copy memblock memNum,254,normOffset,normOffset+lineSize,otherLineSize

copy memblock memNum,254,UVOffset,UVoffset+UVLineSize,((tilesZ-1)*UVLineSize)

rem copy header and vertices infos

copy memblock memNum,254,0,0,normOffset

rem Copy faces

copy memblock memNum,254,faceOffset,faceOffset,faceSize*4

rem Copy the new memblock to the old one

copy memblock 254,memNum,0,0,memSize

delete memblock 254

endfunction

rem Move all tiles one step left (along the X axis), with a wrapping effect

rem -> the first column of tiles become the last, the other columns go left.

` Parameters:

` Memblock number

function shiftMemMatrixLeft(memNum)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

rem Get datas sizes

memsize=get memblock size(memNum)

vertOffset=memblock dword(memNum,4)

normOffset=memblock dword(memNum,12)

faceOffset=memblock dword(memNum,20)

faceSize=memblock dword(memNum,24)

UVOffset=memblock dword(memNum,28)

rem Useful values

lineSize=tilesX*48

lineMinusOneColumn=lineSize-48

vertCtr=vertOffset+4+48

vertCtr2=vertOffset+4

vertCtr3=vertOffset+4

vertCtr4=vertCtr3+lineMinusOneColumn

UVlineSize = tilesX*32

normCtr=normOffset

uvCtr=UVOffset

rem Create a memblock to store modified matrix

make memblock 254,memsize

rem For each line:

for cz=1 to tilesZ

rem Save the first column

copy memblock memNum,254,vertCtr3,vertCtr3,40

rem Shift each tile to the left

for cx=2 to tilesX

copy memblock memNum,memNum,vertCtr,vertCtr2,4

copy memblock memNum,memNum,vertCtr+12,vertCtr2+12,4

copy memblock memNum,memNum,vertCtr+24,vertCtr2+24,4

copy memblock memNum,memNum,vertCtr+36,vertCtr2+36,4

inc vertCtr,48

inc vertCtr2,48

next cx

inc vertCtr,48

inc vertCtr2,48

rem Restore first column and put it at the right of the line

copy memblock 254,memNum,vertCtr3,vertCtr4,4

copy memblock 254,memNum,vertCtr3+12,vertCtr4+12,4

copy memblock 254,memNum,vertCtr3+24,vertCtr4+24,4

copy memblock 254,memNum,vertCtr3+36,vertCtr4+36,4

inc vertCtr3,lineSize

inc vertCtr4,lineSize

rem copy shifted Normals and UV to memblock 254

copy memblock memNum,254,normCtr+48,normCtr,lineMinusOneColumn

copy memblock memNum,254,normCtr,normCtr+lineMinusOneColumn,48

copy memblock memNum,254,UvCtr+32,UvCtr,UVlineSize-32

copy memblock memNum,254,UvCtr,UvCtr+UVlineSize-32,32

inc normCtr,lineSize

inc UvCtr,UVlineSize

next cz

rem copy header and shifted vertices infos to memblock 254

copy memblock memNum,254,0,0,normOffset

rem Copy faces to memblock 254

copy memblock memNum,254,faceOffset,faceOffset,faceSize*4

rem Copy the new memblock to the old one

copy memblock 254,memNum,0,0,memSize

delete memblock 254

endfunction

rem Move all tiles one step right (along the X axis), with a wrapping effect

rem -> the last column of tiles become the first, the other columns go right.

` Parameters:

` Memblock number

function shiftMemMatrixRight(memNum)

tilesX=memblock Dword(255,memnum*16)

tilesZ=memblock Dword(255,(memnum*16)+4)

rem Get datas sizes

memsize=get memblock size(memNum)

vertOffset=memblock dword(memNum,4)

normOffset=memblock dword(memNum,12)

faceOffset=memblock dword(memNum,20)

faceSize=memblock dword(memNum,24)

UVOffset=memblock dword(memNum,28)

rem Useful values

UVlineSize = tilesX*32

normCtr=normOffset

uvCtr=UVOffset

lineSize=tilesX*48

lineMinusOneColumn=lineSize-48

vertCtr2=normOffset+4-48

vertCtr=vertCtr2-48

vertCtr3=vertCtr2

vertCtr4=vertCtr2-lineMinusOneColumn

rem Create a memblock to store modified matrix

make memblock 254,memsize

rem For each line:

for cz=1 to tilesZ

rem Save the last column

copy memblock memNum,254,vertCtr3,vertCtr3,40

rem Shift each tile to the right

for cx=2 to tilesX

copy memblock memNum,memNum,vertCtr,vertCtr2,4

copy memblock memNum,memNum,vertCtr+12,vertCtr2+12,4

copy memblock memNum,memNum,vertCtr+24,vertCtr2+24,4

copy memblock memNum,memNum,vertCtr+36,vertCtr2+36,4

dec vertCtr,48

dec vertCtr2,48

next cx

dec vertCtr,48

dec vertCtr2,48

rem Restore last column and put it at the left of the line

copy memblock 254,memNum,vertCtr3,vertCtr4,4

copy memblock 254,memNum,vertCtr3+12,vertCtr4+12,4

copy memblock 254,memNum,vertCtr3+24,vertCtr4+24,4

copy memblock 254,memNum,vertCtr3+36,vertCtr4+36,4

dec vertCtr3,lineSize

dec vertCtr4,lineSize

rem copy shifted Normals and UV to memblock 254

copy memblock memNum,254,normCtr,normCtr+48,lineMinusOneColumn

copy memblock memNum,254,normCtr+lineMinusOneColumn,normCtr,48

copy memblock memNum,254,UvCtr,UvCtr+32,UVlineSize-32

copy memblock memNum,254,UvCtr+UVlineSize-32,UvCtr,32

inc normCtr,lineSize

inc UvCtr,UVlineSize

next cz

rem copy header and shifted vertices infos to memblock 254

copy memblock memNum,254,0,0,normOffset

rem Copy faces to memblock 254

copy memblock memNum,254,faceOffset,faceOffset,faceSize*4

rem Copy the new memblock to the old one

copy memblock 254,memNum,0,0,memSize

delete memblock 254

endfunction

Rem Dump the matrix datas to disk

` Parameters:

` Memblock number, name of the file to which write the data

function dumpMemMatrix(memNum,filename$)

if memblock exist(memNum) = 0 then exitfunction

vertNum=memblock dword(memNum,0)

vertOffset=memblock dword(memNum,4)

normNum=memblock dword(memNum,8)

normOffset=memblock dword(memNum,12)

faceNum=memblock dword(memNum,16)

faceOffset=memblock dword(memNum,20)

faceSize=memblock dword(memNum,24)

UVOffset=memblock dword(memNum,28)

memSize = 32 + (12*vertNum) + (12*vertNum) + (28*faceNum) + (8*vertNum)

if file exist(filename$) then delete file filename$

open to write 1,filename$

write string 1, "Memblock size = "+str$( get memblock size(memNum) )

write string 1, "Nb vertex = "+str$(memblock dword(memNum,0))

write string 1, "Vertex infos offset = "+str$(memblock dword(memNum,4))

write string 1, "Nb normals = "+str$(memblock dword(memNum,8))

write string 1, "Normals infos offset = "+str$(memblock dword(memNum,12))

write string 1, "Nb Faces = "+str$(memblock dword(memNum,16))

write string 1, "Faces infos offset = "+str$(memblock dword(memNum,20))

write string 1, "Faces infos size = "+str$(memblock dword(memNum,24))

write string 1, "UV infos offset = "+str$(memblock dword(memNum,28))

write string 1,chr$(13)

vertCtr = 0

faceCtr = 0

UvCtr = 0

for i=0 to vertnum-1

write string 1,"vertex "+str$(i)

write string 1, str$(memblock float(memNum,vertOffset+(i*12)))+","+str$(memblock float(memNum,vertOffset+(i*12)+4))+","+str$(memblock float(memNum,vertOffset+(i*12)+8))

write string 1, str$(memblock float(memNum,normOffset+(i*12)))+","+str$(memblock float(memNum,normOffset+(i*12)+4))+","+str$(memblock float(memNum,normOffset+(i*12)+8))

write string 1,""

next i

write string 1,""

for faceCtr=0 to facenum-1

write string 1,"":write string 1,"Faces "+str$(faceCtr)

f$=""

f$=str$(memblock dword(memNum,faceOffset+(faceCtr*28)))+","+str$(memblock dword(memNum,faceOffset+(faceCtr*28)+4))+","+str$(memblock dword(memNum,faceOffset+(faceCtr*28)+8))

f$=f$+","+str$(memblock dword(memNum,faceOffset+(faceCtr*28)+12))

f$=f$+","+str$(memblock dword(memNum,faceOffset+(faceCtr*28)+16))+","+str$(memblock dword(memNum,faceOffset+(faceCtr*28)+20))+","+str$(memblock dword(memNum,faceOffset+(faceCtr*28)+24))

write string 1,f$

write string 1,""

next faceCtr

write string 1,"":write string 1,""

for uvCtr=0 to vertnum-1

write string 1,"":write string 1,"UV for vertex "+str$(UVCtr)

write string 1, str$(memblock float(memNum,UVoffset+(UvCtr*8)))+","+str$(memblock float(memNum,UVoffset+(UvCtr*8)+4))

CodeBase - Memblock Matrix

Information

Summary

Full Description

DarkBASIC Source Code

Download

Screen Shot

Author

Comments

Author Name:	Kelebrindae
CodeBase Entries:	3