Vast scrolling heightmap - GameCreators Forum

Author

Message

Link102

19

Years of Service

User Offline

Joined: 1st Dec 2004

Location: On your head, weeeeee!

Posted: 20th Nov 2009 02:48 Edited at: 23rd Nov 2009 15:49

Link

I've done it!

Haha I've mastered the heigtmap.
By using memblocks to read rgb data and converting that to a height value. I've managed to get a 2000 x 2000 terrain on a 50 x 50 matrix :3. Can you smell the opportunities? This would be great for a dune racer or a (dare I say it) mmorpg.
go and have a looksy (download button bottom right) and tell me what you smell

things to do:

- 8 bit bmp support (reading a grayvalue instead of a rgb value is faster, rgb value is multifunctional)
- convert the heightmap to a mesh instead of a matrix. (to hopefully boost speed)
- textures (tinker with the uv's, dunno if it will work)
- shadows (either a shadowmap or textured in or calculated one that works with normals)
- weave in difrent levels of detail. (the far away stuff doesn't need much detail)

edit: be sure to check the update 4 posts below.

- Link102

Attachments

Login to view attachments

Back to top

Profile PM

Latch

17

Years of Service

User Offline

Joined: 23rd Jul 2006

Location:

Posted: 20th Nov 2009 17:31

Link

Very nice technique. Nice and concise. Good work!

Just throwing this out there as some other ideas: the use of a single heightmap image has a few limits - including speed, size, memory usage (at once). A variation for virtually unlimited size would be to use a series of smaller sized heightmaps, say 256x256 or even smaller. Load them into the memblock on demand - or convert them into arrays ahead of time and load in the data as arrays on demand based on virtual matrix position.

Thanks for posting this. It's easy to see what you did in your code. I'm gonna have to play around with this idea.

Enjoy your day.

Back to top

Profile PM

Link102

19

Years of Service

User Offline

Joined: 1st Dec 2004

Location: On your head, weeeeee!

Posted: 20th Nov 2009 18:16 Edited at: 21st Nov 2009 15:25

Link

Quote: "Just throwing this out there as some other ideas: the use of a single heightmap image has a few limits - including speed, size, memory usage (at once). A variation for virtually unlimited size would be to use a series of smaller sized heightmaps, say 256x256 or even smaller. Load them into the memblock on demand - or convert them into arrays ahead of time and load in the data as arrays on demand based on virtual matrix position."

I've thought about that. Perhaps I'll add it in the future. It'll go right in with the variations in detail. I'll probably change the code to load 10 tiles instead of each one.
Sidenote: I dont think an array would be that much faster than a bitmap (8bit), because a bitmap is just a strain of numbers with a header.

Quote: "I'm gonna have to play around with this idea."

That's exactly why I'm posting this

I'm working on creating objects from memblocks. so far I've recreated the plain object successfully. Just gotta flip it on it's side and make a matrix out of it.
edit: added a picture of the plain
edit2: well I've accidentally saved a different project over this one. Back to square one T_T
edit3: I don't want to lose this again.

set display mode 1280,1024,32
sync on : sync rate 0
hide mouse

load image "texture.jpg",1

matrix(1,500,500,50,50)

position camera 0,10,-10
point camera 0,0,0

do
`set cursor 0,0
`print get memblock size(1)
   do_camera()
sync
loop

end

function matrix(id,width,height,xsegment,zsegment)
   number_of_vertices = (xsegment+1)*(zsegment+1)
   number_of_faces = xsegment*zsegment*2
   size_of_facedata = number_of_faces*7

offset_to_normals = 32+number_of_vertices*12
   offset_to_faces = offset_to_normals+number_of_vertices*12
   offset_to_uv = offset_to_faces+size_of_facedata*4

make memblock id,offset_to_uv+number_of_vertices*8
`number of vertices
   write memblock dword id,0,number_of_vertices
`offset to vericle data
   write memblock dword id,4,32
`number of normals
   write memblock dword id,8,number_of_vertices
`offset to normals data
   write memblock dword id,12,offset_to_normals
`number of faces
   write memblock dword id,16,number_of_faces
`offset to face data
   write memblock dword id,20,offset_to_faces
`size of face data
   write memblock dword id,24,size_of_facedata
`offset to uv data
   write memblock dword id,28,offset_to_uv

`verticle data
   for y = 0 to zsegment
      for x = 0 to xsegment
         write memblock float id,32+x*12+(xsegment+1)*12*y  ,(width/xsegment)*x
         write memblock float id,32+x*12+(xsegment+1)*12*y+4,0
         write memblock float id,32+x*12+(xsegment+1)*12*y+8,(height/zsegment)*y
      next x
   next y

`normals data
   for x = 0 to number_of_vertices-1
      write memblock float id,offset_to_normals+12*x  ,0
      write memblock float id,offset_to_normals+12*x+4,0
      write memblock float id,offset_to_normals+12*x+8,-1
   next x

`face data
   for y = 0 to zsegment-1
      for x = 0 to xsegment-1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+0,3
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+4,(xsegment*y)+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+8,(xsegment*y)+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+12,(xsegment*y)+x
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+16,(xsegment*y)+x
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+20,(xsegment*y)+x+(xsegment)+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+24,(xsegment*y)+x+(xsegment)+1

write memblock dword id,offset_to_faces+x*56+xsegment*56*y+28,3
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+32,(xsegment*y)+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+36,(xsegment*y)+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+40,(xsegment*y)+x+(xsegment)+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+44,(xsegment*y)+x+(xsegment)+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+48,(xsegment*y)+x+(xsegment)+2
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+52,(xsegment*y)+x+(xsegment)+2
      next x
   next y

`uv data
   for y = 0 to zsegment
      for x = 0 to xsegment
         write memblock float id,offset_to_uv+x*8+(xsegment+1)*8*y  ,(1/xsegment)*x
         write memblock float id,offset_to_uv+x*8+(xsegment+1)*8*y+4,(1/zsegment)*y
      next x
   next y

makeoutput()
   make mesh from memblock 1,1
   make object 1,1,1
   set object 1,0,1,1
endfunction

function makeoutput()
   if file exist("output.txt") then delete file "output.txt"
   open to write 1,"output.txt"
   write string 1,"memblock size: " + str$(get memblock size(1))

for i = 0 to get memblock size(1)-4
      string$ = str$(i) + ": " + str$(memblock byte(1,i)) + " " + str$(memblock byte(1,i+1)) + " " + str$(memblock byte(1,i+2)) + " " + str$(memblock byte(1,i+3))
      write string 1,string$
      i = i+3
   next i
endfunction

function do_camera()
   camrotx# = wrapvalue(camrotx# + mousemovey() )
   camroty# = wrapvalue(camroty# + mousemovex() )
   rotate camera camrotx#,camroty#,0

move camera ((mouseclick()=1)-(mouseclick()=2) )*2
endfunction

remstart
Memblock-Mesh (32 Byte Header)
-Header
--4 BYTES (DWORD) Number Of Vertices
--4 BYTES (DWORD) Offset in Bytes to Vertice Data
--4 BYTES (DWORD) Number Of Normals
--4 BYTES (DWORD) Offset in Bytes to Normals Data
--4 BYTES (DWORD) Number of Faces
--4 BYTES (DWORD) Offset in Bytes to Face Data
--4 BYTES (DWORD) Size Of All Face Data
--4 BYTES (DWORD) Offset in Bytes to Texture UV Data
-Data
--Vertice Data
---For Each Vertex
----4 BYTES (FLOAT) - X Position of 3D Geometry
----4 BYTES (FLOAT) - Y Position of 3D Geometry
----4 BYTES (FLOAT) - Z Position of 3D Geometry
--Normals Data
---For Each Normal
----4 BYTES (FLOAT) - X Normalised Normal of 3D Geometry
----4 BYTES (FLOAT) - Y Normalised Normal of 3D Geometry
----4 BYTES (FLOAT) - Z Normalised Normal of 3D Geometry
--Face Data
---For Each Face (a face makes a polygon using A,B and C as vector points)
----2 BYTES (DWORD) - Number of Vectors in Face (always use 3)
----2 BYTES (DWORD) - Index to Vertex in Vertex Data for Vector A
----2 BYTES (DWORD) - Index to Normal in Vertex Data for Vector A
----2 BYTES (DWORD) - Index to Vertex in Vertex Data for Vector B
----2 BYTES (DWORD) - Index to Normal in Vertex Data for Vector B
----2 BYTES (DWORD) - Index to Vertex in Vertex Data for Vector C
----2 BYTES (DWORD) - Index to Normal in Vertex Data for Vector C
--Texture Data
---For Each Vertex
----4 BYTES (FLOAT) - U Value of Texture
----4 BYTES (FLOAT) - V Value of Texture
remend

function mmatrix()
`the memblock is oversized, but meh
   make memblock 1,1000
`number of vertices
   write memblock dword 1,0,4
`offset to vericle data
   write memblock dword 1,4,32
`number of normals
   write memblock dword 1,8,4
`offset to normals data
   write memblock dword 1,12,80
`number of faces
   write memblock dword 1,16,2
`offset to face data
   write memblock dword 1,20,128
`size of face data
   write memblock dword 1,24,14
`offset to uv data
   write memblock dword 1,28,184

`verticle data
   write memblock float 1,memblock dword(1,4),0
   write memblock float 1,memblock dword(1,4)+4,0
   write memblock float 1,memblock dword(1,4)+4*2,0

write memblock float 1,memblock dword(1,4)+4*3,1
   write memblock float 1,memblock dword(1,4)+4*4,0
   write memblock float 1,memblock dword(1,4)+4*5,0

write memblock float 1,memblock dword(1,4)+4*6,0
   write memblock float 1,memblock dword(1,4)+4*7,0
   write memblock float 1,memblock dword(1,4)+4*8,1

write memblock float 1,memblock dword(1,4)+4*9,1
   write memblock float 1,memblock dword(1,4)+4*10,0
   write memblock float 1,memblock dword(1,4)+4*11,1

`normals data
   write memblock float 1,memblock dword(1,12),0
   write memblock float 1,memblock dword(1,12)+4,0
   write memblock float 1,memblock dword(1,12)+4*2,-1

write memblock float 1,memblock dword(1,12)+4*3,0
   write memblock float 1,memblock dword(1,12)+4*4,0
   write memblock float 1,memblock dword(1,12)+4*5,-1

write memblock float 1,memblock dword(1,12)+4*6,0
   write memblock float 1,memblock dword(1,12)+4*7,0
   write memblock float 1,memblock dword(1,12)+4*8,-1

write memblock float 1,memblock dword(1,12)+4*9,0
   write memblock float 1,memblock dword(1,12)+4*10,0
   write memblock float 1,memblock dword(1,12)+4*11,-1

`face data
   write memblock dword 1,memblock dword(1,20),3
   write memblock dword 1,memblock dword(1,20)+4,0
   write memblock dword 1,memblock dword(1,20)+4*2,0
   write memblock dword 1,memblock dword(1,20)+4*3,3
   write memblock dword 1,memblock dword(1,20)+4*4,3
   write memblock dword 1,memblock dword(1,20)+4*5,1
   write memblock dword 1,memblock dword(1,20)+4*6,1

write memblock dword 1,memblock dword(1,20)+4*7,3
   write memblock dword 1,memblock dword(1,20)+4*8,3
   write memblock dword 1,memblock dword(1,20)+4*9,3
   write memblock dword 1,memblock dword(1,20)+4*10,0
   write memblock dword 1,memblock dword(1,20)+4*11,0
   write memblock dword 1,memblock dword(1,20)+4*12,2
   write memblock dword 1,memblock dword(1,20)+4*13,2

`uv data
   write memblock float 1,memblock dword(1,28),0
   write memblock float 1,memblock dword(1,28)+4,1

write memblock float 1,memblock dword(1,28)+4*2,1
   write memblock float 1,memblock dword(1,28)+4*3,1

write memblock float 1,memblock dword(1,28)+4*4,0
   write memblock float 1,memblock dword(1,28)+4*5,0

write memblock float 1,memblock dword(1,28)+4*6,1
   write memblock float 1,memblock dword(1,28)+4*7,0

make mesh from memblock 1,1
   make object 1,1,1
endfunction

+ Code Snippet

set display mode 1280,1024,32
sync on : sync rate 0
hide mouse

load image "texture.jpg",1

matrix(1,500,500,50,50)

position camera 0,10,-10
point camera 0,0,0

do
`set cursor 0,0
`print get memblock size(1)
   do_camera()
sync
loop

end

function matrix(id,width,height,xsegment,zsegment)
   number_of_vertices = (xsegment+1)*(zsegment+1)
   number_of_faces = xsegment*zsegment*2
   size_of_facedata = number_of_faces*7

   offset_to_normals = 32+number_of_vertices*12
   offset_to_faces = offset_to_normals+number_of_vertices*12
   offset_to_uv = offset_to_faces+size_of_facedata*4

   make memblock id,offset_to_uv+number_of_vertices*8
`number of vertices
   write memblock dword id,0,number_of_vertices
`offset to vericle data
   write memblock dword id,4,32
`number of normals
   write memblock dword id,8,number_of_vertices
`offset to normals data
   write memblock dword id,12,offset_to_normals
`number of faces
   write memblock dword id,16,number_of_faces
`offset to face data
   write memblock dword id,20,offset_to_faces
`size of face data
   write memblock dword id,24,size_of_facedata
`offset to uv data
   write memblock dword id,28,offset_to_uv


`verticle data
   for y = 0 to zsegment
      for x = 0 to xsegment
         write memblock float id,32+x*12+(xsegment+1)*12*y  ,(width/xsegment)*x
         write memblock float id,32+x*12+(xsegment+1)*12*y+4,0
         write memblock float id,32+x*12+(xsegment+1)*12*y+8,(height/zsegment)*y
      next x
   next y

`normals data
   for x = 0 to number_of_vertices-1
      write memblock float id,offset_to_normals+12*x  ,0
      write memblock float id,offset_to_normals+12*x+4,0
      write memblock float id,offset_to_normals+12*x+8,-1
   next x

`face data
   for y = 0 to zsegment-1
      for x = 0 to xsegment-1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+0,3
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+4,(xsegment*y)+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+8,(xsegment*y)+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+12,(xsegment*y)+x
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+16,(xsegment*y)+x
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+20,(xsegment*y)+x+(xsegment)+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+24,(xsegment*y)+x+(xsegment)+1

         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+28,3
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+32,(xsegment*y)+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+36,(xsegment*y)+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+40,(xsegment*y)+x+(xsegment)+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+44,(xsegment*y)+x+(xsegment)+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+48,(xsegment*y)+x+(xsegment)+2
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+52,(xsegment*y)+x+(xsegment)+2
      next x
   next y

`uv data
   for y = 0 to zsegment
      for x = 0 to xsegment
         write memblock float id,offset_to_uv+x*8+(xsegment+1)*8*y  ,(1/xsegment)*x
         write memblock float id,offset_to_uv+x*8+(xsegment+1)*8*y+4,(1/zsegment)*y
      next x
   next y

   makeoutput()
   make mesh from memblock 1,1
   make object 1,1,1
   set object 1,0,1,1
endfunction

function makeoutput()
   if file exist("output.txt") then delete file "output.txt"
   open to write 1,"output.txt"
   write string 1,"memblock size: " + str$(get memblock size(1))

   for i = 0 to get memblock size(1)-4
      string$ = str$(i) + ": " + str$(memblock byte(1,i)) + " " + str$(memblock byte(1,i+1)) + " " + str$(memblock byte(1,i+2)) + " " + str$(memblock byte(1,i+3))
      write string 1,string$
      i = i+3
   next i
endfunction

function do_camera()
   camrotx# = wrapvalue(camrotx# + mousemovey() )
   camroty# = wrapvalue(camroty# + mousemovex() )
   rotate camera camrotx#,camroty#,0

   move camera ((mouseclick()=1)-(mouseclick()=2) )*2
endfunction

remstart
Memblock-Mesh (32 Byte Header)
-Header
--4 BYTES (DWORD) Number Of Vertices
--4 BYTES (DWORD) Offset in Bytes to Vertice Data
--4 BYTES (DWORD) Number Of Normals
--4 BYTES (DWORD) Offset in Bytes to Normals Data
--4 BYTES (DWORD) Number of Faces
--4 BYTES (DWORD) Offset in Bytes to Face Data
--4 BYTES (DWORD) Size Of All Face Data
--4 BYTES (DWORD) Offset in Bytes to Texture UV Data
-Data
--Vertice Data
---For Each Vertex
----4 BYTES (FLOAT) - X Position of 3D Geometry
----4 BYTES (FLOAT) - Y Position of 3D Geometry
----4 BYTES (FLOAT) - Z Position of 3D Geometry
--Normals Data
---For Each Normal
----4 BYTES (FLOAT) - X Normalised Normal of 3D Geometry
----4 BYTES (FLOAT) - Y Normalised Normal of 3D Geometry
----4 BYTES (FLOAT) - Z Normalised Normal of 3D Geometry
--Face Data
---For Each Face (a face makes a polygon using A,B and C as vector points)
----2 BYTES (DWORD) - Number of Vectors in Face (always use 3)
----2 BYTES (DWORD) - Index to Vertex in Vertex Data for Vector A
----2 BYTES (DWORD) - Index to Normal in Vertex Data for Vector A
----2 BYTES (DWORD) - Index to Vertex in Vertex Data for Vector B
----2 BYTES (DWORD) - Index to Normal in Vertex Data for Vector B
----2 BYTES (DWORD) - Index to Vertex in Vertex Data for Vector C
----2 BYTES (DWORD) - Index to Normal in Vertex Data for Vector C
--Texture Data
---For Each Vertex
----4 BYTES (FLOAT) - U Value of Texture
----4 BYTES (FLOAT) - V Value of Texture
remend

function mmatrix()
`the memblock is oversized, but meh
   make memblock 1,1000
`number of vertices
   write memblock dword 1,0,4
`offset to vericle data
   write memblock dword 1,4,32
`number of normals
   write memblock dword 1,8,4
`offset to normals data
   write memblock dword 1,12,80
`number of faces
   write memblock dword 1,16,2
`offset to face data
   write memblock dword 1,20,128
`size of face data
   write memblock dword 1,24,14
`offset to uv data
   write memblock dword 1,28,184

`verticle data
   write memblock float 1,memblock dword(1,4),0
   write memblock float 1,memblock dword(1,4)+4,0
   write memblock float 1,memblock dword(1,4)+4*2,0

   write memblock float 1,memblock dword(1,4)+4*3,1
   write memblock float 1,memblock dword(1,4)+4*4,0
   write memblock float 1,memblock dword(1,4)+4*5,0

   write memblock float 1,memblock dword(1,4)+4*6,0
   write memblock float 1,memblock dword(1,4)+4*7,0
   write memblock float 1,memblock dword(1,4)+4*8,1

   write memblock float 1,memblock dword(1,4)+4*9,1
   write memblock float 1,memblock dword(1,4)+4*10,0
   write memblock float 1,memblock dword(1,4)+4*11,1

`normals data
   write memblock float 1,memblock dword(1,12),0
   write memblock float 1,memblock dword(1,12)+4,0
   write memblock float 1,memblock dword(1,12)+4*2,-1

   write memblock float 1,memblock dword(1,12)+4*3,0
   write memblock float 1,memblock dword(1,12)+4*4,0
   write memblock float 1,memblock dword(1,12)+4*5,-1

   write memblock float 1,memblock dword(1,12)+4*6,0
   write memblock float 1,memblock dword(1,12)+4*7,0
   write memblock float 1,memblock dword(1,12)+4*8,-1

   write memblock float 1,memblock dword(1,12)+4*9,0
   write memblock float 1,memblock dword(1,12)+4*10,0
   write memblock float 1,memblock dword(1,12)+4*11,-1

`face data
   write memblock dword 1,memblock dword(1,20),3
   write memblock dword 1,memblock dword(1,20)+4,0
   write memblock dword 1,memblock dword(1,20)+4*2,0
   write memblock dword 1,memblock dword(1,20)+4*3,3
   write memblock dword 1,memblock dword(1,20)+4*4,3
   write memblock dword 1,memblock dword(1,20)+4*5,1
   write memblock dword 1,memblock dword(1,20)+4*6,1

   write memblock dword 1,memblock dword(1,20)+4*7,3
   write memblock dword 1,memblock dword(1,20)+4*8,3
   write memblock dword 1,memblock dword(1,20)+4*9,3
   write memblock dword 1,memblock dword(1,20)+4*10,0
   write memblock dword 1,memblock dword(1,20)+4*11,0
   write memblock dword 1,memblock dword(1,20)+4*12,2
   write memblock dword 1,memblock dword(1,20)+4*13,2

`uv data
   write memblock float 1,memblock dword(1,28),0
   write memblock float 1,memblock dword(1,28)+4,1

   write memblock float 1,memblock dword(1,28)+4*2,1
   write memblock float 1,memblock dword(1,28)+4*3,1

   write memblock float 1,memblock dword(1,28)+4*4,0
   write memblock float 1,memblock dword(1,28)+4*5,0

   write memblock float 1,memblock dword(1,28)+4*6,1
   write memblock float 1,memblock dword(1,28)+4*7,0

   make mesh from memblock 1,1
   make object 1,1,1
endfunction

- Link102

Attachments

Login to view attachments

Back to top

Profile PM

Latch

17

Years of Service

User Offline

Joined: 23rd Jul 2006

Location:

Posted: 20th Nov 2009 20:04

Link

Quote: "Sidenote: I dont think an array would be that much faster than a bitmap (8bit), because a bitmap is just a strain of numbers with a header."

I was thinking about that. But if you want the height to be more than 255 units, you have to use some kind of multiplication or other maths to scale the height. If you use a 32 bit value, or even a 16 bit value, you can eliminate the scaling and just store the actual desired height either in an array or a block of memory. Assumingly, on your 50x50 matrix, if you want a wider lanscape at a time, instead of make matrix 1,500,500,50,50 you wanted make matrix 1,5000,5000,50,50, you'd have to do a multiplication for each vertex that you wanted to scale. In this example the height would be 10x higher. So the total number of multiplys would be 51*51 or 2601 per matrix update.

So perhaps, precalculating the height values and storing them somehow for whatever size matrix one will use might cut down the in-game overhead.

Oh, and I noticed you were getting the height and width of your image from the memblock the hard way:

+ Code Snippet

width = memblock byte(1,0) + memblock byte(1,1)*256 + memblock byte(1,2) * 65536 + memblock byte(1,3) * 16777216
height = memblock byte(1,4) + memblock byte(1,5)*256 + memblock byte(1,6) * 65536 + memblock byte(1,7) * 16777216

You could just

+ Code Snippet

make memblock from image 1,1
width=memblock dword(1,0)
height=memblock dword(1,4)
depth=memblock dword(1,8)

Enjoy your day.

Back to top

Profile PM

Link102

19

Years of Service

User Offline

Joined: 1st Dec 2004

Location: On your head, weeeeee!

Posted: 20th Nov 2009 20:11 Edited at: 20th Nov 2009 22:25

Link

Quote: "you have to use some kind of multiplication or other maths to scale the height."

that's the "/ 3" at the end of line 50 where the height# value gets asigned. (note the code is mean for a 500*500 matrix, it's not open to bigger ones yet). It's not the actual height that gets changed, it's the detail that you can change it. 8 bit has 256 steps, 24 bit has 256*256*256 = 16777216.

Quote: "Oh, and I noticed you were getting the height and width of your image from the memblock the hard way:"

hmm maybe I should read the rgb values as dwords too, so you'd still have the detail and the speed. Thanks for the tip.
The reason I used bytes was because I was unsure about dwords. I'm still learning about dwords, floats and all that stuff.

Latch, do you have any ideas for a blended texture?

update: (just performance, no new functions)

set display mode 1280,1024,32
sync on : sync rate 0
hide mouse

load image "heightmap.bmp",1
make memblock from image 1,1
width = memblock dword(1,0)
height = memblock dword(1,4)
make matrix 1,500,500,50,50
makematrix(xpos,ypox,width)

position camera -50,200,-50

do
set cursor 0,0
print "coordinates: ",xpos," ",ypos
print "use the mouse and mousebuttons to move the camera"
print "use the arrowkeys to scroll"

if leftkey() and xpos > 0 then xpos = xpos - 1
   if rightkey() and xpos < width-51 then xpos = xpos + 1
   if downkey() and ypos > 0 then ypos = ypos - 1
   if upkey() and ypos < height-51 then ypos = ypos + 1

if xpos<>oldxpos or ypos<>oldypos then makematrix(xpos,ypos,width)
   oldxpos = xpos
   oldypos = ypos

do_camera()
   sync
loop

function do_camera()
   camrotx# = wrapvalue(camrotx# + mousemovey() )
   camroty# = wrapvalue(camroty# + mousemovex() )
   rotate camera camrotx#,camroty#,0

move camera ((mouseclick()=1)-(mouseclick()=2) )*5
endfunction

function makematrix(xpos,ypos,width)
   width = width * 4
   for x = 0 to 50
      for y = 0 to 50
         height# = memblock dword(1,12 + (y+ypos)*4 + (x+xpos)*width)/49344
         set matrix height 1,x,y,height#
      next y
   next x
   update matrix 1
endfunction

+ Code Snippet

set display mode 1280,1024,32
sync on : sync rate 0
hide mouse

load image "heightmap.bmp",1
make memblock from image 1,1
width = memblock dword(1,0)
height = memblock dword(1,4)
make matrix 1,500,500,50,50
makematrix(xpos,ypox,width)


position camera -50,200,-50

do
set cursor 0,0
print "coordinates: ",xpos," ",ypos
print "use the mouse and mousebuttons to move the camera"
print "use the arrowkeys to scroll"


   if leftkey() and xpos > 0 then xpos = xpos - 1
   if rightkey() and xpos < width-51 then xpos = xpos + 1
   if downkey() and ypos > 0 then ypos = ypos - 1
   if upkey() and ypos < height-51 then ypos = ypos + 1

   if xpos<>oldxpos or ypos<>oldypos then makematrix(xpos,ypos,width)
   oldxpos = xpos
   oldypos = ypos

   do_camera()
   sync
loop

function do_camera()
   camrotx# = wrapvalue(camrotx# + mousemovey() )
   camroty# = wrapvalue(camroty# + mousemovex() )
   rotate camera camrotx#,camroty#,0

   move camera ((mouseclick()=1)-(mouseclick()=2) )*5
endfunction

function makematrix(xpos,ypos,width)
   width = width * 4
   for x = 0 to 50
      for y = 0 to 50
         height# = memblock dword(1,12 + (y+ypos)*4 + (x+xpos)*width)/49344
         set matrix height 1,x,y,height#
      next y
   next x
   update matrix 1
endfunction

Your signature has been erased by a mod - Please reduce it to 600x120 maximum size

Attachments

Login to view attachments

Back to top

Profile PM

Link102

19

Years of Service

User Offline

Joined: 1st Dec 2004

Location: On your head, weeeeee!

Posted: 21st Nov 2009 16:17 Edited at: 21st Nov 2009 19:05

Link

well here's a litle update (save attachment as "texture.jpg")

set display mode 1280,1024,32
sync on : sync rate 0
hide mouse

load image "texture.jpg",1

matrix(1,300,300,30,30)

position camera 150,10,-10

do
   do_camera()
sync
loop

end

function matrix(id,width,height,xsegment,zsegment)
   number_of_vertices = (xsegment+1)*(zsegment+1)
   number_of_faces = xsegment*zsegment*2
   size_of_facedata = number_of_faces*7

offset_to_normals = 32+number_of_vertices*12
   offset_to_faces = offset_to_normals+number_of_vertices*12
   offset_to_uv = offset_to_faces+size_of_facedata*4

make memblock id,offset_to_uv+number_of_vertices*8
`number of vertices
   write memblock dword id,0,number_of_vertices
`offset to vericle data
   write memblock dword id,4,32
`number of normals
   write memblock dword id,8,number_of_vertices
`offset to normals data
   write memblock dword id,12,offset_to_normals
`number of faces
   write memblock dword id,16,number_of_faces
`offset to face data
   write memblock dword id,20,offset_to_faces
`size of face data
   write memblock dword id,24,size_of_facedata
`offset to uv data
   write memblock dword id,28,offset_to_uv

`verticle data
   for y = 0 to zsegment
      for x = 0 to xsegment
         write memblock float id,32+x*12+(xsegment+1)*12*y  ,(width/xsegment)*x
         write memblock float id,32+x*12+(xsegment+1)*12*y+4,0
         write memblock float id,32+x*12+(xsegment+1)*12*y+8,(height/zsegment)*y
      next x
   next y

`normals data
   for x = 0 to number_of_vertices-1
      write memblock float id,offset_to_normals+12*x  ,0
      write memblock float id,offset_to_normals+12*x+4,0
      write memblock float id,offset_to_normals+12*x+8,-1
   next x

`face data
   for y = 0 to zsegment-1
      for x = 0 to xsegment-1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+0,3
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+4,(xsegment+1)*y+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+8,(xsegment+1)*y+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+12,(xsegment+1)*y+x
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+16,(xsegment+1)*y+x
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+20,(xsegment+1)*y+x+xsegment+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+24,(xsegment+1)*y+x+xsegment+1

write memblock dword id,offset_to_faces+x*56+xsegment*56*y+28,3
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+32,(xsegment+1)*y+x+xsegment+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+36,(xsegment+1)*y+x+xsegment+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+40,(xsegment+1)*y+x+xsegment+2
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+44,(xsegment+1)*y+x+xsegment+2
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+48,(xsegment+1)*y+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+52,(xsegment+1)*y+x+1
      next x
   next y

`uv data
   for y = 0 to zsegment
      for x = 0 to xsegment
         write memblock float id,offset_to_uv+x*8+(xsegment+1)*8*y  ,1-x
         write memblock float id,offset_to_uv+x*8+(xsegment+1)*8*y+4,1-y
      next x
   next y

make mesh from memblock id,id
   make object id,id,1
   `set object id,0,1,1
endfunction

function do_camera()
   camrotx# = wrapvalue(camrotx# + mousemovey() )
   camroty# = wrapvalue(camroty# + mousemovex() )
   rotate camera camrotx#,camroty#,0

move camera ((mouseclick()=1)-(mouseclick()=2) )*2
endfunction

+ Code Snippet

set display mode 1280,1024,32
sync on : sync rate 0
hide mouse

load image "texture.jpg",1

matrix(1,300,300,30,30)

position camera 150,10,-10

do
   do_camera()
sync
loop

end

function matrix(id,width,height,xsegment,zsegment)
   number_of_vertices = (xsegment+1)*(zsegment+1)
   number_of_faces = xsegment*zsegment*2
   size_of_facedata = number_of_faces*7

   offset_to_normals = 32+number_of_vertices*12
   offset_to_faces = offset_to_normals+number_of_vertices*12
   offset_to_uv = offset_to_faces+size_of_facedata*4

   make memblock id,offset_to_uv+number_of_vertices*8
`number of vertices
   write memblock dword id,0,number_of_vertices
`offset to vericle data
   write memblock dword id,4,32
`number of normals
   write memblock dword id,8,number_of_vertices
`offset to normals data
   write memblock dword id,12,offset_to_normals
`number of faces
   write memblock dword id,16,number_of_faces
`offset to face data
   write memblock dword id,20,offset_to_faces
`size of face data
   write memblock dword id,24,size_of_facedata
`offset to uv data
   write memblock dword id,28,offset_to_uv


`verticle data
   for y = 0 to zsegment
      for x = 0 to xsegment
         write memblock float id,32+x*12+(xsegment+1)*12*y  ,(width/xsegment)*x
         write memblock float id,32+x*12+(xsegment+1)*12*y+4,0
         write memblock float id,32+x*12+(xsegment+1)*12*y+8,(height/zsegment)*y
      next x
   next y

`normals data
   for x = 0 to number_of_vertices-1
      write memblock float id,offset_to_normals+12*x  ,0
      write memblock float id,offset_to_normals+12*x+4,0
      write memblock float id,offset_to_normals+12*x+8,-1
   next x

`face data
   for y = 0 to zsegment-1
      for x = 0 to xsegment-1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+0,3
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+4,(xsegment+1)*y+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+8,(xsegment+1)*y+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+12,(xsegment+1)*y+x
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+16,(xsegment+1)*y+x
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+20,(xsegment+1)*y+x+xsegment+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+24,(xsegment+1)*y+x+xsegment+1

         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+28,3
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+32,(xsegment+1)*y+x+xsegment+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+36,(xsegment+1)*y+x+xsegment+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+40,(xsegment+1)*y+x+xsegment+2
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+44,(xsegment+1)*y+x+xsegment+2
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+48,(xsegment+1)*y+x+1
         write memblock dword id,offset_to_faces+x*56+xsegment*56*y+52,(xsegment+1)*y+x+1
      next x
   next y

`uv data
   for y = 0 to zsegment
      for x = 0 to xsegment
         write memblock float id,offset_to_uv+x*8+(xsegment+1)*8*y  ,1-x
         write memblock float id,offset_to_uv+x*8+(xsegment+1)*8*y+4,1-y
      next x
   next y

   make mesh from memblock id,id
   make object id,id,1
   `set object id,0,1,1
endfunction

function do_camera()
   camrotx# = wrapvalue(camrotx# + mousemovey() )
   camroty# = wrapvalue(camroty# + mousemovex() )
   rotate camera camrotx#,camroty#,0

   move camera ((mouseclick()=1)-(mouseclick()=2) )*2
endfunction

You might be wondering "what is this?". This, my dear friend, is a 1 sided mesh matrix, that doesn't have the limitations that normal matrixes in dbc have. It's made by writing to memblocks then converting the data to a mesh. Go and have a play with it, like this: matrix(1,1000,1000,100,100). It can support up to 254*254=x segments (as long as x stays at 64516 max) wich is more than necessary (or safe).
Now if you don't mind, I'll have to check in at a hospital, because I've cracked my brain.

ps. if you come across a bug please let me know.
ps2. I'm thinking of writing a tutorial about memblock meshes when I'm done.

- Link102

Attachments

Login to view attachments

Back to top

Profile PM

Latch

17

Years of Service

User Offline

Joined: 23rd Jul 2006

Location:

Posted: 21st Nov 2009 18:45

Link

Quote: "Latch, do you have any ideas for a blended texture?"

Yeah, actually. I've tried a couple different things in the past. I'm trying to find a method that can create good detail for up close, and general detail for far away. The up close part is hard because the only thing I can come up with is creating individual textures for each tile that are unique to the specific heights. Even on a small terrain such as 10x10, that would mean 100 textures which may eat of processing when you want other things going on in the game. It's a blanacing act.

Anyway, as far as blending techniques, there's a couple ways you might approach this.
1. Create a fixed number of blended textures ahead of time. Say you have 4 different terrains: water, sand, grass, and rock. Based on a height map, you have ranges within 0 to 255. Divide 255 into 4 groups that represent the height range of a particular terrain. Let the ranges overlap a bit.

For example, water is set to a range of 0 to 30, maybe sand is in the range 20 to 80. You make grass have a range of 70 to 200, and you make rock have a range of 180 to 255. Based on these values, you create a series of predefined blended textures. Maybe you want 20 textures. Divide 255/20 = about 13.

So, at 13, your 1st texture would be a pure water texture.

At 26 you would blend sand and water based on a percentage. Water runs 0 to 30 and sand starts at 20. So the percentages for each texture might be calculated as
((30-20)/100)*((30-20)-(30-26)) = .6 for sand
and
1 - .6 = .4 for water

You create a new texture by looping and grabbing the pixel color in the same position of each texture and alphablending them based on the percentages.

Then you check the next value increment by 13 (remember, we want 20 predefined textures based on any hieght from 0 to 255 - so that's increments of 13)

At 39, that would be pure sand. It's not until the 6th texture does grass start to make it's appearance = 78.
((80-70)/100)*((80-70)-(80-78)) = .8 for grass
and
1 - .8 = .2 for sand
And you continue until you create your 20 preblended textures. Hopefully, the 4 original textures were all seamless so they could be used to repeat.

Now, based on your heightmap, or the tile height of your terrain, if the height falls withing the range of a predefined texture, then you texture that cell. The ranges for the 20 textures are based on heights from 0 to 12, 13 to 25, 26 to 38, and etc.

2. Use preblended textures but texture the terrain by hand for better control. For this method, take a look at:
Blending Textures
The code here will take 2 textures and output 12 preblended textures. You can use the textures to create a fairlywell blended landscape but you'd have to do it by hand.

3. Create terrain specific textures by using the heightmap to blend multiple textures together. This is similar to method 1 from above. The difference is you create a master texture by blending multiple textures together based on the heightmap. Unlike method 1, the percentages weighed are pixel to pixel instead of entire texture to entire texture. This results in a much smoother blended texture but is much more expensive in terms of processing cost depending on the size of your resulting texture(s).

Enjoy your day.

Back to top

Profile PM

Link102

19

Years of Service

User Offline

Joined: 1st Dec 2004

Location: On your head, weeeeee!

Posted: 21st Nov 2009 22:10 Edited at: 21st Nov 2009 22:11

Link

what I'm looking for is this

wich I believe is method nr 3.
I'm looking for an effective way to do it or the way valve did it in their engine (the source engine)

- Link102

Attachments

Login to view attachments

Back to top

Profile PM

Latch

17

Years of Service

User Offline

Joined: 23rd Jul 2006

Location:

Posted: 22nd Nov 2009 02:34

Link

From the look of the picture, it looks a lot like No. 2 for the blending method (if you tried out the code). I say that because of the squareness of the blend. Could be like No. 1 But it's hard to say. I would be guessing.

I'll attach an example of terrain I'm using in the DarkPros thread. This is blending method 3 using 3 textures.

Enjoy your day.

Attachments

Login to view attachments

Back to top

Profile PM

Link102

19

Years of Service

User Offline

Joined: 1st Dec 2004

Location: On your head, weeeeee!

Posted: 22nd Nov 2009 02:55

Link

What valve did was give each vertice a value, probably 0 to 255. 0 being completely grass and 255 being completely stone.
What I'm wondering is should I build the blended textures ahead of time, resulting in 4228250625 texture files. Or should I treat it as one big texture like a texture map. Or should I build the textures at runtime resulting in lag?
Again, how did valve make it? or is it some kind of build in feature of directx?

- Link102

Back to top

Profile PM

Latch

17

Years of Service

User Offline

Joined: 23rd Jul 2006

Location:

Posted: 22nd Nov 2009 04:27

Link

If it is as you say, then it's probably like No. 1 except maybe more textures (maybe even 255 !) Then as the terrain is drawn, look at the lower left vertice of the tile and choose the texture for that height/cell - I'm assuming DBC. If it's done in Direct X then you have more options including rendering textures and alpha blending per drawn triangle.

If it's Direct X directly, as each triangle is rendered, you can look at the "heights" of the vertices. One way based on the heights, you alpha blend the textures as you render the triangles. When the complete mesh, in this case the terrain, is drawn to screen, the textures are blended.

For DBC, the options seem limited without resulting in ginat overhead in terms of texture size or sheer number - or resolving to use a managed number prerendered textures based on 0 to 255

Enjoy your day.

Back to top

Profile PM

Link102

19

Years of Service

User Offline

Joined: 1st Dec 2004

Location: On your head, weeeeee!

Posted: 22nd Nov 2009 15:57

Link

So it's either tiles or a texture map.
dbc has it's limits sometimes...

- Link102

Back to top

Profile PM

Latch

17

Years of Service

User Offline

Joined: 23rd Jul 2006

Location:

Posted: 22nd Nov 2009 17:42

Link

Don't take my word for it. I have a few ideas because this is something I've been struggling with myself. There are probably ways to do it in DBC - just haven't figured them out yet; at least how to do them efficiently.

Enjoy your day.

Back to top

Profile PM

Pincho Paxton

21

Years of Service

User Offline

Joined: 8th Dec 2002

Location:

Posted: 22nd Nov 2009 23:31

Link

It looks good... now where do I get the data for Mars...

Back to top

Profile PM Email Website

Link102

19

Years of Service

User Offline

Joined: 1st Dec 2004

Location: On your head, weeeeee!

Posted: 22nd Nov 2009 23:48 Edited at: 22nd Nov 2009 23:54

Link

a mars heightmap can be found here
you should be able to load it if you replace the heightmap.bmp image by this one.
Just be sure to convert it to a 24 bit bmp

- Link102

Back to top

Profile PM

Pincho Paxton

21

Years of Service

User Offline

Joined: 8th Dec 2002

Location:

Posted: 23rd Nov 2009 18:14 Edited at: 23rd Nov 2009 18:18

Link

Thanks! Very flat isn't it.

Back to top

Profile PM Email Website

Link102

19

Years of Service

User Offline

Joined: 1st Dec 2004

Location: On your head, weeeeee!

Posted: 23rd Nov 2009 18:23 Edited at: 23rd Nov 2009 18:25

Link

Well it only looks flat because the map is scaled down a couple thousand times.
But if you absolutely want bigger mountains you could decrease the "/49344" value

- Link102

Back to top

Profile PM

Pincho Paxton

21

Years of Service

User Offline

Joined: 8th Dec 2002

Location:

Posted: 23rd Nov 2009 18:34

Link

Thanks! How do you make the mesh bigger?

Back to top

Profile PM Email Website

Link102

19

Years of Service

User Offline

Joined: 1st Dec 2004

Location: On your head, weeeeee!

Posted: 24th Nov 2009 04:29 Edited at: 24th Nov 2009 04:31

Link

what are you up to?

set display mode 1280,1024,32
sync on : sync rate 0
hide mouse

load image "heightmap.bmp",1
make memblock from image 1,1
width = memblock dword(1,0)
height = memblock dword(1,4)
xsegments = 50
zsegments = 50
make matrix 1,500,500,xsegments,zsegments
makematrix(xpos,ypox,width,xsegments,zsegments)

position camera -50,200,-50

do
set cursor 0,0
print "coordinates: ",xpos," ",ypos
print "use the mouse and mousebuttons to move the camera"
print "use the arrowkeys to scroll"

if leftkey() and xpos > 0 then xpos = xpos - 1
   if rightkey() and xpos < width-xsegments+1 then xpos = xpos + 1
   if downkey() and ypos > 0 then ypos = ypos - 1
   if upkey() and ypos < height-zsegments+1 then ypos = ypos + 1

if xpos<>oldxpos or ypos<>oldypos then makematrix(xpos,ypos,width,xsegments,zsegments)
   oldxpos = xpos
   oldypos = ypos

do_camera()
   sync
loop

function do_camera()
   camrotx# = wrapvalue(camrotx# + mousemovey() )
   camroty# = wrapvalue(camroty# + mousemovex() )
   rotate camera camrotx#,camroty#,0

move camera ((mouseclick()=1)-(mouseclick()=2) )*5
endfunction

function makematrix(xpos,ypos,width,xsegments,zsegments)
   width = width * 4
   for x = 0 to xsegments
      for y = 0 to zsegments
         height# = memblock dword(1,12 + (y+ypos)*4 + (x+xpos)*width)/49344
         set matrix height 1,x,y,height#
      next y
   next x
   update matrix 1
endfunction

+ Code Snippet

set display mode 1280,1024,32
sync on : sync rate 0
hide mouse

load image "heightmap.bmp",1
make memblock from image 1,1
width = memblock dword(1,0)
height = memblock dword(1,4)
xsegments = 50
zsegments = 50
make matrix 1,500,500,xsegments,zsegments
makematrix(xpos,ypox,width,xsegments,zsegments)


position camera -50,200,-50

do
set cursor 0,0
print "coordinates: ",xpos," ",ypos
print "use the mouse and mousebuttons to move the camera"
print "use the arrowkeys to scroll"


   if leftkey() and xpos > 0 then xpos = xpos - 1
   if rightkey() and xpos < width-xsegments+1 then xpos = xpos + 1
   if downkey() and ypos > 0 then ypos = ypos - 1
   if upkey() and ypos < height-zsegments+1 then ypos = ypos + 1

   if xpos<>oldxpos or ypos<>oldypos then makematrix(xpos,ypos,width,xsegments,zsegments)
   oldxpos = xpos
   oldypos = ypos

   do_camera()
   sync
loop

function do_camera()
   camrotx# = wrapvalue(camrotx# + mousemovey() )
   camroty# = wrapvalue(camroty# + mousemovex() )
   rotate camera camrotx#,camroty#,0

   move camera ((mouseclick()=1)-(mouseclick()=2) )*5
endfunction

function makematrix(xpos,ypos,width,xsegments,zsegments)
   width = width * 4
   for x = 0 to xsegments
      for y = 0 to zsegments
         height# = memblock dword(1,12 + (y+ypos)*4 + (x+xpos)*width)/49344
         set matrix height 1,x,y,height#
      next y
   next x
   update matrix 1
endfunction

- Link102

Back to top

Profile PM

Pincho Paxton

21

Years of Service

User Offline

Joined: 8th Dec 2002

Location:

Posted: 26th Nov 2009 22:23

Link

No the mesh size? The square is too small.

Back to top

Profile PM Email Website

Link102

19

Years of Service

User Offline

Joined: 1st Dec 2004

Location: On your head, weeeeee!

Posted: 27th Nov 2009 17:16

Link

lol XD

make matrix 1,500,500,50,50
to
make matrix 1,5000,5000,50,50

Back to top

Profile PM

Sorry your browser is not supported!

DarkBASIC Discussion / Vast scrolling heightmap

Attachments

Attachments

Attachments

Attachments

Attachments

Attachments