@aura3d/scene 1.3.3 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aura3d/scene",
-  "version": "1.3.3",
+  "version": "1.4.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -12,7 +12,39 @@
   },
   "sideEffects": false,
   "dependencies": {
-    "@aura3d/core": "1.3.3",
-    "@aura3d/math": "1.3.3"
-  }
+    "@aura3d/core": "1.4.1",
+    "@aura3d/math": "1.4.1"
+  },
+  "description": "Transform hierarchy, scene nodes, bounds, traversal, queries, cameras, lights, renderable descriptors, scene registry, and serialization for Aura3D.",
+  "keywords": [
+    "aura3d",
+    "3d",
+    "browser-3d",
+    "web-3d",
+    "typescript",
+    "scene",
+    "scene-graph",
+    "transforms",
+    "camera",
+    "lights",
+    "serialization",
+    "renderables"
+  ],
+  "homepage": "https://aura3d.auraone.ai",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/auraoneai/aura3d.git",
+    "directory": "packages/scene"
+  },
+  "bugs": {
+    "url": "https://github.com/auraoneai/aura3d/issues"
+  },
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ]
 }

package/src/Bounds.ts

@@ -1,68 +0,0 @@
-import { Box3, Vector3 } from "@aura3d/math";
-import { transformPoint, type Mat4, type Vec3 } from "./MathTypes.js";
-
-export class Bounds3 {
-  min: Vec3;
-  max: Vec3;
-
-  constructor(min: Vec3 = [Infinity, Infinity, Infinity], max: Vec3 = [-Infinity, -Infinity, -Infinity]) {
-    this.min = [...min] as Vec3;
-    this.max = [...max] as Vec3;
-  }
-
-  static fromCenterSize(center: Vec3, size: Vec3): Bounds3 {
-    return new Bounds3(
-      [center[0] - size[0] / 2, center[1] - size[1] / 2, center[2] - size[2] / 2],
-      [center[0] + size[0] / 2, center[1] + size[1] / 2, center[2] + size[2] / 2]
-    );
-  }
-
-  static fromMathBox(box: Box3): Bounds3 {
-    return new Bounds3(box.min.toArray(), box.max.toArray());
-  }
-
-  isEmpty(): boolean {
-    return this.toMathBox().isEmpty();
-  }
-
-  union(other: Bounds3): Bounds3 {
-    return Bounds3.fromMathBox(this.toMathBox().union(other.toMathBox()));
-  }
-
-  intersects(other: Bounds3): boolean {
-    return this.toMathBox().intersectsBox(other.toMathBox());
-  }
-
-  containsPoint(point: Vec3): boolean {
-    return this.toMathBox().containsPoint(new Vector3(point[0], point[1], point[2]));
-  }
-
-  transform(matrix: Mat4): Bounds3 {
-    if (this.isEmpty()) return new Bounds3();
-    const corners: Vec3[] = [
-      [this.min[0], this.min[1], this.min[2]],
-      [this.max[0], this.min[1], this.min[2]],
-      [this.min[0], this.max[1], this.min[2]],
-      [this.min[0], this.min[1], this.max[2]],
-      [this.max[0], this.max[1], this.min[2]],
-      [this.max[0], this.min[1], this.max[2]],
-      [this.min[0], this.max[1], this.max[2]],
-      [this.max[0], this.max[1], this.max[2]]
-    ];
-    return corners.reduce((bounds, corner) => bounds.includePoint(transformPoint(matrix, corner)), new Bounds3());
-  }
-
-  includePoint(point: Vec3): Bounds3 {
-    this.min = [Math.min(this.min[0], point[0]), Math.min(this.min[1], point[1]), Math.min(this.min[2], point[2])];
-    this.max = [Math.max(this.max[0], point[0]), Math.max(this.max[1], point[1]), Math.max(this.max[2], point[2])];
-    return this;
-  }
-
-  clone(): Bounds3 {
-    return new Bounds3(this.min, this.max);
-  }
-
-  toMathBox(): Box3 {
-    return new Box3(new Vector3(this.min[0], this.min[1], this.min[2]), new Vector3(this.max[0], this.max[1], this.max[2]));
-  }
-}

package/src/Camera.ts

@@ -1,56 +0,0 @@
-import { ValidationError } from "@aura3d/core";
-import { Frustum } from "@aura3d/math";
-import { extractFrustumPlanes, identityMat4, multiplyMat4, toMathMat4, type Mat4, type PlaneTuple } from "./MathTypes.js";
-import { SceneNode } from "./SceneNode.js";
-
-export interface CameraViewport {
-  x: number;
-  y: number;
-  width: number;
-  height: number;
-}
-
-export abstract class Camera extends SceneNode {
-  viewport: CameraViewport = { x: 0, y: 0, width: 1, height: 1 };
-  readonly frustumPlanes: PlaneTuple[] = [];
-  frustum: Frustum = Frustum.fromMatrix(toMathMat4(identityMat4()));
-  projectionMatrix: Mat4;
-  viewMatrix: Mat4;
-  viewProjectionMatrix: Mat4;
-
-  protected constructor(name: string, id?: string) {
-    super({ id, name });
-    this.projectionMatrix = identityMat4();
-    this.viewMatrix = this.transform.inverseWorldMatrix;
-    this.viewProjectionMatrix = multiplyMat4(this.projectionMatrix, this.viewMatrix);
-  }
-
-  abstract computeProjectionMatrix(): Mat4;
-
-  updateCameraMatrices(): void {
-    updateAncestors(this);
-    this.updateWorldTransform();
-    this.projectionMatrix = this.computeProjectionMatrix();
-    this.viewMatrix = this.transform.inverseWorldMatrix;
-    this.viewProjectionMatrix = multiplyMat4(this.projectionMatrix, this.viewMatrix);
-    this.frustum = Frustum.fromMatrix(toMathMat4(this.viewProjectionMatrix));
-    this.frustumPlanes.splice(0, this.frustumPlanes.length, ...extractFrustumPlanes(this.viewProjectionMatrix));
-  }
-
-  setViewport(viewport: CameraViewport): void {
-    if (viewport.width <= 0 || viewport.height <= 0) throw new ValidationError("CAMERA_VIEWPORT", "Camera viewport dimensions must be positive.");
-    this.viewport = { ...viewport };
-  }
-}
-
-function updateAncestors(node: SceneNode): void {
-  const ancestors: SceneNode[] = [];
-  let parent = node.parent;
-  while (parent) {
-    ancestors.unshift(parent);
-    parent = parent.parent;
-  }
-  for (const ancestor of ancestors) {
-    ancestor.transform.updateWorld(ancestor.parent?.transform.worldMatrix);
-  }
-}

package/src/DirectionalLight.ts

@@ -1,13 +0,0 @@
-import { normalizeVec3, type Vec3 } from "./MathTypes.js";
-import { Light } from "./Light.js";
-
-export class DirectionalLight extends Light {
-  constructor(name = "DirectionalLight", id?: string) {
-    super("directional", name, id);
-  }
-
-  getDirection(): Vec3 {
-    const m = this.transform.worldMatrix;
-    return normalizeVec3([-m[8], -m[9], -m[10]]);
-  }
-}

package/src/Hierarchy.ts

@@ -1,20 +0,0 @@
-import { assertCanParent, type AddChildOptions, type SceneNode } from "./SceneNode.js";
-
-export function isAncestor(ancestor: SceneNode, node: SceneNode): boolean {
-  return ancestor.isAncestorOf(node);
-}
-
-export function reparent(node: SceneNode, newParent: SceneNode, options: AddChildOptions = {}): void {
-  assertCanParent(newParent, node);
-  newParent.addChild(node, options);
-}
-
-export function batchReparent(nodes: readonly SceneNode[], newParent: SceneNode, options: AddChildOptions = {}): void {
-  for (const node of nodes) reparent(node, newParent, options);
-}
-
-export function removeAllChildren(node: SceneNode): SceneNode[] {
-  const removed = [...node.children];
-  for (const child of removed) node.removeChild(child);
-  return removed;
-}

package/src/Layers.ts

@@ -1,24 +0,0 @@
-export class Layers {
-  mask = 1;
-
-  set(channel: number): void {
-    this.mask = 1 << validateChannel(channel);
-  }
-
-  enable(channel: number): void {
-    this.mask |= 1 << validateChannel(channel);
-  }
-
-  disable(channel: number): void {
-    this.mask &= ~(1 << validateChannel(channel));
-  }
-
-  test(other: Layers): boolean {
-    return (this.mask & other.mask) !== 0;
-  }
-}
-
-function validateChannel(channel: number): number {
-  if (!Number.isInteger(channel) || channel < 0 || channel > 31) throw new Error("Layer channel must be an integer in [0, 31].");
-  return channel;
-}

package/src/Light.ts

@@ -1,27 +0,0 @@
-import { ValidationError } from "@aura3d/core";
-import { type Vector3 } from "@aura3d/math";
-import { type Vec3 } from "./MathTypes.js";
-import { SceneNode } from "./SceneNode.js";
-
-export type LightKind = "directional" | "point" | "spot";
-
-export abstract class Light extends SceneNode {
-  readonly kind: LightKind;
-  color: Vec3 | Vector3 = [1, 1, 1];
-  castsShadow = false;
-  private currentIntensity = 1;
-
-  protected constructor(kind: LightKind, name: string, id?: string) {
-    super({ id, name });
-    this.kind = kind;
-  }
-
-  get intensity(): number {
-    return this.currentIntensity;
-  }
-
-  set intensity(value: number) {
-    if (!(value >= 0) || !Number.isFinite(value)) throw new ValidationError("LIGHT_INTENSITY", "Light intensity must be a finite non-negative number.");
-    this.currentIntensity = value;
-  }
-}

package/src/Lights.ts

@@ -1,5 +0,0 @@
-export { DirectionalLight } from "./DirectionalLight.js";
-export { Light } from "./Light.js";
-export type { LightKind } from "./Light.js";
-export { PointLight } from "./PointLight.js";
-export { SpotLight } from "./SpotLight.js";

package/src/MathTypes.ts

@@ -1,157 +0,0 @@
-import { Frustum, Matrix4, Quaternion, Vector3 } from "@aura3d/math";
-
-export type Vec3 = [number, number, number];
-export type Quat = [number, number, number, number];
-export type Mat4 = [
-  number, number, number, number,
-  number, number, number, number,
-  number, number, number, number,
-  number, number, number, number
-];
-export type PlaneTuple = [number, number, number, number];
-
-export const EPSILON = 1e-8;
-
-export function vec3(x = 0, y = 0, z = 0): Vec3 {
-  return [x, y, z];
-}
-
-export function quat(x = 0, y = 0, z = 0, w = 1): Quat {
-  return fromMathQuat(new Quaternion(x, y, z, w).normalize());
-}
-
-export function identityMat4(): Mat4 {
-  return fromMathMat4(Matrix4.identity());
-}
-
-export function cloneMat4(value: Mat4): Mat4 {
-  return [...value] as Mat4;
-}
-
-export function addVec3(a: Vec3, b: Vec3): Vec3 {
-  return toMathVec3(a).add(toMathVec3(b)).toArray();
-}
-
-export function subVec3(a: Vec3, b: Vec3): Vec3 {
-  return toMathVec3(a).subtract(toMathVec3(b)).toArray();
-}
-
-export function scaleVec3(a: Vec3, scalar: number): Vec3 {
-  return toMathVec3(a).multiplyScalar(scalar).toArray();
-}
-
-export function lengthVec3(a: Vec3): number {
-  return toMathVec3(a).length();
-}
-
-export function normalizeVec3(a: Vec3): Vec3 {
-  return toMathVec3(a).normalize().toArray();
-}
-
-export function normalizeQuat(value: Quat): Quat {
-  return fromMathQuat(toMathQuat(value).normalize());
-}
-
-export function quatFromEuler(x: number, y: number, z: number): Quat {
-  const sx = Math.sin(x / 2);
-  const cx = Math.cos(x / 2);
-  const sy = Math.sin(y / 2);
-  const cy = Math.cos(y / 2);
-  const sz = Math.sin(z / 2);
-  const cz = Math.cos(z / 2);
-  return quat(
-    sx * cy * cz + cx * sy * sz,
-    cx * sy * cz - sx * cy * sz,
-    cx * cy * sz + sx * sy * cz,
-    cx * cy * cz - sx * sy * sz
-  );
-}
-
-export function multiplyMat4(a: Mat4, b: Mat4): Mat4 {
-  return fromMathMat4(toMathMat4(a).multiply(toMathMat4(b)));
-}
-
-export function composeMat4(position: Vec3, rotation: Quat, scale: Vec3): Mat4 {
-  return fromMathMat4(Matrix4.compose(toMathVec3(position), toMathQuat(rotation), toMathVec3(scale)));
-}
-
-export function transformPoint(matrix: Mat4, point: Vec3): Vec3 {
-  return toMathMat4(matrix).transformPoint(toMathVec3(point)).toArray();
-}
-
-export function invertMat4(matrix: Mat4): Mat4 {
-  return fromMathMat4(toMathMat4(matrix).inverse());
-}
-
-export function perspectiveMat4(fovYRadians: number, aspect: number, near: number, far: number): Mat4 {
-  return fromMathMat4(Matrix4.perspective(fovYRadians, aspect, near, far));
-}
-
-export function orthographicMat4(left: number, right: number, bottom: number, top: number, near: number, far: number): Mat4 {
-  return fromMathMat4(Matrix4.orthographic(left, right, bottom, top, near, far));
-}
-
-export function extractFrustumPlanes(viewProjection: Mat4): PlaneTuple[] {
-  return Frustum.fromMatrix(toMathMat4(viewProjection)).planes.map((plane) => [
-    plane.normal.x,
-    plane.normal.y,
-    plane.normal.z,
-    plane.constant
-  ]);
-}
-
-export function toMathVec3(value: Vec3): Vector3 {
-  return new Vector3(value[0], value[1], value[2]);
-}
-
-export function toMathQuat(value: Quat): Quaternion {
-  return new Quaternion(value[0], value[1], value[2], value[3]);
-}
-
-export function toMathMat4(value: Mat4): Matrix4 {
-  return new Matrix4(value);
-}
-
-export function fromMathMat4(value: Matrix4): Mat4 {
-  return [...value.elements] as Mat4;
-}
-
-export function fromMathQuat(value: Quaternion): Quat {
-  return [value.x, value.y, value.z, value.w];
-}
-
-export function decomposeMat4(matrix: Mat4): { position: Vec3; rotation: Quat; scale: Vec3 } {
-  const position: Vec3 = [matrix[12], matrix[13], matrix[14]];
-  const sx = Math.hypot(matrix[0], matrix[1], matrix[2]);
-  const sy = Math.hypot(matrix[4], matrix[5], matrix[6]);
-  const sz = Math.hypot(matrix[8], matrix[9], matrix[10]);
-  if (sx <= EPSILON || sy <= EPSILON || sz <= EPSILON) throw new Error("Cannot decompose transform matrix with zero scale.");
-
-  const m00 = matrix[0] / sx;
-  const m01 = matrix[4] / sy;
-  const m02 = matrix[8] / sz;
-  const m10 = matrix[1] / sx;
-  const m11 = matrix[5] / sy;
-  const m12 = matrix[9] / sz;
-  const m20 = matrix[2] / sx;
-  const m21 = matrix[6] / sy;
-  const m22 = matrix[10] / sz;
-  const trace = m00 + m11 + m22;
-  let rotation: Quat;
-
-  if (trace > 0) {
-    const s = Math.sqrt(trace + 1) * 2;
-    rotation = [(m21 - m12) / s, (m02 - m20) / s, (m10 - m01) / s, 0.25 * s];
-  } else if (m00 > m11 && m00 > m22) {
-    const s = Math.sqrt(1 + m00 - m11 - m22) * 2;
-    rotation = [0.25 * s, (m01 + m10) / s, (m02 + m20) / s, (m21 - m12) / s];
-  } else if (m11 > m22) {
-    const s = Math.sqrt(1 + m11 - m00 - m22) * 2;
-    rotation = [(m01 + m10) / s, 0.25 * s, (m12 + m21) / s, (m02 - m20) / s];
-  } else {
-    const s = Math.sqrt(1 + m22 - m00 - m11) * 2;
-    rotation = [(m02 + m20) / s, (m12 + m21) / s, 0.25 * s, (m10 - m01) / s];
-  }
-
-  return { position, rotation: normalizeQuat(rotation), scale: [sx, sy, sz] };
-}

package/src/Object3D.ts

@@ -1,149 +0,0 @@
-import { SceneNode, type SceneNodeOptions } from "./SceneNode.js";
-import { Renderable, type RenderableDescriptor } from "./Renderable.js";
-import type { Mat4, Quat, Vec3 } from "./MathTypes.js";
-
-export interface Object3DOptions extends SceneNodeOptions {
-  readonly visible?: boolean;
-  readonly layerMask?: number;
-  readonly renderOrder?: number;
-  readonly userData?: Record<string, unknown>;
-}
-
-export class Object3D extends SceneNode {
-  readonly isObject3D = true;
-
-  constructor(options: Object3DOptions = {}) {
-    super(options);
-    applyObject3DOptions(this, options);
-  }
-
-  get position(): Vec3 {
-    return this.transform.position;
-  }
-
-  get quaternion(): Quat {
-    return this.transform.rotation;
-  }
-
-  get scale(): Vec3 {
-    return this.transform.scale;
-  }
-
-  get matrix(): Mat4 {
-    return this.transform.localMatrix;
-  }
-
-  get matrixWorld(): Mat4 {
-    return this.transform.worldMatrix;
-  }
-
-  get matrixAutoUpdate(): boolean {
-    return this.transform.matrixAutoUpdate;
-  }
-
-  set matrixAutoUpdate(enabled: boolean) {
-    this.transform.setMatrixAutoUpdate(enabled);
-  }
-
-  setLocalMatrix(matrix: Mat4, options: { readonly decompose?: boolean; readonly matrixAutoUpdate?: boolean } = {}): this {
-    this.transform.setLocalMatrix(matrix, options);
-    return this;
-  }
-}
-
-export class Group extends Object3D {
-  readonly isGroup = true;
-}
-
-export interface MeshOptions extends Object3DOptions {
-  readonly renderable?: Renderable | RenderableDescriptor;
-}
-
-export class Mesh extends Object3D {
-  readonly isMesh = true;
-
-  constructor(options: MeshOptions = {}) {
-    super(options);
-    if (options.renderable) this.renderable = toRenderable(options.renderable);
-  }
-
-  setRenderable(renderable: Renderable | RenderableDescriptor): this {
-    this.renderable = toRenderable(renderable);
-    return this;
-  }
-}
-
-export class SkinnedMesh extends Mesh {
-  readonly isSkinnedMesh = true;
-
-  get skinning(): Renderable["skinning"] | undefined {
-    return this.renderable?.skinning;
-  }
-
-  setSkinning(skinning: NonNullable<Renderable["skinning"]>): this {
-    if (!this.renderable) throw new Error("SkinnedMesh requires a renderable before skinning can be assigned.");
-    this.renderable.skinning = {
-      jointCount: skinning.jointCount,
-      matrices: new Float32Array(skinning.matrices)
-    };
-    return this;
-  }
-}
-
-export class InstancedMesh extends Mesh {
-  readonly isInstancedMesh = true;
-
-  get instanceTransforms(): Float32Array | undefined {
-    return this.renderable?.instanceTransforms;
-  }
-
-  get instanceColors(): Float32Array | undefined {
-    return this.renderable?.instanceColors;
-  }
-
-  setInstanceTransforms(transforms: Float32Array | readonly number[]): this {
-    if (!this.renderable) throw new Error("InstancedMesh requires a renderable before instance transforms can be assigned.");
-    this.renderable.instanceTransforms = new Renderable({
-      geometry: this.renderable.geometry,
-      material: this.renderable.material,
-      layerMask: this.renderable.layerMask,
-      castShadow: this.renderable.castShadow,
-      receiveShadow: this.renderable.receiveShadow,
-      skinning: this.renderable.skinning,
-      morphWeights: this.renderable.morphWeights,
-      instanceTransforms: transforms,
-      instanceColors: this.renderable.instanceColors
-    }).instanceTransforms;
-    return this;
-  }
-
-  setInstanceColors(colors: Float32Array | readonly number[]): this {
-    if (!this.renderable) throw new Error("InstancedMesh requires a renderable before instance colors can be assigned.");
-    this.renderable.instanceColors = new Renderable({
-      geometry: this.renderable.geometry,
-      material: this.renderable.material,
-      layerMask: this.renderable.layerMask,
-      castShadow: this.renderable.castShadow,
-      receiveShadow: this.renderable.receiveShadow,
-      skinning: this.renderable.skinning,
-      morphWeights: this.renderable.morphWeights,
-      instanceTransforms: this.renderable.instanceTransforms,
-      instanceColors: colors
-    }).instanceColors;
-    return this;
-  }
-}
-
-function applyObject3DOptions(node: SceneNode, options: Object3DOptions): void {
-  if (options.visible !== undefined) node.visible = options.visible;
-  if (options.layerMask !== undefined) node.layerMask = options.layerMask;
-  if (options.renderOrder !== undefined) {
-    if (!Number.isFinite(options.renderOrder)) throw new Error("Object3D renderOrder must be finite.");
-    node.renderOrder = options.renderOrder;
-  }
-  if (options.userData) node.userData = { ...options.userData };
-}
-
-function toRenderable(renderable: Renderable | RenderableDescriptor): Renderable {
-  return renderable instanceof Renderable ? renderable : new Renderable(renderable);
-}

package/src/OrthographicCamera.ts

@@ -1,73 +0,0 @@
-import { ValidationError } from "@aura3d/core";
-import { orthographicMat4, type Mat4 } from "./MathTypes.js";
-import { Camera } from "./Camera.js";
-
-export interface OrthographicCameraOptions {
-  id?: string;
-  name?: string;
-  left?: number;
-  right?: number;
-  bottom?: number;
-  top?: number;
-  near?: number;
-  far?: number;
-  zoom?: number;
-  resizeMode?: OrthographicResizeMode;
-}
-
-export type OrthographicResizeMode = "fit-vertical" | "fit-horizontal" | "preserve-frustum";
-
-export class OrthographicCamera extends Camera {
-  left: number;
-  right: number;
-  bottom: number;
-  top: number;
-  near: number;
-  far: number;
-  zoom: number;
-  resizeMode: OrthographicResizeMode;
-
-  constructor(options: OrthographicCameraOptions = {}) {
-    super(options.name ?? "OrthographicCamera", options.id);
-    this.left = options.left ?? -1;
-    this.right = options.right ?? 1;
-    this.bottom = options.bottom ?? -1;
-    this.top = options.top ?? 1;
-    this.near = options.near ?? 0.1;
-    this.far = options.far ?? 1000;
-    this.zoom = options.zoom ?? 1;
-    this.resizeMode = options.resizeMode ?? "fit-vertical";
-    this.projectionMatrix = this.computeProjectionMatrix();
-  }
-
-  computeProjectionMatrix(): Mat4 {
-    if (!(this.zoom > 0)) throw new ValidationError("CAMERA_ZOOM", "Orthographic zoom must be positive.");
-    return orthographicMat4(this.left / this.zoom, this.right / this.zoom, this.bottom / this.zoom, this.top / this.zoom, this.near, this.far);
-  }
-
-  resize(width: number, height: number): void {
-    if (width <= 0 || height <= 0) throw new ValidationError("CAMERA_RESIZE", "Orthographic resize dimensions must be positive.");
-    const aspect = width / height;
-    const centerX = (this.left + this.right) / 2;
-    const centerY = (this.bottom + this.top) / 2;
-    const halfWidth = (this.right - this.left) / 2;
-    const halfHeight = (this.top - this.bottom) / 2;
-    if (this.resizeMode === "fit-horizontal") {
-      const resizedHalfHeight = halfWidth / aspect;
-      this.bottom = centerY - resizedHalfHeight;
-      this.top = centerY + resizedHalfHeight;
-    } else if (this.resizeMode === "preserve-frustum") {
-      const resizedHalfWidth = Math.max(halfWidth, halfHeight * aspect);
-      const resizedHalfHeight = Math.max(halfHeight, halfWidth / aspect);
-      this.left = centerX - resizedHalfWidth;
-      this.right = centerX + resizedHalfWidth;
-      this.bottom = centerY - resizedHalfHeight;
-      this.top = centerY + resizedHalfHeight;
-    } else {
-      const resizedHalfWidth = halfHeight * aspect;
-      this.left = centerX - resizedHalfWidth;
-      this.right = centerX + resizedHalfWidth;
-    }
-    this.updateCameraMatrices();
-  }
-}