@directivegames/genesys.js 3.1.28 → 3.1.30

package/dist/src/components/visual/SplineMeshComponent.js

@@ -0,0 +1,373 @@
+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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+/**
+ * SplineMeshComponent generates a flat ribbon mesh along a Catmull-Rom spline.
+ *
+ * Use cases include roads, paths, rivers, and any geometry that follows a curved path.
+ * The component samples points along the spline and creates a ribbon with proper
+ * UV mapping for texture tiling based on world distance.
+ *
+ * Recommended usage (for humans and AI assistants):
+ * - Provide an array of control points defining the path
+ * - Adjust width, segments, and tension for desired appearance
+ * - Use uvScale to control texture tiling density
+ * - Enable showDebug to visualize control points and spline curve
+ */
+import * as THREE from 'three';
+import { MaterialUtils } from '../../materials.js';
+import { EngineClass } from '../../systems/ClassRegistry.js';
+import { resourceManager } from '../../utils/ResourceManager.js';
+import { isNode } from '../../utils/Utils.js';
+import { PrimitiveComponent } from '../PrimitiveComponent.js';
+let SplineMeshComponent = class SplineMeshComponent extends PrimitiveComponent {
+    static get DEFAULT_OPTIONS() {
+        return {
+            ...PrimitiveComponent.DEFAULT_OPTIONS,
+            // Provide default starter points so the spline is visible when created
+            points: [
+                new THREE.Vector3(-2, 0, 0),
+                new THREE.Vector3(0, 0, 1),
+                new THREE.Vector3(2, 0, 0),
+            ],
+            width: 1,
+            segments: 50,
+            closed: false,
+            tension: 0.5,
+            uvScale: 1,
+            material: '', // Asset path to material JSON file
+            showDebug: false,
+            physicsOptions: {
+                ...PrimitiveComponent.DEFAULT_PHYSICS_OPTIONS,
+                enabled: false,
+            },
+        };
+    }
+    constructor(options = {}) {
+        super(options);
+        Object.defineProperty(this, "mesh", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "curve", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        Object.defineProperty(this, "debugGroup", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: null
+        });
+        this.rebuildMesh();
+    }
+    /**
+     * Returns the THREE.Mesh object associated with this component
+     */
+    getMesh() {
+        return this.mesh;
+    }
+    /**
+     * Returns the underlying Catmull-Rom curve
+     */
+    getCurve() {
+        return this.curve;
+    }
+    /**
+     * Sets new control points and rebuilds the mesh
+     */
+    setPoints(points) {
+        this.options.points = points;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets the ribbon width and rebuilds the mesh
+     */
+    setWidth(width) {
+        this.options.width = width;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets the segment count and rebuilds the mesh
+     */
+    setSegments(segments) {
+        this.options.segments = segments;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets the Catmull-Rom tension and rebuilds the mesh
+     */
+    setTension(tension) {
+        this.options.tension = tension;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets the UV scale and rebuilds the mesh
+     */
+    setUvScale(uvScale) {
+        this.options.uvScale = uvScale;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets whether the spline is closed and rebuilds the mesh
+     */
+    setClosed(closed) {
+        this.options.closed = closed;
+        this.rebuildMesh();
+    }
+    /**
+     * Sets the material for the mesh
+     */
+    setMaterial(material) {
+        this.options.material = material;
+        if (this.mesh) {
+            resourceManager.loadGenericMaterial(material).then((loadedMaterial) => {
+                if (loadedMaterial && this.mesh) {
+                    this.mesh.material = loadedMaterial;
+                }
+            });
+        }
+        else {
+            // Mesh doesn't exist yet - rebuild to create it with the new material
+            this.rebuildMesh();
+        }
+    }
+    /**
+     * Toggles debug visualization
+     */
+    setShowDebug(show) {
+        this.options.showDebug = show;
+        this.updateDebugVisualization();
+    }
+    /**
+     * Rebuilds the ribbon mesh based on current options
+     */
+    rebuildMesh() {
+        // Filter out null/undefined points and ensure they are Vector3 instances
+        // (points may be plain {x,y,z} objects after deserialization)
+        const rawPoints = this.options.points ?? [];
+        const points = rawPoints
+            .filter((p) => p != null)
+            .map(p => p instanceof THREE.Vector3 ? p : new THREE.Vector3(p.x, p.y, p.z));
+        if (points.length < 2) {
+            this.clearMesh();
+            return;
+        }
+        // Create the Catmull-Rom curve
+        this.curve = new THREE.CatmullRomCurve3(points, this.options.closed ?? false, 'catmullrom', this.options.tension ?? 0.5);
+        const segments = this.options.segments ?? 50;
+        const width = this.options.width ?? 1;
+        const uvScale = this.options.uvScale ?? 1;
+        const halfWidth = width / 2;
+        // Generate geometry
+        const geometry = this.generateRibbonGeometry(this.curve, segments, halfWidth, uvScale);
+        // Remove old mesh if exists
+        if (this.mesh) {
+            this.mesh.removeFromParent();
+            this.mesh.geometry.dispose();
+        }
+        // Create new mesh with default material initially
+        this.mesh = new THREE.Mesh(geometry, MaterialUtils.DefaultMaterial);
+        this.mesh.setTransient(true);
+        this.bindObject3DProperties(this.mesh, ['castShadow', 'receiveShadow']);
+        this.add(this.mesh);
+        // Load material if specified
+        if (!isNode() && this.options.material) {
+            resourceManager.loadGenericMaterial(this.options.material).then((loadedMaterial) => {
+                if (loadedMaterial && this.mesh) {
+                    this.mesh.material = loadedMaterial;
+                }
+            });
+        }
+        // Update debug visualization
+        this.updateDebugVisualization();
+    }
+    /**
+     * Generates a ribbon geometry along the curve
+     */
+    generateRibbonGeometry(curve, segments, halfWidth, uvScale) {
+        const vertices = [];
+        const normals = [];
+        const uvs = [];
+        const indices = [];
+        const totalLength = curve.getLength();
+        const up = new THREE.Vector3(0, 1, 0);
+        const tempTangent = new THREE.Vector3();
+        const tempNormal = new THREE.Vector3();
+        const tempBinormal = new THREE.Vector3();
+        // Sample points along the curve
+        for (let i = 0; i <= segments; i++) {
+            const t = i / segments;
+            const point = curve.getPointAt(t);
+            const tangent = curve.getTangentAt(t).normalize();
+            // Calculate binormal (perpendicular to tangent and up)
+            tempBinormal.crossVectors(up, tangent).normalize();
+            // Handle degenerate case when tangent is parallel to up
+            if (tempBinormal.lengthSq() < 0.001) {
+                tempBinormal.set(1, 0, 0);
+            }
+            // Calculate normal (perpendicular to tangent and binormal)
+            tempNormal.crossVectors(tangent, tempBinormal).normalize();
+            // Create two vertices at this point (left and right edges)
+            const leftPoint = point.clone().addScaledVector(tempBinormal, -halfWidth);
+            const rightPoint = point.clone().addScaledVector(tempBinormal, halfWidth);
+            vertices.push(leftPoint.x, leftPoint.y, leftPoint.z);
+            vertices.push(rightPoint.x, rightPoint.y, rightPoint.z);
+            // Normals point up
+            normals.push(tempNormal.x, tempNormal.y, tempNormal.z);
+            normals.push(tempNormal.x, tempNormal.y, tempNormal.z);
+            // UVs: U tiles along length based on world distance, V is 0-1 across width
+            const distanceAlongCurve = t * totalLength;
+            const u = distanceAlongCurve * uvScale;
+            uvs.push(u, 0); // Left edge
+            uvs.push(u, 1); // Right edge
+        }
+        // Generate indices for triangle strip (CCW winding for upward-facing normals)
+        for (let i = 0; i < segments; i++) {
+            const baseIndex = i * 2;
+            // First triangle: left[i] -> left[i+1] -> right[i]
+            indices.push(baseIndex, baseIndex + 2, baseIndex + 1);
+            // Second triangle: right[i] -> left[i+1] -> right[i+1]
+            indices.push(baseIndex + 1, baseIndex + 2, baseIndex + 3);
+        }
+        const geometry = new THREE.BufferGeometry();
+        geometry.setAttribute('position', new THREE.Float32BufferAttribute(vertices, 3));
+        geometry.setAttribute('normal', new THREE.Float32BufferAttribute(normals, 3));
+        geometry.setAttribute('uv', new THREE.Float32BufferAttribute(uvs, 2));
+        geometry.setIndex(indices);
+        return geometry;
+    }
+    /**
+     * Clears the current mesh
+     */
+    clearMesh() {
+        if (this.mesh) {
+            this.mesh.removeFromParent();
+            this.mesh.geometry.dispose();
+            this.mesh = null;
+        }
+        this.curve = null;
+        this.clearDebugVisualization();
+    }
+    /**
+     * Updates debug visualization showing control points and spline
+     */
+    updateDebugVisualization() {
+        this.clearDebugVisualization();
+        if (!this.options.showDebug || !this.curve) {
+            return;
+        }
+        this.debugGroup = new THREE.Group();
+        this.debugGroup.setTransient(true);
+        // Filter out null/undefined points and ensure they are Vector3 instances
+        const rawPoints = this.options.points ?? [];
+        const points = rawPoints
+            .filter((p) => p != null)
+            .map(p => p instanceof THREE.Vector3 ? p : new THREE.Vector3(p.x, p.y, p.z));
+        // Draw control point spheres
+        const sphereGeometry = new THREE.SphereGeometry(0.15);
+        const sphereMaterial = new THREE.MeshBasicMaterial({ color: 0xff0000 });
+        for (let i = 0; i < points.length; i++) {
+            const sphere = new THREE.Mesh(sphereGeometry, sphereMaterial);
+            sphere.position.copy(points[i]);
+            this.debugGroup.add(sphere);
+        }
+        // Draw spline curve line
+        const curvePoints = this.curve.getPoints(100);
+        const lineGeometry = new THREE.BufferGeometry().setFromPoints(curvePoints);
+        const lineMaterial = new THREE.LineBasicMaterial({ color: 0x00ff00 });
+        const line = new THREE.Line(lineGeometry, lineMaterial);
+        this.debugGroup.add(line);
+        // Draw tangent indicators at control points
+        const arrowMaterial = new THREE.LineBasicMaterial({ color: 0x0000ff });
+        for (let i = 0; i < points.length; i++) {
+            const t = this.options.closed ? i / points.length : i / (points.length - 1);
+            const tangent = this.curve.getTangentAt(Math.min(t, 1)).normalize();
+            const arrowPoints = [
+                points[i].clone(),
+                points[i].clone().addScaledVector(tangent, 0.5)
+            ];
+            const arrowGeometry = new THREE.BufferGeometry().setFromPoints(arrowPoints);
+            const arrow = new THREE.Line(arrowGeometry, arrowMaterial);
+            this.debugGroup.add(arrow);
+        }
+        this.add(this.debugGroup);
+    }
+    /**
+     * Clears debug visualization
+     */
+    clearDebugVisualization() {
+        if (this.debugGroup) {
+            this.debugGroup.removeFromParent();
+            this.debugGroup.traverse((child) => {
+                if (child instanceof THREE.Mesh || child instanceof THREE.Line) {
+                    child.geometry.dispose();
+                    if (Array.isArray(child.material)) {
+                        child.material.forEach(m => m.dispose());
+                    }
+                    else {
+                        child.material.dispose();
+                    }
+                }
+            });
+            this.debugGroup = null;
+        }
+    }
+    calcBoundingBox() {
+        if (this.mesh) {
+            this.mesh.geometry.computeBoundingBox();
+            this._boundingBox.copy(this.mesh.geometry.boundingBox).applyMatrix4(this.mesh.matrixWorld);
+        }
+    }
+    getEditorClassIcon() {
+        return 'Icon_Path';
+    }
+    onEditorPropertyChanged(path, value, result) {
+        super.onEditorPropertyChanged(path, value, result);
+        // Rebuild mesh when any spline-related property changes
+        if (result.isOptions) {
+            if (path === 'material') {
+                this.setMaterial(value);
+            }
+            else if (path === 'points' || path.startsWith('points[') || path.startsWith('points.')) {
+                // Handle array changes: full replacement, element changes, or property changes
+                this.rebuildMesh();
+            }
+            else if (['width', 'segments', 'tension', 'uvScale', 'closed', 'showDebug'].includes(path)) {
+                this.rebuildMesh();
+            }
+        }
+    }
+};
+Object.defineProperty(SplineMeshComponent, "EDITOR_CLASS_META", {
+    enumerable: true,
+    configurable: true,
+    writable: true,
+    value: {
+        ...PrimitiveComponent.EDITOR_CLASS_META,
+        points: { array: { child: { type: THREE.Vector3 } } },
+        width: { number: { min: 0.1, max: 100, step: 0.1, decimals: 2 } },
+        segments: { integer: { min: 2, max: 500, step: 1 } },
+        tension: { number: { min: 0, max: 1, step: 0.05, decimals: 2 } },
+        uvScale: { number: { min: 0.01, max: 10, step: 0.1, decimals: 2 } },
+        closed: { boolean: {} },
+        showDebug: { boolean: {} },
+        material: { type: ['material'] },
+    }
+});
+SplineMeshComponent = __decorate([
+    EngineClass('SplineMeshComponent'),
+    __metadata("design:paramtypes", [Object])
+], SplineMeshComponent);
+export { SplineMeshComponent };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SplineMeshComponent.js","sourceRoot":"","sources":["../../../../src/components/visual/SplineMeshComponent.ts"],"names":[],"mappings":"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"}

package/dist/src/components/visual/index.d.ts

@@ -21,3 +21,4 @@ export * from './TerrainMeshComponent.js';
 export * from './SkyboxComponent.js';
 export * from './FogComponent.js';
 export * from './UI3DComponent.js';
+export * from './SplineMeshComponent.js';

package/dist/src/components/visual/index.js

@@ -21,4 +21,5 @@ export * from './TerrainMeshComponent.js';
 export * from './SkyboxComponent.js';
 export * from './FogComponent.js';
 export * from './UI3DComponent.js';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy92aXN1YWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUc7QUFDSCxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUMifQ==
+export * from './SplineMeshComponent.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvY29tcG9uZW50cy92aXN1YWwvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7Ozs7Ozs7O0dBUUc7QUFDSCxjQUFjLHlCQUF5QixDQUFDO0FBQ3hDLGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLHdCQUF3QixDQUFDO0FBQ3ZDLGNBQWMseUJBQXlCLENBQUM7QUFDeEMsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLGlDQUFpQyxDQUFDO0FBQ2hELGNBQWMsNkJBQTZCLENBQUM7QUFDNUMsY0FBYyxvQkFBb0IsQ0FBQztBQUNuQyxjQUFjLCtCQUErQixDQUFDO0FBQzlDLGNBQWMsMkJBQTJCLENBQUM7QUFDMUMsY0FBYyxzQkFBc0IsQ0FBQztBQUNyQyxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLGNBQWMsb0JBQW9CLENBQUM7QUFDbkMsY0FBYywwQkFBMEIsQ0FBQyJ9

package/dist/test/prefab.test.js

@@ -53,7 +53,7 @@ QUnit.module('Prefab', hooks => {
         for (let index = 0; index < 4; index++) {
             const instanceRootData = [index === 0 ? -123 : undefined, index === 1 ? -456 : undefined];
             const instanceComponentData = [index === 2 ? -789 : undefined, index === 3 ? -101 : undefined];
-            // laod an instance actor them modify its properties
+            // load an instance actor then modify its properties
             const instanceActor = await ENGINE.Actor.spawnPrefabActor(prefabName, {
                 position: instancePosition,
                 rotation: instanceRotation,

package/games/index.ts

@@ -12,6 +12,7 @@ export * from './performance-test-demo.js';
 export * from './postprocess-demo.js';
 export * from './ragdoll-demo-simple.js';
 export * from './ragdoll-demo.js';
+export * from './spline-mesh-demo.js';
 export * from './swipe-tap-demo.js';
 export * from './tween-demo.js';
 export * from './ui-demo.js';

package/games/spline-mesh-demo.ts

@@ -0,0 +1,119 @@
+import * as ENGINE from '@directivegames/genesys.js';
+import * as THREE from 'three';
+
+/**
+ * SplineMeshDemo showcases the SplineMeshComponent.
+ *
+ * Demonstrates:
+ * - Creating a road-like path using control points
+ * - Debug visualization of control points and spline curve
+ * - UV tiling for texture mapping
+ */
+export class SplineMeshDemo extends ENGINE.BaseGameLoop {
+  private splineActor: ENGINE.Actor | null = null;
+  private splineComponent: ENGINE.SplineMeshComponent | null = null;
+
+  protected override async preStart(): Promise<void> {
+    // Setup camera
+    const { pawn } = ENGINE.GameBuilder.createDefaultPawn(this.world, new THREE.Vector3(0, 15, 20));
+    const camera = pawn.getComponent(THREE.Camera)!;
+    camera.position.set(0, 15, 20);
+    camera.lookAt(0, 0, 0);
+
+    // Setup lighting
+    ENGINE.GameBuilder.createDefaultLighting(this.world);
+
+    // Create ground plane with grass color
+    const groundMaterial = new THREE.MeshStandardMaterial({ color: 0x228833 });
+    const groundGeometry = new THREE.BoxGeometry(50, 0.1, 50);
+    const ground = new ENGINE.Actor({
+      rootComponent: new ENGINE.MeshComponent({
+        position: new THREE.Vector3(0, -0.1, 0),
+        geometry: groundGeometry,
+        material: groundMaterial,
+      })
+    });
+    this.world.addActor(ground);
+
+    // Create a winding road path
+    this.createRoadPath();
+
+    // Create a river path
+    this.createRiverPath();
+  }
+
+  private createRoadPath(): void {
+    // Define control points for a winding road
+    const roadPoints = [
+      new THREE.Vector3(-15, 0, -10),
+      new THREE.Vector3(-8, 0, -5),
+      new THREE.Vector3(-3, 0, 0),
+      new THREE.Vector3(0, 0, 5),
+      new THREE.Vector3(5, 0, 3),
+      new THREE.Vector3(10, 0, -2),
+      new THREE.Vector3(15, 0, 0),
+    ];
+
+    // Create the spline mesh component with a texture
+    this.splineComponent = new ENGINE.SplineMeshComponent({
+      points: roadPoints,
+      width: 3,
+      segments: 80,
+      tension: 0.3,
+      uvScale: 0.5,
+      material: '@engine/assets/dev/materials/RoadAsphalt.json',
+      showDebug: true, // Enable debug visualization
+    });
+
+    // Create actor and add component
+    this.splineActor = new ENGINE.Actor();
+    this.splineActor.rootComponent.add(this.splineComponent);
+    this.world.addActor(this.splineActor);
+  }
+
+  private createRiverPath(): void {
+    // Define control points for a river
+    const riverPoints = [
+      new THREE.Vector3(-12, 0.01, 8),
+      new THREE.Vector3(-6, 0.01, 12),
+      new THREE.Vector3(0, 0.01, 10),
+      new THREE.Vector3(6, 0.01, 14),
+      new THREE.Vector3(12, 0.01, 12),
+    ];
+
+    // Create river material with blue color
+    const riverMaterial = new THREE.MeshStandardMaterial({
+      color: 0x2266aa,
+      roughness: 0.2,
+      metalness: 0.3,
+      transparent: true,
+      opacity: 0.8,
+    });
+
+    // Create the spline mesh component for river
+    const riverComponent = new ENGINE.SplineMeshComponent({
+      points: riverPoints,
+      width: 2,
+      segments: 60,
+      tension: 0.5,
+      uvScale: 1,
+      material: riverMaterial,
+      showDebug: true,
+    });
+
+    // Create actor and add component
+    const riverActor = new ENGINE.Actor();
+    riverActor.rootComponent.add(riverComponent);
+    this.world.addActor(riverActor);
+  }
+
+  public override destroy(): void {
+    if (this.splineActor) {
+      this.splineActor.destroy();
+      this.splineActor = null;
+    }
+    this.splineComponent = null;
+    super.destroy();
+  }
+}
+

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@directivegames/genesys.js",
-  "version": "3.1.28",
+  "version": "3.1.30",
   "description": "Mini game engine built on top of three.js",
   "license": "UNLICENSED",
   "main": "./dist/src/index.js",

package/src/actors/Actor.ts

@@ -196,6 +196,7 @@ export class Actor<TOptions extends ActorOptions = ActorOptions> extends Playabl
   constructor(readonly options: TOptions = {} as TOptions) {
     super();
     this.ctorArgOptions = options;
+
     options = { ...Actor.DEFAULT_OPTIONS, ...options, };
     this.name = ObjectNamingSystem.generateName(this);
     this.actorTags = options.actorTags ? [...options.actorTags] : [];
@@ -236,6 +237,13 @@ export class Actor<TOptions extends ActorOptions = ActorOptions> extends Playabl
     if (legacyPrefabName) {
       this.prefabName = legacyPrefabName;
     }
+
+    // HACK copy the ctorArgOptions and delete the transform data, so they get populated by the data stored in root component when loaded
+    // and also this won't mutate the original `options` passed in
+    this.ctorArgOptions = {...this.ctorArgOptions};
+    delete this.ctorArgOptions.position;
+    delete this.ctorArgOptions.rotation;
+    delete this.ctorArgOptions.scale;
   }
 
   /**
@@ -263,7 +271,7 @@ export class Actor<TOptions extends ActorOptions = ActorOptions> extends Playabl
   }
 
   /**
-   * Sets the prefab name and data of this actor
+   * @deprecated deprecated, use $$prefab, setAsPrefabInstance instead
    * @param name The prefab name
    * @param data The prefab data
    * @param inheritanceChain The full prefab inheritance chain (optional)
@@ -277,7 +285,7 @@ export class Actor<TOptions extends ActorOptions = ActorOptions> extends Playabl
   }
 
   /**
-   * Clears the prefab name and data of this actor
+   * @deprecated Clears the prefab name and data of this actor. Use setAsPrefabInstance(null) instead
    * @returns This actor instance for method chaining
    */
   public clearPrefab(): this {