2

Description

"This script allows generating the mesh information for a single crystal shard cluster. The entry point function is `genereate_cluster` which returns an array of vertices, indices, normals, uvs and colors. The data returned by this function can be directly used as an input of an `ArrayMesh`.\r\n\r\n> [!WARNING]\r\n> The mesh generator makes heavy use of random generated data.\r\n> This may not be suitable for `PrimitiveMesh` or as instance of a `MultiMeshInstance3D`.\r\n> However, with a bit of adaptation and a supplemental vertex shader, a per-instance parameterization could be done. But it is not in the scope of this snippet.\r\n\r\n### Parameters\r\n\r\nThe in-editor interface is the following :\r\n\r\n\r\n> [!NOTE]\r\n> In the following, you will find many pairs of parameters as \"param \/ param_variance\". It is related to the randomness of the generation. Given those values, a parameter will be randomly chosen in the interval \\[param - param_variance, param + param_variance\\] .\r\n\r\n* **Cluster** : Crystal cluster characteristics\r\n * **crystal_min_sides** *(from 3 to 6, default 3)* : Minimum number of sides\r\n * **crystal_max_sides** *(from 3 to 8, default 5)* : Maximum number of sides\r\n * **crystal_min_satellites** *(from 0 to 12, default 3)* : Minimum number of satellite crystals\r\n * **crystal_max_satellites** *(from 0 to 12, default 7)* : Maximum number of satellite crystals\r\n* **Crystal** : Crystal shard characteristics\r\n * **Size** : Common sizing info\r\n * **base_size_ratio** *(default 0.8)* : Determine the ratio of size between the base of the crystal and the upper rim\r\n * **base_size_variance** *(default 0.1)* : Determine the variation range of the base size ratio\r\n * **height_ratio** *(default 3)* : Height of the crystal\r\n * **height_variance** *(default 0.2)* : Height variation\r\n * **Point** : Shard point info\r\n * **Height** : Point height\r\n\t\t\t* **point_height_ratio** *(default 0.3)* : Height ratio of the point compared to the overall crystal height \r\n * **point_height_variance** *(default 0.1)* : Height ratio variance\r\n * **Offset** : Point offsetting from the center\r\n\t\t\t* **point_offset** *(default 0.3)* : Distance ratio of the point offset from the center of the crystal (on XZ plane)\r\n * **point_offset_variance** *(default 0.2)* : Offset variance\r\n* **Satellites** : Satellite crystals characteristics\r\n\t* **satellites_independant_topology** *(default true)* : Determines if the topology (number of faces, etc.) of the satellites must mimmick the one of the central shard or if the satellites should use randomisation\r\n\t* **Size** : Sizing info relative to main shard\r\n\t\t* **satellite_size_ratio** *(default 0.6)* : Size ratio compared to central shard\r\n * **satellite_size_variance** *(default 0.1)* : Size ratio variance\r\n\t* **Angle** : Angle info (as the satellite shards are rotated relatively to the central shard)\r\n\t\t* **satellites_angle** *(default 0.385)* : Angle from the center (in radians)\r\n * **satellites_angle_variance** *(default 0.2)* : Angle variance (in radians)\r\n\t* **Distance** : Distance from the center\r\n\t\t* **satellites_distance** *(default 0.8)* : Distance from the center\r\n * **satellites_distance_variance** *(default 0.1)* : Distance variance\r\n\r\n### Example of Rendering\r\n\r\n\r\n\r\n> [!TIP] \r\n> A possible rendering consists in applying a neat fresnel effect. The following minimal shader is used for the previous screenshot.\r\n\r\n```glsl\r\nshader_type spatial;\r\n\r\nuniform vec4 base_color : source_color = vec4(0.5, 0.2, 0.9, 1.0);\r\nuniform vec4 fresnel_color : source_color = vec4(0.0, 0.7, 0.9, 1.0);\r\n\r\nvec3 fresnel_glow(float amount, float intensity, vec3 color, vec3 normal, vec3 view)\r\n{\r\n\treturn pow((1.0 - dot(normalize(normal), normalize(view))), amount) * color * intensity;\r\n}\r\n\r\nvoid fragment() {\r\n vec3 glow_fresnel = fresnel_glow(4.0, 4.5, fresnel_color.rgb, NORMAL, VIEW);\r\n\r\n ALBEDO = base_color.rgb + glow_fresnel;\r\n CLEARCOAT = 0.9;\r\n CLEARCOAT_ROUGHNESS = 0.035;\r\n EMISSION = glow_fresnel;\r\n}\r\n```"

Main code

class_name CrystalGenerator
extends Node

@export_group("Cluster")
@export_range(3, 6) var crystal_min_sides : int = 3
@export_range(3, 8) var crystal_max_sides : int = 5
@export_range(0, 12) var crystal_min_satellites : int = 3
@export_range(0, 12) var crystal_max_satellites : int = 7
@export_group("Crystal")
@export_subgroup("Size")
@export var base_size_ratio : float = 0.8
@export var base_size_ariance : float = 0.1
@export var height_ratio : float = 3
@export var height_variance : float = 0.2
@export_subgroup("Point")
@export_subgroup("Point/Height")
@export var point_height_ratio : float = 0.3
@export var point_height_variance : float = 0.1
@export_subgroup("Point/Offset")
@export var point_offset : float = 0.3
@export var point_offset_variance : float = 0.2
@export_group("Satellites")
@export var satellites_independant_topology : bool = true
@export_subgroup("Size")
@export var satellite_size_ratio : float = 0.6
@export var satellite_size_variance : float = 0.1
@export_subgroup("Angle")
@export var satellites_angle : float = 0.385
@export var satellites_angle_variance : float = 0.2
@export_subgroup("Distance")
@export var satellites_distance : float = 0.8
@export var satellites_distance_variance : float = 0.1

const QUAD_COL : Color = Color.RED
const TRI_COL : Color = Color.BLUE

func _generate_shard() -> Array:
	var sides : int = randi_range(min(crystal_min_sides, crystal_max_sides), max(crystal_min_sides, crystal_max_sides))
	# Generate base.
	var vertices : Array[Vector3] = []
	var normals : Array[Vector3] = []
	var uvs : Array[Vector2] = []
	var colors : Array[Color] = []
	var angle_dist : float = (2 * PI) / float(sides)
	var angle_offset : float = randf_range(0, PI/2)
	var base_ratio : float = randf_range(base_size_ratio - base_size_ariance, base_size_ratio + base_size_ariance)
	for i in range(sides):
		var left : Vector3 = (Vector3.BACK * base_ratio).rotated(Vector3.UP, angle_offset + ((i - 0.5) * angle_dist))
		var right : Vector3 = (Vector3.BACK * base_ratio).rotated(Vector3.UP, angle_offset + ((i + 0.5) * angle_dist))
		vertices.append(left)
		vertices.append(right)
		uvs.append(Vector2(0, 0))
		uvs.append(Vector2(1, 0))
		colors.append(QUAD_COL)
		colors.append(QUAD_COL)
		normals.append(Vector3.UP)
		normals.append(Vector3.UP)

	# Extrude.
	var max_up : float = 0.0
	var extrude_offset : Array[Vector3] = []
	for i in range(sides):
		var crystal_up : float = randf_range(height_ratio - height_variance, height_ratio + height_variance)
		if max_up < crystal_up:
			max_up = crystal_up
		extrude_offset.append(Vector3.UP * 2.0 * crystal_up)
	for i in range(sides):
		var left : Vector3 = Vector3.BACK.rotated(Vector3.UP, angle_offset + ((i - 0.5) * angle_dist))
		var right : Vector3 = Vector3.BACK.rotated(Vector3.UP, angle_offset + ((i + 0.5) * angle_dist))
		vertices.append(left + extrude_offset[i])
		uvs.append(Vector2(0, 1))
		colors.append(QUAD_COL)
		vertices.append(right + extrude_offset[(i+1) % (sides)])
		uvs.append(Vector2(1, 1))
		colors.append(QUAD_COL)
		normals.append(Vector3.UP)
		normals.append(Vector3.UP)

	# Compute indices and normals.
	var indices : Array[int] = []
	for i in range(sides):
		var first : Array[int] = [
			2 * (i + sides),
			(i * 2) + 1,
			(i * 2)
		]
		var second : Array[int] = [
			2 * (i + sides),
			((i * 2) + 1) + (2 * sides),
			(i * 2) + 1
		]
		# Compute normal.
		var n : Vector3 = -(vertices[first[0]] - vertices[first[1]]).cross(vertices[first[0]] - vertices[first[2]]).normalized()
		indices.append_array(first)
		indices.append_array(second)
		normals[first[0]] = n
		normals[first[1]] = n
		normals[first[2]] = n
		normals[second[1]] = n

	var crystal_point : float = 2.0 * max_up * (1 + randf_range(point_height_ratio - point_height_variance, point_height_ratio + point_height_variance))
	var point_distance : float = cos(0.5 * angle_dist) * randf_range(point_offset - point_offset_variance, point_offset + point_offset_variance)
	var point_angle : float = randf() * 2 * PI
	for i in range(sides):
		vertices.append(Vector3(0, 0, point_distance).rotated(Vector3.UP, point_angle) + Vector3(0, crystal_point, 0))
		uvs.append(Vector2.ZERO)
		colors.append(TRI_COL)
		var face : Array[int] = [
			vertices.size() - 1,
			((i * 2) + 1) + (2 * sides),
			2 * (i + sides) ]
		vertices.append(vertices[face[1]])
		uvs.append(Vector2(1, 0))
		colors.append(TRI_COL)
		vertices.append(vertices[face[2]])
		uvs.append(Vector2(0, 1))
		colors.append(TRI_COL)
		indices.append_array([vertices.size() - 3, vertices.size() - 2, vertices.size() - 1])
		var n : Vector3 = -(vertices[face[0]] - vertices[face[1]]).cross(vertices[face[0]] - vertices[face[2]]).normalized()
		normals.append(n)
		normals.append(n)
		normals.append(n)
	return [vertices, normals, indices, uvs, colors]

func generate_cluster() -> Array:
		# Base shard.
	var result : Array = _generate_shard()

	var vertices : Array[Vector3] = result[0]
	var normals : Array[Vector3] = result[1]
	var indices : Array[int] = result[2]
	var uvs : Array[Vector2] = result[3]
	var colors : Array[Color] = result[4]
	
	var global_vertices : Array[Vector3] = []
	var global_normals : Array[Vector3] = []
	var global_indices : Array[int] = []
	var global_uvs : Array[Vector2] = []
	var global_colors : Array[Color] = []
	
	# Add the core crystal.
	global_vertices.append_array(vertices)
	global_normals.append_array(normals)
	global_indices.append_array(indices)
	global_uvs.append_array(uvs)
	global_colors.append_array(colors)

	# Add satellites.
	var crystal_satellites : int = randi_range(min(crystal_min_satellites, crystal_max_satellites), max(crystal_min_satellites, crystal_max_satellites))
	if crystal_satellites > 0:
		var angle_dist : float = (2 * PI) / float(crystal_satellites)
		var angle_offset : float = randf_range(0.0, angle_dist)
		for i in range(crystal_satellites):
			var x_angle : float = randf_range(satellites_angle - satellites_angle_variance, satellites_angle + satellites_angle_variance)
			var s_scale : float = randf_range(satellite_size_ratio - satellite_size_variance, satellite_size_ratio + satellite_size_variance)
			var s_dist : float = randf_range(satellites_distance - satellites_distance_variance, satellites_distance + satellites_distance_variance)
			var s_vertices : Array[Vector3] = []
			var s_normals : Array[Vector3] = []
			var s_indices : Array[int] = []
			var v_transform : Transform3D = Transform3D.IDENTITY
			v_transform = v_transform.scaled(Vector3(s_scale, s_scale, s_scale))
			v_transform = v_transform.rotated(Vector3.UP, (i * angle_dist) + angle_offset)
			v_transform = v_transform.translated(Vector3(0, 0, s_dist))
			v_transform = v_transform.rotated(Vector3(1, 0, 0), x_angle)
			var n_transform : Transform3D = Transform3D.IDENTITY
			n_transform = n_transform.rotated(Vector3.UP, (i * angle_dist) + angle_offset)
			n_transform = n_transform.rotated(Vector3(1, 0, 0), x_angle)
			
			var v_source : Array[Vector3]
			var n_source : Array[Vector3]
			var i_source : Array[int]
			var u_source : Array[Vector2]
			var c_source : Array[Color]
			if satellites_independant_topology:
				result = _generate_shard()
				v_source = result[0]
				n_source = result[1]
				i_source = result[2]
				u_source = result[3]
				c_source = result[4]
			else:
				v_source = vertices
				n_source = normals
				i_source = indices
				u_source = uvs
				c_source = colors

			for j in v_source:
				s_vertices.append(j * v_transform)
			for j in n_source:
				s_normals.append(j * n_transform)
			var start_idx : int = global_vertices.size()
			for j in i_source:
				s_indices.append(j + start_idx)
			global_vertices.append_array(s_vertices)
			global_normals.append_array(s_normals)
			global_indices.append_array(s_indices)
			global_uvs.append_array(u_source)
			global_colors.append_array(c_source)
	
	return [ global_vertices, global_normals, global_indices, global_uvs, global_colors ]

Comments