3d plane mesh created from memblock is colored pink

Author

Message

spenland

4

Years of Service

User Offline

Joined: 14th Nov 2019

Location:

Posted: 15th Nov 2019 18:51

Link

I created a plane mesh with the diamond-square algorithm. The mesh is created correctly but the light doesn't look right on it and also the color is all pink, even though I assigned colors to the vertices in the memblock based on the Y value of the vertex.

I didn't know how to setup nx, ny, nz (normals) on the memblock so I just set them all to (0, 1, 0) which allows me to see the mesh...

Do I need to get into Shaders or something to make my plane look like a low-poly mesh where the surface normals are pointing outward from the surface perpendicularly to give the plane mesh a low poly look.

Please help! Not sure how active these forms are.

Attachments

Login to view attachments

Back to top

Profile PM

spenland

4

Years of Service

User Offline

Joined: 14th Nov 2019

Location:

Posted: 15th Nov 2019 20:30

Link

Okay, figured out the coloring problem. I had 0x101010FF as the color (I saw the FF somewhere and thought it was needed) so I removed the FF at the end and now have valid colors.

My question now is, how do I make the mesh cast receive shadows or look like a low poly terrain. Below does not look like I want.

Attachments

Login to view attachments

Back to top

Profile PM

Santman

12

Years of Service

User Offline

Joined: 15th Sep 2011

Location: Inverness

Posted: 15th Nov 2019 20:45

Link

Normals are the issue. What you've done is essentially tell the shader the entire surface is dead flat. Changing mesh vertices heights wont set the normals correctly.

Someone shared an algorithm with me before to auto calculate normals, but not sure it will work on your mesh.

Back to top

Profile PM

spenland

4

Years of Service

User Offline

Joined: 14th Nov 2019

Location:

Posted: 15th Nov 2019 20:55

Link

Can you explain vertex normals? A vertex makes sense, a X, Y, Z position in space. The normal in the memblock also has an X, Y, Z... how does that work? It seems like you'd only have one "normal X,Y,Z position" for each triangle and it would be in the center of the triangle pushed forward outwards. Having x,y,z normals for every vertex is confusing me.

Back to top

Profile PM

janbo

15

Years of Service

User Offline

Joined: 10th Nov 2008

Location: Germany

Posted: 15th Nov 2019 22:25 Edited at: 15th Nov 2019 22:37

Link

How did you create your plane mesh ?
All by yourself or by using the CreateObjectFromHeightMap() command ?

To get hard edges(the low poly look) you need to create a mesh without indices/triangles which share vertices.
Each vertex needs to have their own normal data.
OR you use a shader I made some time ago: Flat shading

You can calculate the normal of Vertex A by calculating the cross product of the Vectors between the triangle edge B-A and C-A.
There are vector commands for that.

If you did it by yourself i.e creating a mesh with the right size, setting the vertex count, index count etc, adding vertex attributes and vertex and ~~index~~ data then...
did you add the vertex data manually or with for example SetMeshMemblockVertexColor() ?
Because the color attribute is a little bit different than the others(normalize flag and maybe its AGBR not sure)
To make some self advertising If you got my shader pack you also have the code to generate Softnormals and Hard edges as a byproduct

Back to top

Profile PM Email Website

Bengismo

6

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 16th Nov 2019 00:11 Edited at: 16th Nov 2019 01:24

Link

Santman and Janbo are completely correct and have given great answers above.

in order for it to look right you need correct normals. You are right that the normal is just a direction outwards from the face of every triangle. You will have to set them for the lighting to look correct.

Janbo is (of course) correct when he says you cannot share vertices with flat shading and the normal is then the same for all 3 vertices on the triangle

A couple of examples

Each triangle on the left has the same normal for each of its 3 vertices which is directly away from the triangles surface.
You cant share vertices between triangles using this method..(well unless two adjacent triangles just happen to have the same normals)

On the right is an alternative solution where you calculate the normal for a whole square of your terrain and set the normal across all of the 4 vertices which gives a nice retro look too and allows you to share 2 of the vertices.

No matter what you choose you will need to set the normals which means getting the cross product of any of the two sides of each triangle and ensuring that you have enough vertices in your memblock to store all the unique positions and normals.

You make the mesh cast and receive shadows with SetObjectCastShadow( objID, 1 ) and SetObjectReceiveShadow( objID, 1 )....also set your shadow mapping mode too.

EDITED: to correct image link

Back to top

Profile PM

spenland

4

Years of Service

User Offline

Joined: 14th Nov 2019

Location:

Posted: 16th Nov 2019 00:25

Link

I'm making the plane using the memblock to mesh function.

This is what I worked up:

From that I wrote:

// Create terrian polygons
	triangles as Triangle3D[0]
	
	// Needed parts
	a as Vector3
	b as Vector3
	c as Vector3
	tri as Triangle3D
	
	// Top triangles
	for row = 0 to array_grid.length - 1
		
		offset = row + 1
		
		for col = 0 to array_grid.length - 1
			
			// -------------------------------------------------------
			// Point A of Triangle
			//--------------------
			a.x = offset * terrian_spread
			a.y = array_grid[offset, col + 1]
			a.z = (col + 1) * terrian_spread
			// -------------------------------------------------------
			
			// -------------------------------------------------------
			// Point B of Triangle
			//--------------------
			b.x = row * terrian_spread
			b.y = array_grid[row, col + 1]
			b.z = (col + 1) * terrian_spread
			// -------------------------------------------------------
			
			// -------------------------------------------------------
			// Point C of Triangle
			//--------------------
			c.x = row * terrian_spread
			c.y = array_grid[row, col]
			c.z = col * terrian_spread
			// -------------------------------------------------------
			
			// Increase triangles for new triangle
			triangles.length = triangles.length + 1
			
			// Create new triangle
			tri.a = a
			tri.b = b
			tri.c = c
			
			// Add triangle
			triangles[triangles.length - 1] = tri
			
		next col
		
	next row
	
	// Bottom vertices
	for col = 0 to array_grid.length - 1
		
		offset = col + 1
		
		for row = 0 to array_grid.length - 1
			
			// -------------------------------------------------------
			// Point A of Triangle
			//--------------------
			a.x = row * terrian_spread
			a.y = array_grid[row, col]
			a.z = col * terrian_spread
			// -------------------------------------------------------
			
			// -------------------------------------------------------
			// Point B of Triangle
			//--------------------
			b.x = (row + 1) * terrian_spread
			b.y = array_grid[row + 1, col]
			b.z = col * terrian_spread
			// -------------------------------------------------------
			
			// -------------------------------------------------------
			// Point C of Triangle
			//--------------------
			c.x = (row + 1) * terrian_spread
			c.y = array_grid[row + 1, offset]
			c.z = offset * terrian_spread
			// -------------------------------------------------------
			
			// Increase triangles for new triangle
			triangles.length = triangles.length + 1
			
			// Create new triangle
			tri.a = a
			tri.b = b
			tri.c = c
			
			// Add triangle
			triangles[triangles.length - 1] = tri
			
		next row
		
	next col

+ Code Snippet

// Create terrian polygons
	triangles as Triangle3D[0]
	
	// Needed parts
	a as Vector3
	b as Vector3
	c as Vector3
	tri as Triangle3D
	
	// Top triangles
	for row = 0 to array_grid.length - 1
		
		offset = row + 1
		
		for col = 0 to array_grid.length - 1
			
			// -------------------------------------------------------
			// Point A of Triangle
			//--------------------
			a.x = offset * terrian_spread
			a.y = array_grid[offset, col + 1]
			a.z = (col + 1) * terrian_spread
			// -------------------------------------------------------
			
			// -------------------------------------------------------
			// Point B of Triangle
			//--------------------
			b.x = row * terrian_spread
			b.y = array_grid[row, col + 1]
			b.z = (col + 1) * terrian_spread
			// -------------------------------------------------------
			
			// -------------------------------------------------------
			// Point C of Triangle
			//--------------------
			c.x = row * terrian_spread
			c.y = array_grid[row, col]
			c.z = col * terrian_spread
			// -------------------------------------------------------
			
			// Increase triangles for new triangle
			triangles.length = triangles.length + 1
			
			// Create new triangle
			tri.a = a
			tri.b = b
			tri.c = c
			
			// Add triangle
			triangles[triangles.length - 1] = tri
			
		next col
		
	next row
	
	// Bottom vertices
	for col = 0 to array_grid.length - 1
		
		offset = col + 1
		
		for row = 0 to array_grid.length - 1
			
			// -------------------------------------------------------
			// Point A of Triangle
			//--------------------
			a.x = row * terrian_spread
			a.y = array_grid[row, col]
			a.z = col * terrian_spread
			// -------------------------------------------------------
			
			// -------------------------------------------------------
			// Point B of Triangle
			//--------------------
			b.x = (row + 1) * terrian_spread
			b.y = array_grid[row + 1, col]
			b.z = col * terrian_spread
			// -------------------------------------------------------
			
			// -------------------------------------------------------
			// Point C of Triangle
			//--------------------
			c.x = (row + 1) * terrian_spread
			c.y = array_grid[row + 1, offset]
			c.z = offset * terrian_spread
			// -------------------------------------------------------
			
			// Increase triangles for new triangle
			triangles.length = triangles.length + 1
			
			// Create new triangle
			tri.a = a
			tri.b = b
			tri.c = c
			
			// Add triangle
			triangles[triangles.length - 1] = tri
			
		next row
		
	next col

Then with that array of Triangles3D, I do this:

// Colors
	c_snow = 0xf7f7f7
	c_mountain = 0xbba45d
	c_light_grass = 0x88dd8f
	c_dark_grass = 0x408746
	c_dirt = 0x736336
	
	// Allocate space for data
	memblock = CreateMemblock(100000000)
	
	// Set amount of vertices in mesh to be created
	SetMemblockInt(memblock, 0, triangles.length * 3)
	
	// All polygons
	SetMemblockInt(memblock, 4, 0)
	
	// All vertices have 3 attributes
	// -- pos, normal, color
	SetMemblockByte(memblock, 8, 3)
	
	// Memory for each vertex
	// -- (x,y,z  nx,ny,nz  color) * 4
	SetMemblockByte(memblock, 12, 28)
	
	// Offset of vertex data
	SetMemblockInt(memblock, 16, 64)
	
	// Indices offset - none, so 0
	SetMemblockInt(memblock, 20, 0)
	
	// Refer to online docs (NOT SURE WHAT THIS DOES)
	SetMemBlockInt(memblock,24,0x0C000300)
	SetMemblockString(memblock,28,"position") 
	SetMemblockInt(memblock,40,0x08000300)
	SetMemblockString(memblock,44,"normal")
	SetMemblockInt(memblock,52,0x08010401)
	SetMemblockString(memblock,56,"color")
	
	// Allocate color array
	colors as integer[0]
	
	// Color polygon based on height
	for i = 0 to triangles.length - 1
	
		// Get triangle points
		tri_a as Vector3 
		tri_a = triangles[i].a
		
		tri_b as Vector3 
		tri_b = triangles[i].b
		
		tri_c as Vector3 
		tri_c = triangles[i].c
		
		// Increase colors array by one
		colors.length = colors.length + 1
		
		// Set min to max
		min = max_height
		
		// Get lowest point on polygon
		if tri_a.y < min
			min = tri_a.y
		endif
		
		if tri_b.y < min
			min = tri_b.y
		endif
		
		if tri_c.y < min
			min = tri_c.y
		endif
		
		// Determine color for min polygon height
		if min > max_height * 0.85
			
			colors[colors.length - 1] = c_snow
		
		elseif min > max_height * 0.75
			
			colors[colors.length - 1] = c_mountain
			
		elseif min > max_height * 0.35
			
			colors[colors.length - 1] = c_light_grass
			
		elseif min > max_height * 0.15
			
			colors[colors.length - 1] = c_dark_grass
			
		else
			
			colors[colors.length - 1] = c_dirt
			
		endif
		
				
	next i
		
	// Add all vertices to vertices array
	offset = 0
	offset_inc = 28 // 28 parts of each vertex
	
	for i = 0 to triangles.length - 1
		
		// Get triangle
		tri as Triangle3D
		tri = triangles[i]
		
		// Get points on triangle
		a as Vector3
		a = tri.a
		
		b as Vector3
		b = tri.b
		
		c as Vector3
		c = tri.c
		
		// Add vertex A
		SetMemblockFloat(memblock, 64 + offset, a.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, a.y)						// y
        SetMemblockFloat(memblock, 72 + offset, a.z)						// z
        
       SetMemblockFloat(memblock, 76 + offset, 1) 						// nx ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 80 + offset, 1) 						// ny ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 84 + offset, 1)						// nz ---- THESE VALUES I don't know how to get
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex B
		SetMemblockFloat(memblock, 64 + offset, b.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, b.y)						// y
        SetMemblockFloat(memblock, 72 + offset, b.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, 1) 						// nx ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 80 + offset, 1) 						// ny ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 84 + offset, 1)						// nz ---- THESE VALUES I don't know how to get
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex C
		SetMemblockFloat(memblock, 64 + offset, c.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, c.y)						// y
        SetMemblockFloat(memblock, 72 + offset, c.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, 1) 						// nx ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 80 + offset, 1) 						// ny ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 84 + offset, 1)						// nz ---- THESE VALUES I don't know how to get
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
	
	next i

+ Code Snippet

// Colors
	c_snow = 0xf7f7f7
	c_mountain = 0xbba45d
	c_light_grass = 0x88dd8f
	c_dark_grass = 0x408746
	c_dirt = 0x736336
	
	// Allocate space for data
	memblock = CreateMemblock(100000000)
	
	// Set amount of vertices in mesh to be created
	SetMemblockInt(memblock, 0, triangles.length * 3)
	
	// All polygons
	SetMemblockInt(memblock, 4, 0)
	
	// All vertices have 3 attributes
	// -- pos, normal, color
	SetMemblockByte(memblock, 8, 3)
	
	// Memory for each vertex
	// -- (x,y,z  nx,ny,nz  color) * 4
	SetMemblockByte(memblock, 12, 28)
	
	// Offset of vertex data
	SetMemblockInt(memblock, 16, 64)
	
	// Indices offset - none, so 0
	SetMemblockInt(memblock, 20, 0)
	
	// Refer to online docs (NOT SURE WHAT THIS DOES)
	SetMemBlockInt(memblock,24,0x0C000300)
	SetMemblockString(memblock,28,"position") 
	SetMemblockInt(memblock,40,0x08000300)
	SetMemblockString(memblock,44,"normal")
	SetMemblockInt(memblock,52,0x08010401)
	SetMemblockString(memblock,56,"color")
	
	// Allocate color array
	colors as integer[0]
	
	// Color polygon based on height
	for i = 0 to triangles.length - 1
	
		// Get triangle points
		tri_a as Vector3 
		tri_a = triangles[i].a
		
		tri_b as Vector3 
		tri_b = triangles[i].b
		
		tri_c as Vector3 
		tri_c = triangles[i].c
		
		// Increase colors array by one
		colors.length = colors.length + 1
		
		// Set min to max
		min = max_height
		
		// Get lowest point on polygon
		if tri_a.y < min
			min = tri_a.y
		endif
		
		if tri_b.y < min
			min = tri_b.y
		endif
		
		if tri_c.y < min
			min = tri_c.y
		endif
		
		// Determine color for min polygon height
		if min > max_height * 0.85
			
			colors[colors.length - 1] = c_snow
		
		elseif min > max_height * 0.75
			
			colors[colors.length - 1] = c_mountain
			
		elseif min > max_height * 0.35
			
			colors[colors.length - 1] = c_light_grass
			
		elseif min > max_height * 0.15
			
			colors[colors.length - 1] = c_dark_grass
			
		else
			
			colors[colors.length - 1] = c_dirt
			
		endif
		
				
	next i
		
	// Add all vertices to vertices array
	offset = 0
	offset_inc = 28 // 28 parts of each vertex
	
	for i = 0 to triangles.length - 1
		
		// Get triangle
		tri as Triangle3D
		tri = triangles[i]
		
		// Get points on triangle
		a as Vector3
		a = tri.a
		
		b as Vector3
		b = tri.b
		
		c as Vector3
		c = tri.c
		
		// Add vertex A
		SetMemblockFloat(memblock, 64 + offset, a.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, a.y)						// y
        SetMemblockFloat(memblock, 72 + offset, a.z)						// z
        
       SetMemblockFloat(memblock, 76 + offset, 1) 						// nx ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 80 + offset, 1) 						// ny ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 84 + offset, 1)						// nz ---- THESE VALUES I don't know how to get
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex B
		SetMemblockFloat(memblock, 64 + offset, b.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, b.y)						// y
        SetMemblockFloat(memblock, 72 + offset, b.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, 1) 						// nx ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 80 + offset, 1) 						// ny ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 84 + offset, 1)						// nz ---- THESE VALUES I don't know how to get
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex C
		SetMemblockFloat(memblock, 64 + offset, c.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, c.y)						// y
        SetMemblockFloat(memblock, 72 + offset, c.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, 1) 						// nx ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 80 + offset, 1) 						// ny ---- THESE VALUES I don't know how to get
        SetMemblockFloat(memblock, 84 + offset, 1)						// nz ---- THESE VALUES I don't know how to get
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
	
	next i

Any help on how to get those nx,ny,nz values? Or am I doing this all wrong? I just started apk two days ago and haven't been through all the guides and docs.

(Also that shader pack looks bad ass. I'm want to buy it. Does it work with AppGameKit Studio? I don't have "Classic" -- not sure what the difference is.

Attachments

Login to view attachments

Back to top

Profile PM

spenland

4

Years of Service

User Offline

Joined: 14th Nov 2019

Location:

Posted: 16th Nov 2019 03:56

Link

The image on the right is the one I am going for. Cool thanks.

I'm now making progress so that's good. Thanks!

One thing I didn't really understand is "shared vertices". You said no shared vertices but are they not shared where the triangles connect to each other?

Back to top

Profile PM

janbo

15

Years of Service

User Offline

Joined: 10th Nov 2008

Location: Germany

Posted: 16th Nov 2019 11:17 Edited at: 16th Nov 2019 13:34

Link

Quote: "Does it work with AppGameKit Studio?"

In the App Shader Kit thread there was someone who asked the same.
Do you mind if I just refer to my answer ?

For two days in AppGameKit you are picking it up pretty fast
In your code: // Refer to online docs (NOT SURE WHAT THIS DOES)

+ Code Snippet

    SetMemBlockInt(memblock,24,0x0C000300)
    SetMemblockString(memblock,28,"position") 
    SetMemblockInt(memblock,40,0x08000300)
    SetMemblockString(memblock,44,"normal")
    SetMemblockInt(memblock,52,0x08010401)
    SetMemblockString(memblock,56,"color")

This tells the mesh abbout the names of each vertex attribute, it gets important when you need custom attributes for your shaders.
SetMemBlockInt(memblock,24,0x0C000300) is actually 4 bytes

The first byte tells you if the attributes components are floats or integers.
The second one is the number of components i.e vec3,vec4.
The third is the normalize flag (0-1 or 0-255 needed for the color attribute)
The last one is the following string length (it's a bit special)
I calculate it like this:

+ Code Snippet

Position$="position"+chr(0)
PositionLength=GetNextValueOfFour(bytelen(Position$)) <---

function GetNextValueOfFour(Value)
	local p as integer
	p=4
	while p<Value
		p=p+4
	endwhile
endfunction p

And the string is just the attribute name

Back to top

Profile PM Email Website

Bengismo

6

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 17th Nov 2019 14:33 Edited at: 17th Nov 2019 14:57

Link

To calculate the flat shaded normals I have a couple of functions which are shown below.

One sets flat shaded normal's on each triangle
The other sets flat shaded quads

They produce the results in the pic above.

You should just be able to set the vertex positions in the memblock then call either of these functions to set the normals for flat shading. Nice and simple. As already discussed you cant use indexed triangles with either of these functions but you aren't using them by the looks of it so far, so that's fine

// function to set FLAT SHADED normals of each triangle in a mesh memblock
// Please note: - triangles must be NONE INDEXED - No shared vertices
// Number of indices should be zero 
// mblk is a memblock id which stores your vertex information
function SetMeshMemblockNormalsFlatShadedTriangles(mblk as integer)

nindices = Getmemblockint(mblk, 4)
	if nindices > 0 then exitfunction

nvertices = GetMemblockInt(mblk,0)
	ntriangles = nvertices/3
	
	v = 0 // vertex offset
	
	// loop through all the triangles
	for t = 0 to ntriangles-1

// Get vertex 1		
		v1x# = GetMeshMemblockVertexX(mblk,v)
		v1y# = GetMeshMemblockVertexY(mblk,v)
		v1z# = GetMeshMemblockVertexZ(mblk,v)
		
		// get vertex 2		
		v2x# = GetMeshMemblockVertexX(mblk,v+1)
		v2y# = GetMeshMemblockVertexY(mblk,v+1)
		v2z# = GetMeshMemblockVertexZ(mblk,v+1)
		
		// get vertex 3		
		v3x# = GetMeshMemblockVertexX(mblk,v+2)
		v3y# = GetMeshMemblockVertexY(mblk,v+2)
		v3z# = GetMeshMemblockVertexZ(mblk,v+2)
		
		// get edge 1  (v1-v2)
		e1x# = v1x# - v2x# 
		e1y# = v1y# - v2y# 
		e1z# = v1z# - v2z#

// get edge 2 (v1-v3)
		e2x# = v3x# - v1x# 
		e2y# = v3y# - v1y# 
		e2z# = v3z# - v1z#

// calculate cross product  (e1 x e2)
		cx# = e1y# * e2z# - e1z#*e2y#
		cy# = e1z# * e2x# - e1x#*e2z#
		cz# = e1x# * e2y# - e1y#*e2x#
		
		// normalise it (as we only want direction - not magnitude)
		nli# = pow(cx#*cx# + cy#*cy# + cz#*cz#,-0.5) // inverse of length
		cx# = cx# *nli# 
		cy# = cy# *nli# 
		cz# = cz# *nli# 
		
		// set the 3 vertex normals
		SetMeshMemblockVertexNormal(mblk,v,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+1,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+2,cx#,cy#,cz#)

// move on to next triangle
		v=v+3
		
	next t
	
endfunction

// function to set FLAT SHADED normals of each quad in a mesh memblock
// Please note: - triangles must be NONE INDEXED - No shared vertices
// Number of indices should be zero 
// each pair of triangles making up the quad must be concurrent in the memblock
// Ie: each 6 vertices should make a quad
// Vertex numbers 0,1,2 and 5 should be the 4 corners of the quad
// vertexes 2,3 should be shared with 4,5
// change vertex 4 below if that isnt the case
function SetMeshMemblockNormalsFlatShadedQuads(mblk as integer)

nindices = Getmemblockint(mblk, 4)
	if nindices > 0 then exitfunction

nvertices = GetMemblockInt(mblk,0)
	ntriangles = nvertices/3
	nquads = ntriangles/2
	
	v = 0 // vertex offset
	
	// loop through all the quads
	for t = 0 to nquads-1

// Get vertex 1		
		v1x# = GetMeshMemblockVertexX(mblk,v)
		v1y# = GetMeshMemblockVertexY(mblk,v)
		v1z# = GetMeshMemblockVertexZ(mblk,v)  // vertex 1 of the quad is offset 0
		
		// get vertex 2		
		v2x# = GetMeshMemblockVertexX(mblk,v+1)
		v2y# = GetMeshMemblockVertexY(mblk,v+1)
		v2z# = GetMeshMemblockVertexZ(mblk,v+1)
		
		// get vertex 3		
		v3x# = GetMeshMemblockVertexX(mblk,v+2)
		v3y# = GetMeshMemblockVertexY(mblk,v+2)
		v3z# = GetMeshMemblockVertexZ(mblk,v+2)

// get vertex 4		
		v4x# = GetMeshMemblockVertexX(mblk,v+5) // vertex 4 of the quad is at offset 5 
		v4y# = GetMeshMemblockVertexY(mblk,v+5) // note this may need to be chnaged depending on how you make your triangles in code
		v4z# = GetMeshMemblockVertexZ(mblk,v+5)

// get diagonal 1  (v1-v4)
		e1x# = v1x# - v4x# 
		e1y# = v1y# - v4y# 
		e1z# = v1z# - v4z#

// get diagonal 2 (v3-v2)
		e2x# = v3x# - v2x# 
		e2y# = v3y# - v2y# 
		e2z# = v3z# - v2z#

// calculate cross product  (e1 x e2)
		cx# = e1y# * e2z# - e1z#*e2y#
		cy# = e1z# * e2x# - e1x#*e2z#
		cz# = e1x# * e2y# - e1y#*e2x#
		
		// normalise it (as we only want direction - not magnitude)
		nli# = pow(cx#*cx# + cy#*cy# + cz#*cz#,-0.5) // inverse of length
		cx# = cx# *nli# 
		cy# = cy# *nli# 
		cz# = cz# *nli# 
		
		// set the 6 vertex normals
		SetMeshMemblockVertexNormal(mblk,v,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+1,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+2,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+3,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+4,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+5,cx#,cy#,cz#)

// move on to next triangle
		v=v+6
		
	next t
	
endfunction

+ Code Snippet

// function to set FLAT SHADED normals of each triangle in a mesh memblock
// Please note: - triangles must be NONE INDEXED - No shared vertices
// Number of indices should be zero 
// mblk is a memblock id which stores your vertex information
function SetMeshMemblockNormalsFlatShadedTriangles(mblk as integer)

	nindices = Getmemblockint(mblk, 4)
	if nindices > 0 then exitfunction

	nvertices = GetMemblockInt(mblk,0)
	ntriangles = nvertices/3
	
	v = 0 // vertex offset
	
	// loop through all the triangles
	for t = 0 to ntriangles-1

		// Get vertex 1		
		v1x# = GetMeshMemblockVertexX(mblk,v)
		v1y# = GetMeshMemblockVertexY(mblk,v)
		v1z# = GetMeshMemblockVertexZ(mblk,v)
		
		// get vertex 2		
		v2x# = GetMeshMemblockVertexX(mblk,v+1)
		v2y# = GetMeshMemblockVertexY(mblk,v+1)
		v2z# = GetMeshMemblockVertexZ(mblk,v+1)
		
		// get vertex 3		
		v3x# = GetMeshMemblockVertexX(mblk,v+2)
		v3y# = GetMeshMemblockVertexY(mblk,v+2)
		v3z# = GetMeshMemblockVertexZ(mblk,v+2)
		
		// get edge 1  (v1-v2)
		e1x# = v1x# - v2x# 
		e1y# = v1y# - v2y# 
		e1z# = v1z# - v2z# 

		// get edge 2 (v1-v3)
		e2x# = v3x# - v1x# 
		e2y# = v3y# - v1y# 
		e2z# = v3z# - v1z# 

		// calculate cross product  (e1 x e2)
		cx# = e1y# * e2z# - e1z#*e2y#
		cy# = e1z# * e2x# - e1x#*e2z#
		cz# = e1x# * e2y# - e1y#*e2x#
		
		// normalise it (as we only want direction - not magnitude)
		nli# = pow(cx#*cx# + cy#*cy# + cz#*cz#,-0.5) // inverse of length
		cx# = cx# *nli# 
		cy# = cy# *nli# 
		cz# = cz# *nli# 
		
		// set the 3 vertex normals
		SetMeshMemblockVertexNormal(mblk,v,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+1,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+2,cx#,cy#,cz#)

		// move on to next triangle
		v=v+3
		
	next t
	
endfunction




// function to set FLAT SHADED normals of each quad in a mesh memblock
// Please note: - triangles must be NONE INDEXED - No shared vertices
// Number of indices should be zero 
// each pair of triangles making up the quad must be concurrent in the memblock
// Ie: each 6 vertices should make a quad
// Vertex numbers 0,1,2 and 5 should be the 4 corners of the quad
// vertexes 2,3 should be shared with 4,5
// change vertex 4 below if that isnt the case
function SetMeshMemblockNormalsFlatShadedQuads(mblk as integer)

	nindices = Getmemblockint(mblk, 4)
	if nindices > 0 then exitfunction

	nvertices = GetMemblockInt(mblk,0)
	ntriangles = nvertices/3
	nquads = ntriangles/2
	
	v = 0 // vertex offset
	
	// loop through all the quads
	for t = 0 to nquads-1

		// Get vertex 1		
		v1x# = GetMeshMemblockVertexX(mblk,v)
		v1y# = GetMeshMemblockVertexY(mblk,v)
		v1z# = GetMeshMemblockVertexZ(mblk,v)  // vertex 1 of the quad is offset 0
		
		// get vertex 2		
		v2x# = GetMeshMemblockVertexX(mblk,v+1)
		v2y# = GetMeshMemblockVertexY(mblk,v+1)
		v2z# = GetMeshMemblockVertexZ(mblk,v+1)
		
		// get vertex 3		
		v3x# = GetMeshMemblockVertexX(mblk,v+2)
		v3y# = GetMeshMemblockVertexY(mblk,v+2)
		v3z# = GetMeshMemblockVertexZ(mblk,v+2)

		// get vertex 4		
		v4x# = GetMeshMemblockVertexX(mblk,v+5) // vertex 4 of the quad is at offset 5 
		v4y# = GetMeshMemblockVertexY(mblk,v+5) // note this may need to be chnaged depending on how you make your triangles in code
		v4z# = GetMeshMemblockVertexZ(mblk,v+5)

		
		// get diagonal 1  (v1-v4)
		e1x# = v1x# - v4x# 
		e1y# = v1y# - v4y# 
		e1z# = v1z# - v4z# 

		// get diagonal 2 (v3-v2)
		e2x# = v3x# - v2x# 
		e2y# = v3y# - v2y# 
		e2z# = v3z# - v2z# 

		// calculate cross product  (e1 x e2)
		cx# = e1y# * e2z# - e1z#*e2y#
		cy# = e1z# * e2x# - e1x#*e2z#
		cz# = e1x# * e2y# - e1y#*e2x#
		
		// normalise it (as we only want direction - not magnitude)
		nli# = pow(cx#*cx# + cy#*cy# + cz#*cz#,-0.5) // inverse of length
		cx# = cx# *nli# 
		cy# = cy# *nli# 
		cz# = cz# *nli# 
		
		// set the 6 vertex normals
		SetMeshMemblockVertexNormal(mblk,v,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+1,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+2,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+3,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+4,cx#,cy#,cz#)
		SetMeshMemblockVertexNormal(mblk,v+5,cx#,cy#,cz#)

		// move on to next triangle
		v=v+6
		
	next t
	
endfunction

For indexed meshes with shared vertices then smooth shading is the way to go and i have a few functions for those too if they are wanted.

PLEASE Note:
To get correctly flat shaded quads: the order of the vertices that you put into the memblock affects whether these functions will work or not. In my meshes V1,V2,V3 and V6 are the four corners of my quads. (V4=V2 and V5 = V3 - these are duplicated internal vertices). If this isnt the case for your meshes then you may need to change a few offsets used inside the quad function - (Looking at your code - you WILL have to change a few offsets when the vertex positions for the 4 corners are retrieved as the ordering is different to mine). I have also assumed you are using the same winding order as me but it might be that you aren't but i haven't checked if you are.

They should work fine if these are all set correctly or amended to match your vertex creation order.

Back to top

Profile PM

Bengismo

6

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 17th Nov 2019 14:52

Link

I almost forgot....

In your code you create a ludicrously large memblock....its like 100Mb (ish)??. i assume that you just wanted it "big enough not to worry about running out of room"

// Allocate space for data
memblock = CreateMemblock(100000000) <--- this is perhaps overkill

It would be a good idea to look at how to calculate the space you will need based on your vertex size and how may triangles you will make and the header info in the memblock. And also ensure you delete the memblock when you are done with it.

Back to top

Profile PM

spenland

4

Years of Service

User Offline

Joined: 14th Nov 2019

Location:

Posted: 17th Nov 2019 16:45

Link

So, I can't seem to get the quad flat shading to work although I thought I had everything right.

Here is how my triangles are put into an array:

// Make grid 
	for i = 0 to divisions
		
		for j = 0 to divisions
			
			vertex as Vector4
			vertex2 as Vector4
			vertex3 as Vector4
			
			vertex.x = -half_size + j * division_size 
			vertex.y = 1.0
			vertex.z = half_size - i * division_size
			vertex.i = i * (divisions + 1) + j
			
			terrian_grid[i * (divisions + 1) + j] = vertex
			
			if i < divisions and j < divisions
				
				top_left = i * (divisions + 1) + j
				bottom_left = (i + 1) * (divisions + 1) + j
				
				// Vertex indexes
				v1 = top_left
				v2 = top_left + 1
				v3 = bottom_left + 1
				v4 = top_left
				v5 = bottom_left
				v6 = bottom_left + 1
				
				triangle_1 as Triangle3DIndex
				// --------------
				triangle_1.a = vertex
				triangle_1.a.i = v1
				
				// --------------
				vertex2.x = vertex.x
				vertex2.y = vertex.y
				vertex2.z = vertex.z - division_size
				
				triangle_1.b = vertex2
				triangle_1.b.i = v5
				
				// -------------
				vertex3.x = vertex2.x + division_size
				vertex3.y = vertex2.y
				vertex3.z = vertex2.z
				
				triangle_1.c = vertex3
				triangle_1.c.i = v3
				
				triangles.length = triangles.length + 1
				triangles[triangles.length - 1] = triangle_1
				
				// -- Tri 2
				triangle_2 as Triangle3DIndex
				
				// -------------
				triangle_2.c = vertex
				triangle_2.c.i = v4
				
				// -------------
				vertex2.x = vertex.x + division_size
				vertex2.y = vertex.y
				vertex2.z = vertex.z 
				
				triangle_2.b = vertex2
				triangle_2.b.i = v2
				
				// --------------
				vertex3.x = vertex2.x
				vertex3.y = vertex2.y
				vertex3.z = vertex2.z - division_size
				
				triangle_2.a = vertex3
				triangle_2.a.i = v6
				
				triangles.length = triangles.length + 1
				triangles[triangles.length - 1] = triangle_2
				
			endif
			
		next j
			
	next i

+ Code Snippet

// Make grid 
	for i = 0 to divisions
		
		for j = 0 to divisions
			
			vertex as Vector4
			vertex2 as Vector4
			vertex3 as Vector4
			
			vertex.x = -half_size + j * division_size 
			vertex.y = 1.0
			vertex.z = half_size - i * division_size
			vertex.i = i * (divisions + 1) + j
			
			terrian_grid[i * (divisions + 1) + j] = vertex
			
			if i < divisions and j < divisions
				
				top_left = i * (divisions + 1) + j
				bottom_left = (i + 1) * (divisions + 1) + j
				
				// Vertex indexes
				v1 = top_left
				v2 = top_left + 1
				v3 = bottom_left + 1
				v4 = top_left
				v5 = bottom_left
				v6 = bottom_left + 1
				
				triangle_1 as Triangle3DIndex
				// --------------
				triangle_1.a = vertex
				triangle_1.a.i = v1
				
				// --------------
				vertex2.x = vertex.x
				vertex2.y = vertex.y
				vertex2.z = vertex.z - division_size
				
				triangle_1.b = vertex2
				triangle_1.b.i = v5
				
				// -------------
				vertex3.x = vertex2.x + division_size
				vertex3.y = vertex2.y
				vertex3.z = vertex2.z
				
				triangle_1.c = vertex3
				triangle_1.c.i = v3
				
				triangles.length = triangles.length + 1
				triangles[triangles.length - 1] = triangle_1
				
				// -- Tri 2
				triangle_2 as Triangle3DIndex
				
				// -------------
				triangle_2.c = vertex
				triangle_2.c.i = v4
				
				// -------------
				vertex2.x = vertex.x + division_size
				vertex2.y = vertex.y
				vertex2.z = vertex.z 
				
				triangle_2.b = vertex2
				triangle_2.b.i = v2
				
				// --------------
				vertex3.x = vertex2.x
				vertex3.y = vertex2.y
				vertex3.z = vertex2.z - division_size
				
				triangle_2.a = vertex3
				triangle_2.a.i = v6
				
				triangles.length = triangles.length + 1
				triangles[triangles.length - 1] = triangle_2
				
			endif
			
		next j
			
	next i

Here is how I'm constructing the memblock and calculating normal (using the formulas above):

// Colors
	c_snow = 0xf7f7f7
	c_mountain = 0x5da4bb
	c_light_grass = 0x8fdd88
	c_dark_grass = 0x468740
	c_dirt = 0x366373
	
	// Allocate space for data
	memblock = CreateMemblock(100000000)
	
	// Set amount of vertices in mesh to be created
	SetMemblockInt(memblock, 0, triangles.length * 3)
	
	// All polygons
	SetMemblockInt(memblock, 4, 0)
	
	// All vertices have 3 attributes
	// -- pos, normal, color
	SetMemblockByte(memblock, 8, 3)
	
	// Memory for each vertex
	// -- (x,y,z  nx,ny,nz  color) * 4
	SetMemblockByte(memblock, 12, 28)
	
	// Offset of vertex data
	SetMemblockInt(memblock, 16, 64)
	
	// Indices offset - none, so 0
	SetMemblockInt(memblock, 20, 0)
	
	// Refer to online docs
	SetMemBlockInt(memblock,24,0x0C000300)
	SetMemblockString(memblock,28,"position") 
	SetMemblockInt(memblock,40,0x08000300)
	SetMemblockString(memblock,44,"normal")
	SetMemblockInt(memblock,52,0x08010401)
	SetMemblockString(memblock,56,"color")
	
	// Normals
	normals as Vector3[0]
	
	// Calculate normals (quad-flat-shading)
	for i = 1 to triangles.length - 1 step 2
	
		norm as Vector3
		
		// Get triangles
		tri_1 as Triangle3DIndex
		tri_2 as Triangle3DIndex
		
		tri_1 = triangles[i - 1]
		tri_2 = triangles[i]
		
		// Get four corners
		top_left as Vector4
		top_left = tri_1.a
		
		bottom_left as Vector4
		bottom_left = tri_1.b
		
		top_right as Vector4
		top_right = tri_2.b
		
		bottom_right as Vector4
		bottom_right = tri_1.c
		
		// Calculate normals for four corners
		// -- Diagonal top left to bottom right
        d1_x = top_left.x - bottom_right.x 
        d1_y = top_left.y - bottom_right.y
        d1_z = top_left.z - bottom_right.z
 
        // -- Diagonal top right to bottom left
        d2_x = top_right.x - bottom_left.x
        d2_y = top_right.y - bottom_left.y
        d2_z = top_right.z - bottom_left.z
 
        // -- Cross product
        cx = d1_y * d2_z - d1_z * d2_y
        cy = d1_z * d2_x - d1_x * d2_z
        cz = d1_x * d2_y - d1_y * d2_x
         
        // -- Normalize
        n = pow(cx * cx + cy * cy + cz * cz, -0.5)
        cx = cx * n 
        cy = cy * n 
        cz = cz * n
		
		norm.x = cx
		norm.y = cy
		norm.z = cz
											
		// Set normals
		normals.length = normals.length + 1
		normals[normals.length - 1] = norm
				
	next i
	
	// Allocate color array
	colors as integer[0]
	
	// Color polygon based on height
	for i = 0 to triangles.length - 1
	
		// Get triangle points
		tri_a as Vector4
		tri_a = triangles[i].a
		
		tri_b as Vector4 
		tri_b = triangles[i].b
		
		tri_c as Vector4 
		tri_c = triangles[i].c
		
		// Increase colors array by one
		colors.length = colors.length + 1
		
		// Set min to max
		min = max_height
		
		// Get lowest point on polygon
		if tri_a.y < min
			min = tri_a.y
		endif
		
		if tri_b.y < min
			min = tri_b.y
		endif
		
		if tri_c.y < min
			min = tri_c.y
		endif
		
		// Determine color for min polygon height
		if min > max_height * 0.85
			
			colors[colors.length - 1] = c_snow
		
		elseif min > max_height * 0.75
			
			colors[colors.length - 1] = c_mountain
			
		elseif min > max_height * 0.35
			
			colors[colors.length - 1] = c_light_grass
			
		elseif min > max_height * 0.15
			
			colors[colors.length - 1] = c_dark_grass
			
		else
			
			colors[colors.length - 1] = c_dirt
			
		endif
		
				
	next i
		
	// Add all vertices to vertices array
	offset = 0
	offset_inc = 28 // 28 parts of each vertex
	
	for i = 0 to triangles.length - 1
		
		// Get normal index
		normals_index = floor(i/2)
		
		// Get triangle
		tri as Triangle3DIndex
		tri = triangles[i]
		
		// Get points on triangle
		a as Vector4
		a = tri.a
		
		b as Vector4
		b = tri.b
		
		c as Vector4
		c = tri.c
		
		// Add vertex A
		SetMemblockFloat(memblock, 64 + offset, a.x) 						// x
		SetMemblockFloat(memblock, 68 + offset, a.y)						// y
	    SetMemblockFloat(memblock, 72 + offset, a.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex B
		SetMemblockFloat(memblock, 64 + offset, b.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, b.y)						// y
        SetMemblockFloat(memblock, 72 + offset, b.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex C
		SetMemblockFloat(memblock, 64 + offset, c.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, c.y)						// y
        SetMemblockFloat(memblock, 72 + offset, c.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
	
	next i

+ Code Snippet

// Colors
	c_snow = 0xf7f7f7
	c_mountain = 0x5da4bb
	c_light_grass = 0x8fdd88
	c_dark_grass = 0x468740
	c_dirt = 0x366373
	
	// Allocate space for data
	memblock = CreateMemblock(100000000)
	
	// Set amount of vertices in mesh to be created
	SetMemblockInt(memblock, 0, triangles.length * 3)
	
	// All polygons
	SetMemblockInt(memblock, 4, 0)
	
	// All vertices have 3 attributes
	// -- pos, normal, color
	SetMemblockByte(memblock, 8, 3)
	
	// Memory for each vertex
	// -- (x,y,z  nx,ny,nz  color) * 4
	SetMemblockByte(memblock, 12, 28)
	
	// Offset of vertex data
	SetMemblockInt(memblock, 16, 64)
	
	// Indices offset - none, so 0
	SetMemblockInt(memblock, 20, 0)
	
	// Refer to online docs
	SetMemBlockInt(memblock,24,0x0C000300)
	SetMemblockString(memblock,28,"position") 
	SetMemblockInt(memblock,40,0x08000300)
	SetMemblockString(memblock,44,"normal")
	SetMemblockInt(memblock,52,0x08010401)
	SetMemblockString(memblock,56,"color")
	
	// Normals
	normals as Vector3[0]
	
	// Calculate normals (quad-flat-shading)
	for i = 1 to triangles.length - 1 step 2
	
		norm as Vector3
		
		// Get triangles
		tri_1 as Triangle3DIndex
		tri_2 as Triangle3DIndex
		
		tri_1 = triangles[i - 1]
		tri_2 = triangles[i]
		
		// Get four corners
		top_left as Vector4
		top_left = tri_1.a
		
		bottom_left as Vector4
		bottom_left = tri_1.b
		
		top_right as Vector4
		top_right = tri_2.b
		
		bottom_right as Vector4
		bottom_right = tri_1.c
		
		// Calculate normals for four corners
		// -- Diagonal top left to bottom right
        d1_x = top_left.x - bottom_right.x 
        d1_y = top_left.y - bottom_right.y
        d1_z = top_left.z - bottom_right.z
 
        // -- Diagonal top right to bottom left
        d2_x = top_right.x - bottom_left.x
        d2_y = top_right.y - bottom_left.y
        d2_z = top_right.z - bottom_left.z
 
        // -- Cross product
        cx = d1_y * d2_z - d1_z * d2_y
        cy = d1_z * d2_x - d1_x * d2_z
        cz = d1_x * d2_y - d1_y * d2_x
         
        // -- Normalize
        n = pow(cx * cx + cy * cy + cz * cz, -0.5)
        cx = cx * n 
        cy = cy * n 
        cz = cz * n
		
		norm.x = cx
		norm.y = cy
		norm.z = cz
											
		// Set normals
		normals.length = normals.length + 1
		normals[normals.length - 1] = norm
				
	next i
	
	// Allocate color array
	colors as integer[0]
	
	// Color polygon based on height
	for i = 0 to triangles.length - 1
	
		// Get triangle points
		tri_a as Vector4
		tri_a = triangles[i].a
		
		tri_b as Vector4 
		tri_b = triangles[i].b
		
		tri_c as Vector4 
		tri_c = triangles[i].c
		
		// Increase colors array by one
		colors.length = colors.length + 1
		
		// Set min to max
		min = max_height
		
		// Get lowest point on polygon
		if tri_a.y < min
			min = tri_a.y
		endif
		
		if tri_b.y < min
			min = tri_b.y
		endif
		
		if tri_c.y < min
			min = tri_c.y
		endif
		
		// Determine color for min polygon height
		if min > max_height * 0.85
			
			colors[colors.length - 1] = c_snow
		
		elseif min > max_height * 0.75
			
			colors[colors.length - 1] = c_mountain
			
		elseif min > max_height * 0.35
			
			colors[colors.length - 1] = c_light_grass
			
		elseif min > max_height * 0.15
			
			colors[colors.length - 1] = c_dark_grass
			
		else
			
			colors[colors.length - 1] = c_dirt
			
		endif
		
				
	next i
		
	// Add all vertices to vertices array
	offset = 0
	offset_inc = 28 // 28 parts of each vertex
	
	for i = 0 to triangles.length - 1
		
		// Get normal index
		normals_index = floor(i/2)
		
		// Get triangle
		tri as Triangle3DIndex
		tri = triangles[i]
		
		// Get points on triangle
		a as Vector4
		a = tri.a
		
		b as Vector4
		b = tri.b
		
		c as Vector4
		c = tri.c
		
		// Add vertex A
		SetMemblockFloat(memblock, 64 + offset, a.x) 						// x
		SetMemblockFloat(memblock, 68 + offset, a.y)						// y
	    SetMemblockFloat(memblock, 72 + offset, a.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex B
		SetMemblockFloat(memblock, 64 + offset, b.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, b.y)						// y
        SetMemblockFloat(memblock, 72 + offset, b.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex C
		SetMemblockFloat(memblock, 64 + offset, c.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, c.y)						// y
        SetMemblockFloat(memblock, 72 + offset, c.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
	
	next i

And here is the result:

Do I need to do anything with lighting? I'm just using the default lighting/shading.

Attachments

Login to view attachments

Back to top

Profile PM

Bengismo

6

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 17th Nov 2019 17:25 Edited at: 17th Nov 2019 17:30

Link

You dont need to do anything with the lighting,

Its quite likely that two of the vertices need swapping in the cross product - ive not looked through your code though so it could be something else. Chances are all those normals are pointing straight down right now rather than up.

Just guessing but trymultiplying by -n to rule that out first

// -- Normalize
n = pow(cx * cx + cy * cy + cz * cz, -0.5)
cx = cx * -n
cy = cy * -n
cz = cz * -n

Rather than trying to integrate the calculation into your code like you have done....you could have just used your old code without normals and just called one of the functions I listed right before creating the object from a memblock. That should work ok.

Back to top

Profile PM

spenland

4

Years of Service

User Offline

Joined: 14th Nov 2019

Location:

Posted: 17th Nov 2019 18:20

Link

Finally got it working. It was like you said. I had the points wrong on the corners.

Here is the fix.

// Normals
	normals as Vector3[0]
	
	// Calculate normals (quad-flat-shading)
	for i = 1 to triangles.length - 1 step 2
	
		norm as Vector3
		
		// Get triangles
		tri_1 as Triangle3DIndex
		tri_2 as Triangle3DIndex
		
		tri_1 = triangles[i - 1]
		tri_2 = triangles[i]
		
		// Get four corners
		top_left as Vector4
		top_left = tri_1.a
		v1 = CreateVector3(-top_left.x, -top_left.y, -top_left.z) // Negative so it subtracts below
		
		bottom_left as Vector4
		bottom_left = tri_1.b
		v2 = CreateVector3(bottom_left.x, bottom_left.y, bottom_left.z)
		
		top_right as Vector4
		top_right = tri_2.b
		v3 = CreateVector3(top_right.x, top_right.y, top_right.z)
		
		bottom_right as Vector4
		bottom_right = tri_1.c
		v4 = CreateVector3(bottom_right.x, bottom_right.y, bottom_right.z)
		
		// Calculate normals for four corners
		cross = CreateVector3()
		cross_u = v2
		GetVector3Add(cross_u, v1)
		cross_v = v3
		GetVector3Add(cross_v, v1)
		GetVector3Cross(cross, cross_u, cross_v)
        
        cx = GetVector3X(cross)
        cy = GetVector3Y(cross)
        cz = GetVector3Z(cross)
        
		n = sqrt(cx * cx + cy * cy + cz * cz)
		norm.x = cx * n
		norm.y = cy * n
		norm.z = cz * n
											
		// Set normals
		normals.length = normals.length + 1
		normals[normals.length - 1] = norm
		
		// Clean up
		DeleteVector3(cross)
		DeleteVector3(v1)
		DeleteVector3(v2)
		DeleteVector3(v3)
		DeleteVector3(v4)		
				
	next i

+ Code Snippet

// Normals
	normals as Vector3[0]
	
	// Calculate normals (quad-flat-shading)
	for i = 1 to triangles.length - 1 step 2
	
		norm as Vector3
		
		// Get triangles
		tri_1 as Triangle3DIndex
		tri_2 as Triangle3DIndex
		
		tri_1 = triangles[i - 1]
		tri_2 = triangles[i]
		
		// Get four corners
		top_left as Vector4
		top_left = tri_1.a
		v1 = CreateVector3(-top_left.x, -top_left.y, -top_left.z) // Negative so it subtracts below
		
		bottom_left as Vector4
		bottom_left = tri_1.b
		v2 = CreateVector3(bottom_left.x, bottom_left.y, bottom_left.z)
		
		top_right as Vector4
		top_right = tri_2.b
		v3 = CreateVector3(top_right.x, top_right.y, top_right.z)
		
		bottom_right as Vector4
		bottom_right = tri_1.c
		v4 = CreateVector3(bottom_right.x, bottom_right.y, bottom_right.z)
		
		// Calculate normals for four corners
		cross = CreateVector3()
		cross_u = v2
		GetVector3Add(cross_u, v1)
		cross_v = v3
		GetVector3Add(cross_v, v1)
		GetVector3Cross(cross, cross_u, cross_v)
        
        cx = GetVector3X(cross)
        cy = GetVector3Y(cross)
        cz = GetVector3Z(cross)
        
		n = sqrt(cx * cx + cy * cy + cz * cz)
		norm.x = cx * n
		norm.y = cy * n
		norm.z = cz * n
											
		// Set normals
		normals.length = normals.length + 1
		normals[normals.length - 1] = norm
		
		// Clean up
		DeleteVector3(cross)
		DeleteVector3(v1)
		DeleteVector3(v2)
		DeleteVector3(v3)
		DeleteVector3(v4)		
				
	next i

Thanks everyone who helped! I'm glad you guys were here...this would have taken forever without your help!

Attachments

Login to view attachments

Back to top

Profile PM

Bengismo

6

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 17th Nov 2019 19:02

Link

Its good that it appears to be working, ...some great progress there

but.... There is quite a lot that seems "odd" in your code...lol im really not sure why its working

1) Your diagonal vectors for the quad dont seem to be calculated correctly. You should subtract one vertex position from another to get the vector between two vertices...you are adding for some reason?

2) You only calculate the normal for 1 of the 2 triangles in your quad (only using V1,V2 and V3 ...... V4 isnt used at all? - there was no point in putting it into a vector really) meaning that the normal for the whole quad wont be right. The normal for the quad should be the average of the two triangles making it up. Those two normals are not the same

2) You calculate a normal then you are multiplying by its length to normalise it - This is wrong...To normalize it you calculate its length then divide the normal by the length

I really dont mean to criticise at all, Its great progress and even seems to look right...but there does seem to be some "issues"

Back to top

Profile PM

spenland

4

Years of Service

User Offline

Joined: 14th Nov 2019

Location:

Posted: 17th Nov 2019 19:44

Link

I change the sign of v1.x, v1.y, and v1.z to negative so when I GetVertex3Add() it is actually a subtraction. I didn't see a way to GetVertex3Subtract()

I use two triangles for the vertices...

tri_1.a --------------------------- tri_2.b
| |
| |
| |
tri_1.b --------------------------- tri_1.c

My triangles are store in an order where the first triangle is the bottom left of above drawn and the next triangle is the top right of quad above.

And since the normal of that quad will be the normal of all the vertices I only add it once to the normal array and when getting normal I do this:

for i = 0 to triangles.length - 1
		
		// Get normal index
		normals_index = floor(i/2) // <<<<<<<<<< ----- same normal for upcoming triangle too
		
		// Get triangle
		tri as Triangle3DIndex
		tri = triangles[i]
		
		// Get points on triangle
		a as Vector4
		a = tri.a
		
		b as Vector4
		b = tri.b
		
		c as Vector4
		c = tri.c
		
		// Add vertex A
		SetMemblockFloat(memblock, 64 + offset, a.x) 						// x
		SetMemblockFloat(memblock, 68 + offset, a.y)						// y
	    SetMemblockFloat(memblock, 72 + offset, a.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex B
		SetMemblockFloat(memblock, 64 + offset, b.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, b.y)						// y
        SetMemblockFloat(memblock, 72 + offset, b.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex C
		SetMemblockFloat(memblock, 64 + offset, c.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, c.y)						// y
        SetMemblockFloat(memblock, 72 + offset, c.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
	
	next i

+ Code Snippet

for i = 0 to triangles.length - 1
		
		// Get normal index
		normals_index = floor(i/2) // <<<<<<<<<< ----- same normal for upcoming triangle too
		
		// Get triangle
		tri as Triangle3DIndex
		tri = triangles[i]
		
		// Get points on triangle
		a as Vector4
		a = tri.a
		
		b as Vector4
		b = tri.b
		
		c as Vector4
		c = tri.c
		
		// Add vertex A
		SetMemblockFloat(memblock, 64 + offset, a.x) 						// x
		SetMemblockFloat(memblock, 68 + offset, a.y)						// y
	    SetMemblockFloat(memblock, 72 + offset, a.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex B
		SetMemblockFloat(memblock, 64 + offset, b.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, b.y)						// y
        SetMemblockFloat(memblock, 72 + offset, b.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
        
        // Add vertex C
		SetMemblockFloat(memblock, 64 + offset, c.x) 						// x
        SetMemblockFloat(memblock, 68 + offset, c.y)						// y
        SetMemblockFloat(memblock, 72 + offset, c.z)						// z
        
        SetMemblockFloat(memblock, 76 + offset, normals[normals_index].x) 						// nx
        SetMemblockFloat(memblock, 80 + offset, normals[normals_index].y) 						// ny
        SetMemblockFloat(memblock, 84 + offset, normals[normals_index].z)						// nz
        
        SetMemblockInt(memblock, 88 + offset, colors[i]) 					// color
        
        // Increase to next vertex position
        offset = offset + offset_inc
	
	next i

I think it is working but it's hard to tell 100%. I have a bug in my diamond-square algorithm which is causing any terrain with 32 or more divisions to skip vertices... so I'm working on that again to try to get it working better. Once I get it correct, I'll come back to the normals and make sure they're working right. hard to test the normals on a completely screwed up terrain lol although everything looks okay with 2, 4, 8, and 16 divisions

Back to top

Profile PM

spenland

4

Years of Service

User Offline

Joined: 14th Nov 2019

Location:

Posted: 17th Nov 2019 20:25

Link

Yup. I think you are right. I think I have the algorithm fixed now. This doesn't seem right:

(hope it's okay to keep posting pictures...)

Attachments

Login to view attachments

Back to top

Profile PM

Bengismo

6

Years of Service

User Offline

Joined: 20th Nov 2017

Location: Yorkshire, England

Posted: 17th Nov 2019 21:28 Edited at: 17th Nov 2019 21:46

Link

Well, at least you have something thats looking sort of right

What you have already done is great and is a credit to you.

however...here's the "but"

Firstly (normalizing a vector):
Your code above uses this :
n = sqrt(cx * cx + cy * cy + cz * cz)
norm.x = cx * n
norm.y = cy * n
norm.z = cz * n

n is the the length of the normal. To normalize any vector, you have to divide by length. So...it should be

norm.x = cx / n
norm.y = cy / n
norm.z = cz / n

or use....
n = 1.0/sqrt(cx * cx + cy * cy + cz * cz) then multiply by n which is the INVERSE of the length...so multiplying by that value is the same as dividing by it

no matter how you do it....All normals should have a length of 1.0 -> Meaning sqrt(x*x +y*y +z*z) = 1.0

Secondly:
Your code to calculate the normal for a quad only uses 3 of the vertices. So...to put it simply: your code just cant be correct if it isnt using all 4 vertices

You use
// Calculate normals for four corners
cross = CreateVector3()
cross_u = v2
GetVector3Add(cross_u, v1)
cross_v = v3
GetVector3Add(cross_v, v1)
GetVector3Cross(cross, cross_u, cross_v)

You use V1,V2 and V3...but v4 is never referenced. V4 may not be coplanar with the other 3 so there is a correct way to get normals for quads

Id calculate the normal for a non coplanar, flat shaded quad by getting the cross product of the diagonal vectors

d1 = V3 - V1
d2 = V2 - V4

crossp = d1 x d2

This method gets a correct representation of the average across the quad face.

An alternate method is to calculate the normal of triangle 1 in the quad and the normal of triangle 2 and then average them (add them then normalize the result). This second method gives the exact same result as the cross product of the diagonals though so its why I use the first method.

Once the normal is truly calculated correctly - then you are right that you set that normal to all 6 vertices that make up the quad.
Technically , 2 vertices could be shared and you could index this quad and save some memory but that snot that important right now. First things first - get it working and ensure its absolutely correct.

Other than that....it looks like you have it sorted.

Sorry for being a stickler on the detail...i guess i have OCD or something...

Kudos to you and not many people get deep into 3d geometry when first starting in any game language!! So having working memblock code is greatly impressive.

Last thing I want to do is come across negative or critical. just trying to help is all.

Always really good to see people making the effort to learn how to do things in 3d

awesome

Back to top

Profile PM

spenland

4

Years of Service

User Offline

Joined: 14th Nov 2019

Location:

Posted: 18th Nov 2019 01:36

Link

So...I decided to just use your code from above. I had to play with this:

+ Code Snippet

// Get vertex 1     
        v1x# = GetMeshMemblockVertexX(mblk,v)
        v1y# = GetMeshMemblockVertexY(mblk,v)
        v1z# = GetMeshMemblockVertexZ(mblk,v)  // vertex 1 of the quad is offset 0
         
        // get vertex 2     
        v2x# = GetMeshMemblockVertexX(mblk,v+1)
        v2y# = GetMeshMemblockVertexY(mblk,v+1)
        v2z# = GetMeshMemblockVertexZ(mblk,v+1)
         
        // get vertex 3     
        v3x# = GetMeshMemblockVertexX(mblk,v+2)
        v3y# = GetMeshMemblockVertexY(mblk,v+2)
        v3z# = GetMeshMemblockVertexZ(mblk,v+2)
 
        // get vertex 4     
        v4x# = GetMeshMemblockVertexX(mblk,v+5) // vertex 4 of the quad is at offset 5 
        v4y# = GetMeshMemblockVertexY(mblk,v+5) // note this may need to be chnaged depending on how you make your triangles in code
        v4z# = GetMeshMemblockVertexZ(mblk,v+5)

And change some of the v+1, v+2 ...to be different indices before I could see the terrain and it wasn't all dark.

I fixed up my generation algorithm some, turns out random(-100, 100) seems to produce 0 - 100 instead of -100 - 100 so I made a little function for that which seems to work. I also got my colors working which helps the look of the mesh but I'm still a little unsure if the results are right. It looks okay, but I feel like it could be better...not sure if it's the normal or the generation (divisions and size stuff)

Attachments

Login to view attachments

Back to top

Profile PM

blink0k

Moderator

11

Years of Service

User Offline

Joined: 22nd Feb 2013

Location: the land of oz

Posted: 18th Nov 2019 01:48

Link

that looks awesome

Back to top

Profile PM

fubarpk

Retired Moderator

19

Years of Service

User Offline

Joined: 11th Jan 2005

Playing: AGK is my friend

Posted: 18th Nov 2019 06:32

Link

Looks great and shows the skills of many years of programming

fubarpk
fubarpk on Itch...………...https://fubarpk.itch.io/
fubarpk on googleplay..https://play.google.com/store/apps/developer?id=fubarpk

Back to top

Profile PM Email Website

Xaby

FPSC Reloaded TGC Backer

17

Years of Service

User Offline

Joined: 17th Apr 2007

Location: Berlin

Posted: 19th Nov 2019 19:52

Link

@blink0k,

It looks, like we have to drive with your kart on this mountain

Back to top

Profile PM Website

blink0k

Moderator

11

Years of Service

User Offline

Joined: 22nd Feb 2013

Location: the land of oz

Posted: 19th Nov 2019 20:22

Link

Quote: "It looks, like we have to drive with your kart on this mountain"

Hahahaha

Back to top

Profile PM

tiresius

21

Years of Service

User Offline

Joined: 13th Nov 2002

Location: MA USA

Posted: 20th Nov 2019 21:26

Link

How are you all doing the terrain generation itself (diamond square) ?

Funcygames.com

Back to top

Profile PM Email

spenland

4

Years of Service

User Offline

Joined: 14th Nov 2019

Location:

Posted: 22nd Nov 2019 18:35

Link

Yes, it's diamond-square.

I tweaked some things to get close to what I liked. I mainly just took a Unity diamond-square tutorial and ported it to agc.

Back to top

Profile PM

tiresius

21

Years of Service

User Offline

Joined: 13th Nov 2002

Location: MA USA

Posted: 22nd Nov 2019 19:18

Link

Ok cool, I spent a long time doing a diamond square algorithm using wikipedia and other web sources as well into agk and was worried there was some easy 3D function to do it and I wasted some time.

Funcygames.com

Back to top

Profile PM Email

Sorry your browser is not supported!

AppGameKit Studio Chat / 3d plane mesh created from memblock is colored pink

Attachments

Attachments

Attachments

Attachments

Attachments

Attachments

Attachments