array(v: ?) → void

native(fn: ?) → void

arg(a: ?, k: ?, n: ?, name: ?, default: ?) → void

vecOf(x: ?) → void

trackQuat(v: ?, track: ?, up: ?) → void

mathutils Vector.to_track_quat: Blender's vec_to_quat (math_rotation.cc), on the negated vector.

vlen(d: ?) → void

VGET(key: ?, V: ?) → void

VSET(key: ?, value: ?, V: ?) → void

VITER(V: ?) → void

VBIN(op: ?, b: ?, V: ?) → void

VRBIN(op: ?, a: ?, V: ?) → void

vector(data: ?, onChange: ?) → void

v3(v: ?) → void

normal(vertices: ?, f: ?) → void

orient(mesh: ?) → void

new(name: ?) → void

unique(wanted: ?, collection: ?) → void

findObject(proxy: ?) → void

sync(o: ?) → void

activate(o: ?) → void

active( ) → void

pull(o: ?) → void

newObject(name: ?, mesh: ?) → void

hostPath(p: ?) → void

Replays of real Blender sessions: paths on the host machine are redirected into the document (S.hostRoot), and a fresh document can be given Blender's startup scene (Camera and Light here; the replay adds the Cube).

seedBlenderDefaults( ) → void

worldMatrix(o: ?, depth: ?) → void

Blender world matrix: parent world @ matrix_parent_inverse @ basis.

parentWorld(o: ?, depth: ?) → void

The frame a child hangs from: the parent's world, or a bone's tail for BONE parenting.

setBasis(o: ?, m: ?) → void

setWorld(o: ?, W: ?) → void

unparentKeep(o: ?) → void

zeroTransform(W: ?) → void

Zero entity transform (basis (x,y,z) -> (x,z,-y)) for a Blender matrix.

objectType(o: ?) → void

curveMesh(o: ?) → void

A curve/text object renders through a mesh derived from its curve data.

ref(name: ?) → void

uvSync(mesh: ?) → void

uvRenderData(mesh: ?) → void

resetUV(mesh: ?) → void

Blender's default UV for a new first layer: each quad fills 0..1; other n-gons sit on a unit circle.

copyUV(d: ?) → void

seq(name: ?, items: ?, lookup: ?, at: ?) → void

`at(i)` (0-based) answers one element without building the whole list: per-element access inside a loop must stay O(1).

q8(x: ?) → void

imageProxy(img: ?) → void

touch( ) → void

setAll(v: ?) → void

textureProxy(t: ?) → void

sampleTex(t: ?, u: ?, v: ?) → void

Blender image texture lookup: nearest = floor(u*W); interpolated = bilinear with texel centres at u*W-0.5. Pixels are stored bottom row first, as in Blender.

wrap(i: ?, n: ?) → void

px(x: ?, y: ?) → void

mix(a: ?, b: ?, c: ?, d: ?) → void

decodeCpu(cpu: ?) → void

encodeImage(img: ?, rep: ?) → void

rep > 1 blows each texel up to rep x rep (crisp 'Closest' look under any sampler).

b(x: ?) → void

safeName(x: ?) → void

imageTexture(img: ?, folder: ?, cache: ?, filter: ?) → void

Texture asset for an image, rewritten only when its pixels changed.

packRM(pk: ?, folder: ?, cache: ?, matName: ?) → void

glTF metallic-roughness packing: G = roughness, B = metallic.

sample(im: ?, x: ?, y: ?) → void

shaderPath(id: ?) → void

parseDefault(d: ?) → void

shaderSchema(id: ?) → void

zeroIns(n: ?) → void

newNode(mat: ?, bl: ?) → void

setZeroShader(n: ?, id: ?) → void

ensureGraph(mat: ?) → void

sockProxy(mat: ?, n: ?, sname: ?, isOut: ?) → void

nodeProxy(mat: ?, n: ?) → void

sockets(get: ?, isOut: ?) → void

materialSpec(mat: ?) → void

Zero PBR properties and texture slots for a material's node graph.

src(name: ?) → void

img(l: ?) → void

materialShader(mat: ?) → void

materialSig(mat: ?) → void

applyMaterial(ref: ?, mat: ?, texFolder: ?, cache: ?) → void

serializeGraph(mat: ?) → void

restoreGraph(mat: ?, g: ?) → void

materialProxy(mat: ?) → void

linkProxy(l: ?) → void

vertexProxy(mesh: ?, i: ?) → void

loopStarts(mesh: ?) → void

Face-corner (loop) numbering, as Blender's mesh.loops: faces in order, corners in order.

locateLoop(mesh: ?, li: ?) → void

newell(pts: ?) → void

polyTris(pts: ?) → void

Triangles (1-based corner positions) covering one polygon: quads split 1-3 as Blender does, ngons ear-clipped.

loopTris(mesh: ?) → void

loopTriProxy(mesh: ?, i: ?, t: ?) → void

corners( ) → void

deepCopy(v: ?, seen: ?) → void

faceProxy(mesh: ?, i: ?, bm: ?) → void

center( ) → void

edgeList(mesh: ?) → void

addEdge(a: ?, b: ?, fi: ?) → void

edgeProxy(mesh: ?, e: ?, bm: ?) → void

getSel( ) → void

setSel(v: ?) → void

meshProxy(mesh: ?) → void

nv(li: ?) → void

loopProxy(li: ?, fi: ?, c: ?) → void

layerProxy(l: ?) → void

idx( ) → void

uvLoop(fi: ?, k: ?) → void

byKey(k: ?) → void

addModifier(o: ?, name: ?, typ: ?) → void

modifierProxy(mod: ?) → void

objectProxy(o: ?) → void

rec(p: ?) → void

getitem(k: ?) → void

setitem(k: ?, v: ?) → void

pointProxy(sp: ?, p: ?) → void

pointSeq(sp: ?, want: ?) → void

splineProxy(sp: ?) → void

curveProxy(cu: ?) → void

qmul(a: ?, b: ?) → void

qaxis(ax: ?, ang: ?) → void

eulerQuat(e: ?) → void

qrot(q: ?, v: ?) → void

quatProxy(q: ?, onChange: ?) → void

binary(op: ?, b: ?) → void

toQuat(v: ?) → void

eulerProxy(e: ?) → void

matrixProxy(m: ?, onChange: ?) → void

binary(op: ?, b: ?) → void

toEulerVec(e: ?) → void

viewSet( ) → void

viewSettings(name: ?, t: ?) → void

viewContext(key: ?) → void

fit(b: ?, hfov: ?, vfov: ?) → void

cameraPose(view: ?, persp: ?, aspect: ?) → void

Camera pose for the current view, in Zero coordinates. view: FRONT..BOTTOM, ISO or CURRENT.

worldPose(pose: ?) → void

Session-local camera pose -> world pose, following wherever the session root was placed.

qm(a: ?, b: ?) → void

fitView(names: ?) → void

finished( ) → void

saveMain(a: ?, kw: ?) → void

walk(x: ?) → void

dispatch(group: ?, op: ?) → void

info(msg: ?) → void

pollEdit(op: ?) → void

selVerts(mesh: ?) → void

selEdgeKeys(mesh: ?) → void

selFaces(mesh: ?) → void

setSel(mesh: ?, vset: ?, fset: ?) → void

setSelFaces(mesh: ?, list: ?) → void

editOp(name: ?, fn: ?) → void

loopcut(mesh: ?, k: ?) → void

toLocal(o: ?, p: ?, isDir: ?) → void

shadeTargets( ) → void

setShade(o: ?, smooth: ?, angle: ?) → void

byAngle(a: ?, kw: ?) → void

capFill(fs: ?, vs: ?, ids: ?, z: ?, fill: ?) → void

id(r: ?, s: ?) → void

mid(a: ?, b: ?) → void

addCurveObject(kw: ?, baseName: ?, cu: ?) → void

nurbsPrim(baseName: ?, pts: ?, order: ?, endpoint: ?, cyclic: ?) → void

polysToGeom(vs: ?, fs: ?) → void

geomToPolys(g: ?) → void

cloneFaces(fs: ?) → void

mirrorPolys(vs: ?, fs: ?, axis: ?, merge: ?, thr: ?) → void

generates(o: ?) → void

renderable(o: ?) → void

evaluate(o: ?, stop: ?) → void

Returns evaluated triangle geometry, per-triangle material slots (multi-material meshes only) and the polygon form when the last modifier preserved it.

needGeom( ) → void

toPolys( ) → void

locateInto(newGeom: ?) → void

rgb(i: ?) → void

dirLocal(a: ?) → void

shadeArrays(g: ?, smooth: ?, tuv: ?, byIndex: ?) → void

Shading arrays in Zero basis (x,z,-y): flat splits every triangle, smooth welds by position.

tn(a: ?, b: ?, c: ?) → void

at(v: ?) → void

shadeByAngle(g: ?, angle: ?, tuv: ?) → void

Blender "Smooth by Angle": a corner averages the normals of faces around its position whose angle to its own face is within the limit; sharper edges stay hard.

at(v: ?) → void

renderGeometry(o: ?, apply: ?) → void

subMesh(rg: ?, slot: ?) → void

place(e: ?, o: ?) → void

bmeshProxy(mesh: ?) → void

fresh( ) → void

key(x: ?, y: ?) → void

add(f: ?, src: ?) → void

quoteList(l: ?) → void

Render settings are kept (and introspectable through bl_rna) so scripts that configure renders run; Zero does not render them (bpy.ops.render.render is a no-op).

propType(v: ?) → void

enumItems(list: ?) → void

rnaBag(name: ?, spec: ?, hooks: ?) → void

val(k: ?) → void

propProxy(k: ?) → void

makeRender(frames: ?) → void

makeDisplay( ) → void

sceneExtra(k: ?) → void

sceneExtraSet(k: ?, v: ?) → void

newScene(nm: ?) → void

dataProxy(d: ?) → void

enumItemsProxy(list: ?) → void

enumProp(full: ?, pn: ?) → void

rnaType(tname: ?) → void

rnaFor(n: ?) → void

sub3(x: ?, y: ?) → void

dot3(x: ?, y: ?) → void

closest(p: ?, a: ?, b: ?, c: ?) → void

Closest point on triangle abc to p (Ericson, Real-Time Collision Detection 5.1.5).

bvhProxy(V: ?, T: ?) → void

cellOf(x: ?, k: ?) → void

nearest(p: ?, maxd: ?) → void

writeBundle(sessionRoot: ?, issues: ?, triangles: ?) → void

The document's output.bundle: clips, entity_template and README, from the live hierarchy.

geoSize(g: ?) → void

writePending(id: ?, it: ?) → void

queueMesh(id: ?, name: ?, geo: ?) → void

spawn(fn: ?) → void

cancel( ) → void

Stop everything this document has running and drop what it queued. The document keeps its last saved state on disk; nothing outlives the cancel.

startPersist(root: ?) → void

saveNow( ) → void

settle(timeout: ?) → void

flush( ) → void

hashInto(h: ?, v: ?) → void

Change detection hashes the geometry in place: encoding every mesh to JSON on each flush allocated the whole document again, every call.

geoHash(m: ?) → void

signature(o: ?) → void

exportList(opts: ?) → void

slotMaterial(o: ?, slot: ?) → void

exportGLB(path: ?, opts: ?) → void

glTF 2.0 binary export (Y-up, the basis Zero renders in). One primitive per material slot.

blob(kind: ?, data: ?, target: ?) → void

materialFor(m: ?) → void

writeProvenance(path: ?, result: ?) → void

Records which session, script history and modeling-code version produced an export.

exportBundle(path: ?, opts: ?) → void

Native Zero bundle: meshes and materials are written inside the bundle, so it is a self-contained snapshot. Materials bound with zero_material are referenced as-is (custom shaders survive, which a GLB cannot carry).

safe(x: ?) → void

matFor(m: ?) → void

restore(doc: ?) → void

Rebuild the live, editable session (objects, meshes, materials, modifier stacks, parenting, view) from a saved session.json document.

objectsCount(t: ?) → void

scene_info( ) → void

hideFromEditor( ) → void

Keep the editor camera's view clean: add !modelingWorkspace to its filter once. The user can take it out again (renderLayer.camera) to watch the agent work.

workspace( ) → void

resolve(name: ?) → void

onMemoryPressure( ) → void

previewName(key: ?) → void

evict(key: ?, force: ?) → void

closeWorkspace( ) → void

armIdleClose( ) → void

useSession(key: ?) → void

session(name: ?) → void