@needle-tools/engine 4.9.3-next.0facab6 → 4.9.3

package/src/engine/engine_camera.fit.ts

@@ -1,288 +0,0 @@
-import { Camera, Object3D, PerspectiveCamera, Vector3, Vector3Like } from "three";
-
-import { GroundProjectedEnv } from "../engine-components/GroundProjection.js";
-import { findObjectOfType } from "./engine_components.js";
-import { Context } from "./engine_context.js";
-import { Gizmos } from "./engine_gizmos.js";
-import { getBoundingBox } from "./engine_three_utils.js";
-import { NeedleXRSession } from "./xr/NeedleXRSession.js";
-
-
-/**
- * Options for fitting the camera to the scene. Used in {@link OrbitControls.fitCamera}
- */
-export type FitCameraOptions = {
-    /** When enabled debug rendering will be shown */
-    debug?: boolean,
-
-    /**
-     * If true the camera position and target will be applied immediately
-     * @default true
-     */
-    autoApply?: boolean,
-
-    /**
-     * The context to use. If not provided the current context will be used
-     */
-    context?: Context,
-
-    /**
-     * The camera to fit. If not provided the current camera will be used
-     */
-    camera?: Camera,
-
-    currentZoom?: number,
-    minZoom?: number,
-    maxZoom?: number,
-
-    /**
-     * The objects to fit the camera to. If not provided the scene children will be used
-     */
-    objects?: Object3D[] | Object3D;
-
-    /** Fit offset: A factor to multiply the distance to the objects by
-     * @default 1.1
-     */
-    fitOffset?: number,
-
-    /** The direction from which the camera should be fitted in worldspace. If not defined the current camera's position will be used */
-    fitDirection?: Vector3Like,
-
-    /** If set to "y" the camera will be centered in the y axis */
-    centerCamera?: "none" | "y",
-    /** Set to 'auto' to update the camera near or far plane based on the fitted-objects bounds */
-    cameraNearFar?: "keep" | "auto",
-
-    /**
-     * Offset the camera position in world space
-     */
-    cameraOffset?: Partial<Vector3Like>,
-    /**
-     * Offset the camera position relative to the size of the objects being focused on (e.g. x: 0.5).  
-     * Value range: -1 to 1
-     */
-    relativeCameraOffset?: Partial<Vector3Like>,
-
-    /**
-     * Offset the camera target position in world space
-     */
-    targetOffset?: Partial<Vector3Like>,
-    /**
-     * Offset the camera target position relative to the size of the objects being focused on.  
-     * Value range: -1 to 1
-     */
-    relativeTargetOffset?: Partial<Vector3Like>,
-
-    /**
-     * Field of view (FOV) for the camera
-     */
-    fov?: number,
-}
-
-export type FitCameraReturnType = {
-    camera: Camera,
-    position: Vector3,
-    lookAt: Vector3,
-    fov: number | undefined
-}
-
-
-export function fitCamera(objectsOrOptions?: Object3D | Array<Object3D> | FitCameraOptions, options?: FitCameraOptions): null | FitCameraReturnType {
-
-    if (NeedleXRSession.active) {
-        // camera fitting in XR is not supported
-        console.warn('[OrbitControls] Can not fit camera while XR session is active');
-        return null;
-    }
-
-    const context = Context.Current;
-    if (!context) {
-        console.warn('[OrbitControls] No context found');
-        return null;
-    }
-    const camera = options?.camera || context.mainCamera;
-
-    let objects: Object3D | Array<Object3D> | undefined = undefined;
-    // If the user passed in an array as first argument
-    if (Array.isArray(objectsOrOptions)) {
-        objects = objectsOrOptions;
-    }
-    // If the user passed in an object as first argument
-    else if (objectsOrOptions && "type" in objectsOrOptions) {
-        objects = objectsOrOptions;
-    }
-    // If the user passed in an object as first argument and options as second argument
-    else if (objectsOrOptions && typeof objectsOrOptions === "object") {
-        if (!(objectsOrOptions instanceof Object3D) && !Array.isArray(objectsOrOptions)) {
-            options = objectsOrOptions;
-            objects = options.objects;
-        }
-    }
-    // Ensure objects are setup correctly
-    if (objects && !Array.isArray(objects)) {
-        objects = [objects];
-    }
-    if (!Array.isArray(objects) || objects && objects.length <= 0) {
-        objects = context.scene.children;
-    }
-
-    // Make sure there's anything to fit to
-    if (!Array.isArray(objects) || objects.length <= 0) {
-        console.warn("No objects to fit camera to...");
-        return null;
-    }
-
-
-    // const controls = this._controls as ThreeOrbitControls | null;
-
-    if (!camera) {
-        console.warn("No camera or controls found to fit camera to objects...");
-        return null;
-    }
-
-    if (!options) options = {}
-    options.autoApply = options.autoApply !== false; // default to true
-    options.minZoom ||= 0;
-    options.maxZoom ||= Infinity;
-
-    const {
-        centerCamera,
-        cameraNearFar = "auto",
-        fitOffset = 1.1,
-        fov = camera instanceof PerspectiveCamera ? camera?.fov : -1
-    } = options;
-
-    const size = new Vector3();
-    const center = new Vector3();
-    const aspect = camera instanceof PerspectiveCamera ? camera.aspect : 1;
-    // TODO would be much better to calculate the bounds in camera space instead of world space - 
-    // we would get proper view-dependant fit.
-    // Right now it's independent from where the camera is actually looking from,
-    // and thus we're just getting some maximum that will work for sure.
-    const box = getBoundingBox(objects, undefined, camera?.layers);
-    const boxCopy = box.clone();
-    box.getCenter(center);
-
-    const box_size = new Vector3();
-    box.getSize(box_size);
-
-    // project this box into camera space
-    if (camera instanceof PerspectiveCamera) camera.updateProjectionMatrix();
-    camera.updateMatrixWorld();
-    box.applyMatrix4(camera.matrixWorldInverse);
-
-    box.getSize(size);
-    box.setFromCenterAndSize(center, size);
-    if (Number.isNaN(size.x) || Number.isNaN(size.y) || Number.isNaN(size.z)) {
-        console.warn("Camera fit size resultet in NaN", camera, box);
-        return null;
-    }
-    if (size.length() <= 0.0000000001) {
-        console.warn("Camera fit size is zero", box);
-        return null;
-    }
-
-    const verticalFov = fov;
-    const horizontalFov = 2 * Math.atan(Math.tan(verticalFov * Math.PI / 360 / 2) * aspect) / Math.PI * 360;
-    const fitHeightDistance = size.y / (2 * Math.atan(Math.PI * verticalFov / 360));
-    const fitWidthDistance = size.x / (2 * Math.atan(Math.PI * horizontalFov / 360));
-
-    const distance = fitOffset * Math.max(fitHeightDistance, fitWidthDistance) + size.z / 2;
-    options.maxZoom = distance * 10;
-    options.minZoom = distance * 0.01;
-
-    if (options.debug === true) {
-        console.log("Fit camera to objects", { fitHeightDistance, fitWidthDistance, distance, verticalFov, horizontalFov });
-    }
-
-    const verticalOffset = 0.05;
-    const lookAt = center.clone();
-    lookAt.y -= size.y * verticalOffset;
-    if (options.targetOffset) {
-        if (options.targetOffset.x !== undefined) lookAt.x += options.targetOffset.x;
-        if (options.targetOffset.y !== undefined) lookAt.y += options.targetOffset.y;
-        if (options.targetOffset.z !== undefined) lookAt.z += options.targetOffset.z;
-    }
-    if (options.relativeTargetOffset) {
-        if (options.relativeTargetOffset.x !== undefined) lookAt.x += options.relativeTargetOffset.x * size.x;
-        if (options.relativeTargetOffset.y !== undefined) lookAt.y += options.relativeTargetOffset.y * size.y;
-        if (options.relativeTargetOffset.z !== undefined) lookAt.z += options.relativeTargetOffset.z * size.z;
-    }
-    // this.setLookTargetPosition(lookAt, immediate);
-    // this.setFieldOfView(options.fov, immediate);
-
-    if (cameraNearFar == undefined || cameraNearFar == "auto") {
-        // Check if the scene has a GroundProjectedEnv and include the scale to the far plane so that it doesnt cut off
-        const groundprojection = findObjectOfType(GroundProjectedEnv);
-        const groundProjectionRadius = groundprojection ? groundprojection.radius : 0;
-        const boundsMax = Math.max(box_size.x, box_size.y, box_size.z, groundProjectionRadius);
-        // TODO: this doesnt take the Camera component nearClipPlane into account
-        if (camera instanceof PerspectiveCamera) {
-            camera.near = (distance / 100);
-            camera.far = boundsMax + distance * 10;
-            camera.updateProjectionMatrix();
-        }
-
-        // adjust maxZoom so that the ground projection radius is always inside
-        if (groundprojection) {
-            options.maxZoom = Math.max(Math.min(options.maxZoom, groundProjectionRadius * 0.5), distance);
-        }
-    }
-
-    // ensure we're not clipping out of the current zoom level just because we're fitting
-    if (options.currentZoom !== undefined) {
-        if (options.currentZoom < options.minZoom) options.minZoom = options.currentZoom * 0.9;
-        if (options.currentZoom > options.maxZoom) options.maxZoom = options.currentZoom * 1.1;
-    }
-
-    const direction = center.clone();
-    if (options.fitDirection) {
-        direction.sub(new Vector3().copy(options.fitDirection).multiplyScalar(1_000_000));
-    }
-    else {
-        direction.sub(camera.worldPosition);
-    }
-    if (centerCamera === "y")
-        direction.y = 0;
-    direction.normalize();
-    direction.multiplyScalar(distance);
-    if (centerCamera === "y")
-        direction.y += -verticalOffset * 4 * distance;
-
-    let cameraLocalPosition = center.clone().sub(direction);
-    if (options.cameraOffset) {
-        if (options.cameraOffset.x !== undefined) cameraLocalPosition.x += options.cameraOffset.x;
-        if (options.cameraOffset.y !== undefined) cameraLocalPosition.y += options.cameraOffset.y;
-        if (options.cameraOffset.z !== undefined) cameraLocalPosition.z += options.cameraOffset.z;
-    }
-    if (options.relativeCameraOffset) {
-        if (options.relativeCameraOffset.x !== undefined) cameraLocalPosition.x += options.relativeCameraOffset.x * size.x;
-        if (options.relativeCameraOffset.y !== undefined) cameraLocalPosition.y += options.relativeCameraOffset.y * size.y;
-        if (options.relativeCameraOffset.z !== undefined) cameraLocalPosition.z += options.relativeCameraOffset.z * size.z;
-    }
-    if (camera.parent) {
-        cameraLocalPosition = camera.parent.worldToLocal(cameraLocalPosition);
-    }
-    // this.setCameraTargetPosition(cameraLocalPosition, immediate);
-
-    if (options.debug) {
-        Gizmos.DrawWireBox3(box, 0xffff33, 10);
-        Gizmos.DrawWireBox3(boxCopy, 0x00ff00, 10);
-    }
-
-    if (options.autoApply) {
-        camera.position.copy(cameraLocalPosition);
-        camera.lookAt(lookAt);
-        if (fov > 0 && camera instanceof PerspectiveCamera) {
-            camera.fov = fov;
-            camera.updateProjectionMatrix();
-        }
-    }
-
-    return {
-        camera: camera,
-        position: cameraLocalPosition,
-        lookAt: lookAt,
-        fov: options.fov,
-    }
-}

package/src/engine-components/web/HoverAnimation.ts

@@ -1,99 +0,0 @@
-import { AnimationClip } from "three";
-
-import { ScaleClipType } from "../../engine/engine_animation.js";
-import { AnimationUtils } from "../../engine/engine_animation.js";
-import { serializable } from "../../engine/engine_serialization_decorator.js";
-import { registerType } from "../../engine/engine_typestore.js";
-import { Animation } from "../Animation.js";
-import { Behaviour } from "../Component.js";
-
-
-/**
- * @category Web
- * @group Components
- * @component
- */
-@registerType
-export class HoverAnimation extends Behaviour {
-
-    /**
-     * Default hover animation type if no custom clip is provided.  
-     * **Node**: This is only used if no custom hover animation clip is provided.  
-     * @default "linear"
-     */
-    @serializable()
-    type: ScaleClipType = "linear";
-
-    /**
-     * Duration of the hover animation in seconds.  
-     * **Node**: This is only used if no custom hover animation clip is provided.
-     * @default 0.1
-     */
-    @serializable()
-    duration: number = 0.1;
-
-    /**
-     * Scale factor to apply when hovering.  
-     * **Node**: This is only used if no custom hover animation clip is provided.
-     * @default 1.1
-     */
-    @serializable()
-    scaleFactor: number = 1.1;
-
-
-    /**
-     * Animation clip to play when hovering. If null, a default scale-up animation is used.
-     */
-    @serializable(AnimationClip)
-    hovered: AnimationClip | null = null;
-
-    /**
-     * Animation clip to play when not hovering. If null, an empty clip is used.
-     */
-    @serializable(AnimationClip)
-    idle: AnimationClip | null = null;
-
-    private animation: Animation | null = null;
-
-    start() {
-        if (!this.idle) this.idle = AnimationUtils.emptyClip();
-
-        if (!this.hovered) {
-            this.hovered = AnimationUtils.createScaleClip({
-                type: "linear",
-                duration: this.duration || 0.1,
-                scale: this.gameObject.scale,
-                scaleFactor: this.scaleFactor || 1.1,
-            });
-        }
-
-        this.animation ??= this.gameObject.addComponent(Animation);
-        this.animation.playAutomatically = false;
-        this.playIdle();
-    }
-
-    onEnable() {
-        if (this.animation) this.animation.enabled = true;
-        this.playIdle();
-    }
-    onDisable() {
-        if (this.animation) this.animation.enabled = false;
-        this.playIdle();
-    }
-
-    onPointerEnter() {
-        this.playHover();
-    }
-
-    onPointerExit() {
-        this.playIdle();
-    }
-
-    private playIdle() {
-        if (this.idle) this.animation?.play(this.idle, { exclusive: true, fadeDuration: .1, loop: true });
-    }
-    private playHover() {
-        if (this.hovered) this.animation?.play(this.hovered, { exclusive: true, fadeDuration: .1, loop: false, clampWhenFinished: true });
-    }
-
-}