slightly improved sphere generation

Nebulix/Rendering/Mesh.cs

@@ -24,24 +24,26 @@ namespace Nebulix.Rendering
 
 		public void CalculateNormals()
 		{
-			// normals = new Vector3D<float>[vertices.Length];
-			// for (int j = 0; j < vertices.Length; j++)
-			// {
-			// 	normals[j] = Vector3D<float>.Zero;
-			// }
-
-			// return;
 			for (int i = 0; i < indices.Length; i += 3)
 			{
-				Vector3D<float> a = vertices[indices[i]];
+				uint i0 = indices[i];
-				Vector3D<float> b = vertices[indices[i + 1]];
+				uint i1 = indices[i+1];
-				Vector3D<float> c = vertices[indices[i + 2]];
+				uint i2 = indices[i+2];
+				Vector3D<float> v0 = vertices[i0];
+				Vector3D<float> v1 = vertices[i1];
+				Vector3D<float> v2 = vertices[i2];
 
-				Vector3D<float> normal = Vector3D.Cross(b-a, c-a);
+				Vector3D<float> normal = Vector3D.Cross(v1-v0, v2-v0);
+				// Commenting this out, will result in the normals being weighted based on the triangle area
 				normal = Vector3D.Normalize(normal);
-				normals[indices[i]] = normal;
+				normals[i0] += normal;
-				normals[indices[i + 1]] = normal;
+				normals[i1] += normal;
-				normals[indices[i + 2]] = normal;
+				normals[i2] += normal;
+			}
+
+			for (int i = 0; i < normals.Length; i++)
+			{
+				normals[i] = Vector3D.Normalize(normals[i]); // smoothing for shared vertices
 			}
 		}
 		
@@ -84,8 +86,7 @@ namespace Nebulix.Rendering
 				meshData[insert + 5] = normals[i].Z;
 				insert += 6;
 			}
-			// extractedVertices.CopyTo(meshData, 0);
+
-			// extractedNormals.CopyTo(meshData, extractedVertices.Length);
 			gl.BindBuffer(BufferTargetARB.ArrayBuffer, vbo);
 			fixed(void* data = &meshData[0])
 			{

src/Shaders/Sphere/sphere.frag

@@ -57,7 +57,7 @@ vec3 CalculatePointLight(PointLight light, vec3 normal, vec3 fragPos, vec3 viewD
 
     vec3 ambientLight = light.ambient * attenuation;// * texture(material.diffuseMap, TexCoords).rgb;
     vec3 diffuseLight = light.diffuse * diff * attenuation;// * texture(material.diffuseMap, TexCoords).rgb;
-    vec3 specularLight = light.specular * spec * attenuation;// * texture(material.specularMap, TexCoords).rgb;
+    vec3 specularLight = vec3(0);//light.specular * spec * attenuation;// * texture(material.specularMap, TexCoords).rgb;
 
     return ambientLight + diffuseLight + specularLight;
 }

src/Sphere.cs

@@ -8,7 +8,7 @@ namespace Engine_silk.NET
 	// also maybe make an ISphere and call this class "CubeSphere"?
 	public class Sphere
 	{
-		private readonly Face[] sphereFaces = new Face[6];
+		private readonly Mesh mesh = new();
 		private readonly uint resolution;
 		
 		public Sphere(uint resolution)
@@ -21,6 +21,7 @@ namespace Engine_silk.NET
 
 		public void CreateSphere()
 		{
+			// TODO: merge the individual meshes to one mesh
 			Vector3D<float>[] directions =
 			[
 				Vector3D<float>.UnitZ, -Vector3D<float>.UnitZ, 
@@ -28,23 +29,33 @@ namespace Engine_silk.NET
 				Vector3D<float>.UnitX, -Vector3D<float>.UnitX
 			];
 
-			for (int i = 0; i < sphereFaces.Length; i++)
+			List<Vector3D<float>> vertices = new();
+			List<uint> indices = new();
+			for (int i = 0; i < directions.Length; i++)
 			{
-				sphereFaces[i] = new Face(directions[i], new Mesh(), resolution);
+				Mesh m = new();
-				sphereFaces[i].GenerateMesh();
+				Face f = new(directions[i], m, resolution);
+				f.GenerateMesh();
+
+				vertices.AddRange(m.Vertices);
+				for (int j = 0; j < m.Indices.Length; j++)
+				{
+					indices.Add(m.Indices[j] + (uint)(m.Vertices.Length * i));
 				}
 			}
+			// TODO get rid of overlapping vertices maybe
+			mesh.Clear();
+			mesh.Vertices = vertices.ToArray();
+			mesh.Indices = indices.ToArray();
+			mesh.CalculateNormals();
+		}
 		
 		/// <summary>
 		/// Renders the mesh. No Shader is specified and <see cref="CreateSphere"/> needs to be called beforehand 
 		/// </summary>
 		public void RenderSphere(GL gl) // Will not be needed  
 		{
-			// Use default shader etc. to render the sphere
+			mesh.Render(gl);
-			for (int i = 0; i < 6; i++)
-			{
-				sphereFaces[i].Mesh.Render(gl);
-			}
 		}
 	}