@needle-tools/engine 3.47.5-beta → 3.47.5-beta.1

package/src/engine/engine_utils_screenshot.ts

@@ -1,4 +1,4 @@
-import { Camera, Color, ColorRepresentation, PerspectiveCamera } from "three";
+import { Camera, CanvasTexture, Color, ColorRepresentation, MirroredRepeatWrapping, PerspectiveCamera, RepeatWrapping, Texture, Vector2, WebGLRenderTarget } from "three";
 
 import { Renderer } from "../engine-components/Renderer.js";
 import { getComponentsInChildren } from "./engine_components.js";
@@ -64,19 +64,31 @@ export declare type ScreenshotOptions = {
      */
     background?: Color | RGBAColor | ColorRepresentation,
 
+    /**
+     * If true onBeforeRender and onAfterRender will be invoked on all renderers in the scene.
+     * @default true
+     */
+    render_events?: boolean,
+};
+
+
+export declare type ScreenshotOptionsDataUrl = ScreenshotOptions & {
     /**
      * If set the screenshot will be downloaded using the provided filename.   
      * NOTE: if you need more control you can manually download the returned image using {@link saveImage}
      * @default undefined
      */
     download_filename?: string,
+}
 
+export declare type ScreenshotOptionsTexture = ScreenshotOptions & {
+    type: "texture",
     /**
-     * If true onBeforeRender and onAfterRender will be invoked on all renderers in the scene.
-     * @default true
+     * If set the screenshot will be saved to the provided texture.
+     * @default undefined
      */
-    render_events?: boolean,
-};
+    target?: Texture,
+}
 
 /**
  * Take a screenshot from the current scene.  
@@ -93,15 +105,14 @@ export declare type ScreenshotOptions = {
  * saveImage(res, "screenshot.webp");
  * ```
  */
-export function screenshot2(opts: ScreenshotOptions = {
-    mimeType: "image/png",
-    transparent: false,
-}): string | null {
+export function screenshot2(opts: ScreenshotOptionsTexture): Texture | null;
+export function screenshot2(opts: ScreenshotOptionsDataUrl): string | null;
+export function screenshot2(opts: ScreenshotOptionsDataUrl | ScreenshotOptionsTexture): Texture | string | null {
 
     if (!opts) opts = {}
 
+    const { mimeType = "image/png", transparent = false } = opts;
     let { context, width, height, camera } = opts;
-    const { mimeType } = opts;
 
     if (!context) {
         context = ContextRegistry.Current as Context;
@@ -118,6 +129,7 @@ export function screenshot2(opts: ScreenshotOptions = {
             return null;
         }
     }
+
     const prevWidth = context.renderer.domElement.width;
     const prevHeight = context.renderer.domElement.height;
 
@@ -133,9 +145,11 @@ export function screenshot2(opts: ScreenshotOptions = {
     context.renderer.domElement.style.width = width + "px";
     context.renderer.domElement.style.height = height + "px";
 
+    const prevRenderTarget = context.renderer.getRenderTarget();
     const previousClearColor = context.renderer.getClearColor(new Color());
     const previousClearAlpha = context.renderer.getClearAlpha();
     const previousBackground = context.scene.background;
+    const previousAspect: number | null = "aspect" in camera ? camera.aspect : null;
 
     try {
 
@@ -150,7 +164,7 @@ export function screenshot2(opts: ScreenshotOptions = {
             renderers.forEach(r => r?.onBeforeRender());
         }
 
-        if (opts.transparent) {
+        if (transparent) {
             context.scene.background = null;
             context.renderer.setClearColor(0x000000, 0);
         }
@@ -161,7 +175,7 @@ export function screenshot2(opts: ScreenshotOptions = {
                 context.renderer.setClearAlpha(opts.background.a);
             }
         }
-        if (opts.transparent) {
+        if (transparent) {
             context.renderer.setClearAlpha(0);
         }
 
@@ -174,8 +188,22 @@ export function screenshot2(opts: ScreenshotOptions = {
             camera = camera.cam;
         }
         // update the camera aspect and matrix
-        if (camera instanceof PerspectiveCamera)
-            context.updateAspect(camera, width, height);
+        if (camera instanceof PerspectiveCamera) {
+            camera.aspect = width / height;
+            camera.updateProjectionMatrix();
+        }
+
+        const textureOutput = "type" in opts && opts.type === "texture";
+        let targetTexture: WebGLRenderTarget | null = null;
+
+        if (textureOutput) {
+            targetTexture = new WebGLRenderTarget(width, height, {
+                wrapS: MirroredRepeatWrapping,
+                wrapT: MirroredRepeatWrapping,
+                format: 1023,
+            });
+            context.renderer.setRenderTarget(targetTexture);
+        }
 
         // render now
         context.renderNow(camera || null);
@@ -183,19 +211,42 @@ export function screenshot2(opts: ScreenshotOptions = {
         if (callRenderEvents)
             renderers.forEach(r => r.onAfterRender());
 
+        if ("type" in opts) {
+            if (opts.type === "texture") {
+                if (!targetTexture) {
+                    console.error("No target texture found");
+                    return null;
+                }
+                if (opts.target) {
+                    opts.target.image = targetTexture?.texture.image;
+                    opts.target.needsUpdate = true;
+                }
+                targetTexture.texture.offset.set(0, -1);
+                targetTexture.texture.needsUpdate = true;
+                return targetTexture.texture;
+            }
+        }
+
         const dataUrl = canvas.toDataURL(mimeType);
 
-        if (opts.download_filename) {
+        if ("download_filename" in opts && opts.download_filename) {
             saveImage(dataUrl, opts.download_filename);
         }
 
         return dataUrl;
     }
     finally {
+        context.renderer.setRenderTarget(prevRenderTarget);
         context.scene.background = previousBackground;
         context.renderer.setSize(prevWidth, prevHeight, false);
-        context.updateSize();
+        context.updateSize(true);
         context.renderer.setClearColor(previousClearColor, previousClearAlpha);
+        // Make sure to reset the aspect ratio. This is crucial if the main camera is not the currently active rendering camera
+        // For example if we did a screenshot from a different camera that has a different aspect ratio / fov
+        if (previousAspect != null && camera instanceof PerspectiveCamera) {
+            camera.aspect = previousAspect;
+            camera.updateProjectionMatrix();
+        }
     }
 
     return null;

package/src/engine-components/CameraUtils.ts

@@ -86,9 +86,15 @@ function createDefaultCameraControls(context: IContext, cam?: ICamera) {
         const orbit = getOrAddComponent(cameraObject, OrbitControls) as OrbitControls;
         orbit.sourceId = cam?.sourceId ?? "unknown";
         const autoRotate = context.domElement.getAttribute("auto-rotate");
-        orbit.autoRotate = autoRotate !== undefined && (autoRotate === "" || autoRotate === "true")
+        orbit.autoRotate = autoRotate !== undefined && autoRotate !== null && (autoRotate != "0" && autoRotate?.toLowerCase() != "false");
         orbit.autoRotateSpeed = 0.5;
         orbit.autoFit = true;
+        if (orbit.autoRotate && autoRotate) {
+            const autoRotateValue = parseFloat(autoRotate);
+            if (!isNaN(autoRotateValue)) {
+                orbit.autoRotateSpeed = autoRotateValue;
+            }
+        }
     }
     else {
         console.warn("Missing camera object, can not add orbit controls")

package/src/engine-components/RigidBody.ts

@@ -1,4 +1,4 @@
-import { Matrix4, Object3D, Quaternion, Vector3 } from "three";
+import { Matrix4, Object3D, Quaternion, Vector3, Vector3Like } from "three";
 
 import { CollisionDetectionMode, RigidbodyConstraints } from "../engine/engine_physics.types.js";
 import { serializable } from "../engine/engine_serialization_decorator.js";
@@ -455,19 +455,30 @@ export class Rigidbody extends Behaviour implements IRigidbody {
         return this._currentVelocity;
     }
 
-    public setAngularVelocity(x: number | Vector3, y?: number, z?: number, wakeup: boolean = true) {
-        if (x instanceof Vector3) {
+    public setAngularVelocity(x: Vec3, wakeup?: boolean);
+    public setAngularVelocity(x: number, y: number, z: number, wakeup?: boolean);
+    public setAngularVelocity(x: number | Vec3, y?: number | boolean, z?: number, wakeup: boolean = true) {
+
+        if (typeof x === "object") {
             const vec = x;
             this.context.physics.engine?.setAngularVelocity(this, vec, wakeup);
             return;
         }
-        if (y === undefined || z === undefined) return;
+        if (y === undefined || z === undefined || typeof y === "boolean") {
+            console.warn("setAngularVelocity expects either a Vec3 or 3 numbers");
+            return;
+        }
         this.context.physics.engine?.setAngularVelocity(this, { x: x, y: y, z: z }, wakeup);
     }
 
     /** Set the angular velocity of a rigidbody (equivalent to calling `setAngularVelocity`) */
-    public setTorque(x: number | Vector3, y: number, z: number) {
-        this.setAngularVelocity(x, y, z);
+    public setTorque(x: Vec3);
+    public setTorque(x: number, y: number, z: number);
+    public setTorque(x: number | Vec3, y?: number, z?: number) {
+        if (typeof x === "number") {
+            this.setAngularVelocity(x, y!, z!);
+        }
+        else this.setAngularVelocity(x);
     }
 
     /** Returns the rigidbody velocity smoothed over ~ 10 frames */