TouhouGD/addons/MagicaVoxel_Importer_with_Extensions/CulledMeshGenerator.gd

const Faces = preload("./Faces.gd");
const vox_to_godot = Basis(Vector3.RIGHT, Vector3.FORWARD, Vector3.UP);

func generate(vox, voxel_data, scale, snaptoground):
	var generator = VoxelMeshGenerator.new(vox, voxel_data, scale, snaptoground);

	return generator.generate_mesh();

class MeshGenerator:
	var surfaces = {};

	func ensure_surface_exists(surface_index: int, color: Color, material: Material):
		if (surfaces.has(surface_index)): return;

		var st = SurfaceTool.new();
		st.begin(Mesh.PRIMITIVE_TRIANGLES);
		st.set_color(color);
		st.set_material(material);
		surfaces[surface_index] = st;

	func add_vertex(surface_index: int, vertex: Vector3):
		var st = surfaces[surface_index] as SurfaceTool;
		st.add_vertex(vertex);

	func combine_surfaces():
		var mesh = null;
		for surface_index in surfaces:
			var surface = surfaces[surface_index] as SurfaceTool;
			surface.index();
			surface.generate_normals();
			mesh = surface.commit(mesh);

			var new_surface_index = mesh.get_surface_count() - 1;
			var name = str(surface_index);
			mesh.surface_set_name(new_surface_index, name);
		return mesh;

class VoxelMeshGenerator:
	var vox;
	var voxel_data = {};
	var scale:float;
	var snaptoground:bool;

	func _init(vox,voxel_data,scale,snaptoground):
		self.vox = vox;
		self.voxel_data = voxel_data;
		self.scale = scale;
		self.snaptoground = snaptoground;

	func get_material(voxel):
		var surface_index = voxel_data[voxel];
		return vox.materials[surface_index]

	func face_is_visible(voxel, face):
		if (not voxel_data.has(voxel + face)):
			return true;
		var local_material = get_material(voxel);
		var adj_material = get_material(voxel + face);
		return adj_material.is_glass() && !local_material.is_glass();

	func generate_mesh():

		# Minimum extends of the volume
		var mins :Vector3 = Vector3(1000000, 1000000, 1000000)
		# Maximum extends of the volume
		var maxs :Vector3 = Vector3(-1000000,-1000000,-1000000)	

		# Find bounds
		for v in voxel_data:
			mins.x = min(mins.x, v.x)
			mins.y = min(mins.y, v.y)
			mins.z = min(mins.z, v.z)
			maxs.x = max(maxs.x, v.x)
			maxs.y = max(maxs.y, v.y)
			maxs.z = max(maxs.z, v.z)	

		var vox_to_godot = Basis(Vector3.RIGHT, Vector3.FORWARD, Vector3.UP);
		var yoffset = Vector3(0,0,0);
		if snaptoground : yoffset = Vector3(0, -mins.z * scale, 0);
		var gen = MeshGenerator.new();

		for voxel in voxel_data:
			var voxelSides = []
			if face_is_visible(voxel, Vector3.UP): voxelSides += Faces.Top
			if face_is_visible(voxel, Vector3.DOWN): voxelSides += Faces.Bottom
			if face_is_visible(voxel, Vector3.LEFT): voxelSides += Faces.Left
			if face_is_visible(voxel, Vector3.RIGHT): voxelSides += Faces.Right
			if face_is_visible(voxel, Vector3.BACK): voxelSides += Faces.Front
			if face_is_visible(voxel, Vector3.FORWARD): voxelSides += Faces.Back

			var surface_index = voxel_data[voxel];
			var color = vox.colors[surface_index];
			var material = vox.materials[surface_index].get_material(color);
			gen.ensure_surface_exists(surface_index, color, material);

			for t in voxelSides:
				gen.add_vertex(surface_index, yoffset + vox_to_godot * (t + voxel) * scale);

		return gen.combine_surfaces();