@cyclonium/canvas-3d 0.0.100

package/lib/w3.js

@@ -0,0 +1,269 @@
+import { Mat4, Vec3 } from 'cc';
+import { copyPrimitiveDrawState, createQuadCorners, createPrimitiveDrawState, drawPrimitive, normalizeLineDash, PrimitiveEntryType, resolveCapsule, resolveCapsuleSegments, resolveCylinder, resolveCylinderSegments, resolveDiscSegments, resolveDiscRadius, resolveHalfExtents, resolveRingRadii, resolveRingSegments, resolveSphereSegments, setColor, } from './geometry.js';
+export class Canvas3DW3Impl {
+    constructor(enqueueGeometry) {
+        this._enqueueGeometry = enqueueGeometry;
+        this._directScope = new Canvas3DW3ScopeImpl(enqueueGeometry);
+    }
+    scope(draw) {
+        draw(new Canvas3DW3ScopeImpl(this._enqueueGeometry));
+        return this;
+    }
+    line(options) {
+        this._drawDirect((scope) => {
+            scope.line(options);
+        });
+        return this;
+    }
+    box(options) {
+        this._drawDirect((scope) => {
+            scope.box(options);
+        });
+        return this;
+    }
+    quad(options) {
+        this._drawDirect((scope) => {
+            scope.quad(options);
+        });
+        return this;
+    }
+    cylinder(options) {
+        this._drawDirect((scope) => {
+            scope.cylinder(options);
+        });
+        return this;
+    }
+    disc(options) {
+        this._drawDirect((scope) => {
+            scope.disc(options);
+        });
+        return this;
+    }
+    ring(options) {
+        this._drawDirect((scope) => {
+            scope.ring(options);
+        });
+        return this;
+    }
+    sphere(options) {
+        this._drawDirect((scope) => {
+            scope.sphere(options);
+        });
+        return this;
+    }
+    capsule(options) {
+        this._drawDirect((scope) => {
+            scope.capsule(options);
+        });
+        return this;
+    }
+    _drawDirect(draw) {
+        draw(this._directScope);
+    }
+    _enqueueGeometry;
+    _directScope;
+}
+class Canvas3DW3ScopeImpl {
+    constructor(enqueueGeometry) {
+        this._enqueueGeometry = enqueueGeometry;
+    }
+    get lineWidth() {
+        return this._state.lineWidth;
+    }
+    set lineWidth(value) {
+        this._state.lineWidth = Math.max(0, value);
+    }
+    get lineJoin() {
+        return this._state.lineJoin;
+    }
+    set lineJoin(value) {
+        this._state.lineJoin = value;
+    }
+    get lineCap() {
+        return this._state.lineCap;
+    }
+    set lineCap(value) {
+        this._state.lineCap = value;
+    }
+    get lineDash() {
+        return this.getLineDash();
+    }
+    set lineDash(value) {
+        this.setLineDash(value);
+    }
+    get lineDashOffset() {
+        return this._state.lineDashOffset;
+    }
+    set lineDashOffset(value) {
+        this._state.lineDashOffset = Number.isFinite(value) ? value : 0;
+    }
+    get strokeColor() {
+        return this._state.strokeColor;
+    }
+    set strokeColor(value) {
+        this._state.strokeColor.set(value);
+    }
+    get fillColor() {
+        return this._state.fillColor;
+    }
+    set fillColor(value) {
+        this._state.fillColor.set(value);
+    }
+    color(value) {
+        setColor(this._state.fillColor, value);
+        setColor(this._state.strokeColor, value);
+        return this;
+    }
+    depthTest(value = true) {
+        this._state.depthTest = value;
+        return this;
+    }
+    depthWrite(value = true) {
+        this._state.depthWrite = value;
+        return this;
+    }
+    save() {
+        const state = this._stateStack[this._stateStackDepth] ??= createPrimitiveDrawState();
+        copyPrimitiveDrawState(state, this._state);
+        this._stateStackDepth++;
+        return this;
+    }
+    restore() {
+        if (this._stateStackDepth > 0) {
+            this._stateStackDepth--;
+            copyPrimitiveDrawState(this._state, this._stateStack[this._stateStackDepth]);
+        }
+        return this;
+    }
+    resetTransform() {
+        Mat4.identity(this._state.transform);
+        return this;
+    }
+    setTransform(transform) {
+        this._state.transform.set(transform);
+        return this;
+    }
+    transform(transform) {
+        Mat4.multiply(this._state.transform, this._state.transform, transform);
+        return this;
+    }
+    translate(x, y, z = 0) {
+        Mat4.transform(this._state.transform, this._state.transform, new Vec3(x, y, z));
+        return this;
+    }
+    scale(x, y = x, z = x) {
+        Mat4.scale(this._state.transform, this._state.transform, new Vec3(x, y, z));
+        return this;
+    }
+    rotate(rad, axis) {
+        Mat4.rotate(this._state.transform, this._state.transform, rad, axis);
+        return this;
+    }
+    rotateX(rad) {
+        Mat4.rotateX(this._state.transform, this._state.transform, rad);
+        return this;
+    }
+    rotateY(rad) {
+        Mat4.rotateY(this._state.transform, this._state.transform, rad);
+        return this;
+    }
+    rotateZ(rad) {
+        Mat4.rotateZ(this._state.transform, this._state.transform, rad);
+        return this;
+    }
+    line(options) {
+        drawPrimitive(this._enqueueGeometry, this._state, [{
+                type: PrimitiveEntryType.line,
+                from: options.from.clone(),
+                to: options.to.clone(),
+            }], options);
+        return this;
+    }
+    box(options) {
+        drawPrimitive(this._enqueueGeometry, this._state, [{
+                type: PrimitiveEntryType.box,
+                center: options.center.clone(),
+                halfExtents: resolveHalfExtents(options.halfExtents),
+            }], options);
+        return this;
+    }
+    quad(options) {
+        drawPrimitive(this._enqueueGeometry, this._state, [{
+                type: PrimitiveEntryType.quad,
+                corners: createQuadCorners(options),
+            }], options);
+        return this;
+    }
+    cylinder(options) {
+        const cylinder = resolveCylinder(options);
+        const segments = resolveCylinderSegments(options);
+        drawPrimitive(this._enqueueGeometry, this._state, [{
+                type: PrimitiveEntryType.cylinder,
+                from: cylinder.from,
+                to: cylinder.to,
+                radius: cylinder.radius,
+                radialSegments: segments.radialSegments,
+                wireSegments: segments.wireSegments,
+            }], options);
+        return this;
+    }
+    disc(options) {
+        drawPrimitive(this._enqueueGeometry, this._state, [{
+                type: PrimitiveEntryType.disc,
+                center: options.center.clone(),
+                normal: options.normal.clone(),
+                radius: resolveDiscRadius(options),
+                segments: resolveDiscSegments(options),
+            }], options);
+        return this;
+    }
+    ring(options) {
+        const radii = resolveRingRadii(options);
+        drawPrimitive(this._enqueueGeometry, this._state, [{
+                type: PrimitiveEntryType.ring,
+                center: options.center.clone(),
+                normal: options.normal.clone(),
+                innerRadius: radii.innerRadius,
+                outerRadius: radii.outerRadius,
+                segments: resolveRingSegments(options),
+            }], options);
+        return this;
+    }
+    sphere(options) {
+        const segments = resolveSphereSegments(options);
+        drawPrimitive(this._enqueueGeometry, this._state, [{
+                type: PrimitiveEntryType.sphere,
+                center: options.center.clone(),
+                radius: Math.max(0, options.radius),
+                latitudeSegments: segments.latitudeSegments,
+                longitudeSegments: segments.longitudeSegments,
+                wireSegments: segments.wireSegments,
+            }], options);
+        return this;
+    }
+    capsule(options) {
+        const capsule = resolveCapsule(options);
+        const segments = resolveCapsuleSegments(options);
+        drawPrimitive(this._enqueueGeometry, this._state, [{
+                type: PrimitiveEntryType.capsule,
+                from: capsule.from,
+                to: capsule.to,
+                radius: capsule.radius,
+                radialSegments: segments.radialSegments,
+                wireSegments: segments.wireSegments,
+                capSegments: segments.capSegments,
+            }], options);
+        return this;
+    }
+    getLineDash() {
+        return this._state.lineDash.slice();
+    }
+    setLineDash(value) {
+        this._state.lineDash = normalizeLineDash(value);
+    }
+    _stateStack = [];
+    _enqueueGeometry;
+    _state = createPrimitiveDrawState();
+    _stateStackDepth = 0;
+}
+//# sourceMappingURL=w3.js.map

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "@cyclonium/canvas-3d",
+  "version": "0.0.100",
+  "type": "module",
+  "files": [
+    "lib/**/*{.js,.d.ts}"
+  ],
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "peerDependencies": {
+    "@cyclonium/core": "0.0.100"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.2",
+    "@vitest/browser-playwright": "^4.1.5",
+    "playwright": "^1.59.1",
+    "typescript": "^6.0.2",
+    "vitest": "^4.1.5",
+    "@cyclonium/cc-test": "0.0.100",
+    "@cyclonium/types-cc": "0.0.100",
+    "@cyclonium/workflow": "0.0.100"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "tsc -b --watch",
+    "test:browser": "vitest --no-file-parallelism --disableConsoleIntercept",
+    "test": "npm run test:compile && npm run t",
+    "test:compile": "tsc -b test/tsconfig.json",
+    "t": "npm run test:browser -- run --browser.headless=true"
+  }
+}