@cyclonium/debug-draw 0.0.100

package/lib/index.d.ts

@@ -0,0 +1,108 @@
+import { Camera, Color, GeometryRenderer, Mat4, Quat, Vec3 } from 'cc';
+import { CycloComponent } from '@cyclonium/core/framework';
+import type { Vec2 } from '@cyclonium/core/math/vec2';
+export declare class DebugDrawTarget extends CycloComponent {
+    get geometryRenderer(): GeometryRenderer | null | undefined;
+    private get _camera();
+}
+export declare function tryGetDebugGeometryRenderer(camera?: Camera): GeometryRenderer | null | undefined;
+export declare function getDebugGeometryRenderer(): GeometryRenderer;
+export declare class DebugDrawContext {
+    static fromEditorCamera(): DebugDrawContext | undefined;
+    static fromDebugDrawTarget(target: DebugDrawTarget): DebugDrawContext;
+    static fromDebugDrawTargets(target: DebugDrawTarget[]): DebugDrawContext;
+    constructor(geometryRenderers: GeometryRenderer[]);
+    get geometryRenderers_internal(): GeometryRenderer[];
+    rect(opts: {
+        center: Readonly<Vec3>;
+        halfExtent: Readonly<Vec2> | number;
+        right?: Readonly<Vec3>;
+        up?: Readonly<Vec3>;
+        color?: Readonly<Color>;
+        wireframe?: boolean;
+        depthTest?: boolean;
+        unlit?: boolean;
+        transform?: Readonly<Mat4>;
+    }): void;
+    cube(opts: {
+        center: Readonly<Vec3>;
+        halfExtent: Readonly<Vec3> | number;
+        color?: Readonly<Color>;
+        wireframe?: boolean;
+        depthTest?: boolean;
+        transform?: Readonly<Mat4>;
+    }): this;
+    lineFromTo(opts: {
+        from: Readonly<Vec3>;
+        to: Readonly<Vec3>;
+        color?: Readonly<Color>;
+        depthTest?: boolean;
+    }): this;
+    lineFromDirLength(opts: {
+        from: Readonly<Vec3>;
+        dir: Readonly<Vec3>;
+        length: number;
+        color?: Readonly<Color>;
+        depthTest?: boolean;
+    }): this;
+    sphere(opts: {
+        center: Readonly<Vec3>;
+        radius: number;
+        color?: Readonly<Color>;
+        wireframe?: boolean;
+        depthTest?: boolean;
+        segments?: number;
+    }): this;
+    capsule(opts: {
+        center: Readonly<Vec3>;
+        radius: number;
+        height: number;
+        color?: Readonly<Color>;
+        wireframe?: boolean;
+        depthTest?: boolean;
+        segments?: number;
+        transform?: {
+            position?: Readonly<Vec3>;
+            rotation?: Readonly<Quat>;
+            scale?: Readonly<Vec3>;
+        };
+    }): this;
+    circle(opts: {
+        center: Readonly<Vec3>;
+        radius: number;
+        normal?: Readonly<Vec3>;
+        color?: Readonly<Color>;
+        wireframe?: boolean;
+        depthTest?: boolean;
+        segments?: number;
+        transform?: Mat4;
+    }): void;
+    arc(opts: {
+        center: Readonly<Vec3>;
+        radius: number;
+        startAngle: number;
+        endAngle: number;
+        normal?: Readonly<Vec3>;
+        color?: Readonly<Color>;
+        wireframe?: boolean;
+        depthTest?: boolean;
+        segments?: number;
+        transform?: Mat4;
+    }): void;
+    sector(opts: {
+        center: Readonly<Vec3>;
+        radius: number;
+        halfVector?: Readonly<Vec3>;
+        halfAngle?: number;
+        normal?: Readonly<Vec3>;
+        color?: Readonly<Color>;
+        wireframe?: boolean;
+        depthTest?: boolean;
+        segments?: number;
+        transform?: Mat4;
+        unlit?: boolean;
+    }): void;
+    private _geometryRenderers;
+}
+export * from './legacy.js';
+//# sourceMappingURL=index.d.ts.map

package/lib/index.js

@@ -0,0 +1,220 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+import { Camera, Color, GeometryRenderer, Mat4, Quat, Vec3, director, find, geometry, renderer } from 'cc';
+import { EDITOR_NOT_IN_PREVIEW } from 'cc/env';
+import { CycloComponent } from '@cyclonium/core/framework';
+import { cycloBuiltinClass } from '@cyclonium/core/internal';
+import { requiresComponent } from '@cyclonium/core/legacy-decorator';
+import { toDegrees } from '@cyclonium/core/math/trigonometry';
+let DebugDrawTarget = class DebugDrawTarget extends CycloComponent {
+    get geometryRenderer() {
+        return tryGetDebugGeometryRenderer(this._camera);
+    }
+    get _camera() { return undefined; }
+};
+__decorate([
+    requiresComponent(Camera)
+], DebugDrawTarget.prototype, "_camera", null);
+DebugDrawTarget = __decorate([
+    cycloBuiltinClass('DebugDrawTarget')
+], DebugDrawTarget);
+export { DebugDrawTarget };
+export function tryGetDebugGeometryRenderer(camera) {
+    let renderCamera = undefined;
+    if (camera) {
+        renderCamera = camera.camera;
+    }
+    else if (EDITOR_NOT_IN_PREVIEW) {
+        renderCamera = globalThis.cce?.Camera.camera.camera;
+    }
+    else {
+        renderCamera = find('World/Main Camera')?.getComponent(Camera)?.camera;
+    }
+    if (!renderCamera) {
+        return;
+    }
+    if (renderCamera) {
+        renderCamera.initGeometryRenderer();
+    }
+    const geometryRenderer = renderCamera?.geometryRenderer ?? director.root?.pipeline.geometryRenderer;
+    return geometryRenderer;
+}
+export function getDebugGeometryRenderer() {
+    const geometryRenderer = tryGetDebugGeometryRenderer();
+    if (!geometryRenderer) {
+        throw new Error(`Can not get debug geometry renderer.`);
+    }
+    return geometryRenderer;
+}
+function getGeometryRendererFromCamera(camera) {
+    const renderCamera = camera.camera;
+    if (!renderCamera) {
+        return undefined;
+    }
+    renderCamera.initGeometryRenderer();
+    const geometryRenderer = renderCamera.geometryRenderer;
+    if (!geometryRenderer) {
+        return undefined;
+    }
+    return geometryRenderer;
+}
+const cacheAABB = new geometry.AABB();
+export class DebugDrawContext {
+    static fromEditorCamera() {
+        const camera = globalThis.cce?.Camera.camera;
+        if (!camera) {
+            return undefined;
+        }
+        const geometryRenderer = getGeometryRendererFromCamera(camera);
+        if (!geometryRenderer) {
+            return undefined;
+        }
+        return new DebugDrawContext([geometryRenderer]);
+    }
+    static fromDebugDrawTarget(target) {
+        return this.fromDebugDrawTargets([target]);
+    }
+    static fromDebugDrawTargets(target) {
+        const geometryRenderers = target.map((t) => t.geometryRenderer).filter((r) => r !== undefined);
+        return new DebugDrawContext(geometryRenderers);
+    }
+    constructor(geometryRenderers) {
+        this._geometryRenderers = geometryRenderers;
+    }
+    get geometryRenderers_internal() {
+        return this._geometryRenderers;
+    }
+    rect(opts) {
+        const { center, halfExtent, right = Vec3.RIGHT, up = Vec3.UP, color, unlit, wireframe, depthTest, transform, } = opts;
+        const hx = typeof halfExtent === 'number' ? halfExtent : halfExtent.x;
+        const hy = typeof halfExtent === 'number' ? halfExtent : halfExtent.y;
+        let iVec3Cache = 0;
+        const v1 = Vec3.scaleAndAdd(vec3Caches[iVec3Cache++], center, right, hx);
+        Vec3.scaleAndAdd(v1, v1, up, hy);
+        const v2 = Vec3.scaleAndAdd(vec3Caches[iVec3Cache++], center, up, hy);
+        Vec3.scaleAndAdd(v2, v2, right, -hx);
+        const v3 = Vec3.scaleAndAdd(vec3Caches[iVec3Cache++], center, up, -hy);
+        Vec3.scaleAndAdd(v3, v3, right, -hx);
+        const v4 = Vec3.scaleAndAdd(vec3Caches[iVec3Cache++], center, right, hx);
+        Vec3.scaleAndAdd(v4, v4, up, -hy);
+        if (transform) {
+            Vec3.transformMat4(v1, v1, transform);
+            Vec3.transformMat4(v2, v2, transform);
+            Vec3.transformMat4(v3, v3, transform);
+            Vec3.transformMat4(v4, v4, transform);
+        }
+        this._geometryRenderers.forEach((g) => {
+            g.addQuad(v1, v2, v3, v4, color ?? Color.BLACK, wireframe, depthTest, unlit);
+        });
+    }
+    cube(opts) {
+        const { center, halfExtent, color, wireframe, depthTest, transform, } = opts;
+        const hx = typeof halfExtent === 'number' ? halfExtent : halfExtent.x;
+        const hy = typeof halfExtent === 'number' ? halfExtent : halfExtent.y;
+        const hz = typeof halfExtent === 'number' ? halfExtent : halfExtent.z;
+        this._geometryRenderers.forEach((g) => {
+            g.addBoundingBox(geometry.AABB.set(cacheAABB, center.x, center.y, center.z, hx, hy, hz), color ?? Color.BLACK, wireframe, depthTest, undefined, transform ? true : false, transform);
+        });
+        return this;
+    }
+    lineFromTo(opts) {
+        const { from, to, color = Color.BLACK, depthTest, } = opts;
+        this._geometryRenderers.forEach((g) => {
+            g.addLine(from, to, color, depthTest);
+        });
+        return this;
+    }
+    lineFromDirLength(opts) {
+        const { from, dir, length, color = Color.BLACK, depthTest, } = opts;
+        this._geometryRenderers.forEach((g) => {
+            g.addLine(from, Vec3.add(new Vec3(), from, Vec3.multiplyScalar(new Vec3(), dir, length)), color, depthTest);
+        });
+        return this;
+    }
+    sphere(opts) {
+        const { center, radius, color = Color.BLACK, wireframe, depthTest, segments = 16, } = opts;
+        this._geometryRenderers.forEach((g) => {
+            g.addSphere(center, radius, color, segments, segments, wireframe, depthTest);
+        });
+        return this;
+    }
+    capsule(opts) {
+        const { center, radius, height, color = Color.BLACK, wireframe, depthTest, segments = 16, transform, } = opts;
+        let transformMatrix = undefined;
+        if (transform) {
+            if (transform instanceof Mat4) {
+                transformMatrix = transform;
+            }
+            else {
+                const { position, rotation, scale } = transform;
+                transformMatrix = Mat4.fromSRT(new Mat4(), rotation ?? Quat.IDENTITY, position ?? Vec3.ZERO, scale ?? Vec3.ONE);
+            }
+        }
+        this._geometryRenderers.forEach((g) => {
+            g.addCapsule(center, radius, height, color, segments, segments, wireframe, depthTest, undefined, !!transformMatrix, transformMatrix);
+        });
+        return this;
+    }
+    circle(opts) {
+        return this.arc({
+            ...opts,
+            startAngle: 0,
+            endAngle: Math.PI * 2,
+        });
+    }
+    arc(opts) {
+        const { center, radius, startAngle, endAngle, normal = Vec3.UNIT_Y, color = Color.BLACK, wireframe, depthTest, segments = 64, transform, } = opts;
+        const finalTransform = new Mat4();
+        Mat4.fromSRT(finalTransform, Quat.rotationTo(new Quat(), Vec3.UNIT_Y, normal), center, Vec3.ONE);
+        if (transform) {
+            Mat4.multiply(finalTransform, transform, finalTransform);
+        }
+        this._geometryRenderers.forEach((g) => {
+            g.addArc(Vec3.ZERO, radius, color, toDegrees(startAngle), toDegrees(endAngle), segments, depthTest, true, finalTransform);
+        });
+    }
+    sector(opts) {
+        let iCacheMat4 = 0;
+        let iCacheQuat = 0;
+        let iCacheVec3 = 0;
+        const { center, radius, halfVector = Vec3.UNIT_Z, halfAngle = Math.PI / 2, normal = Vec3.UNIT_Y, color = Color.BLACK, wireframe = false, depthTest, segments = 64, transform, unlit = false, } = opts;
+        const finalTransform = Mat4.identity(mat4Caches[iCacheMat4++]);
+        // Scale
+        Mat4.scale(finalTransform, finalTransform, Vec3.multiplyScalar(vec3Caches[iCacheVec3++], Vec3.ONE, radius));
+        // Rotate
+        {
+            const inputHalfVector = Vec3.normalize(vec3Caches[iCacheVec3++], halfVector);
+            const inputNormal = Vec3.normalize(vec3Caches[iCacheVec3++], normal);
+            const cross = Vec3.cross(vec3Caches[iCacheVec3++], inputHalfVector, inputNormal).normalize();
+            const newY = Vec3.cross(vec3Caches[iCacheVec3++], cross, inputHalfVector).normalize();
+            const newX = Vec3.transformQuat(vec3Caches[iCacheVec3++], inputHalfVector, Quat.fromAxisAngle(quatCaches[iCacheQuat++], newY, halfAngle));
+            const newZ = Vec3.cross(vec3Caches[iCacheVec3++], newX, newY).normalize();
+            const newMat4 = mat4FromAxes(mat4Caches[iCacheMat4++], newX, newY, newZ);
+            Mat4.multiply(finalTransform, newMat4, finalTransform);
+        }
+        // Translate
+        Mat4.translate(finalTransform, finalTransform, center);
+        // User defined transform
+        if (transform) {
+            Mat4.multiply(finalTransform, transform, finalTransform);
+        }
+        const startAngle = 0;
+        const endAngle = startAngle + halfAngle * 2;
+        this._geometryRenderers.forEach((g) => {
+            g.addSector(Vec3.ZERO, 1.0, color, toDegrees(startAngle), toDegrees(endAngle), segments, wireframe, depthTest, unlit, true, finalTransform);
+        });
+    }
+    _geometryRenderers;
+}
+function mat4FromAxes(mat4, xAxis, yAxis, zAxis) {
+    return Mat4.set(mat4, xAxis.x, xAxis.y, xAxis.z, 0, yAxis.x, yAxis.y, yAxis.z, 0, zAxis.x, zAxis.y, zAxis.z, 0, 0, 0, 0, 1);
+}
+export * from './legacy.js';
+const vec3Caches = Array.from({ length: 10 }, () => new Vec3());
+const mat4Caches = Array.from({ length: 10 }, () => new Mat4());
+const quatCaches = Array.from({ length: 10 }, () => new Quat());
+//# sourceMappingURL=index.js.map

package/lib/legacy.d.ts

@@ -0,0 +1,29 @@
+import { Mat3 } from "@cyclonium/core/math/mat3";
+import { Vec2 } from "@cyclonium/core/math/vec2";
+import { Mat4, type GeometryRenderer, type Color, Vec3 } from "cc";
+export declare const drawBox2D: (geometryRenderer: GeometryRenderer, center: Readonly<Vec2>, halfExtent: Readonly<Vec2> | number, color: Readonly<Color>, { wireframe, depthTest, z, transform, }?: {
+    wireframe?: boolean;
+    depthTest?: boolean;
+    z?: number;
+    transform?: Mat3;
+}) => void;
+export declare const drawCircleXY: (geometryRenderer: GeometryRenderer, center: Readonly<Vec3>, radius: number, color: Readonly<Color>, { wireframe, depthTest, segments, }?: {
+    wireframe?: boolean;
+    depthTest?: boolean;
+    segments?: number;
+}) => void;
+export declare const drawLineFromTo2D: (geometryRenderer: GeometryRenderer, from: Readonly<Vec2>, to: Readonly<Vec2>, color: Readonly<Color>, { depthTest, transform, }?: {
+    depthTest?: boolean;
+    transform?: Mat3 | Mat4;
+}) => void;
+export declare const drawCircle2D: (geometryRenderer: GeometryRenderer, { center, radius, color, segments, wireframe, depthTest, z, transform, }: {
+    center: Vec2;
+    radius: number;
+    color: Color;
+    segments?: number;
+    wireframe?: boolean;
+    depthTest?: boolean;
+    z?: number;
+    transform?: Mat3;
+}) => void;
+//# sourceMappingURL=legacy.d.ts.map

package/lib/legacy.js

@@ -0,0 +1,75 @@
+import { Mat3 } from "@cyclonium/core/math/mat3";
+import { decomposeSRTMat3 } from "@cyclonium/core/math/transform-2d";
+import { Vec2 } from "@cyclonium/core/math/vec2";
+import { Mat4, Quat, Vec3 } from "cc";
+export const drawBox2D = (() => {
+    return (geometryRenderer, center, halfExtent, color, { wireframe = true, depthTest = true, z = 0, transform, } = {}) => {
+        const hx = typeof halfExtent === 'number' ? halfExtent : halfExtent.x;
+        const hy = typeof halfExtent === 'number' ? halfExtent : halfExtent.y;
+        const v0 = new Vec2(center.x + hx, center.y + hy);
+        const v1 = new Vec2(center.x - hx, center.y + hy);
+        const v2 = new Vec2(center.x - hx, center.y - hy);
+        const v3 = new Vec2(center.x + hx, center.y - hy);
+        if (transform) {
+            transform.transformVec2(v0, v0);
+            transform.transformVec2(v1, v1);
+            transform.transformVec2(v2, v2);
+            transform.transformVec2(v3, v3);
+        }
+        geometryRenderer.addQuad(new Vec3(v0.x, v0.y, z), new Vec3(v1.x, v1.y, z), new Vec3(v2.x, v2.y, z), new Vec3(v3.x, v3.y, z), color, wireframe, depthTest);
+    };
+})();
+export const drawCircleXY = (() => {
+    const transform = Mat4.fromQuat(new Mat4(), Quat.fromAxisAngle(new Quat(), Vec3.UNIT_X, Math.PI / 2));
+    return (geometryRenderer, center, radius, color, { wireframe = true, depthTest = true, segments = 32, } = {}) => {
+        geometryRenderer.addCircle(center, radius, color, segments, depthTest, true, transform);
+    };
+})();
+export const drawLineFromTo2D = (() => {
+    const from3 = new Vec3();
+    const to3 = new Vec3();
+    const transform2To3 = (v, out) => {
+        Vec3.set(out, v.x, v.y, 0);
+        return out;
+    };
+    const transformMat4 = (v, out, transform) => {
+        transform2To3(v, out);
+        Vec3.transformMat4(out, out, transform);
+        return out;
+    };
+    const transformMat3 = (v, out, transform) => {
+        const v2 = new Vec2(v.x, v.y);
+        transform.transformVec2(v, v2);
+        transform2To3(v2, out);
+        return out;
+    };
+    return (geometryRenderer, from, to, color, { depthTest = true, transform, } = {}) => {
+        if (transform instanceof Mat3) {
+            transformMat3(from, from3, transform);
+            transformMat3(to, to3, transform);
+        }
+        else if (transform instanceof Mat4) {
+            transformMat4(from, from3, transform);
+            transformMat4(to, to3, transform);
+        }
+        else {
+            transform2To3(from, from3);
+            transform2To3(to, to3);
+        }
+        geometryRenderer.addLine(from3, to3, color, depthTest);
+    };
+})();
+export const drawCircle2D = (() => {
+    const rotation2To3 = Quat.fromAxisAngle(new Quat(), Vec3.UNIT_X, Math.PI / 2);
+    return (geometryRenderer, { center, radius, color, segments = 32, wireframe = true, depthTest = true, z = 0, transform, }) => {
+        const center3 = new Vec3(center.x, center.y, z);
+        const transformMatrix = Mat4.fromSRTOrigin(new Mat4(), rotation2To3, Vec3.ZERO, Vec3.ONE, center3);
+        if (transform) {
+            const srt = decomposeSRTMat3(transform);
+            const transform4 = Mat4.fromSRT(new Mat4(), Quat.fromAxisAngle(new Quat(), Vec3.UNIT_Z, srt.rotation), new Vec3(srt.translation.x, srt.translation.y, z), new Vec3(srt.scale.x, srt.scale.y, z));
+            Mat4.multiply(transformMatrix, transform4, transformMatrix);
+        }
+        geometryRenderer.addCircle(center3, radius, color, segments, depthTest, true, transformMatrix);
+    };
+})();
+//# sourceMappingURL=legacy.js.map

package/package.json

@@ -0,0 +1,26 @@
+{
+  "name": "@cyclonium/debug-draw",
+  "version": "0.0.100",
+  "type": "module",
+  "files": [
+    "lib/**/*{.js,.d.ts}"
+  ],
+  "exports": {
+    ".": "./lib/index.js"
+  },
+  "dependencies": {
+    "@cyclonium/algorithm": "0.0.100"
+  },
+  "peerDependencies": {
+    "@cyclonium/core": "0.0.100"
+  },
+  "devDependencies": {
+    "typescript": "^6.0.2",
+    "@cyclonium/types-cc": "0.0.100",
+    "@cyclonium/workflow": "0.0.100"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "dev": "tsc --watch"
+  }
+}