map tests

assets/shaders/postprocess.glsl

@@ -28,6 +28,7 @@ void main() {
     int row = int(mod(gl_FragCoord.y, 4));
     float threshold = float(bayer16[col + 4 * row]) / 16.0 - 0.5;
     grey = clamp(grey + threshold * 0.1 , 0.01, 0.99);
+    // texelColor.rgb = clamp(texelColor.rgb + vec3(threshold * 0.1), 0.01, 0.99);
 
     vec2 paluv = vec2(grey, 0.5);
     vec4 paletteValue = texture(texture1, paluv);

assets/shaders/vshader.glsl

@@ -31,5 +31,6 @@ void main()
     fragNormal = normalize(vec3(matNormal*vec4(vertexNormal, 1.0)));
 
     // Calculate final vertex position
+    // vertexPosition = floor(vertexPosition * 6.0) / 6.0;
     gl_Position = mvp*vec4(vertexPosition, 1.0);
 }

collisions/main.odin

@@ -143,7 +143,7 @@ main :: proc() {
 	}
 	lights[0].power = 0.9
 	lights[0].distanceNear = 0
-	lights[0].distanceFar = 15
+	lights[0].distanceFar = 25
 	light_update_uniforms(&lights[0])
 	rl.SetShaderValue(shader, lights[0].distanceNearLoc, &(lights[0].distanceNear), .FLOAT)
 	rl.SetShaderValue(shader, lights[0].powerLoc, &(lights[0].power), .FLOAT)
@@ -157,32 +157,55 @@ main :: proc() {
 		material.shader = shader
 	}
 	Tri :: [3][3]f32
-	tris := [dynamic]Tri{}
+	Mesh :: struct {
+		aabb:      [2][3]f32,
+		triangles: [dynamic]Tri,
+	}
+	// tris := [dynamic]Tri{}
+	meshes := [dynamic]Mesh{}
+
 	// vtx := [dynamic]f32{}
 	scale: f32 = 0.04
 	for &mesh in mdl.meshes[:mdl.meshCount] {
 		// mesh := mdl.meshes[mdl.meshCount-1]
+		append(&meshes, Mesh{aabb = {{9999, 9999, 9999}, {-9999, -9999, -9999}}})
+		m := &(meshes[len(meshes) - 1])
 		fmt.printf("Mesh: %d %d\n", mesh.vertexCount, mesh.triangleCount)
 		for i: i32 = 0; i < mesh.vertexCount * 3; i += 9 {
+			tri := Tri{}
+			for j: i32 = 0; j < 3; j += 1 {
+				c := j * 3
+				for k: i32 = 0; k < 3; k += 1 {
+					value := mesh.vertices[i + c + k] * scale
+					if value < m.aabb[0][k] {
+						m.aabb[0][k] = value
+					}
+					if value > m.aabb[1][k] {
+						m.aabb[1][k] = value
+					}
+					tri[j][k] = value
+				}
+			}
 			append(
-				&tris,
+				&m.triangles,
-				Tri {
+				tri,
-					{
+				// Tri {
-						mesh.vertices[i] * scale,
+				// 	{
-						mesh.vertices[i + 1] * scale,
+				// 		mesh.vertices[i] * scale,
-						mesh.vertices[i + 2] * scale,
+				// 		mesh.vertices[i + 1] * scale,
-					},
+				// 		mesh.vertices[i + 2] * scale,
-					{
+				// 	},
-						mesh.vertices[i + 3] * scale,
+				// 	{
-						mesh.vertices[i + 4] * scale,
+				// 		mesh.vertices[i + 3] * scale,
-						mesh.vertices[i + 5] * scale,
+				// 		mesh.vertices[i + 4] * scale,
-					},
+				// 		mesh.vertices[i + 5] * scale,
-					{
+				// 	},
-						mesh.vertices[i + 6] * scale,
+				// 	{
-						mesh.vertices[i + 7] * scale,
+				// 		mesh.vertices[i + 6] * scale,
-						mesh.vertices[i + 8] * scale,
+				// 		mesh.vertices[i + 7] * scale,
-					},
+				// 		mesh.vertices[i + 8] * scale,
-				},
+				// 	},
+				// },
 			)
 			// append(&vtx, mesh.vertices[i] * scale)
 		}
@@ -263,25 +286,35 @@ main :: proc() {
 		vel *= 1.0 / (1.0 + delta * 2)
 
 		// Collide
-		for t in tris {
+		for mesh in meshes {
-			closest := closest_point_on_triangle(cam.position, t[0], t[1], t[2])
+			if cam.position.x + RAD < mesh.aabb[0].x &&
-			diff := cam.position - closest
+			   cam.position.y + RAD < mesh.aabb[0].y &&
-			dist := linalg.length(diff)
+			   cam.position.z + RAD < mesh.aabb[0].z &&
-			normal := diff / dist
+			   cam.position.x - RAD > mesh.aabb[1].x &&
-			diff.xz *= 2
+			   cam.position.y - RAD > mesh.aabb[1].y &&
-			dist = linalg.length(diff)
+			   cam.position.z - RAD > mesh.aabb[1].z {continue}
 
-			rl.DrawCubeV(closest, 0.05, dist > RAD ? rl.ORANGE : rl.WHITE)
 
-			if dist < RAD {
+			for t in mesh.triangles {
-				cam.position += normal * (RAD - dist)
+				closest := closest_point_on_triangle(cam.position, t[0], t[1], t[2])
-				// project velocity to the normal plane, if moving towards it
+				diff := cam.position - closest
-				vel_normal_dot := linalg.dot(vel, normal)
+				dist := linalg.length(diff)
-				if vel_normal_dot < 0 {
+				normal := diff / dist
-					vel -= normal * vel_normal_dot
+				diff.xz *= 2
-					if normal.y > 0.6 && !moving {
+				dist = linalg.length(diff)
-						vel.xz = rl.Vector2MoveTowards(vel.xz, {}, 35 * delta)
+
-						vel.y = 0
+				rl.DrawCubeV(closest, 0.05, dist > RAD ? rl.ORANGE : rl.WHITE)
+
+				if dist < RAD {
+					cam.position += normal * (RAD - dist)
+					// project velocity to the normal plane, if moving towards it
+					vel_normal_dot := linalg.dot(vel, normal)
+					if vel_normal_dot < 0 {
+						vel -= normal * vel_normal_dot
+						if normal.y > 0.6 && !moving {
+							vel.xz = rl.Vector2MoveTowards(vel.xz, {}, 35 * delta)
+							vel.y = 0
+						}
 					}
 				}
 			}
@@ -320,6 +353,15 @@ main :: proc() {
 		// 	rl.DrawSphere(tri[2], 0.5, rl.WHITE)
 		// 	rl.DrawTriangle3D(tri[0], tri[1], tri[2], rl.RED)
 		// }
+		// for mesh in meshes {
+		// 	// rl.DrawBoundingBox(rl.BoundingBox{min = mesh.aabb[0], max = mesh.aabb[1]}, rl.RED)
+		// 	for &tri in mesh.triangles {
+		// 		// rl.DrawSphere(tri[0], 0.5, rl.WHITE)
+		// 		// rl.DrawSphere(tri[1], 0.5, rl.WHITE)
+		// 		// rl.DrawSphere(tri[2], 0.5, rl.WHITE)
+		// 		// rl.DrawTriangle3D(tri[0], tri[1], tri[2], {255, 255, 255, 10})
+		// 	}
+		// }
 		rl.BeginShaderMode(shader)
 		rl.DrawModelEx(mdl, {}, {}, 0, 0.04, rl.WHITE)
 
@@ -343,6 +385,7 @@ main :: proc() {
 			0,
 			rl.WHITE,
 		)
+		rl.DrawFPS(0, 0)
 		rl.EndDrawing()
 	}
 }