Cheese-water/path_mesh
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Updated for Godot 4.6

Browse source
This commit is contained in:
Patrick Marsee 2026-03-30 19:02:17 -04:00
parent 10c2e5f2b0
commit 9a8ed5cfce
2 changed files with 38 additions and 29 deletions
Download patch file Download diff file Expand all files Collapse all files

6
Cargo.toml
View file

@ -1,7 +1,7 @@
[package] [package]
name = "path_mesh" name = "path_mesh"
version = "0.1.0" version = "0.2.0"
edition = "2021" edition = "2024"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@ -9,4 +9,4 @@ edition = "2021"
crate-type = ["cdylib"] # Compile this crate to a dynamic C library. crate-type = ["cdylib"] # Compile this crate to a dynamic C library.
[dependencies] [dependencies]
godot = { git = "https://github.com/godot-rust/gdext", branch = "master" } godot = "0.5.0"

61
src/path_mesh_3d.rs
View file

@ -2,7 +2,6 @@ use crate::prelude::*;
use std::cmp::Eq; use std::cmp::Eq;
use std::cmp::PartialEq; use std::cmp::PartialEq;
use std::collections::HashMap; use std::collections::HashMap;
//use std::collections::BTreeMap;
use std::hash::Hash; use std::hash::Hash;
use std::hash::Hasher; use std::hash::Hasher;
use std::iter::zip; use std::iter::zip;
@ -13,7 +12,6 @@ use godot::classes::mesh::PrimitiveType;
use godot::classes::Mesh; use godot::classes::Mesh;
use godot::classes::ArrayMesh; use godot::classes::ArrayMesh;
use godot::classes::Curve3D; use godot::classes::Curve3D;
use godot::classes::Material;
use godot::classes::MeshInstance3D; use godot::classes::MeshInstance3D;
use godot::classes::IMeshInstance3D; use godot::classes::IMeshInstance3D;
@ -208,10 +206,10 @@ impl PathMesh3D {
let arrays = mesh.surface_get_arrays(i); let arrays = mesh.surface_get_arrays(i);
if let Ok(new_arrays) = self.process_array(&arrays, &mut data) { if let Ok(new_arrays) = self.process_array(&arrays, &mut data) {
new_mesh.add_surface_from_arrays(primitive, new_arrays); new_mesh.add_surface_from_arrays(primitive, &new_arrays);
new_mesh.surface_set_name(i, name); new_mesh.surface_set_name(i, &name);
if let Some(material) = mesh.surface_get_material(i) { if let Some(material) = mesh.surface_get_material(i) {
new_mesh.surface_set_material(i, material); new_mesh.surface_set_material(i, &material);
} }
} }
} }
@ -219,7 +217,8 @@ impl PathMesh3D {
if VERBOSE { if VERBOSE {
godot_print!("new_mesh.surface_count = {}", new_mesh.get_surface_count()); godot_print!("new_mesh.surface_count = {}", new_mesh.get_surface_count());
} }
self.base_mut().set_mesh(new_mesh.upcast::<Mesh>()); //self.base_mut().set_mesh(new_mesh.upcast::<Mesh>());
self.base_mut().set_mesh(&new_mesh);
} }
} }
} }
@ -231,43 +230,53 @@ impl PathMesh3D {
// Caching curve samples could speed up their processing. // Caching curve samples could speed up their processing.
// 2. Current method results in duplicate vertices where model ends meet. // 2. Current method results in duplicate vertices where model ends meet.
// Reusing previous vertices could speed up processing and be lighter on memory. // Reusing previous vertices could speed up processing and be lighter on memory.
let mut processed = VariantArray::new(); let mut processed = VarArray::new();
processed.resize(ArrayType::MAX.ord().try_into().unwrap(), &Variant::nil()); processed.resize(ArrayType::MAX.ord().try_into().unwrap(), &Variant::nil());
if data.curve.get_point_count() > 1 { if data.curve.get_point_count() > 1 {
let vertices = original.at(ARRAY_VERTEX).to::<PackedVector3Array>(); //must have let vertices = original.at(ARRAY_VERTEX).to::<PackedVector3Array>(); //must have
let new_vertices = self.generate_vertices(&vertices, data); let new_vertices = self.generate_vertices(&vertices, data);
if let Ok(normals) = original.at(ARRAY_NORMAL).try_to::<PackedVector3Array>() { let normals = original.at(ARRAY_NORMAL);
processed.set(ARRAY_NORMAL, self.generate_normals(&normals, &vertices, data).to_variant()); if !normals.is_nil() && let Ok(normals) = normals.try_to::<PackedVector3Array>() {
processed.set(ARRAY_NORMAL, &self.generate_normals(&normals, &vertices, data).to_variant());
} }
if let Ok(tangents) = original.at(ARRAY_TANGENT).try_to::<PackedFloat32Array>() { let tangents = original.at(ARRAY_TANGENT);
processed.set(ARRAY_TANGENT, self.generate_tangents(&tangents, &vertices, data).to_variant()); if !tangents.is_nil() && let Ok(tangents) = tangents.try_to::<PackedFloat32Array>() {
processed.set(ARRAY_TANGENT, &self.generate_tangents(&tangents, &vertices, data).to_variant());
} }
if let Ok(colors) = original.at(ARRAY_COLOR).try_to::<PackedColorArray>() { let colors = original.at(ARRAY_COLOR);
processed.set(ARRAY_COLOR, self.generate_colors(&colors, data).to_variant()); if !colors.is_nil() && let Ok(colors) = colors.try_to::<PackedColorArray>() {
processed.set(ARRAY_COLOR, &self.generate_colors(&colors, data).to_variant());
} }
if let Ok(uvs) = original.at(ARRAY_TEX_UV).try_to::<PackedVector2Array>() { let uvs = original.at(ARRAY_TEX_UV);
processed.set(ARRAY_TEX_UV, self.generate_uvs(&uvs, data).to_variant()); if !uvs.is_nil() {
} if let Ok(uvs) = uvs.try_to::<PackedVector2Array>() {
else if let Ok(_uvs) = original.at(ARRAY_TEX_UV).try_to::<PackedVector3Array>() { processed.set(ARRAY_TEX_UV, &self.generate_uvs(&uvs, data).to_variant());
processed.set(ARRAY_TEX_UV, self.generate_triplanar_uvs(&vertices).to_variant()); }
else if let Ok(uvs) = uvs.try_to::<PackedVector3Array>() {
processed.set(ARRAY_TEX_UV, &self.generate_triplanar_uvs(&vertices).to_variant());
}
} }
if let Ok(uvs) = original.at(ARRAY_TEX_UV2).try_to::<PackedVector2Array>() { let uvs = original.at(ARRAY_TEX_UV);
processed.set(ARRAY_TEX_UV2, self.generate_uvs(&uvs, data).to_variant()); if !uvs.is_nil() {
} if let Ok(uvs) = uvs.try_to::<PackedVector2Array>() {
else if let Ok(_uvs) = original.at(ARRAY_TEX_UV2).try_to::<PackedVector3Array>() { processed.set(ARRAY_TEX_UV2, &self.generate_uvs(&uvs, data).to_variant());
processed.set(ARRAY_TEX_UV2, self.generate_triplanar_uvs(&vertices).to_variant()); }
else if let Ok(uvs) = uvs.try_to::<PackedVector3Array>() {
processed.set(ARRAY_TEX_UV2, &self.generate_triplanar_uvs(&vertices).to_variant());
}
} }
if let Ok(indecies) = original.at(ARRAY_INDEX).try_to::<PackedInt32Array>() { let indecies = original.at(ARRAY_INDEX);
processed.set(ARRAY_INDEX, self.generate_indecies(&indecies, vertices.len() as i32, data).to_variant()); if !indecies.is_nil() && let Ok(indecies) = indecies.try_to::<PackedInt32Array>() {
processed.set(ARRAY_INDEX, &self.generate_indecies(&indecies, vertices.len() as i32, data).to_variant());
} }
processed.set(ARRAY_VERTEX, new_vertices.to_variant()); processed.set(ARRAY_VERTEX, &new_vertices.to_variant());
return Ok(processed); return Ok(processed);
} }
return Err(MeshArrayError::NotEnoughPoints); return Err(MeshArrayError::NotEnoughPoints);