ProcGeo

new Geometry() constructor

const geo = new pg.Geometry();

addPoint method

const ptIdx = geo.addPoint(1.0, 2.0, 3.0);

setPointPos method

geo.setPointPos(0, 5.0, 0.0, 0.0);

addFace method

const p0 = geo.addPoint(0, 0, 0);
const p1 = geo.addPoint(1, 0, 0);
const p2 = geo.addPoint(1, 1, 0);
const primIdx = geo.addFace([p0, p1, p2]);

addPolyline method

const lineIdx = geo.addPolyline([p0, p1, p2]);

numPoints getter

numPrims getter

numVertices getter

pointPos method

const [x, y, z] = geo.pointPos(0);

boundingBox method

const bbox = geo.boundingBox();
console.log(bbox.min, bbox.max);

getPositions method

const positions = geo.getPositions();
// positions.length === geo.numPoints * 3

getTriangleIndices method

const indices = geo.getTriangleIndices();

getNormals method

const normals = geo.getNormals();
if (normals) {
  bufferGeometry.setAttribute('normal', new THREE.BufferAttribute(normals, 3));
}

getColors method

const colors = geo.getColors();
if (colors) {
  bufferGeometry.setAttribute('color', new THREE.BufferAttribute(colors, 3));
}

attribNames method

const pointAttribs = geo.attribNames("point");
// e.g. ["N", "Cd", "uv"]

attribType method

attribSize method

attribData method

const uvs = geo.attribData("vertex", "uv");
bufferGeometry.setAttribute('uv', new THREE.BufferAttribute(uvs, 2));

attribDataString method

primPointIndices method

const pts = geo.primPointIndices(0);
// e.g. [0, 1, 2, 3] for a quad

primVertexCount method

vertexPoint method

toObj method

const objString = geo.toObj();
download("model.obj", objString);

toGlb method

const glbBytes = geo.toGlb();
const blob = new Blob([glbBytes], { type: "model/gltf-binary" });

width getter

height getter

getPixels method

const pixels = await image.getPixels();
// pixels.length === image.width * image.height * 4
// Each pixel: [r, g, b, a] in 0..1 range

createBox creation

let geo = pg.createBox({ size: [2, 1, 3], center: [0, 0.5, 0] });

createGrid creation

let grid = pg.createGrid({ rows: 10, cols: 10, sizeX: 5, sizeY: 5 });

createSphere creation

let sphere = pg.createSphere({ radius: 2, rows: 24, cols: 48 });

createTube creation

let cone = pg.createTube({ radiusBottom: 1, radiusTop: 0, height: 2 });

createTorus creation

let torus = pg.createTorus({ radiusOuter: 2, radiusInner: 0.5, rows: 24, cols: 48 });

createCircle creation

let circle = pg.createCircle({ radius: 3, divisions: 32 });

createLine creation

let line = pg.createLine({ origin: [0, 0, 0], direction: [1, 0, 0], length: 5, points: 10 });

createMetaball creation

let meta = pg.createMetaball({
  balls: [
    { center: [0, 0, 0], radius: 1, weight: 1 },
    { center: [1.2, 0, 0], radius: 0.8, weight: 1 }
  ],
  resolution: 64,
  kernel: "wyvill"
});

transform transform

geo = pg.transform(geo, { translate: [0, 1, 0], rotate: [0, 45, 0], scale: [2, 2, 2] });

subdivide transform

geo = pg.subdivide(geo, { depth: 2, mode: "catmullClark" });

smooth transform

geo = pg.smooth(geo, { iterations: 5, strength: 0.8 });

revolve transform

let profile = pg.createLine({ origin: [1, 0, 0], direction: [0, 1, 0], points: 10 });
let vase = pg.revolve(profile, { divisions: 32, endAngle: 360 });

resample transform

geo = pg.resample(geo, { length: 0.05 });

polyExtrude topology

geo = pg.polyExtrude(geo, { distance: 0.5, inset: 0.1 });

polyBevel topology

geo = pg.polyBevel(geo, { offset: 0.05, divisions: 3 });

polyWire topology

let wireframe = pg.polyWire(geo, { radius: 0.05, divisions: 6 });

polyFill topology

geo = pg.polyFill(geo, { mode: "fan" });

polyReduce topology

geo = pg.polyReduce(geo, { targetPercent: 25 });

clip topology

geo = pg.clip(geo, { origin: [0, 0.5, 0], normal: [0, 1, 0] });

fuse topology

geo = pg.fuse(geo, { distance: 0.01 });

reverse topology

geo = pg.reverse(geo);

scatter topology

let points = pg.scatter(geo, { count: 500, seed: 42 });

copyToPoints topology

let box = pg.createBox({ size: [0.1, 0.1, 0.1] });
let pts = pg.scatter(pg.createGrid(), { count: 50 });
let instanced = pg.copyToPoints(box, pts);

merge topology

let box = pg.createBox();
let sphere = pg.createSphere();
let merged = pg.merge(box, sphere);

// Merge three:
let third = pg.createTorus();
merged = pg.merge(pg.merge(box, sphere), third);

voronoiFracture topology

let box = pg.createBox({ size: [2, 2, 2] });
let seeds = pg.scatter(box, { count: 20 });
let fractured = pg.voronoiFracture(box, seeds, { createInsideFaces: true });

computeNormals utility

geo = pg.computeNormals(geo);

color utility

geo = pg.color(geo, { color: [0.2, 0.6, 1.0] });

blast utility

geo = pg.blast(geo, { groupName: "top_faces", negate: true });

deleteSop utility

geo = pg.deleteSop(geo, { entity: "primitives", rangeStart: 0, rangeEnd: 5 });

sort utility

geo = pg.sort(geo, { seed: 42 });

connectivity utility

geo = pg.connectivity(geo);
// Each primitive now has a "class" attribute

enumerateAttrib utility

geo = pg.enumerateAttrib(geo, { name: "id", start: 0 });

measure utility

geo = pg.measure(geo, { attribName: "area" });

attribCreate attributes

geo = pg.attribCreate(geo, { name: "density", attribType: "Float", valueFloat: 1.0 });
geo = pg.attribCreate(geo, {
  name: "up", class: "point", attribType: "Vector3", valueVector3: [0, 1, 0]
});

attribDelete attributes

geo = pg.attribDelete(geo, { name: "temp_data", class: "point" });

attribRename attributes

geo = pg.attribRename(geo, { fromName: "Cd", toName: "base_color" });

attribPromote attributes

geo = pg.attribPromote(geo, {
  name: "Cd", fromClass: "point", toClass: "vertex", method: "average"
});

attribNoise attributes

geo = pg.attribNoise(geo, {
  attribName: "height",
  noiseType: "simplex",
  elementSize: 2.0,
  amplitude: 0.5
});

attribRandomize attributes

geo = pg.attribRandomize(geo, {
  attribName: "pscale", seed: 42, minValue: 0.5, maxValue: 2.0
});

attribTransfer attributes

geo = pg.attribTransfer(destGeo, sourceGeo, {
  attribName: "Cd", class: "point", attribType: "Vector3"
});

attribCopy attributes

geo = pg.attribCopy(geo, null, {
  attribName: "Cd", class: "point", newName: "Cd_backup"
});

attribSort attributes

geo = pg.attribSort(geo, { attribName: "area", order: "Descending" });

attribBlur attributes

geo = pg.attribBlur(geo, { attribName: "noise", iterations: 5, stepSize: 0.3 });

attribFill attributes

geo = pg.attribFill(geo, {
  attribName: "temperature", boundaryGroup: "edges", iterations: 20
});

groupCreate groups

// Select top-facing primitives
geo = pg.groupCreate(geo, {
  name: "top_faces",
  groupType: "primitives",
  mode: "normal",
  normalDirection: [0, 1, 0],
  normalSpread: 45
});

// Select a range of points
geo = pg.groupCreate(geo, {
  name: "first_ten", groupType: "points", mode: "range", rangeStart: 0, rangeEnd: 10
});

groupCombine groups

geo = pg.groupCombine(geo, {
  nameA: "top_faces", nameB: "large_faces", result: "selected", operation: "intersect"
});

copConstant generator

await pg.initCopGpu();
let img = pg.copConstant({ color: [1, 0, 0, 1], width: 512, height: 512 });

copCheckerboard generator

let checker = pg.copCheckerboard({
  colorA: [1, 1, 1, 1], colorB: [0, 0, 0, 1], frequency: [16, 16]
});

copNoise generator

let noise = pg.copNoise({
  noiseType: "simplex", frequency: 8, octaves: 6, width: 512, height: 512
});

copRamp generator

let ramp = pg.copRamp({
  rampType: "radial",
  stops: [
    { position: 0.0, color: [1, 1, 1, 1] },
    { position: 1.0, color: [0, 0, 0, 1] }
  ]
});

copLoadImage generator

let img = pg.copLoadImage({ path: "/textures/diffuse.png" });

copBlur filter

let blurred = pg.copBlur(img, { blurType: "gaussian", radiusX: 8, radiusY: 8 });

copFlip filter

let flipped = pg.copFlip(img, { horizontal: true, vertical: false });

copMirror filter

let mirrored = pg.copMirror(img, { axis: "x", offset: 0.5 });

copChannelSwap filter

// Convert to grayscale by using red channel for all
let gray = pg.copChannelSwap(img, { r: "r", g: "r", b: "r", a: "one" });

copResize filter

let small = pg.copResize(img, { width: 128, height: 128, filter: "bilinear" });

copRotate filter

let rotated = pg.copRotate(img, { angle: 45 });

copSwirl filter

let swirled = pg.copSwirl(img, { angle: 180, radius: 0.4 });

copComposite composite

let layerA = pg.copNoise({ frequency: 4 });
let layerB = pg.copCheckerboard({ frequency: [8, 8] });
let result = pg.copComposite(layerA, layerB, { operation: "multiply", mix: 0.5 });

executeSop registry

let geo = pg.createBox();
geo = pg.executeSop("subdivide", geo, { depth: 2, mode: "catmull_clark" });

executeSopCreate registry

let geo = pg.executeSopCreate("box", { size: [2, 2, 2] });

listSops registry

const sops = pg.listSops();
// ["box", "grid", "sphere", "tube", "torus", "circle", "line", ...]

executeCopCreate registry

let img = pg.executeCopCreate("noise", { frequency: 8 });

executeCop registry

let blurred = pg.executeCop("blur", img, { radius_x: 4, radius_y: 4 });

executeCopComposite registry

let result = pg.executeCopComposite("composite", imgA, imgB, { operation: "add" });

listCops registry

const cops = pg.listCops();
// ["constant", "checkerboard", "noise", "ramp", "blur", ...]

initCopGpu registry

await pg.initCopGpu();

toObj i/o

const objData = geo.toObj();

toGlb i/o

const glb = geo.toGlb();
const blob = new Blob([glb], { type: "model/gltf-binary" });
const url = URL.createObjectURL(blob);