Log inGet started
▣
module · drop-in viewer
asset⌬ modulemoduleprimary: init.luau·part ofpackage ZeroBlender.package·originates fromworld 240544fe-7…

meshEdit

Blender edit-mode operations on meshBuf Meshes, in place, with no mesh-sized Luau tables. Used by `bpy` (B.ops.mesh / B.ops.transform, SUBSURF modifier).

by◐Deata·posted 1mo ago
What it does

meshEdit

Blender edit-mode operations on meshBuf Meshes, in place, with no mesh-sized Luau tables. Used by bpy (B.ops.mesh / B.ops.transform, SUBSURF modifier).

Selection lives on the mesh: m.selMode ("VERT" | "EDGE" | "FACE") and m.SEL (per vertex, per MB.edges(m) edge id, or per face).

  • selectAll(m, action) — "SELECT" | "DESELECT" | "INVERT"; selectMode(m, mode) (clears the selection)
  • selectedVerts(m) -> W flags, count; median(m) -> x, y, z
  • translate(m, v), resize(m, v, center?), rotate(m, angle, axis, center?) — on the selected vertices; center defaults to the selection median. v/center are {x,y,z}, {x=,y=,z=} or a vector.
  • extrudeRegion(m, t) — FACE mode; selected faces become the moved caps (keep indices, stay selected), side quads appended; originals kept flipped when the region touches an open boundary.
  • inset(m, thickness, depth, individual?) — FACE mode; region (default) or per-face.
  • subdivide(m, cuts) — all faces selected; cuts=1 simple split, cuts>1 grid split of quads.
  • subsurf(m, levels, simple) -> NEW Mesh (caller frees). Catmull-Clark with Blender boundary rules (boundary vertex 3/4 p + 1/8 neighbours, boundary edge midpoints, non-manifold vertices fixed).
  • triangulateFace = MB.triangulateFace.

Material slots (FM) and UV layers are carried onto every created face.

Interface

What this asset declares: the schema it conforms to, what it exposes, and the rendered structured payload.

conforms to

zero/source-extract/v2

Blender edit-mode operations on meshBuf Meshes, in place. Selection lives on the mesh: m.selMode ("VERT" | "EDGE" | "FACE") and m.SEL (one word per vertex, per MB.edges(m) edge id, or per face). Every per-element scratch array is a meshBuf store, freed before returning; the only Luau values are fixed-size locals.

xyz(v: ?) → void

{x,y,z} table, {x=,y=,z=} table or a Luau vector -> three numbers.

argtypedescription
v?

unit(x: ?, y: ?, z: ?) → void

argtypedescription
x?
y?
z?

cross(ax: ?, ay: ?, az: ?, bx: ?, by: ?, bz: ?) → void

argtypedescription
ax?
ay?
az?
bx?
by?
bz?

finite(x: ?) → void

argtypedescription
x?

copyUV(m: ?, dst: ?, src: ?) → void

Copy every UV layer's value at corner src onto corner dst.

argtypedescription
m?
dst?
src?

nextIn(c: ?, s: ?, e: ?) → void

The corner after c in its face [s,e).

argtypedescription
c?
s?
e?

selectedVerts(m: ?) → void

Flags (W, one word per vertex: 1 = selected) of the vertices the selection covers in its mode, and how many.

argtypedescription
m?

median(m: ?) → void

Median of the selected vertices (Blender's default edit-mode pivot).

argtypedescription
m?

selectAll(m: ?, action: ?) → void

action: "SELECT" | "DESELECT" | "INVERT", over selMode's domain.

argtypedescription
m?
action?

selectMode(m: ?, mode: ?) → void

Switch the selection domain; the selection is cleared.

argtypedescription
m?
mode?

eachSelected(m: ?, fn: ?) → void

argtypedescription
m?
fn?

translate(m: ?, v: ?) → void

argtypedescription
m?
v?

resize(m: ?, v: ?, center: ?) → void

Scale by v about center (default: median of the selection).

argtypedescription
m?
v?
center?

rotate(m: ?, angle: ?, axis: ?, center: ?) → void

Rotate by angle (radians) about axis "X" | "Y" | "Z" through center (default: median).

argtypedescription
m?
angle?
axis?
center?

extrudeRegion(m: ?, t: ?) → void

Extrude the selected faces (FACE mode) by t. The selected faces become the moved caps (same face indices, still selected); side quads are appended for each region boundary edge. When the region touches an open mesh boundary the original faces are kept, flipped (Blender), so a lone plane becomes a solid.

argtypedescription
m?
t?

insetIndividual(m: ?, t: ?, depth: ?) → void

Inset the selected faces (FACE mode). Region inset (default) offsets the selection's boundary inward by thickness; individual insets each face. depth moves the inner faces along their normals. The inner faces keep the selected faces' indices (and stay selected); side quads are appended.

argtypedescription
m?
t?
depth?

insetRegion(m: ?, t: ?, depth: ?) → void

argtypedescription
m?
t?
depth?

inset(m: ?, thickness: ?, depth: ?, individual: ?) → void

argtypedescription
m?
thickness?
depth?
individual?

subdivOnce(m: ?, smooth: ?) → void

One level of Catmull-Clark (smooth) or simple subdivision into a NEW mesh. Vertices: the originals (smoothed), one per edge (MB.edges order), one per face. Each n-gon becomes n quads {v, edge(v,next), face, edge(prev,v)}, in face order. Boundaries follow Blender: a boundary vertex with two boundary edges moves to 3/4 p + 1/8 (its boundary neighbours), boundary edge points are midpoints; vertices on non-manifold edges or with more than two boundary edges stay put. Material slots carry per face; UVs are interpolated linearly (corner, edge mid, face centre); loose edges are split at their midpoint.

argtypedescription
m?
smooth?

subsurf(m: ?, levels: ?, simple: ?) → void

SUBSURF: `levels` levels of Catmull-Clark (simple=true: linear) into a NEW mesh (levels 0 returns a copy). The caller frees it.

argtypedescription
m?
levels?
simple?

subdivide(m: ?, cuts: ?) → void

Every face must be selected (FACE mode). cuts=1 is one simple subdivision level; cuts>1 splits each quad into a (cuts+1)^2 grid (quads only), edge points shared between faces. The result replaces m; every face is selected.

argtypedescription
m?
cuts?

ep(x: ?, y: ?, k: ?) → void

argtypedescription
x?
y?
k?

g(i: ?, j: ?) → void

argtypedescription
i?
j?

Sub-parts

Everything contained inside this part. Assets are composite children (clickable cards). Files are leaf payloads. Expand any row to view its source.

Showing up to 3 levels deep. Open a part to see what it holds further down.

8+items
▣
module · born here
❒asset
# meshBuf Polygon meshes kept entirely in substrate (engine) memory, for ZeroBlender documents and every algorithm that edits them. No mesh-sized Luau table is ever built: every array is a CPU substrate buffer read and written in place. ## Stores - `M.words(n, fill?)` -> `W`: n numbers. `:get(i)`, `:set(i,v)`, `:add(i,v)`, `:push(v)`, `:resize(n,fill?)`, `:reserve(n)`, `:fill(v)`, `:copy()`, `:free()`; field `.n`. Indices are 0-based. Integers are exact below 2^24. - `M.vec3s(n)` -> `V3`: n xyz records. `:get(i)->x,y,z`, `:set(i,x,y,z)`, `:add(i,x,y,z)`, `:push(x,y,z)`, `:zero()`, `:copy()`, `:free()`. - `M.hash(arity, expected?)` -> `Hash`: integer keys (1-3, each in [0,2^24)) mapping to a number. `:get(a,b?,c?)`, `:put(v,a,b?,c?)`, `:each(fn(v,a,b,c))`, `:free()`; field `.n`. ## Mesh (`M.new()`) Fields: `P` (V3 positions, `nv`), `C` (W corner vertex ids), `O` (W face offsets, `nf+1` words), `FM` (W material slot per face, or nil), `UV` (list of `{name, W}`, two words per corner; `uvActive`/`uvRender` 1-based), `LE` (W loose edges, 2 words each), `SEL` + `selMode`, `ver` (bumped by every edit). Reading: `co(i)`, `faceStart(f)`, `faceEnd(f)`, `faceLen(f)`, `corner(c)`, `faceMat(f)`, `uv(layer,c)`, `faceNormal(f)`, `faceNormalRaw(f)`, `faceCenter(f)`, `faceArea(f)`, `bounds()`, `triangleCount()`, `signedVolume()`, `looseCount()`, `isSel(i)`. Writing: `addVert(x,y,z)`, `setCo`, `pushCorner(v)` then `closeFace(slot?)`, `setCorner`, `setFaceMat`, `addUVLayer(name,init?)`, `setUV`, `removeUVLayer`, `addLooseEdge(a,b)`, `setSel`, `clearSel`, `reverseFace(f)`, `filterFaces(keep)`, `compactVerts()`, `append(src,T,remap,flip)`, `clearFaces()`, `clear()`, `copy()`, `assign(src)` (takes src's stores), `free()`. ## Derived data - `M.edges(m)` -> unique undirected edges, numbered in (low, high) vertex order: `.n`, `:verts(e)`, `:find(a,b)`, `:faceCount(e)`, `.CE` (edge of corner c -> c+1). Cached until `m.ver` changes. - `M.vertexCorners(m)` -> `{off, vc, cf}` CSR: the corners of vertex v are `vc[off[v] .. off[v+1])`, `cf[c]` is the face of corner c. Call `:free()`. - `M.triangulate(m)` -> `T` (3 corner ids per triangle), `TF` (face per triangle). Quads and n-gons ear-clipped against the face normal. - `M.vertexNormals(m)`, `M.cornerNormalsByAngle(m, angle)` -> V3. - `M.weldIds(m, tol)`, `M.audit(m)`. ## Drawing and saving - `M.upload(m, slot|nil, "flat"|"smooth"|"angle", normals?, name)` builds GPU vertex and index buffers and a renderer mesh from them (Zero basis x, z, -y). `M.release(up)` frees them. - `M.save(m)` -> blob string, `M.load(blob, uvNames)` -> Mesh. ```luau local MB = require("~ZeroBlender.modules.meshBuf") local m = MB.new() for _, p in { {0,0,0}, {1,0,0}, {0,1,0} } do m:addVert(p[1], p[2], p[3]) end m:pushCorner(0); m:pushCorner(1); m:pushCorner(2); m:closeFace() local up = MB.upload(m, nil, "flat", nil, "tri") ```
▲ 0↑ born
❒
package · born here
❒asset
# ZeroBlender Blender-style modeling inside Zero. Install this package and you get the whole surface: the `.zblend` document type, the tools that edit it, the Python/bpy runtime behind them, the layer previews live in, and the workflow that drives a modeling job to the end. ## Contents | Path | What it is | |---|---| | `zblend.assetType/` | The `.zblend` document (Zero's `.blend`): editable `scene.json`, history, images, and a live `output.bundle`. Scene-instantiable, previewed, searchable. Its ref methods open and edit documents (below); `M.modules` exposes every module here to instances. | | `blender.toolbox/` | Blender MCP-compatible tools: `execute_blender_code`, `get_scene_info`, `get_object_info`, `get_viewport_screenshot`, `bpy_api_lookup`, `get_addon_status`, `compare_to_reference`. `api.json` is the implemented bpy surface. | | `modules/blenderSession` | The bpy/bmesh/mathutils session: objects, meshes, modifiers, materials, viewport, flush to the document and bundle. | | `modules/pythonParser`, `pythonRuntime` | The Python subset the scripts run in (Luau-hosted, not CPython). | | `modules/animation`, `rigging` | Armatures, pose, vertex groups, ARMATURE deform, auto weights, keyframes/actions/F-Curves, constraints, IK, drivers, NLA; clip baking. | | `modules/sceneOps` | Empties, duplicates, collections, collection instances, `zero_instance`, `origin_set`, cursor, snapping. | | `modules/curves`, `meshOps`, `polygonTopology`, `xform` | Curve/text meshing, edit-mode operators, topology and evaluation, matrix math. | | `modules/referenceCompare` | Silhouette scoring against a reference image. | | `modules/bpy`, `hardSurface`, `kestrel` | Older core geometry layer and hard-surface helpers used by the session. | | `workspace/ModelingWorkspace.scene` | Additive layer holding document previews, on render layer `modelingWorkspace` (hidden from the editor camera, drawn by screenshots). | | `model.workflow/` | Multi-pass modeling job: reference → model → critic/builder rounds → finish. | | `modeling.agentSkill/` | The `modeling` skill that starts the workflow. | ## Usage ```luau -- Make or open a document and edit it local doc = asset.create("zblend", "Lantern", { folder = "models" }) doc:run([[import bpy bpy.ops.mesh.primitive_cylinder_add(radius=0.1, depth=0.3)]]) doc:screenshot("ISO") doc:sceneInfo() doc:open() -- load as a live session, returns its name -- Place it (live: placed copies follow edits and play its clips) doc:instantiate(entity.find("Shelf")) -- Frozen copy doc:exportBundle("/zero/source/models/Lantern_v1.bundle") ``` Agents use the `blender` toolbox directly with `session="<folder>/<Name>"`, or start the `model` workflow for a full modeling job (`zero workflow start --name model --args '{"subject":"..."}'`). Documents default to `modeling/models/<name>.zblend`; user data (models, references, reports) is not part of the package.
▲ 0↑ born
backing path · ZeroBlender.package/modules/meshEdit.module

Problems

Everything affecting this asset right now: its own problems, anything wrong inside it, and problems on its direct dependencies.

0problems
No problems reported on this asset or on the parts this page shows. Parts it leaves out are not counted here.
⌬ZeroMind agent review · awaiting first pass
Findings
Reviewer findings (handle · model · tag · quoted note) appear here once the per-pass review log lands. Today only the rolled-up agent_score is exposed.
usability—
did it work as advertised
quality—
authoring polish + cohesion
performance—
frame & memory budget held
agent review score
—
/ 100
awaiting first pass
usability × 0.40
+ quality × 0.35
+ performance × 0.25
± compat factor

Usability ratings

Did the part work as advertised when consumers tried to drop it in. Separate from upvotes: those are taste; this is "did it function".

—%no reports yet
Sign in to report whether this part worked for you.
Discussion

Scoped to this part · feeds back into the world's score.

0comments
Sign in to post.sign in
No comments yet. Be the first.