Struct EditableMesh 

pub struct EditableMesh {
    pub vertices: Vec<Vertex>,
    pub indices: Vec<u32>,
    pub revision: u64,
}

Scene-persistent geometry. Increment revision after manual vertex/index changes.

Fields

vertices: Vec<Vertex>

Position, normal and UV attributes, indexed by triangle data.

indices: Vec<u32>

Triangle-list topology.

revision: u64

Version of geometry; update increments refresh the shared GPU mesh.

Implementations

impl EditableMesh

pub fn vertex_count(&self) -> usize

Number of vertices.

pub fn position(&self, i: usize) -> Option<Vec3>

Local position of vertex i.

pub fn set_position(&mut self, i: usize, p: Vec3) -> bool

Moves one vertex. Returns false for a bad index or a non-finite position.

pub fn bounds(&self) -> (Vec3, Vec3)

Axis-aligned local bounds (min, max); both zero for an empty mesh.

pub fn map_positions(&mut self, f: impl FnMut(usize, Vec3, Vec3) -> Vec3)

Replaces every position with f(index, position, normal). Non-finite results are ignored.

pub fn select_sphere(&self, center: Vec3, radius: f32) -> Vec<usize>

Indices of the vertices inside a sphere (local space): the selection for brush-like edits.

pub fn select_half_space(&self, point: Vec3, normal: Vec3) -> Vec<usize>

Indices of the vertices on the positive side of a plane through point with normal.

pub fn translate_vertices(&mut self, indices: &[usize], delta: Vec3)

Adds delta to the listed vertices.

pub fn translate(&mut self, delta: Vec3)

Moves the whole mesh.

pub fn scale_about(&mut self, center: Vec3, scale: Vec3)

Scales around center per axis.

pub fn transform(&mut self, m: Mat4)

Applies an arbitrary matrix to positions and (rotation part only) normals.

pub fn inflate(&mut self, amount: f32)

Pushes every vertex along its normal (amount metres; negative shrinks).

pub fn twist(&mut self, axis: Vec3, degrees_per_metre: f32)

Twists the mesh around axis through the origin: degrees_per_metre of rotation per metre along the axis.

pub fn taper(&mut self, axis: Vec3, start: f32, end: f32)

Scales the cross-section along axis: start at the lowest point of the mesh, end at the highest.

pub fn bend(&mut self, along: Vec3, bend_axis: Vec3, degrees_per_metre: f32)

Bends the mesh around the bend_axis direction: points are rotated around it by degrees_per_metre times their distance along along.

pub fn wave( &mut self, direction: Vec3, displace: Vec3, amplitude: f32, wavelength: f32, phase: f32, )

A travelling sine wave: vertices move along displace by amplitude * sin(2pi * (d / wavelength + phase)), where d is the position along direction.

pub fn noise_displace(&mut self, noise: &Noise, amplitude: f32, time: f32)

Displaces vertices along their normals by 3D noise (rocks, terrain, hand-made wobble). time slides the noise so repeated calls animate.

pub fn smooth(&mut self, iterations: u32, factor: f32)

Laplacian smoothing: moves each vertex towards the average of its neighbours. Vertices that share a position stay together (hard-edged meshes do not tear).

pub fn default_noise(frequency: f32, seed: u32) -> Noise

A ready noise for Self::noise_displace: smooth Perlin at the given frequency.

impl EditableMesh

pub fn from_mesh(mesh: &MeshData) -> Result<Self, String>

Copies the geometry of a validated source. Material images remain on MeshRenderer.

pub fn mesh(&self) -> MeshData

CPU mesh snapshot, with no imported material runs.

pub fn changed(&mut self)

Marks vertex/index modifications for upload.

pub fn recalculate_normals(&mut self) -> Result<(), String>

Rebuilds area-weighted normals after deformation.

pub fn box_uv(&mut self, scale: f32) -> Result<(), String>

Simple dominant-normal box projection. This is a UV inspection tool, not an island packer.

pub fn sculpt(&mut self, center: Vec3, radius: f32, amount: f32) -> bool

Pushes nearby vertices along their normals with a smooth local-space brush falloff. Coincident split vertices share a direction to keep hard-edged meshes closed.

pub fn to_obj(&self) -> Result<String, String>

OBJ with indexed positions, UVs and normals. Does not export glTF material bindings.

impl EditableMesh

pub fn project_planar(&mut self, axis: Vec3, scale: f32)

Planar projection: UVs are the position on the plane perpendicular to axis, divided by scale (metres per UV unit). Best for floors, walls and decals. Does nothing for a zero axis or scale <= 0.

pub fn project_cylindrical(&mut self, scale: f32)

Cylindrical projection around the Y axis: U is the angle (0..1 around), V the height divided by scale. Good for trunks, bottles and columns. The seam sits at +X.

pub fn project_spherical(&mut self)

Spherical projection around the origin: U is longitude, V latitude (both 0..1). Good for planets and balls.

pub fn normalize_uv(&mut self, margin: f32)

Fits the UVs into the 0..1 square keeping their proportions, with a margin border (0..0.45).

pub fn transform_uv( &mut self, scale: [f32; 2], rotation_degrees: f32, offset: [f32; 2], )

Scales, rotates (degrees) and offsets every UV around (0.5, 0.5).

pub fn flat_normals(&mut self)

Flat shading: every triangle gets its own face normal (vertices are split per triangle).

pub fn smooth_normals(&mut self, angle_degrees: f32)

Smooth shading with a crease angle: neighbouring faces closer than angle_degrees share a smooth normal, sharper edges stay hard. Vertices are split along creases.

Trait Implementations

impl Clone for EditableMesh

fn clone(&self) -> EditableMesh

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Component for EditableMesh

const NAME: &'static str = "EditableMesh"

Stable, globally unique name; keep it identical in the host and script library.

const KEY: u64 = _

Storage key derived from [Self::NAME]. Normally should not be overridden.

impl Component for EditableMesh

const REMOVABLE: bool = true

Whether the user may remove it in the inspector.

fn fields(&mut self) -> Vec<Field<'_>>

Mutable field descriptors used by the Inspector and script property serialization.

impl Default for EditableMesh

fn default() -> EditableMesh

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for EditableMesh

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for EditableMesh

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.