Help calculating normlas on a mesh

Author

Message

Santman

13

Years of Service

User Offline

Joined: 15th Sep 2011

Location: Inverness

Posted: 25th Jun 2018 21:54

Link

Ok, so I've come across an odd effect on the mesh normals on my landscape, where the lighting only works on one axis - so basically if you picture the light moving along the x axis hills far to either wide light correctly, but directly under neath do not light at all.

If you move it along the z axis, the lighting only works on one side of the light source, and stays dark on the other.

Has anyone got any idea how to calculate mesh normals? The following links seem to explain it, but not in AppGameKit terms - my best tranlsation doesn't work.

https://stackoverflow.com/questions/6656358/calculating-normals-in-a-triangle-mesh

https://stats.stackexchange.com/questions/70801/how-to-normalize-data-to-0-1-range

Back to top

Profile PM

Bengismo

7

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 25th Jun 2018 22:22 Edited at: 25th Jun 2018 23:00

Link

Sounds like your normals have an Z or X component only. How are they currently set? Either that or a shader being used isnt quite calculating the light result correctly??

On a terrain the normals should be fairly close to 0,1.0,0 (x,y,z) but obviously varying on the hills etc...

Ive a function for calculating the normals on an AppGameKit mesh in a memblock somewhere...i can dig it out if wanted.

Its basically a case of looping through your triangles...work out the normal for it (using cross product) and add that to each of the 3 vertices that make up the triangle . Then normalise the result in each vertex. Each triangle face then equally contributes to the vertex normal. It gives a result pretty identical to AGKs calculation of normals for terrain. Thats the correct way to do it for an arbitrary mesh.

Theres may be a quicker way as a terrain mesh always has 6 contributing triangles unless its right on the edge but unless your calculating normals every frame then it shouldn't be a problem to do set them once and just use them.

Back to top

Profile PM

Santman

13

Years of Service

User Offline

Joined: 15th Sep 2011

Location: Inverness

Posted: 25th Jun 2018 23:14

Link

Yeah, that's the exact principle that the website said, but it's not working no matter what I do. Wondering now if it's actually my shader......or some silly.little mistake. Could you dig it you?

It's not only the Y value you set, is it?

Back to top

Profile PM

Bengismo

7

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 25th Jun 2018 23:22 Edited at: 27th Jun 2018 14:00

Link

The normal has x,y and z components...on a flat section of terrain it will be 0,1.0,0 but it will vary depending on hills. i set all 3 components as they should be set.

Take a look at the GenerateHeightmapNormals() function, its somewhere in the code below. I can post a full example project showing how to use it if you wanted.

// Generate heightmap from image function
// scale applies to the width and depth of the heightmap (a scale of 1.0 gives a heightmap 1.0 wide and 1.0 deep)
// height scales the maximum height value 
// Smoothing applies some smoothing to the hills
function CreateObjectFromHeightMapImage(ImageId as Integer, scale as float, height as float, smoothing as integer)

// Create a memblock from the image and get its dimensions
	imblk = CreateMemblockFromImage(ImageId)
	imx = GetMemblockInt( imblk, 0 ) // image x dimension
	imy = GetMemblockInt( imblk, 4 ) // image y dimension
	// Image data starts at offset 12 and is in 4byte blocks per pixel RGBA
	
	
	// Calculate the number of triangles in the heightmap mesh  
	NumVertices = imx * imy
	NumTriangles = 2* (imx-1) * (imy-1)
	NumIndices = 3* NumTriangles
	VertexSize = 8 * 4  		// Size of a vertex = 8 floats x 4 bytes = 32 bytes
	
	// calculate the size of memblock we will need
	VertexOffset = 24 + 36
	IndexOffset = VertexOffset + (NumVertices * VertexSize)
	MemSize = IndexOffset + (NumIndices * 4)
	
	// create the memblock
	msblk = CreateMemblock( MemSize )
	
	//debug
	//print("Mesh Memblock ID:" + str(msblk))
	//print("Mesh Memblock Size:" + str(MemSize))
	
	// Start filling it up with relevant info
	SetMemblockInt( msblk, 0, NumVertices ) 
	SetMemblockInt( msblk, 4, NumIndices ) 
	SetMemblockInt( msblk, 8, 3 ) 				// number if attributes (3)
	SetMemblockInt( msblk, 12, VertexSize )		// Bytes per vertex  (32)
	SetMemblockInt( msblk, 16, VertexOffset ) 	// should be (60)
	SetMemblockInt( msblk, 20, IndexOffset )    // varies
	
	// debug
	//print("NumVertices:" + str(NumVertices))
	//print("NumTriangles:" + str(NumTriangles))
	//print("VertexSize:" + str(VertexSize))
	//print("VertexOffset:" + str(VertexOffset))
	//print("IndexOffset:" + str(IndexOffset))
		
	// Set the attribute Data
	// VERTEX ATTRIBUTES
	SetMemblockByte( msblk, 24, 0 )		// float 
	SetMemblockByte( msblk, 25, 3 )		// component count 
	SetMemblockByte( msblk, 26, 0 )		// normalize 
	SetMemblockByte( msblk, 27, 12 )    // string length 
	SetMemblockString( msblk, 28, "position" )

// NORMALS ATTRIBUTES
	SetMemblockByte( msblk, 40, 0 )		// float 
	SetMemblockByte( msblk, 41, 3 )		// component count 
	SetMemblockByte( msblk, 42, 0 )		// normalize 
	SetMemblockByte( msblk, 43, 8 )     // string length 
	SetMemblockString( msblk, 44, "normal" )

// UV ATTRIBUTES
	SetMemblockByte( msblk, 52, 0 )		// float 
	SetMemblockByte( msblk, 53, 2 )		// component count 
	SetMemblockByte( msblk, 54, 0 )		// normalize 
	SetMemblockByte( msblk, 55, 4 )     // string length 
	SetMemblockString( msblk, 56, "uv" )

// Vertex data begins at offset 60
	// Copy the vertex data into memblock
	vertexIndex = 0
	x# = 0
	y# = 0
	z# = 0
	u# = 0
	v# = 0
	
	// Go through all the vertices and set heights, location, UV's and a preliminary normal
	for iy# = 0 to imy-1
		for ix# = 0 to imx-1
		
		// create uv's  (0.0-1.0)
		u#=ix#/(imx-1)
		v#=iy#/(imy-1)
		
		// create positions
		x#= u#
		y#= GetMemblockByte( imblk, 12+(vertexIndex*4))/255.0// get the red value only
		z#= 1.0 - v# 
		
		// Scale the x,y,z   (x &Z by scale...Y is the height)
		x# = x# * scale
		z# = z# * scale
	    y# = y# * height 
		
		// Save these values		
		SetMeshMemblockVertexPosition( msblk, vertexIndex, x#, y#, z# )
		SetMeshMemblockVertexNormal( msblk, vertexIndex, 0.0, 1.0, 0.0 )  // set a default normal to straight up
		SetMeshMemblockVertexUV( msblk, vertexIndex, u#, v# )
	
		// increment the vertex index
		vertexIndex = vertexIndex+1

next ix#
	next iy#
	
	//print("Vertices Added:" + str(vertexIndex))
	
	// Set the indices in the memblock
	// 0,1,1+imx
	// 0,1+imx,0+imx  repeat this - clockwise order??
	IndOffset = IndexOffset
	//print("Indices Start at:" + str(IndOffset))
	
	Index = 0
	for ix = 0 to imx-2
		for iy = 0 to imy-2
			
			Index = ix + (iy*imx) // top left
			
			// First index
			SetMemblockInt( msblk, IndOffset, Index ) // top left
			IndOffset = IndOffset + 4

// third index
			SetMemblockInt( msblk, IndOffset, Index + 1 + imx) // bottom right
			IndOffset = IndOffset + 4

// second index
			SetMemblockInt( msblk, IndOffset, Index + 1 ) // top right
			IndOffset = IndOffset + 4

// First index
			SetMemblockInt( msblk, IndOffset, Index )	// top left
			IndOffset = IndOffset + 4

// Third index
			SetMemblockInt( msblk, IndOffset, Index + imx)	// bottom left
			IndOffset = IndOffset + 4

// Second index
			SetMemblockInt( msblk, IndOffset, Index + 1 + imx )	// bottom right
			IndOffset = IndOffset + 4

next iy
	next ix

// Smooth the heightmap  (can be re-entered multiple times)
	while smoothing>0
		SmoothHeightmap(msblk,imx,imy)
		smoothing = smoothing - 1
	endwhile

// generate the normals 
	GenerateHeightmapNormals(msblk) //,imx,imy)

// copy data into the membuffer
	newobj = CreateObjectFromMeshMemblock( msblk )
	
	// Delete the image memblock
	DeleteMemblock( imblk )

// delete the MeshMemblock
	DeleteMemblock( msblk )

// return the newly created mesh object :)
endfunction newobj

// Performs smoothing on the heightmap
// x is the width of the heightmap
// y is the depth of the heightmap
function SmoothHeightmap(msblk as integer, x as integer, y as integer)

//VertexSize = GetMemblockInt( msblk, 12)		// Bytes per vertex  (should be 32)
	//VertexOffset = GetMemblockInt( msblk, 16 ) 	// (Normally 60)

// Applies a smoothing function to the mesh
	// loop through all the vertices
	for iy = 1 to y-2 // intentionally stays one pixel inside the heightmap
		for ix = 1 to x-2 // intentionally stays one pixel inside the heightmap
	
		// index of this vertex is
		ind = ix + (iy*x)
		xp# = GetMeshMemblockVertexX( msblk, ind )
		yp# = GetMeshMemblockVertexY( msblk, ind )
		zp# = GetMeshMemblockVertexZ( msblk, ind )

// get height of vertex to the left
		yl# = GetMeshMemblockVertexY( msblk, ind-1 )

// get height of vertex to the right
		yr# = GetMeshMemblockVertexY( msblk, ind+1 )
		
		// get height of vertex below 
		yb# = GetMeshMemblockVertexY( msblk, ind+x )

// get height of vertex above 
		ya# = GetMeshMemblockVertexY( msblk, ind-x )

// calculate a new value of height
		filt# = 0.6
		newy# = (filt#*yp#) + ((1-filt#)*(yr# + yb# + ya# + yl#)/4)

// Set the newheight
		SetMeshMemblockVertexPosition( msblk, ind, xp#, newy#, zp# )
		
		next ix
	next iy
	
	
endfunction

// Generate normals for the mesh
// msblk is a meshmemblock which holds the mesh ypou want normals calculating for
// The mesh must be an indexed triangle mesh - see alternate function for non indexed
function GenerateHeightmapNormals(msblk as integer)

// Start by getting the relevant info
	NumVertices = GetMemblockInt( msblk, 0)
	NumIndices = GetMemblockInt( msblk, 4)
	NumTriangles = NumIndices/3  
	//NumAttributes = GetMemblockInt( msblk, 8) 	// number if attributes ( should be 3 for a heightmap)
	//VertexSize = GetMemblockInt( msblk, 12)		// Bytes per vertex  (should be 32)
	//VertexOffset = GetMemblockInt( msblk, 16 ) 	// (Normally 60)
	IndicesOffset = GetMemblockInt( msblk, 20 )

// How to generate surface normals the proper way
	//1)	Normal vectors must all be zero before start!!
	//2)	Iterate through the triangles and get the normal on each triangle then ADD that to each of the 3 vertices normal. Other triangles will add to these values if they share indices.
	//3)	Loop through all the vertices and normalize the normals

// Fill all the vertex normals with 0,0,0
	for ind =0 to NumVertices-1
		SetMeshMemblockVertexNormal(msblk, ind, 0 , 0 , 0)
	next ind

// loop through all the triangles
	Offset = IndicesOffset
	for it = 0 to NumTriangles-1
	
		// Get the indices 
		inda = GetMemblockInt(msblk, Offset)
		indb = GetMemblockInt(msblk, Offset+4)
		indc = GetMemblockInt(msblk, Offset+8)
	
		// Get the first vector (P2-P1)
		Vx# = GetMeshMemblockVertexX(msblk,indb) - GetMeshMemblockVertexX(msblk,inda)
		Vy# = GetMeshMemblockVertexY(msblk,indb) - GetMeshMemblockVertexY(msblk,inda)
		Vz# = GetMeshMemblockVertexZ(msblk,indb) - GetMeshMemblockVertexZ(msblk,inda)

// Get the second vector (P3-P1)
		Wx# = GetMeshMemblockVertexX(msblk,indc) - GetMeshMemblockVertexX(msblk,indb)
		Wy# = GetMeshMemblockVertexY(msblk,indc) - GetMeshMemblockVertexY(msblk,indb)
		Wz# = GetMeshMemblockVertexZ(msblk,indc) - GetMeshMemblockVertexZ(msblk,indb)
	
		// Cross product them to get the normal
		Nx#=(Vz#*Wy#)-(Vy#*Wz#)
		Ny#=(Vx#*Wz#)-(Vz#*Wx#)
		Nz#=(Vy#*Wx#)-(Vx#*Wy#)

// add the calculated normal to each of the vertices in this triangle
		px# = GetMeshMemblockVertexNormalX(msblk, inda)
		py# = GetMeshMemblockVertexNormalY(msblk, inda)
		pz# = GetMeshMemblockVertexNormalZ(msblk, inda)
		SetMeshMemblockVertexNormal(msblk, inda, px# + Nx#, py# + Ny#, pz# + Nz#)
		
		px# = GetMeshMemblockVertexNormalX(msblk, indb)
		py# = GetMeshMemblockVertexNormalY(msblk, indb)
		pz# = GetMeshMemblockVertexNormalZ(msblk, indb)
		SetMeshMemblockVertexNormal(msblk, indb, px# + Nx#, py# + Ny#, pz# + Nz#)

px# = GetMeshMemblockVertexNormalX(msblk, indc)
		py# = GetMeshMemblockVertexNormalY(msblk, indc)
		pz# = GetMeshMemblockVertexNormalZ(msblk, indc)
		SetMeshMemblockVertexNormal(msblk, indc, px# + Nx#, py# + Ny#, pz# + Nz#)

// Move the offset to the next triangle
		Offset = Offset + 12

next it
		
	// Normalise all the vertex normals 
	for ind =0 to NumVertices-1
		// Get the normal
		nx# = GetMeshMemblockVertexNormalX(msblk, ind)
		ny# = GetMeshMemblockVertexNormalY(msblk, ind)
		nz# = GetMeshMemblockVertexNormalZ(msblk, ind)

// normalise the normal
		len# = sqrt((nx#*nx#) + (ny#*ny#) + (nz#*nz#))
		nx# = nx#/len#
		ny# = ny#/len#
		nz# = nz#/len#
		
		// Set the new normal
		SetMeshMemblockVertexNormal( msblk, ind, nx#, ny#, nz# )
	next ind

endfunction

// Get float array from heightmap
// gets an array of floats which contains the y data in the heightmap memblock
// data is the array that gets filled with the heights in the heightmap
// x is the width of the heightmap
// y is the depth of the heightmap
function GetFloatArrayFromHeightmap(msblk as integer, data ref as float[][],x as integer, y as integer)

// loop through all the vertices
	for iy = 0 to y-1 
		for ix = 0 to x-1 
	
		// index of this vertex is
		ind = ix + (iy*x)
		
		// Get this vertex
		yp# = GetMeshMemblockVertexY( msblk, ind )
	
		// Stick it into the array
		data[y,x] = yp#   // should this be [x,y] ?? hmm whats the convention in basic?
		// todo - check this convention?
		
		next ix
	next iy

// TODO - this would be much quicker with in incrementing offset and direct access to the float Y value using GetMemblockFloat(offset) etc...
	// TODO - implement and test that

endfunction

// This Saves the whole memblock to a text readable file - mainly for debugging code
// saves in the standard default AGK save location (HARD TO FIND!!)
Function SaveMeshMemBlockAsText(msblk as integer, Filename as string)

//SetFolder("media")

// open a file
	fid = OpenToWrite(Filename)
	
	// Start saving the relevant info
	WriteLine( fid, "Num Vertices:" + str(GetMemblockInt( msblk, 0)))
	WriteLine( fid, "Num Indices:" + str(GetMemblockInt( msblk, 4)))
	WriteLine( fid, "Num Attributes:" + str(GetMemblockInt( msblk, 8)))
	WriteLine( fid, "Vertex Size:" + str(GetMemblockInt( msblk, 12)))
	WriteLine( fid, "Vertex Data Offset:" + str(GetMemblockInt( msblk, 16)))
	WriteLine( fid, "Vertex Data Size:" + str(GetMemblockInt( msblk, 12) * GetMemblockInt( msblk, 0)))
	
	WriteLine( fid, "Index Data Offset:" + str(GetMemblockInt( msblk, 20)))
	WriteLine( fid, "Index Data Size:" + str(GetMemblockInt( msblk, 4)*4))
	 
	WriteLine( fid, "Total Memblock Size:" + str(GetMemblockSize( msblk)))
	
	offset = 24
	
	// Write out the attributes
	for Att = 1 to GetMemblockInt( msblk, 8)
		WriteLine( fid, "Attribute" + str(Att) +": " + str(GetMemblockByte( msblk, offset))+ str(GetMemblockByte( msblk, offset+1))+ str(GetMemblockByte( msblk, offset+2))+ str(GetMemblockByte( msblk, offset+3)))
		WriteLine( fid, GetMemblockString( msblk, offset+4, GetMemblockByte( msblk, offset+3) ))

// Move the offset
		offset = offset + 4 + GetMemblockByte( msblk, offset+3)
	next Att
	
	// Write out the indices in 3's
	offset = GetMemblockInt( msblk, 20)
	WriteLine( fid, "Indices:")
	
	for ind = 1 to GetMemblockInt( msblk, 4)
		WriteLine( fid, str(GetMemblockInt( msblk, offset)) + " " + str(GetMemblockInt( msblk, offset+4)) + " " + str(GetMemblockInt( msblk, offset+8)))
		offset = offset + 12
	next ind
	
	// Write out the Vertices 
	offset = GetMemblockInt( msblk, 16)
	WriteLine( fid, "Vertices:")
	
	for Ver = 1 to GetMemblockInt( msblk, 0)
		WriteLine( fid, str(GetMemblockFloat( msblk, offset)) + " " + str(GetMemblockfloat( msblk, offset+4)) + " " + str(GetMemblockFloat( msblk, offset+8)))
		offset = offset + GetMemblockInt( msblk, 12)
	next Ver
	
	
	// close the output file
	CloseFile(fid)

Endfunction

+ Code Snippet

// Generate heightmap from image function
// scale applies to the width and depth of the heightmap (a scale of 1.0 gives a heightmap 1.0 wide and 1.0 deep)
// height scales the maximum height value 
// Smoothing applies some smoothing to the hills
function CreateObjectFromHeightMapImage(ImageId as Integer, scale as float, height as float, smoothing as integer)

	// Create a memblock from the image and get its dimensions
	imblk = CreateMemblockFromImage(ImageId)
	imx = GetMemblockInt( imblk, 0 ) // image x dimension
	imy = GetMemblockInt( imblk, 4 ) // image y dimension
	// Image data starts at offset 12 and is in 4byte blocks per pixel RGBA
	
	
	// Calculate the number of triangles in the heightmap mesh  
	NumVertices = imx * imy
	NumTriangles = 2* (imx-1) * (imy-1)
	NumIndices = 3* NumTriangles
	VertexSize = 8 * 4  		// Size of a vertex = 8 floats x 4 bytes = 32 bytes
	
	// calculate the size of memblock we will need
	VertexOffset = 24 + 36
	IndexOffset = VertexOffset + (NumVertices * VertexSize)
	MemSize = IndexOffset + (NumIndices * 4)
	
	// create the memblock
	msblk = CreateMemblock( MemSize )
	
	//debug
	//print("Mesh Memblock ID:" + str(msblk))
	//print("Mesh Memblock Size:" + str(MemSize))
	
	// Start filling it up with relevant info
	SetMemblockInt( msblk, 0, NumVertices ) 
	SetMemblockInt( msblk, 4, NumIndices ) 
	SetMemblockInt( msblk, 8, 3 ) 				// number if attributes (3)
	SetMemblockInt( msblk, 12, VertexSize )		// Bytes per vertex  (32)
	SetMemblockInt( msblk, 16, VertexOffset ) 	// should be (60)
	SetMemblockInt( msblk, 20, IndexOffset )    // varies
	
	// debug
	//print("NumVertices:" + str(NumVertices))
	//print("NumTriangles:" + str(NumTriangles))
	//print("VertexSize:" + str(VertexSize))
	//print("VertexOffset:" + str(VertexOffset))
	//print("IndexOffset:" + str(IndexOffset))
		
	// Set the attribute Data
	// VERTEX ATTRIBUTES
	SetMemblockByte( msblk, 24, 0 )		// float 
	SetMemblockByte( msblk, 25, 3 )		// component count 
	SetMemblockByte( msblk, 26, 0 )		// normalize 
	SetMemblockByte( msblk, 27, 12 )    // string length 
	SetMemblockString( msblk, 28, "position" )

	// NORMALS ATTRIBUTES
	SetMemblockByte( msblk, 40, 0 )		// float 
	SetMemblockByte( msblk, 41, 3 )		// component count 
	SetMemblockByte( msblk, 42, 0 )		// normalize 
	SetMemblockByte( msblk, 43, 8 )     // string length 
	SetMemblockString( msblk, 44, "normal" )

	// UV ATTRIBUTES
	SetMemblockByte( msblk, 52, 0 )		// float 
	SetMemblockByte( msblk, 53, 2 )		// component count 
	SetMemblockByte( msblk, 54, 0 )		// normalize 
	SetMemblockByte( msblk, 55, 4 )     // string length 
	SetMemblockString( msblk, 56, "uv" )

	// Vertex data begins at offset 60
	// Copy the vertex data into memblock
	vertexIndex = 0
	x# = 0
	y# = 0
	z# = 0
	u# = 0
	v# = 0
	
	// Go through all the vertices and set heights, location, UV's and a preliminary normal
	for iy# = 0 to imy-1
		for ix# = 0 to imx-1
		
		// create uv's  (0.0-1.0)
		u#=ix#/(imx-1)
		v#=iy#/(imy-1)
		
		// create positions
		x#= u#
		y#= GetMemblockByte( imblk, 12+(vertexIndex*4))/255.0// get the red value only
		z#= 1.0 - v# 
		
		// Scale the x,y,z   (x &Z by scale...Y is the height)
		x# = x# * scale
		z# = z# * scale
	    y# = y# * height 
		
		// Save these values		
		SetMeshMemblockVertexPosition( msblk, vertexIndex, x#, y#, z# )
		SetMeshMemblockVertexNormal( msblk, vertexIndex, 0.0, 1.0, 0.0 )  // set a default normal to straight up
		SetMeshMemblockVertexUV( msblk, vertexIndex, u#, v# )
	
		// increment the vertex index
		vertexIndex = vertexIndex+1

		next ix#
	next iy#
	
	//print("Vertices Added:" + str(vertexIndex))
	
	// Set the indices in the memblock
	// 0,1,1+imx
	// 0,1+imx,0+imx  repeat this - clockwise order??
	IndOffset = IndexOffset
	//print("Indices Start at:" + str(IndOffset))
	
	Index = 0
	for ix = 0 to imx-2
		for iy = 0 to imy-2
			
			Index = ix + (iy*imx) // top left
			
			// First index
			SetMemblockInt( msblk, IndOffset, Index ) // top left
			IndOffset = IndOffset + 4

			// third index
			SetMemblockInt( msblk, IndOffset, Index + 1 + imx) // bottom right
			IndOffset = IndOffset + 4

			// second index
			SetMemblockInt( msblk, IndOffset, Index + 1 ) // top right
			IndOffset = IndOffset + 4



			// First index
			SetMemblockInt( msblk, IndOffset, Index )	// top left
			IndOffset = IndOffset + 4

			// Third index
			SetMemblockInt( msblk, IndOffset, Index + imx)	// bottom left
			IndOffset = IndOffset + 4

			// Second index
			SetMemblockInt( msblk, IndOffset, Index + 1 + imx )	// bottom right
			IndOffset = IndOffset + 4


		next iy
	next ix

	// Smooth the heightmap  (can be re-entered multiple times)
	while smoothing>0
		SmoothHeightmap(msblk,imx,imy)
		smoothing = smoothing - 1
	endwhile

	// generate the normals 
	GenerateHeightmapNormals(msblk) //,imx,imy)

	// copy data into the membuffer
	newobj = CreateObjectFromMeshMemblock( msblk )
	
	// Delete the image memblock
	DeleteMemblock( imblk )

	// delete the MeshMemblock
	DeleteMemblock( msblk )

	// return the newly created mesh object :)
endfunction newobj 


// Performs smoothing on the heightmap
// x is the width of the heightmap
// y is the depth of the heightmap
function SmoothHeightmap(msblk as integer, x as integer, y as integer)

	//VertexSize = GetMemblockInt( msblk, 12)		// Bytes per vertex  (should be 32)
	//VertexOffset = GetMemblockInt( msblk, 16 ) 	// (Normally 60)

	// Applies a smoothing function to the mesh
	// loop through all the vertices
	for iy = 1 to y-2 // intentionally stays one pixel inside the heightmap
		for ix = 1 to x-2 // intentionally stays one pixel inside the heightmap
	
		// index of this vertex is
		ind = ix + (iy*x)
		xp# = GetMeshMemblockVertexX( msblk, ind )
		yp# = GetMeshMemblockVertexY( msblk, ind )
		zp# = GetMeshMemblockVertexZ( msblk, ind )

	
		// get height of vertex to the left
		yl# = GetMeshMemblockVertexY( msblk, ind-1 )

		// get height of vertex to the right
		yr# = GetMeshMemblockVertexY( msblk, ind+1 )
		
		// get height of vertex below 
		yb# = GetMeshMemblockVertexY( msblk, ind+x )

		// get height of vertex above 
		ya# = GetMeshMemblockVertexY( msblk, ind-x )


		// calculate a new value of height
		filt# = 0.6
		newy# = (filt#*yp#) + ((1-filt#)*(yr# + yb# + ya# + yl#)/4)

		// Set the newheight
		SetMeshMemblockVertexPosition( msblk, ind, xp#, newy#, zp# )
		
		next ix
	next iy
	
	
endfunction


// Generate normals for the mesh
// msblk is a meshmemblock which holds the mesh ypou want normals calculating for
// The mesh must be an indexed triangle mesh - see alternate function for non indexed
function GenerateHeightmapNormals(msblk as integer)


	// Start by getting the relevant info
	NumVertices = GetMemblockInt( msblk, 0)
	NumIndices = GetMemblockInt( msblk, 4)
	NumTriangles = NumIndices/3  
	//NumAttributes = GetMemblockInt( msblk, 8) 	// number if attributes ( should be 3 for a heightmap)
	//VertexSize = GetMemblockInt( msblk, 12)		// Bytes per vertex  (should be 32)
	//VertexOffset = GetMemblockInt( msblk, 16 ) 	// (Normally 60)
	IndicesOffset = GetMemblockInt( msblk, 20 )

	// How to generate surface normals the proper way
	//1)	Normal vectors must all be zero before start!!
	//2)	Iterate through the triangles and get the normal on each triangle then ADD that to each of the 3 vertices normal. Other triangles will add to these values if they share indices.
	//3)	Loop through all the vertices and normalize the normals

	// Fill all the vertex normals with 0,0,0
	for ind =0 to NumVertices-1
		SetMeshMemblockVertexNormal(msblk, ind, 0 , 0 , 0)
	next ind
	
	

	// loop through all the triangles
	Offset = IndicesOffset
	for it = 0 to NumTriangles-1
	
		// Get the indices 
		inda = GetMemblockInt(msblk, Offset)
		indb = GetMemblockInt(msblk, Offset+4)
		indc = GetMemblockInt(msblk, Offset+8)
	
		// Get the first vector (P2-P1)
		Vx# = GetMeshMemblockVertexX(msblk,indb) - GetMeshMemblockVertexX(msblk,inda)
		Vy# = GetMeshMemblockVertexY(msblk,indb) - GetMeshMemblockVertexY(msblk,inda)
		Vz# = GetMeshMemblockVertexZ(msblk,indb) - GetMeshMemblockVertexZ(msblk,inda)

		// Get the second vector (P3-P1)
		Wx# = GetMeshMemblockVertexX(msblk,indc) - GetMeshMemblockVertexX(msblk,indb)
		Wy# = GetMeshMemblockVertexY(msblk,indc) - GetMeshMemblockVertexY(msblk,indb)
		Wz# = GetMeshMemblockVertexZ(msblk,indc) - GetMeshMemblockVertexZ(msblk,indb)
	
		// Cross product them to get the normal
		Nx#=(Vz#*Wy#)-(Vy#*Wz#)
		Ny#=(Vx#*Wz#)-(Vz#*Wx#)
		Nz#=(Vy#*Wx#)-(Vx#*Wy#)

		// add the calculated normal to each of the vertices in this triangle
		px# = GetMeshMemblockVertexNormalX(msblk, inda)
		py# = GetMeshMemblockVertexNormalY(msblk, inda)
		pz# = GetMeshMemblockVertexNormalZ(msblk, inda)
		SetMeshMemblockVertexNormal(msblk, inda, px# + Nx#, py# + Ny#, pz# + Nz#)
		
		px# = GetMeshMemblockVertexNormalX(msblk, indb)
		py# = GetMeshMemblockVertexNormalY(msblk, indb)
		pz# = GetMeshMemblockVertexNormalZ(msblk, indb)
		SetMeshMemblockVertexNormal(msblk, indb, px# + Nx#, py# + Ny#, pz# + Nz#)

		px# = GetMeshMemblockVertexNormalX(msblk, indc)
		py# = GetMeshMemblockVertexNormalY(msblk, indc)
		pz# = GetMeshMemblockVertexNormalZ(msblk, indc)
		SetMeshMemblockVertexNormal(msblk, indc, px# + Nx#, py# + Ny#, pz# + Nz#)

		// Move the offset to the next triangle
		Offset = Offset + 12

	next it
		
	// Normalise all the vertex normals 
	for ind =0 to NumVertices-1
		// Get the normal
		nx# = GetMeshMemblockVertexNormalX(msblk, ind)
		ny# = GetMeshMemblockVertexNormalY(msblk, ind)
		nz# = GetMeshMemblockVertexNormalZ(msblk, ind)

		// normalise the normal
		len# = sqrt((nx#*nx#) + (ny#*ny#) + (nz#*nz#))
		nx# = nx#/len#
		ny# = ny#/len#
		nz# = nz#/len#
		
		// Set the new normal
		SetMeshMemblockVertexNormal( msblk, ind, nx#, ny#, nz# )
	next ind

endfunction


// Get float array from heightmap
// gets an array of floats which contains the y data in the heightmap memblock
// data is the array that gets filled with the heights in the heightmap
// x is the width of the heightmap
// y is the depth of the heightmap
function GetFloatArrayFromHeightmap(msblk as integer, data ref as float[][],x as integer, y as integer)

	// loop through all the vertices
	for iy = 0 to y-1 
		for ix = 0 to x-1 
	
		// index of this vertex is
		ind = ix + (iy*x)
		
		// Get this vertex
		yp# = GetMeshMemblockVertexY( msblk, ind )
	
		// Stick it into the array
		data[y,x] = yp#   // should this be [x,y] ?? hmm whats the convention in basic?
		// todo - check this convention?
		
		next ix
	next iy

	// TODO - this would be much quicker with in incrementing offset and direct access to the float Y value using GetMemblockFloat(offset) etc...
	// TODO - implement and test that

endfunction


// This Saves the whole memblock to a text readable file - mainly for debugging code
// saves in the standard default AGK save location (HARD TO FIND!!)
Function SaveMeshMemBlockAsText(msblk as integer, Filename as string)

	//SetFolder("media")

	// open a file
	fid = OpenToWrite(Filename)
	
	// Start saving the relevant info
	WriteLine( fid, "Num Vertices:" + str(GetMemblockInt( msblk, 0)))
	WriteLine( fid, "Num Indices:" + str(GetMemblockInt( msblk, 4)))
	WriteLine( fid, "Num Attributes:" + str(GetMemblockInt( msblk, 8)))
	WriteLine( fid, "Vertex Size:" + str(GetMemblockInt( msblk, 12)))
	WriteLine( fid, "Vertex Data Offset:" + str(GetMemblockInt( msblk, 16)))
	WriteLine( fid, "Vertex Data Size:" + str(GetMemblockInt( msblk, 12) * GetMemblockInt( msblk, 0)))
	
	WriteLine( fid, "Index Data Offset:" + str(GetMemblockInt( msblk, 20)))
	WriteLine( fid, "Index Data Size:" + str(GetMemblockInt( msblk, 4)*4))
	 
	WriteLine( fid, "Total Memblock Size:" + str(GetMemblockSize( msblk)))
	
	offset = 24
	
	// Write out the attributes
	for Att = 1 to GetMemblockInt( msblk, 8)
		WriteLine( fid, "Attribute" + str(Att) +": " + str(GetMemblockByte( msblk, offset))+ str(GetMemblockByte( msblk, offset+1))+ str(GetMemblockByte( msblk, offset+2))+ str(GetMemblockByte( msblk, offset+3)))
		WriteLine( fid, GetMemblockString( msblk, offset+4, GetMemblockByte( msblk, offset+3) ))

		// Move the offset
		offset = offset + 4 + GetMemblockByte( msblk, offset+3)
	next Att
	
	// Write out the indices in 3's
	offset = GetMemblockInt( msblk, 20)
	WriteLine( fid, "Indices:")
	
	for ind = 1 to GetMemblockInt( msblk, 4)
		WriteLine( fid, str(GetMemblockInt( msblk, offset)) + " " + str(GetMemblockInt( msblk, offset+4)) + " " + str(GetMemblockInt( msblk, offset+8)))
		offset = offset + 12
	next ind
	
	// Write out the Vertices 
	offset = GetMemblockInt( msblk, 16)
	WriteLine( fid, "Vertices:")
	
	for Ver = 1 to GetMemblockInt( msblk, 0)
		WriteLine( fid, str(GetMemblockFloat( msblk, offset)) + " " + str(GetMemblockfloat( msblk, offset+4)) + " " + str(GetMemblockFloat( msblk, offset+8)))
		offset = offset + GetMemblockInt( msblk, 12)
	next Ver
	
	
	// close the output file
	CloseFile(fid)

Endfunction

Back to top

Profile PM

Santman

13

Years of Service

User Offline

Joined: 15th Sep 2011

Location: Inverness

Posted: 25th Jun 2018 23:30

Link

The is Benjisimo, that's awesome. Gonna take me a day or two to work it through, but I'll get there now I think.

Back to top

Profile PM

Santman

13

Years of Service

User Offline

Joined: 15th Sep 2011

Location: Inverness

Posted: 25th Jun 2018 23:33

Link

Actually I've literally just worked it out I think.....I assumed a flat terrain was 0,0,0..... not 0,1,0.....so for my Y height I need to add 1.0 in theory. That would potentily explain why it lights from only one side.....if I move the light source below the mesh it lights the other way.....my Y it at a 90 degree angle I think.

Back to top

Profile PM

Santman

13

Years of Service

User Offline

Joined: 15th Sep 2011

Location: Inverness

Posted: 25th Jun 2018 23:33

Link

Actually I've literally just worked it out I think.....I assumed a flat terrain was 0,0,0..... not 0,1,0.....so for my Y height I need to add 1.0 in theory. That would potentily explain why it lights from only one side.....if I move the light source below the mesh it lights the other way.....my Y it at a 90 degree angle I think.

Back to top

Profile PM

Bengismo

7

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 25th Jun 2018 23:41

Link

Cool....sounds like your position is being used for your normal?

The x,y,z positions can be 0,0,0 but the normal should be approx 0,1,0 so yes...you need to set the normals to point upwards on a flat terrain or correctly calculate them using the technique described above...

Back to top

Profile PM

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 27th Jun 2018 13:02

Link

With each poly [ABC] (points listed clockwise), make two vectors; AB and AC (doesn't really matter). Now take the cross product of those two vector and you'll have a normal (well, after you normalize the result).

That will give you the blocky result you see in Ben's image. You'll then have to smooth out the averages to get a nice effect. There's plenty of examples buried in DBP threads. If you can't find anything or haven't figured it out yet, I'll try to find my old matrix code tonight.

Tiled TMX Importer V.2
XML Parser V.2
Base64 Encoder/Decoder
Purple Token - Free online hi-score database
Legend of Zelda

"I like offending people, because I think people who get offended should be offended." - Linus Torvalds

Back to top

Profile PM Email Website

Bengismo

7

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 27th Jun 2018 13:38 Edited at: 27th Jun 2018 15:17

Link

Quote: "With each poly [ABC] (points listed clockwise), make two vectors; AB and AC (doesn't really matter). Now take the cross product of those two vector and you'll have a normal (well, after you normalize the result).

That will give you the blocky result you see in Ben's image. You'll then have to smooth out the averages to get a nice effect. There's plenty of examples buried in DBP threads. If you can't find anything or haven't figured it out yet, I'll try to find my old matrix code tonight."

Sorry but your getting confused...

The image above was just for illustration as it was the only one I could find with normals shown on a terrain! Its not my image and was posted by someone else. It just happened to have flat shading used on it and its not something rendered in AGK.

The result you get from the methods described by santman and myself above ARE smooth results.

The algorithm adds the normal generated for a number of triangles to each vertex - then normalises (averages) the result. Typically a vertex in the middle of the mesh will be used by 6 triangles and they each equally contribute to the final normal value at the vertex.

... an actual example is shown here. If you use the function I posted you get smoothed normals as it takes into account all the triangles which use the vertex. The only way you get flat triangles in AppGameKit is if you duplicate vertices or used non indexed triangles and set all the normals to be equal for just one triangle.

So you can use the method i described or even use my own function and it works fine and gives a smooth result...like this

And.... which two vectors you use to calculate the normal does matter! - as it will reverse the normal if you choose the wrong ones.

Back to top

Profile PM

Bengismo

7

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 27th Jun 2018 13:56 Edited at: 27th Jun 2018 15:18

Link

Quick example.....

If you create your own terrain using a function or some maths and you dont generate normals for a terrain then the lighting ends up being flat and rubbish

The normals on the terrain below are all set to 0,1,0...

Its suprising how much affect lighting has on the appearance of curvature.

If they are set correctly using the correct method above which calculates the correct smoothed normal

Same 3d heightmap model in both versions and no shadows involved....just correct normals

Thats the code i posted above.

function GenerateHeightmapNormals(msblk as integer)
 
 
    // Start by getting the relevant info
    NumVertices = GetMemblockInt( msblk, 0)
    NumIndices = GetMemblockInt( msblk, 4)
    NumTriangles = NumIndices/3  
    //NumAttributes = GetMemblockInt( msblk, 8)     // number if attributes ( should be 3 for a heightmap)
    //VertexSize = GetMemblockInt( msblk, 12)       // Bytes per vertex  (should be 32)
    //VertexOffset = GetMemblockInt( msblk, 16 )    // (Normally 60)
    IndicesOffset = GetMemblockInt( msblk, 20 )
 
    // How to generate surface normals the proper way
    //1)    Normal vectors must all be zero before start!!
    //2)    Iterate through the triangles and get the normal on each triangle then ADD that to each of the 3 vertices normal. Other triangles will add to these values if they share indices.
    //3)    Loop through all the vertices and normalize the normals
 
    // Fill all the vertex normals with 0,0,0
    for ind =0 to NumVertices-1
        SetMeshMemblockVertexNormal(msblk, ind, 0 , 0 , 0)
    next ind
     
     
 
    // loop through all the triangles
    Offset = IndicesOffset
    for it = 0 to NumTriangles-1
     
        // Get the indices 
        inda = GetMemblockInt(msblk, Offset)
        indb = GetMemblockInt(msblk, Offset+4)
        indc = GetMemblockInt(msblk, Offset+8)
     
        // Get the first vector (P2-P1)
        Vx# = GetMeshMemblockVertexX(msblk,indb) - GetMeshMemblockVertexX(msblk,inda)
        Vy# = GetMeshMemblockVertexY(msblk,indb) - GetMeshMemblockVertexY(msblk,inda)
        Vz# = GetMeshMemblockVertexZ(msblk,indb) - GetMeshMemblockVertexZ(msblk,inda)
 
        // Get the second vector (P3-P1)
        Wx# = GetMeshMemblockVertexX(msblk,indc) - GetMeshMemblockVertexX(msblk,indb)
        Wy# = GetMeshMemblockVertexY(msblk,indc) - GetMeshMemblockVertexY(msblk,indb)
        Wz# = GetMeshMemblockVertexZ(msblk,indc) - GetMeshMemblockVertexZ(msblk,indb)
     
        // Cross product them to get the normal
        Nx#=(Vz#*Wy#)-(Vy#*Wz#)
        Ny#=(Vx#*Wz#)-(Vz#*Wx#)
        Nz#=(Vy#*Wx#)-(Vx#*Wy#)
 
        // add the calculated normal to each of the vertices in this triangle
        px# = GetMeshMemblockVertexNormalX(msblk, inda)
        py# = GetMeshMemblockVertexNormalY(msblk, inda)
        pz# = GetMeshMemblockVertexNormalZ(msblk, inda)
        SetMeshMemblockVertexNormal(msblk, inda, px# + Nx#, py# + Ny#, pz# + Nz#)
         
        px# = GetMeshMemblockVertexNormalX(msblk, indb)
        py# = GetMeshMemblockVertexNormalY(msblk, indb)
        pz# = GetMeshMemblockVertexNormalZ(msblk, indb)
        SetMeshMemblockVertexNormal(msblk, indb, px# + Nx#, py# + Ny#, pz# + Nz#)
 
        px# = GetMeshMemblockVertexNormalX(msblk, indc)
        py# = GetMeshMemblockVertexNormalY(msblk, indc)
        pz# = GetMeshMemblockVertexNormalZ(msblk, indc)
        SetMeshMemblockVertexNormal(msblk, indc, px# + Nx#, py# + Ny#, pz# + Nz#)
 
        // Move the offset to the next triangle
        Offset = Offset + 12
 
    next it
         
    // Normalise all the vertex normals 
    for ind =0 to NumVertices-1
        // Get the normal
        nx# = GetMeshMemblockVertexNormalX(msblk, ind)
        ny# = GetMeshMemblockVertexNormalY(msblk, ind)
        nz# = GetMeshMemblockVertexNormalZ(msblk, ind)
 
        // normalise the normal
        len# = sqrt((nx#*nx#) + (ny#*ny#) + (nz#*nz#))
        nx# = nx#/len#
        ny# = ny#/len#
        nz# = nz#/len#
         
        // Set the new normal
        SetMeshMemblockVertexNormal( msblk, ind, nx#, ny#, nz# )
    next ind
 
endfunction

+ Code Snippet

function GenerateHeightmapNormals(msblk as integer)
 
 
    // Start by getting the relevant info
    NumVertices = GetMemblockInt( msblk, 0)
    NumIndices = GetMemblockInt( msblk, 4)
    NumTriangles = NumIndices/3  
    //NumAttributes = GetMemblockInt( msblk, 8)     // number if attributes ( should be 3 for a heightmap)
    //VertexSize = GetMemblockInt( msblk, 12)       // Bytes per vertex  (should be 32)
    //VertexOffset = GetMemblockInt( msblk, 16 )    // (Normally 60)
    IndicesOffset = GetMemblockInt( msblk, 20 )
 
    // How to generate surface normals the proper way
    //1)    Normal vectors must all be zero before start!!
    //2)    Iterate through the triangles and get the normal on each triangle then ADD that to each of the 3 vertices normal. Other triangles will add to these values if they share indices.
    //3)    Loop through all the vertices and normalize the normals
 
    // Fill all the vertex normals with 0,0,0
    for ind =0 to NumVertices-1
        SetMeshMemblockVertexNormal(msblk, ind, 0 , 0 , 0)
    next ind
     
     
 
    // loop through all the triangles
    Offset = IndicesOffset
    for it = 0 to NumTriangles-1
     
        // Get the indices 
        inda = GetMemblockInt(msblk, Offset)
        indb = GetMemblockInt(msblk, Offset+4)
        indc = GetMemblockInt(msblk, Offset+8)
     
        // Get the first vector (P2-P1)
        Vx# = GetMeshMemblockVertexX(msblk,indb) - GetMeshMemblockVertexX(msblk,inda)
        Vy# = GetMeshMemblockVertexY(msblk,indb) - GetMeshMemblockVertexY(msblk,inda)
        Vz# = GetMeshMemblockVertexZ(msblk,indb) - GetMeshMemblockVertexZ(msblk,inda)
 
        // Get the second vector (P3-P1)
        Wx# = GetMeshMemblockVertexX(msblk,indc) - GetMeshMemblockVertexX(msblk,indb)
        Wy# = GetMeshMemblockVertexY(msblk,indc) - GetMeshMemblockVertexY(msblk,indb)
        Wz# = GetMeshMemblockVertexZ(msblk,indc) - GetMeshMemblockVertexZ(msblk,indb)
     
        // Cross product them to get the normal
        Nx#=(Vz#*Wy#)-(Vy#*Wz#)
        Ny#=(Vx#*Wz#)-(Vz#*Wx#)
        Nz#=(Vy#*Wx#)-(Vx#*Wy#)
 
        // add the calculated normal to each of the vertices in this triangle
        px# = GetMeshMemblockVertexNormalX(msblk, inda)
        py# = GetMeshMemblockVertexNormalY(msblk, inda)
        pz# = GetMeshMemblockVertexNormalZ(msblk, inda)
        SetMeshMemblockVertexNormal(msblk, inda, px# + Nx#, py# + Ny#, pz# + Nz#)
         
        px# = GetMeshMemblockVertexNormalX(msblk, indb)
        py# = GetMeshMemblockVertexNormalY(msblk, indb)
        pz# = GetMeshMemblockVertexNormalZ(msblk, indb)
        SetMeshMemblockVertexNormal(msblk, indb, px# + Nx#, py# + Ny#, pz# + Nz#)
 
        px# = GetMeshMemblockVertexNormalX(msblk, indc)
        py# = GetMeshMemblockVertexNormalY(msblk, indc)
        pz# = GetMeshMemblockVertexNormalZ(msblk, indc)
        SetMeshMemblockVertexNormal(msblk, indc, px# + Nx#, py# + Ny#, pz# + Nz#)
 
        // Move the offset to the next triangle
        Offset = Offset + 12
 
    next it
         
    // Normalise all the vertex normals 
    for ind =0 to NumVertices-1
        // Get the normal
        nx# = GetMeshMemblockVertexNormalX(msblk, ind)
        ny# = GetMeshMemblockVertexNormalY(msblk, ind)
        nz# = GetMeshMemblockVertexNormalZ(msblk, ind)
 
        // normalise the normal
        len# = sqrt((nx#*nx#) + (ny#*ny#) + (nz#*nz#))
        nx# = nx#/len#
        ny# = ny#/len#
        nz# = nz#/len#
         
        // Set the new normal
        SetMeshMemblockVertexNormal( msblk, ind, nx#, ny#, nz# )
    next ind
 
endfunction

Back to top

Profile PM

Santman

13

Years of Service

User Offline

Joined: 15th Sep 2011

Location: Inverness

Posted: 27th Jun 2018 20:22

Link

Ok so I just tried that last code sample.....something's not quite right! Lol.

Attachments

Login to view attachments

Back to top

Profile PM

Bengismo

7

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 27th Jun 2018 20:45

Link

You have used an AppGameKit heightmap object and attempted to generate heightmap normals for that by the looks of it.

The order of indices is different as its actually a triangle strip...not indexed triangles.

Hence I wrote in the code
// The mesh must be an indexed triangle mesh - see alternate function for non indexed

The alternate function alternates normal directions for every other vertex as strips are wound differently. (Clockwise...anticlockwise, clockwise, anticlockwise..etc....)

Back to top

Profile PM

Santman

13

Years of Service

User Offline

Joined: 15th Sep 2011

Location: Inverness

Posted: 27th Jun 2018 20:59

Link

Yup, that's exactly what it is....but I can;t make head nor tail of what the second function is meant to do - this just stores the index values in an array??

Back to top

Profile PM

puzzler2018

User Banned

Posted: 27th Jun 2018 21:00 Edited at: 27th Jun 2018 21:02

Link

You know so much so great Bengismo - joined 2017 but unsure how long you really been programming in agk - this maybe 10 years...I take my hat off to you

It would be nice to know for my own sanity how long you have been programming in AppGameKit to achieve all your knowledge

Back to top

Profile

Santman

13

Years of Service

User Offline

Joined: 15th Sep 2011

Location: Inverness

Posted: 27th Jun 2018 21:19

Link

So I think the easiest thing might be to just abandon the AppGameKit height map and create a blank, empty mesh to work from and try that......

Back to top

Profile PM

puzzler2018

User Banned

Posted: 27th Jun 2018 21:22

Link

We dont know how the Createoobjectfromheightmap is generally engineered by Paul

So starting from a blank canvas maybe a good thing - cause we can have total control on everything thats going on with it

Ooops sorry for jibba jabbing

Back to top

Profile

puzzler2018

User Banned

Posted: 27th Jun 2018 21:24

Link

Back to top

Profile

Bengismo

7

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 27th Jun 2018 21:25 Edited at: 27th Jun 2018 21:47

Link

No...no sorry.....it was my mistake....

I thought id posted both versions of the function above but i hadnt!! DOH!

I created
CreateHeightmapNormals() for meshes id made myself (As i use triangle lists)
CreateHeightmapNormalsAlt() for AGK's heightmaps (as they use Triangle Strips)

So...if you use AGK's created heightmap objects (created with CreateObjectFromHeightMap()) then it creates a triangle strip in the mesh.

The function for creating normals for that is very similar but subtley different

// Generate normals for the Triangle strip based mesh made by agk's GetObjectFromHeightmap()
// msblk is a meshmemblock which holds the mesh you want normals calculating for
// The mesh must be an triangle strip based mesh 
function GenerateHeightmapNormalsAlt(msblk as integer)

// Start by getting the relevant info
	NumVertices = GetMemblockInt( msblk, 0)
	NumIndices = GetMemblockInt( msblk, 4)
	NumTriangles = NumIndices-2  
	//NumAttributes = GetMemblockInt( msblk, 8) 	// number if attributes ( should be 3 for a heightmap)
	//VertexSize = GetMemblockInt( msblk, 12)		// Bytes per vertex  (should be 32)
	//VertexOffset = GetMemblockInt( msblk, 16 ) 	// (Normally 60)
	IndicesOffset = GetMemblockInt( msblk, 20 )

// How to generate surface normals the proper way
	//1)	Normal vectors must all be zero before start!!
	//2)	Iterate through the triangles and get the normal on each triangle then ADD that to each of the 3 vertices normal. Other triangles will add to these values if they share indices.
	//3)	Loop through all the vertices and normalize the normals

// Fill all the vertex normals with 0,0,0
	for ind =0 to NumVertices-1
		SetMeshMemblockVertexNormal(msblk, ind, 0 , 0 , 0)
	next ind

// loop through all the triangles
	Offset = IndicesOffset
	dir# = 1.0
	for it = 0 to NumTriangles-1
	
		// Get the indices 
		inda = GetMemblockInt(msblk, Offset)
		indb = GetMemblockInt(msblk, Offset+4)
		indc = GetMemblockInt(msblk, Offset+8)
	
		// Get the first vector (P2-P1)
		Vx# = GetMeshMemblockVertexX(msblk,indb) - GetMeshMemblockVertexX(msblk,inda)
		Vy# = GetMeshMemblockVertexY(msblk,indb) - GetMeshMemblockVertexY(msblk,inda)
		Vz# = GetMeshMemblockVertexZ(msblk,indb) - GetMeshMemblockVertexZ(msblk,inda)

// Get the second vector (P3-P1)
		Wx# = GetMeshMemblockVertexX(msblk,indc) - GetMeshMemblockVertexX(msblk,indb)
		Wy# = GetMeshMemblockVertexY(msblk,indc) - GetMeshMemblockVertexY(msblk,indb)
		Wz# = GetMeshMemblockVertexZ(msblk,indc) - GetMeshMemblockVertexZ(msblk,indb)
	
		// Cross product them to get the normal
		Nx#=(Vz#*Wy#)-(Vy#*Wz#)
		Ny#=(Vx#*Wz#)-(Vz#*Wx#)
		Nz#=(Vy#*Wx#)-(Vx#*Wy#)

Nx# = Nx#*dir#
		Ny# = Ny#*dir#
		Nz# = Nz#*dir#

// add the calculated normal to each of the vertices in this triangle
		px# = GetMeshMemblockVertexNormalX(msblk, inda)
		py# = GetMeshMemblockVertexNormalY(msblk, inda)
		pz# = GetMeshMemblockVertexNormalZ(msblk, inda)
		SetMeshMemblockVertexNormal(msblk, inda, px# + Nx#, py# + Ny#, pz# + Nz#)
		
		px# = GetMeshMemblockVertexNormalX(msblk, indb)
		py# = GetMeshMemblockVertexNormalY(msblk, indb)
		pz# = GetMeshMemblockVertexNormalZ(msblk, indb)
		SetMeshMemblockVertexNormal(msblk, indb, px# + Nx#, py# + Ny#, pz# + Nz#)

px# = GetMeshMemblockVertexNormalX(msblk, indc)
		py# = GetMeshMemblockVertexNormalY(msblk, indc)
		pz# = GetMeshMemblockVertexNormalZ(msblk, indc)
		SetMeshMemblockVertexNormal(msblk, indc, px# + Nx#, py# + Ny#, pz# + Nz#)

// Move the offset to the next triangle
		Offset = Offset + 4
		dir# = -dir#

next it
		
	// Normalise all the vertex normals 
	for ind =0 to NumVertices-1
		// Get the normal
		nx# = GetMeshMemblockVertexNormalX(msblk, ind)
		ny# = GetMeshMemblockVertexNormalY(msblk, ind)
		nz# = GetMeshMemblockVertexNormalZ(msblk, ind)

// normalise the normal
		len# = sqrt((nx#*nx#) + (ny#*ny#) + (nz#*nz#))
		nx# = nx#/len#
		ny# = ny#/len#
		nz# = nz#/len#
				
		// Set the new normal
		SetMeshMemblockVertexNormal( msblk, ind, nx#, ny#, nz# )
	next ind

endfunction

+ Code Snippet

// Generate normals for the Triangle strip based mesh made by agk's GetObjectFromHeightmap()
// msblk is a meshmemblock which holds the mesh you want normals calculating for
// The mesh must be an triangle strip based mesh 
function GenerateHeightmapNormalsAlt(msblk as integer)


	// Start by getting the relevant info
	NumVertices = GetMemblockInt( msblk, 0)
	NumIndices = GetMemblockInt( msblk, 4)
	NumTriangles = NumIndices-2  
	//NumAttributes = GetMemblockInt( msblk, 8) 	// number if attributes ( should be 3 for a heightmap)
	//VertexSize = GetMemblockInt( msblk, 12)		// Bytes per vertex  (should be 32)
	//VertexOffset = GetMemblockInt( msblk, 16 ) 	// (Normally 60)
	IndicesOffset = GetMemblockInt( msblk, 20 )

	// How to generate surface normals the proper way
	//1)	Normal vectors must all be zero before start!!
	//2)	Iterate through the triangles and get the normal on each triangle then ADD that to each of the 3 vertices normal. Other triangles will add to these values if they share indices.
	//3)	Loop through all the vertices and normalize the normals

	// Fill all the vertex normals with 0,0,0
	for ind =0 to NumVertices-1
		SetMeshMemblockVertexNormal(msblk, ind, 0 , 0 , 0)
	next ind
	
	

	// loop through all the triangles
	Offset = IndicesOffset
	dir# = 1.0
	for it = 0 to NumTriangles-1
	
		// Get the indices 
		inda = GetMemblockInt(msblk, Offset)
		indb = GetMemblockInt(msblk, Offset+4)
		indc = GetMemblockInt(msblk, Offset+8)
	
		// Get the first vector (P2-P1)
		Vx# = GetMeshMemblockVertexX(msblk,indb) - GetMeshMemblockVertexX(msblk,inda)
		Vy# = GetMeshMemblockVertexY(msblk,indb) - GetMeshMemblockVertexY(msblk,inda)
		Vz# = GetMeshMemblockVertexZ(msblk,indb) - GetMeshMemblockVertexZ(msblk,inda)

		// Get the second vector (P3-P1)
		Wx# = GetMeshMemblockVertexX(msblk,indc) - GetMeshMemblockVertexX(msblk,indb)
		Wy# = GetMeshMemblockVertexY(msblk,indc) - GetMeshMemblockVertexY(msblk,indb)
		Wz# = GetMeshMemblockVertexZ(msblk,indc) - GetMeshMemblockVertexZ(msblk,indb)
	
		// Cross product them to get the normal
		Nx#=(Vz#*Wy#)-(Vy#*Wz#)
		Ny#=(Vx#*Wz#)-(Vz#*Wx#)
		Nz#=(Vy#*Wx#)-(Vx#*Wy#)

		Nx# = Nx#*dir#
		Ny# = Ny#*dir#
		Nz# = Nz#*dir#


		// add the calculated normal to each of the vertices in this triangle
		px# = GetMeshMemblockVertexNormalX(msblk, inda)
		py# = GetMeshMemblockVertexNormalY(msblk, inda)
		pz# = GetMeshMemblockVertexNormalZ(msblk, inda)
		SetMeshMemblockVertexNormal(msblk, inda, px# + Nx#, py# + Ny#, pz# + Nz#)
		
		px# = GetMeshMemblockVertexNormalX(msblk, indb)
		py# = GetMeshMemblockVertexNormalY(msblk, indb)
		pz# = GetMeshMemblockVertexNormalZ(msblk, indb)
		SetMeshMemblockVertexNormal(msblk, indb, px# + Nx#, py# + Ny#, pz# + Nz#)

		px# = GetMeshMemblockVertexNormalX(msblk, indc)
		py# = GetMeshMemblockVertexNormalY(msblk, indc)
		pz# = GetMeshMemblockVertexNormalZ(msblk, indc)
		SetMeshMemblockVertexNormal(msblk, indc, px# + Nx#, py# + Ny#, pz# + Nz#)

		// Move the offset to the next triangle
		Offset = Offset + 4
		dir# = -dir#

	next it
		
	// Normalise all the vertex normals 
	for ind =0 to NumVertices-1
		// Get the normal
		nx# = GetMeshMemblockVertexNormalX(msblk, ind)
		ny# = GetMeshMemblockVertexNormalY(msblk, ind)
		nz# = GetMeshMemblockVertexNormalZ(msblk, ind)

		// normalise the normal
		len# = sqrt((nx#*nx#) + (ny#*ny#) + (nz#*nz#))
		nx# = nx#/len#
		ny# = ny#/len#
		nz# = nz#/len#
				
		// Set the new normal
		SetMeshMemblockVertexNormal( msblk, ind, nx#, ny#, nz# )
	next ind

endfunction

I have literally lost track of all the functions i made for this

Ive functions for creating a terrain as a trianglestrip from an image or for creating a trangle list from an image etc.... Way too many to keep track of as I havent touched them myself for months
Theres one for making a terrain from a 16bit greyscale png somewhere too if more Y resolution is wanted

Back to top

Profile PM

Bengismo

7

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 27th Jun 2018 21:53

Link

Puzler wrote: "It would be nice to know for my own sanity how long you have been programming in AppGameKit "

I've had AppGameKit since november last year... just do muck about with it for fun.

Back to top

Profile PM

Santman

13

Years of Service

User Offline

Joined: 15th Sep 2011

Location: Inverness

Posted: 27th Jun 2018 22:03

Link

Bengismo.....you're an absolute genuius, works like a charm. I have literally spent hours and hours trying to sort that!

Attachments

Login to view attachments

Back to top

Profile PM

puzzler2018

User Banned

Posted: 27th Jun 2018 22:07

Link

Exactly.... But Why is he a Genious though - are you a hard games programmer for a company or something

Tell us a bit about yourself -- Where did you come from to learn this so quickly Bengismo!!!!!???

Back to top

Profile

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 29th Jun 2018 07:55 Edited at: 29th Jun 2018 08:00

Link

Quote: "And.... which two vectors you use to calculate the normal does matter! - as it will reverse the normal if you choose the wrong ones."

I thought the normal only reversed if you reversed the order of the vertices?

I just wrote up a quick example to test it myself. Though it still really depends on the direction you form your vectors, I see what you were saying. I think maybe it was myself this time that didn't explain very well what I meant. Generally, I've just always relied on using AB and AC as my two vectors. BC in place of one of those would still give the same result. As long as the vectors created follow a clockwise pattern it'll be the same. But reversing one of them, like B to A instead, then you start flipping the normal.

type vector3D
	x as float
	y as float
	z as float
Endtype

A as vector3D
B as vector3D
C as vector3D

AB as vector3D 
AC as vector3D
BC as vector3D 
BA as vector3D 
CA as vector3D 
CB as vector3D

A = makeVector(random(0, 50), random(0, 50), random(0, 50))
B = makeVector(random(0, 50), random(0, 50), random(0, 50))
C = makeVector(random(0, 50), random(0, 50), random(0, 50))

AB = subtractVector(B, A)
AC = subtractVector(C, A)
BC = subtractVector(C, B)
BA = subtractVector(A, B)
CA = subtractVector(A, C)
CB = subtractVector(B, C)

do
	
	printVector(A)
	printVector(B)
	printVector(C)
    print("")
    
    printVector(normalizeVector(crossProductVector(AB,AC)))
    printVector(normalizeVector(crossProductVector(AB,BC)))
    printVector(normalizeVector(crossProductVector(BA,BC)))
    `printVector(normalizeVector(crossProductVector(AB,CB)))
    
    
    
    
    
    `Print( ScreenFPS() )
    Sync()
loop

function normalizeVector(A as vector3D)
	mag# = sqrt(A.x^2 + A.y^2 + A.z^2)
	
	A.x = A.x / mag#
	A.y = A.y / mag#
	A.z = A.z / mag#
endfunction A

function crossProductVector(A as vector3D, B as vector3D)
	C as vector3D
	C.x = (A.y * B.z) - (A.z * B.y)
	C.y = (A.z * B.x) - (A.x * B.z)
	C.z = (A.x * B.y) - (A.y * B.x)
endfunction C

function subtractVector(A as vector3D, B as vector3D)
	A.x = A.x - B.x
	A.y = A.y - B.y
	A.z = A.z - B.z
endfunction A

function makevector(x as float, y as float, z as float)
	v as vector3D
	v.x = x
	v.y = y
	v.z = z
endfunction v

function printVector(v as vector3D)
	print("X: "+str(v.x)+", Y: "+str(v.y)+", Z: "+str(v.z))
endfunction

+ Code Snippet


type vector3D
	x as float
	y as float
	z as float
Endtype

A as vector3D
B as vector3D
C as vector3D

AB as vector3D 
AC as vector3D
BC as vector3D 
BA as vector3D 
CA as vector3D 
CB as vector3D  

A = makeVector(random(0, 50), random(0, 50), random(0, 50))
B = makeVector(random(0, 50), random(0, 50), random(0, 50))
C = makeVector(random(0, 50), random(0, 50), random(0, 50))




AB = subtractVector(B, A)
AC = subtractVector(C, A)
BC = subtractVector(C, B)
BA = subtractVector(A, B)
CA = subtractVector(A, C)
CB = subtractVector(B, C)




do
	
	printVector(A)
	printVector(B)
	printVector(C)
    print("")
    
    printVector(normalizeVector(crossProductVector(AB,AC)))
    printVector(normalizeVector(crossProductVector(AB,BC)))
    printVector(normalizeVector(crossProductVector(BA,BC)))
    `printVector(normalizeVector(crossProductVector(AB,CB)))
    
    
    
    
    
    `Print( ScreenFPS() )
    Sync()
loop


function normalizeVector(A as vector3D)
	mag# = sqrt(A.x^2 + A.y^2 + A.z^2)
	
	A.x = A.x / mag#
	A.y = A.y / mag#
	A.z = A.z / mag#
endfunction A


function crossProductVector(A as vector3D, B as vector3D)
	C as vector3D
	C.x = (A.y * B.z) - (A.z * B.y)
	C.y = (A.z * B.x) - (A.x * B.z)
	C.z = (A.x * B.y) - (A.y * B.x)
endfunction C



function subtractVector(A as vector3D, B as vector3D)
	A.x = A.x - B.x
	A.y = A.y - B.y
	A.z = A.z - B.z
endfunction A



function makevector(x as float, y as float, z as float)
	v as vector3D
	v.x = x
	v.y = y
	v.z = z
endfunction v


function printVector(v as vector3D)
	print("X: "+str(v.x)+", Y: "+str(v.y)+", Z: "+str(v.z))
endfunction

lol, sounds like Ben has some fans. He might be somewhat new to AppGameKit but I'm sure he's used other languages before that.

Tiled TMX Importer V.2
XML Parser V.2
Base64 Encoder/Decoder
Purple Token - Free online hi-score database
Legend of Zelda

"I like offending people, because I think people who get offended should be offended." - Linus Torvalds

Back to top

Profile PM Email Website

Bengismo

7

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 29th Jun 2018 09:05 Edited at: 29th Jun 2018 09:15

Link

Phaelax wrote: "I thought the normal only reversed if you reversed the order of the vertices?"

In a triangle strip every second triangle has its vertices reversed. (Clockwise,anticlockwise,clockwise)

If its a heightmap made by AGK's CreateMeshFromHeightmap function then its a triangle strip.

Your right for a triangle LIST that you can just take consistant vector so AB and AC would be fine but thats only if its a list of triangles or non indexed triangles.

If its a strip and you just use consistent vectors then you end up with the problem santman had above where every other normal is reversed and the render looks patchy and not correct. ^^ That above is a good example of how it goes wrong.

I'm not clever at all....I make more mistakes than most people and i only know some things because I already tried them and got them really wrong myself.

There's a lot to be learned about 3D and mesh memblocks by just reading the OpenGL tutorials online which explain all of these sorts of issues much better than I ever could. Most of the algorithms for creating meshes and normals were written by others way before I used them.

Back to top

Profile PM

Phaelax

DBPro Master

21

Years of Service

User Offline

Joined: 16th Apr 2003

Location: Metropia

Posted: 2nd Jul 2018 20:01

Link

Wasn't familiar with "strips" like that. I've kinda always worked with a polygon soup (a list). Is this a newer way of building meshes? Or am I just that out of the loop?

Tiled TMX Importer V.2
XML Parser V.2
Base64 Encoder/Decoder
Purple Token - Free online hi-score database
Legend of Zelda

"I like offending people, because I think people who get offended should be offended." - Linus Torvalds

Back to top

Profile PM Email Website

Santman

13

Years of Service

User Offline

Joined: 15th Sep 2011

Location: Inverness

Posted: 4th Jul 2018 21:45

Link

Bengisimo, can you explain this?

Create a blank 256*256 bitmap, then use AppGameKit to create a terrain from it. The create a memblock from that object, and then try to create another object from that memblock - you'll get an error saying the indices must be divisible by 3 (there should be 65,536 vertices, 131,068 indices - which is 43,689.33 recurring). HOWEVER....we can save that memblock, reload it, and set the object mesh based on the memblock contents.

So my thought is...the terrain system has a bug that calcs the vertice count wrong, but memblocks don;t use the vertex or indice count to set a mesh??

Back to top

Profile PM

puzzler2018

User Banned

Posted: 4th Jul 2018 22:03

Link

Possibly investigate after heightmap generation by getting its indices value print(GetMemblockInt(obj ,4)) and see what its returning after creating the heightmap to see if its a bug or not.. Maybe there is more to heightmap memblock generations then we think

But im sure you have done this already

Back to top

Profile

Bengismo

7

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 4th Jul 2018 22:16 Edited at: 4th Jul 2018 22:31

Link

Firstly....AGK only allows you to create objects from scratch using triangle LISTS....it does allow you to manipulate and update Triangle strip based objects

The difference between triangle strips and triangle lists

TRIANGLE LIST: If your image is 256 x 256 you get....
65536 Vertices
130050 Triangles
390150 Indices (Divide by 3 and you get the number triangles above)

TRIANGLE STRIP: If your image is 256 x 256 you get....
65536 Vertices
131066 Triangles
131068 Indices (in a strip the number triangles is always 2 less then the number of indices)

These numbers are correct and make sense looking at the geometry numbers

If you attempt to create a new object from a memblock with a triangle strip in it ....it says NOOOOO!

Its easy enough to just copy a Triangle strip object and then set the new values in this mesh via a memblock....You just cant create one from scratch though and have to go via the CreateObjectfromHeightmap function or copyObject etc...

Its no bug really...we are just meant to create Triangle Lists for brand new objects - theres nothing in the docs about allowing us to create strip based objects even though the heightmaps use them. It would be nice to create strips too but you can work around it fairly easy.

It might be a feature request for paul I guess.... but it never bothered me too much to complain.

EDITED to correct spelling...

Back to top

Profile PM

Sorry your browser is not supported!

AppGameKit Classic Chat / Help calculating normlas on a mesh

Attachments

Attachments