0

Description

"The following can be used as a mesh. It could be used in a `MultiMeshInstance3D`.\r\n\r\n> [!IMPORTANT]\r\n> Only vertices, normals and eventually indices are generated. No UV.\r\n\r\n## Structure\r\n\r\n\r\n\r\nA kelp leaf can be composed of two parts : The tip and the body. The tip is composed of two faces joining the two sides of the leaf at the top. The tip point is offset toward the interior part of the leaf.\r\nThe leaf is two folds of segmented quads.\r\n\r\nThe mesh is bounded to a box sized as follow : `[-cos(segment_angle), 0, 0] - [cos(segment_angle), 1, sin(segment_angle)]`\r\n\r\n## Parameters\r\n\r\n* **faceted** : if _true_, generates a mesh with per face normals, else, it generates a mesh with shared vertices and normals\r\n* **tip_set** : if _true_, generates a leaf tip\r\n* **tip_ratio** : sets the height taken by the tip\r\n* **segment_count** : sets the number of segments for the body\r\n* **segment_angle** : sets the angle made by the body\r\n\r\n## Usage Example\r\n\r\nThe coordinates are computed so the mesh could be easily manipulated through a vertex shader. The following shapes the leaf and makes it ondulating.\r\n\r\n> [!NOTE]\r\n> Due to the normal computation approximation, the faceted aspect of the mesh disappears.\r\n\r\n```glsl\r\nshader_type spatial;\r\n\r\nrender_mode cull_disabled;\r\n\r\nuniform vec3 leaf_color : source_color = vec3(0.3, 0.8, 0.4);\r\n\r\nuniform float height = 3.;\r\n\r\nuniform sampler2D width_variation : hint_default_white, repeat_disable;\r\n\r\nuniform float wave_num : hint_range(0., 8., .1) = 2.;\r\n\r\nuniform float wave_amplitude : hint_range(0., 2., .01) = .4;\r\n\r\nuniform float wave_speed : hint_range(0., 16.) = 0.;\r\n\r\nuniform float normal_offset : hint_range(0.001, 1., 0.001) = 0.001;\r\n\r\nvoid vertex() {\r\n\tVERTEX.x *= texture(width_variation, vec2(VERTEX.y, 0.)).r;\r\n\tfloat variation = TIME * wave_speed;\r\n\tfloat ratio = PI * wave_num;\r\n\tfloat my = wave_amplitude * sin((VERTEX.y - normal_offset) * ratio + variation) * (VERTEX.y - normal_offset);\r\n\tfloat py = wave_amplitude * sin((VERTEX.y + normal_offset) * ratio + variation) * (VERTEX.y + normal_offset);\r\n\r\n\tfloat x_angle = atan(py - my, 2. * normal_offset);\r\n\tfloat cs = cos(x_angle);\r\n\tfloat sn = sin(x_angle);\r\n\tmat3 x_rot = mat3(vec3(1., 0., 0.), vec3(0., cs, -sn), vec3(0., sn, cs));\r\n\tvec3 n = x_rot * NORMAL;\r\n\r\n\tNORMAL = n;\r\n\tVERTEX.z += (wave_amplitude * sin(VERTEX.y * PI * wave_num + TIME * wave_speed) * VERTEX.y);\r\n\tVERTEX.y *= height;\r\n}\r\n\r\nvoid fragment() {\r\n\tALBEDO = leaf_color;\r\n\tROUGHNESS = 0.2;\r\n}\r\n```\r\n"

Main code

@tool
class_name KelpLeaf
extends PrimitiveMesh

@export var faceted : bool = false :
	set(value) : faceted = value; request_update()

@export_subgroup("Tip", "tip")

@export var tip_set : bool = false :
	set(value) : tip_set = value; request_update()

@export_range(0.01, 0.99, 0.01) var tip_ratio : float = 0.2 :
	set(value) : tip_ratio = value; request_update()

@export_subgroup("Segment", "segment")

@export_range(1, 8, 1) var segment_count : int = 2 :
	set(value) : segment_count = value; request_update()

@export_range(0., PI/2., 0.01) var segment_angle : float = PI/6. :
	set(value) : segment_angle = value; request_update()

const TIP_VERTICES_SMOOTH : Array[Vector3] = [
	Vector3( 0., 1., 0.), Vector3(-1., 0., 0.), Vector3( 0., 0., 0.), Vector3( 1., 0., 0.)
]

const LEAF_VERTICES_SMOOTH : Array[Vector3] = [
	Vector3(-1., 0., 0.), Vector3( 0., 0., 0.), Vector3( 1., 0., 0.)
]

const TIP_INDICES_SMOOTH : Array[int] = [
	0, 2, 1, 0, 3, 2
]

const LEAF_INDICES_SMOOTH : Array[int] = [
	0, 4, 3, 0, 1, 4, 1, 2, 4, 2, 5, 4
]

const TIP_VERTICES_FACETED : Array[Vector3] = [
	Vector3( 0., 0., 0.), Vector3( 0., -1., 0.), Vector3(-1., -1., 0.),
	Vector3( 0., 0., 0.), Vector3( 1., -1., 0.), Vector3( 0., -1., 0.)
]

const LEAF_VERTICES_FACETED : Array[Vector3] = [
	Vector3(-1., 0., 0.), Vector3( 0., -1., 0.), Vector3(-1., -1., 0.), 
	Vector3(-1., 0., 0.), Vector3( 0.,  0., 0.), Vector3( 0., -1., 0.), 
	Vector3( 0., 0., 0.), Vector3( 1.,  0., 0.), Vector3( 0., -1., 0.), 
	Vector3( 1., 0., 0.), Vector3( 1., -1., 0.), Vector3( 0., -1., 0.)
]

func _create_faceted() -> Array:
	var body_height : float = 1. - tip_ratio if tip_set else 1.
	var segment_height : float = body_height / float(segment_count)
	var vertices : PackedVector3Array = PackedVector3Array()
	var normals : PackedVector3Array = PackedVector3Array()
	var vertices_count : int = (TIP_VERTICES_FACETED.size() if tip_set else 0) + segment_count * LEAF_VERTICES_FACETED.size()
	vertices.resize(vertices_count)
	normals.resize(vertices_count)
	
	# Structure pass
	var index : int = 0
	var cs : float = cos(segment_angle)
	var sn : float = -sin(segment_angle)

	if tip_set:
		for v in TIP_VERTICES_FACETED:
			vertices[index] = Vector3(v.x * cs, 1. + (v.y * tip_ratio), abs(v.x) * sn)
			index += 1
		vertices[0].z = sn / 2.; vertices[3].z = sn / 2.
	var current_height : float = body_height
	for i in range(segment_count):
		for v in LEAF_VERTICES_FACETED:
			vertices[index] = Vector3(v.x * cs, current_height + (v.y * segment_height), abs(v.x) * sn)
			index += 1
		current_height -= segment_height

	# Normal pass
	@warning_ignore("integer_division")
	var face_count : int = vertices_count / 3
	for i in range(face_count):
		var j : int = i * 3
		var n : Vector3 = -(vertices[j + 1] - vertices[j]).cross(vertices[j + 2] - vertices[j]).normalized()
		normals[j] = n; normals[j + 1] = n; normals[j + 2] = n
	
	# Return mesh
	var mesh : Array = []
	mesh.resize(Mesh.ARRAY_MAX)
	mesh[Mesh.ARRAY_VERTEX] = vertices
	mesh[Mesh.ARRAY_NORMAL] = normals
	return mesh


func _create_smooth() -> Array:
	var body_height : float = 1. - tip_ratio if tip_set else 1.
	var segment_height : float = body_height / float(segment_count)
	var current_height : float = body_height
	var vertices : Array[Vector3] = []
	var indices : Array[int] = []

	# Structure pass
	if tip_set:
		vertices.append_array(TIP_VERTICES_SMOOTH)
		indices.append_array(TIP_INDICES_SMOOTH)
		vertices[1].y = current_height ; vertices[2].y = current_height ; vertices[3].y = current_height
	else:
		vertices.append_array(LEAF_VERTICES_SMOOTH)
		vertices[0].y = current_height ; vertices[1].y = current_height ; vertices[2].y = current_height
	for i in range(segment_count):
		current_height -= segment_height
		var c : int = vertices.size()
		vertices.append_array(LEAF_VERTICES_SMOOTH)
		for j in range(3):
			vertices[c + j].y = current_height
		for j in LEAF_INDICES_SMOOTH:
			indices.append(j + c - 3)

	# Value adjustment pass
	var vertices_count : int = vertices.size()
	var normals : PackedVector3Array = PackedVector3Array()
	normals.resize(vertices_count)
	normals.fill(Vector3(0., 0., 1.))

	var cs : float = cos(segment_angle)
	var sn : float = -sin(segment_angle)

	if tip_set:
		vertices[0].z = sn / 2.
		normals[0].y = -sn / 2. ; normals[0].z = tip_ratio; normals[0] = normals[0].normalized()
	for i in range(1 if tip_set else 0, vertices_count):
		normals[i] = Vector3(-vertices[i].x * sn, 0., cs)
		vertices[i] = Vector3(vertices[i].x * cs, vertices[i].y, abs(vertices[i].x) * sn)

	# Return mesh
	var mesh : Array = []
	mesh.resize(Mesh.ARRAY_MAX)
	mesh[Mesh.ARRAY_VERTEX] = PackedVector3Array(vertices)
	mesh[Mesh.ARRAY_INDEX] = PackedInt32Array(indices)
	mesh[Mesh.ARRAY_NORMAL] = normals
	return mesh

# Primitive Mesh entry point
func _create_mesh_array() -> Array:
	return _create_faceted() if faceted else _create_smooth()

Comments