Allow Rotation of Billboard Sprite3Ds

[Gastronok]

Describe the project you are working on: I'm working on a 2.5D game where the world is 3D but the characters are flat 2D sprites that always face forward.

Describe the problem or limitation you are having in your project: I would like to animate the rotation of one of my player sprites so that it looks like they are flipping upside-down.

As it turns out, Rotation Degrees X/Y/Z have no effect on Sprite3Ds while in Billboard mode.

This makes sense for 2 of the 3 axes (depending on which axis is billboarded) because those need to be fudged in order to make sure the sprite is always facing "forward", but the third axis still makes sense for rotation.

Describe how this feature / enhancement will help you overcome this problem or limitation: Intuitively, one expects to be able to rotate sprites that are facing the screen. Doing so via vector math is complicated, and baking the rotation into a sprite sheet is impractical. Adding this feature to Godot would cause the engine to behave more in line with user expectations.

Show a mock up screenshots/video or a flow diagram explaining how your proposal will work

Here's the billboarded sprite as it currently exists, with a slight offset to the camera angle that's effectively "ignored" by billboarding:

Rotating along the Z-axis has no effect:

Turning off billboarding gets the desired rotation, but now the sprite isn't directly facing the camera:

However it's still clearly possible to have the sprite both face the camera and be rotated along this axis. In this case that was faked by adding some Y-rotation:

Ideally I'd be able to end up with that last screenshot merely by setting the Z-rotation of a billboarded Sprite3D.

Describe implementation detail for your proposal (in code), if possible: I don't know enough about the back-end implementation but it ought to be pretty simple: take into account rotation values for whatever axis we're billboarded on, and apply them to the final rendering.

If this enhancement will not be used often, can it be worked around with a few lines of script? One would have to figure out the vector math necessary to perform billboarding relative to the current active camera and then apply it to every in-game object they wanted to rotate. That seems like a lot for a property that's already exposed in the editor (but ignored in billboard mode).

Is there a reason why this should be core and not an add-on in the asset library? It affects core functionality.

[aXu-AP]

One could write a custom shader to accomplish this.
As a starting point, make a new spatial material with billboard mode set, then convert it to shader material (you'll get the code to use as a template). I think you'll need to change just 1-2 lines to add rotation.

[Gastronok]

The math there may or may not be complicated, but it at least requires a higher degree of domain-specific knowledge than most hobbyists are likely to have, myself included.

That seems like an avenue for a workaround but I still think it's consistent with Godot's design philosophy to make it a core feature. As you just demonstrated, regular billboarding could be accomplished through shaders but for a variety of reasons they decided to expose it as first-class functionality in the engine.

[aXu-AP]

Here's implementation in gdscript. Altough I earlier suggested doing this in shader, this works too:

extends Sprite3D

# Rotation in radians
export(float, -3.142, 3.142) var sprite_rotation : float = 0.0
# Upright position (still rotateable)
export var y_billboard = false

func _process(_delta: float) -> void:
	# Get camera coordinates
	var cam : Camera = get_viewport().get_camera()
	var look_pos : Vector3 = cam.global_translation
	
	# If billboard should be upright, look at camera, but at the height of the object itself
	if y_billboard:
		look_pos.y = global_translation.y
	
	# First look directly at the camera, then rotate around own axis
	# Note: as an up axis here is camera's up, but one might want to use Vector3.UP instead
	look_at(look_pos, cam.global_transform.basis.y)
	rotate_object_local(Vector3.FORWARD, sprite_rotation)

Just slap this into Sprite3D and you're good to go (set Billboard mode to disabled first).

However, if this would make into core, I think it would make sense to accomplish this via modifying standard shader to support rotated billboard mode.

[ratkingsminion]

Just a remark: look_pos : Vector3 = cam.global_translation should be look_pos : Vector3 = global_translation - cam.global_transform.basis.z, because it looks better to let the sprite look into the direction of the camera, instead of at the camera directly. In Godot 4, change global_translation to global_position.

Also instead of adding sprite_rotation value one could get the rotation via var rot := rotation.z at the start of _process and at the end, instead of using rotate_object_local just change it back via rotation.z = rot.

[aXu-AP]

it looks better to let the sprite look into the direction of the camera

Thanks for this addition. It depends on what is the desired look. Personally I'm not huge fan of this technique, since sprites rotate along with the camera and sprites at the very edges of the screen look flatter.

instead of adding sprite_rotation

Wouldn't this result in the sprite spinning uncontrollably since you're modifying the rotation.z every frame and use that as the input on the next frame?

[ratkingsminion]

No, rotation.z doesn't get modified, it actually gets resets after look_at modified it.

[aXu-AP]

You may be right, now that I give it a second thought. At least if we assume that up is Y+ and rotation order is left to YXZ. I'm not sure about the other cases, I don't have too strong intuition of 3d rotations.

[thibault]

I know this is an old discussion, but since I stumbled here looking for the same thing, here is what I came up with.

/**
 * Generate a transformation matrix.
 * This code comes from the Terrain3D project.
 */
mat3 rotation_matrix(vec3 axis, float angle) {
	float c = cos(angle);
	float s = sin(angle);
	float t = 1.0 - c;
	vec3 n = normalize(axis);
	float x = n.x;
	float y = n.y;
	float z = n.z;

	return mat3(
		vec3(t * x * x + c, t * x * y - z * s, t * x * z + y * s),
		vec3(t * x * y + z * s, t * y * y + c, t * y * z - x * s),
		vec3(t * x * z - y * s, t * y * z + x * s, t * z * z + c));
}

void vertex() {
	// Billboard Mode: Enabled (default Godot shader)
	MODELVIEW_MATRIX = VIEW_MATRIX * mat4(
			MAIN_CAM_INV_VIEW_MATRIX[0],
			MAIN_CAM_INV_VIEW_MATRIX[1],
			MAIN_CAM_INV_VIEW_MATRIX[2],
			pos_matrix);
			
	// rotation along the Z axis
        // This is the added part
	vec3 orientation = vec3(0.0, 0.0, 1.0);
        // angle is a value between 0.0 and 1.0
	float angle = INSTANCE_CUSTOM.z;
	mat3 rotation = rotation_matrix(orientation, angle * TAU);
	MODELVIEW_MATRIX = MODELVIEW_MATRIX * mat4(rotation);		

	// Billboard Keep Scale: Enabled
	MODELVIEW_MATRIX = MODELVIEW_MATRIX * mat4(
			vec4(length(MODEL_MATRIX[0].xyz), 0.0, 0.0, 0.0),
			vec4(.0, length(MODEL_MATRIX[1].xyz), 0.0, 0.0),
			vec4(0.0, 0.0, length(MODEL_MATRIX[2].xyz), 0.0),
			vec4(0.0, 0.0, 0.0, 1.0));
	MODELVIEW_NORMAL_MATRIX = mat3(MODELVIEW_MATRIX);
}