Odd Results from Barycentric Coordinates and Mesh Normals [4.2 dev6]

paftdunk

xyz Done and all good there now.

I'm going to raise this and I think it should be the last thing I'll need. I've started to make my own meshes - as the below video shows. The bouncing I was experiencing in earlier posts was absolutely due to the meshes I got from another source. My own meshes have been just fine.

Now, I'm working on getting ramps like this set up. Because it is so steep, I'm of course not surprised by the choppiness of ascending it.

The feel I'm going more towards (trying to recreate exactly, just using this as inspiration) is from older skateboarding/sports games. Similar to this:

As you can see, it's not perfectly smooth, it's still a little bumpy. Of course, I'm fine with getting it as smooth as I can, but I'm going for a stylized retro feel. Would messing with the slerp be the only way to do this? Or should I stick to rounder/smoother meshes?

xyz

paftdunk You need to average/smooth the vertex normals. Your mesh looks like all face vertices have the face normal i.e. it's "flat shaded". If that's the case then bary interpolation does nothing as it interpolates between 3 exactly same normals You can check this by printing the normals. Use auto smooth modifier in blender. If you want it to look flat shaded but to behave smooth then you'll need two versions of the mesh; one for looks and another (invisible one) for normal sampling. Note that the difference between the two is only in normals. The rest of the geometry can be exactly the same. Alternatively you can use a single mesh with smooth normals but bake a normal map that makes it appear flat shaded when lit.

a_kimb0

Hi all!

I've been doing a project similar to this for a while, and have read through and understood the majority of this thread along with the math, save for the aligning to face normals part.

For some reason, in the video shown, it seems that my ship is aligning itself 'nose down' to the mesh's normal. I am unsure as to why this is happening.

I've also attached my current code. I'm unsure if the way I'm handling input and having my ship's mesh rotate could be affecting this, because as far as I know I've done everything pretty much to a T like in this thread.

`func snap_raycast(delta: float) -> void:
if front_raycast.is_colliding():
velocity.y = 0

	var col_mesh = front_raycast.get_collider()
	
	if col_mesh is CollisionGeometry:
		var face_index := front_raycast.get_collision_face_index()
		var vertex_points : Array[Vector3] = col_mesh.get_vertex_positions_at_face_index(face_index)
		var vertex_normals : Array[Vector3] = col_mesh.get_vertex_normals_at_face_index(face_index)
		
		for i in 3:
			csg_array[i].global_position = col_mesh.to_global(vertex_points[i])
		
		var bary_coords : Vector3 = Geometry3D.get_triangle_barycentric_coords(
		front_raycast.get_collision_point(),  
		vertex_points[0], 
		vertex_points[1], 
		vertex_points[2]
		)
		
		var tri_normal : Vector3 = (
			(vertex_normals[0] * bary_coords.x) + 
			(vertex_normals[1] * bary_coords.y) + 
			(vertex_normals[2] * bary_coords.z))
		
		tri_normal = tri_normal.normalized()
		align_body(tri_normal, delta)
else:
	velocity.y -= 5.0 * gravity * delta`

`func align_body(up_normal : Vector3, _delta: float):
var new_basis = Basis()
new_basis.y = up_normal
new_basis.x = up_normal.cross(basis.z).normalized()
new_basis.z = new_basis.x.cross(new_basis.y).normalized()
new_basis = new_basis.orthonormalized()

basis = basis.slerp(new_basis, 0.25)
up_direction = up_normal`

`func handle_driving_input(delta: float) -> void:
var forward_dir = global_transform.basis.z.normalized()
turn_direction = Input.get_axis("turn_right", "turn_left")
is_boosting = Input.is_action_pressed("boost")

if turn_direction:
	rotate_object_local(Vector3(0,1,0), turn_direction * delta)
	#rotate_y(turn_direction * deg_to_rad(vehicle_turn_speed) * delta)
ship_lean(turn_direction, delta)

if is_boosting:
	speed = move_toward(speed, vehicle_top_speed, vehicle_acceleration * delta)
else:
	speed = move_toward(speed, 0.0, vehicle_deceleration * delta)

adjust_properties(is_boosting, delta)

speed = clampf(speed, 0.0, vehicle_top_speed)
velocity.x = forward_dir.x * speed
velocity.z = forward_dir.z * speed`

snap_raycast is called in the physics_process function.
`func ship_lean(direction : float, delta: float) -> void:
var desired_rotation : Vector3 = Vector3.ZERO
#var desired_airbrake_rotation : Vector3 = Vector3.ZERO

if direction != 0.0:
	desired_rotation = Vector3(target_rotation.x, target_rotation.y * direction, target_rotation.z * direction)
#elif direction != 0.0 and Input.is_action_pressed("airbrake"):
	#print("airbraking")
	#desired_rotation = Vector3(target_airbrake_rotation.x, target_airbrake_rotation.y * direction, target_airbrake_rotation.z * direction)
else:
	desired_rotation = Vector3.ZERO
	window_camera.rotation_degrees = Vector3(0, 180, 0)
	#desired_airbrake_rotation = Vector3.ZERO

var curr_rotation = ship_mesh.rotation_degrees
var new_rot = curr_rotation.lerp(desired_rotation, delta * 5.0)
ship_mesh.rotation_degrees = new_rot`

[

xyz

a_kimb0 I'm unsure if the way I'm handling input and having my ship's mesh rotate could be affecting this

Well then remove the input part and check if the problem persists. If yes then it's likely in the actual mesh orientation in respect to player basis. You can either re-orient the mesh manually, or change the axis designation when calculating the basis in align_body()

a_kimb0

xyz Thanks. I took out any input and rotation logic that could have interfered with the alignment code, and I'm still getting issues. I have some debug logs that show the before and after my alignment code is applied once the raycast hits the mesh geometry:

initial basis: [X: (-0.0, 0.0, 1.0), Y: (0.0, 1.0, 0.0), Z: (-1.0, 0.0, -0.0)]
initial transform: [X: (-0.0, 0.0, 1.0), Y: (0.0, 1.0, 0.0), Z: (-1.0, 0.0, -0.0), O: (223.101, 6.545028, 88.8496)]
initial rotation: (0.0, -90.0, 0.0)

triangle normal: (0.994036, 0.106564, 0.023145)
current ship basis: [X: (-0.0, 0.0, 1.0), Y: (0.0, 1.0, 0.0), Z: (-1.0, 0.0, -0.0)]
new basis: [X: (0.0, 0.21224, -0.977217), Y: (0.994036, 0.106564, 0.023145), Z: (0.109049, -0.97139, -0.210975)]

adjusted basis: [X: (0.0, 0.21224, -0.977217), Y: (0.994036, 0.106564, 0.023145), Z: (0.109049, -0.97139, -0.210975)]
adjusted transform: [X: (0.0, 0.21224, -0.977217), Y: (0.994036, 0.106564, 0.023145), Z: (0.109049, -0.97139, -0.210975), O: (223.101, 6.545028, 88.8496)]
adjusted rotation: (76.26151, 152.6664, 63.33912)

Would there be any reason why the rotation suddenly jumps from -90 deg to this new random angle? It seems like the basis alignment is working correctly unless I'm mistaken.

xyz

a_kimb0 Euler rotation numbers are not important. Focus on calculating correct basis vectors.

« Previous Page