@x-viewer/core 0.21.14 → 0.21.15

package/dist/types/core/Configs.d.ts

@@ -119,6 +119,13 @@ export interface ModelConfig {
      * @default false
      */
     merge?: boolean;
+    /**
+     * When true, mesh geometry is quantized after load.
+     * When false, quantization is skipped.
+     * When omitted, {@link Viewer3d} uses {@link BaseViewer.enableQuantization};
+     * @hidden
+     */
+    quantize?: boolean;
     /**
      * Whether to generate and display edges/outlines for the model.
      * Useful for Viewer3d to show wireframe edges.

package/dist/types/core/Constants.d.ts

@@ -49,6 +49,29 @@ export declare const HighlightColorRgba: number[];
  * Object outline color.
  */
 export declare const OutlineColorRgba: number[];
+/**
+ * 3D selection outline (EffectComposer OutlinePass) — saturated UI orange (gltfEditor-like).
+ * Composites after {@link OutputPass}; use display-referred sRGB.
+ */
+export declare const SelectionOutlineVisibleColor = 16742144;
+/**
+ * Hidden-edge tint for OutlinePass. Match {@link SelectionOutlineVisibleColor} so depth-classified “hidden”
+ * segments do not read as missing (closer to gltfeditor-style continuous orange).
+ */
+export declare const SelectionOutlineHiddenColor = 16742144;
+/**
+ * OutlinePass edge strength. Additive blend on bright backgrounds needs a higher value to stay visible.
+ */
+export declare const SelectionOutlineEdgeStrength = 10;
+/** No secondary blur halo (glow pass off). */
+export declare const SelectionOutlineEdgeGlow = 0;
+/** Blur radius in OutlinePass edge buffers — ~2–4 px at full internal resolution; see EffectManager pixel ratio. */
+export declare const SelectionOutlineEdgeThickness = 3.5;
+/**
+ * OutlinePass internal downsample (default in three.js is 2). Use 1 for sharper screen-space edges
+ * (slightly higher GPU cost).
+ */
+export declare const SelectionOutlineDownSampleRatio = 1;
 /**
  * Default object opacity value.
  */

package/dist/types/core/effect/EffectManager.d.ts

@@ -58,6 +58,32 @@ export declare class EffectManager {
     get unrealBloomPassEnabled(): boolean;
     set unrealBloomPassEnabled(enable: boolean);
     setOutlinePassSelectObjects(objects: THREE.Object3D[]): void;
+    /**
+     * Sets current selection outline objects.
+     * When objects is empty, the pass is disabled.
+     *
+     * Intended for 3D viewer selection highlighting; 2D callers should avoid using this.
+     */
+    setSelectionOutline(objects: THREE.Object3D[]): void;
+    /**
+     * OutlinePass is screen-space (depth/normal): not every geometric edge appears.
+     * Colors are sRGB display values (no HDR boost): outline runs after {@link OutputPass}, so it is not
+     * washed out by tone mapping.
+     */
+    private applySelectionOutlineAppearance;
+    /**
+     * The stock {@link OutlinePass} overlay material uses `AdditiveBlending`.
+     * Additive blend on a white background: `clamp(1 + x) = 1` — the outline is **mathematically invisible**.
+     *
+     * Replace the overlay with `NormalBlending` + a shader that outputs proper alpha so the edge color
+     * **covers** the background instead of being added to it. This works on any background brightness.
+     */
+    private patchOutlineOverlayBlending;
+    /**
+     * Internal buffers must use the same pixel dimensions as {@link EffectComposer} (logical size × DPR);
+     * otherwise on HiDPI screens edges are detected on an undersized grid and look ~1px thin and dim.
+     */
+    private outlinePassResolution;
     enableModelEdges(enable: boolean): void;
     showVertexNormals(show: boolean, size?: number): void;
     setSize(width: number, height: number): void;
@@ -74,8 +100,8 @@ export declare class EffectManager {
     private syncWatermarkResolution;
     private ensureComposerOutputPass;
     /**
-     * Keep {@link composerOutputPass} last (screen output), and the GLSL watermark pass immediately before it
-     * so it composites in linear space; OutputPass applies renderer tone mapping and output color space to the canvas.
+     * Order: …other passes… → watermark (linear) → {@link composerOutputPass} (tone map + output encoding)
+     * → {@link outlinePass} when present (selection outline avoids tone mapping by compositing last).
      */
     private ensurePostprocessPassOrder;
 }

package/dist/types/core/loaders/BaseModelLoader.d.ts

@@ -6,6 +6,11 @@ interface BaseModelLoadContext {
     /** Normalized lowercase format token; same semantics as historical `endsWith` checks. */
     readonly format: string;
     readonly onProgress?: (event: ProgressEvent) => void;
+    /**
+     * Per-load mesh quantization (see {@link ModelConfig.quantize}). When `false` or omitted on
+     * {@link ModelConfig}, loaders skip quantization; {@link Viewer3d} fills omission from {@link BaseViewer.enableQuantization}.
+     */
+    readonly quantize?: boolean;
 }
 /**
  * Context for model loading from URL.
@@ -43,7 +48,18 @@ export declare abstract class BaseModelLoader {
      * Override for non-suffix matching.
      */
     match(format: string): boolean;
+    /**
+     * When {@link ModelLoadContext.quantize} is strictly `true`, quantizes mesh
+     * {@link THREE.BufferGeometry} under `scene` (see {@link GeometryUtils.applyMeshQuantizationToSceneRoot}).
+     */
+    protected maybeQuantizeLoadedScene(scene: THREE.Object3D, quantize?: boolean): THREE.Object3D;
     load?(ctx: ModelLoadContext): Promise<THREE.Object3D | void>;
     loadFromBuffer?(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D | void>;
+    /**
+     * Called by ModelLoaderManager when the active LoadingManager changes
+     * (e.g. for multi-file local loads with a URL modifier).
+     * Implementations should reset any cached internal loader instances.
+     */
+    updateManager?(manager: THREE.LoadingManager | undefined): void;
 }
 export {};

package/dist/types/core/loaders/GltfLoader.d.ts

@@ -5,17 +5,18 @@ import { BaseModelLoader } from "./BaseModelLoader";
  * glTF / GLB model loader wrapping GLTFLoader, DRACO path, and progress handling.
  */
 export declare class GltfLoader extends BaseModelLoader {
-    private readonly manager?;
     readonly id = "loader.builtin.gltf";
     readonly priority = 0;
     readonly formats: readonly ["gltf", "glb"];
     private static dracoDecoderPath;
     static setDracoDecoderPath(path: string): void;
     private gltfLoader?;
-    constructor(manager?: THREE.LoadingManager | undefined);
+    private manager?;
+    constructor(manager?: THREE.LoadingManager);
+    updateManager(manager: THREE.LoadingManager | undefined): void;
     load(ctx: ModelLoadContext): Promise<THREE.Object3D>;
     loadFromBuffer(ctx: ModelLoadFromBufferContext): Promise<THREE.Object3D>;
-    parseToScene(data: ArrayBuffer | string, path: string, onLoad: (object: THREE.Object3D) => void, onError?: (event: ErrorEvent) => void): void;
+    parseToScene(data: ArrayBuffer | string, path: string, onLoad: (object: THREE.Object3D) => void, onError?: (event: ErrorEvent) => void, quantize?: boolean): void;
     private obtainLoader;
     private applyRequestHeader;
     private sanitizeUrlForLoad;

package/dist/types/core/loaders/ModelLoaderManager.d.ts

@@ -1,5 +1,6 @@
 import * as THREE from "three";
 import type { BaseModelLoader } from "./BaseModelLoader";
+import type { ModelConfig } from "../../core/Configs";
 import type { FontManager } from "../../core/font";
 export declare class ModelLoaderManager {
     private manager?;
@@ -25,14 +26,20 @@ export declare class ModelLoaderManager {
      */
     getLoaderById(id: string): BaseModelLoader | undefined;
     private computeUrlModelFormat;
+    /**
+     * @param modelCfg Load-related fields from {@link ModelConfig} (`src` is the logical file name for
+     *        format detection when `blobFetchUrl` is set).
+     * @param blobFetchUrl When set (e.g. `blob:` URL), requests use this URL while format is inferred from `modelCfg.src`.
+     */
     private loadModelInternal;
     private loadModelFromBufferInternal;
     setLoadManager(manager?: THREE.LoadingManager): void;
-    loadLocalModel(url: string, src: string, onProgress?: (event: ProgressEvent) => void, mtlUrls?: string[]): Promise<THREE.Object3D>;
-    loadModel(src: string, fileFormat?: string, onProgress?: (event: ProgressEvent) => void, requestHeader?: {
-        [header: string]: string;
-    }): Promise<THREE.Object3D | void>;
-    loadModelFromBuffer(data: ArrayBuffer | Uint8Array, fileFormat: string, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D | void>;
+    /**
+     * @param blobUrl Fetch URL for the main file (often a `blob:` URL); {@link ModelConfig.src} should stay the real file name for format detection.
+     */
+    loadLocalModel(blobUrl: string, modelCfg: ModelConfig, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D>;
+    loadModel(modelCfg: ModelConfig, onProgress?: (event: ProgressEvent) => void, unsupportedMessage?: string): Promise<THREE.Object3D | void>;
+    loadModelFromBuffer(modelCfg: ModelConfig, onProgress?: (event: ProgressEvent) => void): Promise<THREE.Object3D | void>;
     /**
      * For dwg/dxf, we need to set font first.
      */

package/dist/types/core/utils/GeometryUtils.d.ts

@@ -67,5 +67,50 @@ export declare class GeometryUtils {
     static convertWidthLineToMeshGeometry(points: THREE.Vector2[], width: number): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | undefined;
     static releaseGeometryManually(geometry: THREE.BufferGeometry): void;
     static getAdjacentNonRepeatPoints(points: THREE.Vector3[], epsilon?: number): THREE.Vector3[];
+    /**
+     * True when `attr` is a non-instanced per-vertex {@link THREE.BufferAttribute} or
+     * {@link THREE.InterleavedBufferAttribute} with `normalized: true` and an integer
+     * `TypedArray` backing (e.g. glTF normalized BYTE/SHORT or **KHR_mesh_quantization**).
+     * Use this to detect attributes already stored in normalized integer form (not only `position`).
+     */
+    static isNormalizedIntegerVertexAttribute(attr: unknown): boolean;
+    /**
+     * One axis of POSITION quantization: world coordinate → stored Int16 value in
+     * `[-32767, 32767]`, matching `KHR_mesh_quantization` with origin `center` and
+     * half-extent `halfExtent` on this axis.
+     */
+    static quantizePositionComponent(world: number, center: number, halfExtent: number): number;
+    /** Inverse of {@link GeometryUtils.quantizePositionComponent}: quantized → world units. */
+    static dequantizePositionComponent(quantized: number, center: number, halfExtent: number): number;
+    /**
+     * Quantizes geometry attributes in-place for KHR_mesh_quantization-style usage.
+     *
+     * Converts **position** (Float32 → Int16 normalized) when possible, and clears cached
+     * `boundingBox` / `boundingSphere` so world AABBs stay correct after baking the decode
+     * matrix into mesh transforms.
+     *
+     * If **position** already satisfies {@link GeometryUtils.isNormalizedIntegerVertexAttribute}
+     * (e.g. **KHR_mesh_quantization** from glTF), returns `null` and leaves the geometry unchanged
+     * (no double quantization).
+     *
+     * Other attributes (when present, non-instanced, backed by float arrays):
+     * **normal** → Int8 normalized, **uv** / **uv1–uv3** → Uint16 normalized ([0,1] only),
+     * **color** → Uint8 normalized ([0,1] only), **tangent** (vec4) → Int8 normalized.
+     * Does not touch **skinIndex** / **skinWeight** (skinning), morph targets, etc.
+     *
+     * @returns The position-decode `Matrix4` (`T(center) * S(halfExtents)`) when position was
+     *          quantized, or `null` when position was left unchanged. Right-multiply into the
+     *          mesh node matrix: `M_node_final = M_node_original * M_decode`.
+     */
+    static quantizeGeometry(geo: THREE.BufferGeometry): THREE.Matrix4 | null;
+    private static meshQuantMatScratch;
+    private static meshQuantInstanceTmp;
+    /**
+     * Walks `scene`, quantizes each unique mesh {@link THREE.BufferGeometry} (see
+     * {@link GeometryUtils.quantizeGeometry}), and bakes position decode into mesh
+     * transforms / instanced matrices (then syncs pq/s so {@link THREE.Object3D.matrixAutoUpdate}
+     * stays compatible with controls that edit position/quaternion/scale). Used after import.
+     */
+    static applyMeshQuantizationToSceneRoot(scene: THREE.Object3D): THREE.Object3D;
     static mergeBBoxes(bboxes: THREE.Box3[]): THREE.Box3[];
 }

package/dist/types/core/viewers/BaseViewer.d.ts

@@ -29,6 +29,12 @@ export declare abstract class BaseViewer<BaseViewerEvents extends ViewerEvents =
      */
     loadedModels: Model[];
     protected inputManager: InputManager;
+    /**
+     * When true, mesh geometry is quantized after load for supported 3D formats (Viewer3d)
+     * when {@link ModelConfig.quantize} is omitted. Per-model `quantize` overrides this.
+     * Defaults to `false`; set at runtime (e.g. `viewer.enableQuantization = true`) or pass `quantize` on each {@link ModelConfig}.
+     */
+    enableQuantization: boolean;
     /**
      * Enables selecting an object
      */
@@ -84,6 +90,10 @@ export declare abstract class BaseViewer<BaseViewerEvents extends ViewerEvents =
      */
     enableRender: (time?: number) => void;
     resize(): void;
+    /**
+     * Fills {@link ModelConfig.quantize} from {@link enableQuantization} when omitted, without mutating `modelCfg`.
+     */
+    protected modelConfigForLoader(modelCfg: ModelConfig): ModelConfig;
     abstract loadModel(modelCfg: ModelConfig, onProgress?: (event: ProgressEvent) => void): Promise<void>;
     addModel(model: Model): void;
     removeModelById(modelId: string): void;

package/dist/types/core/viewers/Viewer3d.d.ts

@@ -9,6 +9,11 @@ export declare class Viewer3d extends BaseViewer {
     loadedModels: Model3d[];
     private transformGizmo?;
     private transformGizmoCallbacks;
+    /**
+     * 3D selection set (supports multi-select). Order is insertion order.
+     * For legacy single-select APIs, the "highlighted object" is the last selected.
+     */
+    private selectedObjects;
     constructor(viewerCfg: Viewer3dConfig, homeView?: Viewpoint);
     is3d(): boolean;
     loadLocalModel(url: string, modelCfg: ModelConfig, manager?: THREE.LoadingManager, onProgress?: (event: ProgressEvent) => void): Promise<void>;
@@ -105,6 +110,17 @@ export declare class Viewer3d extends BaseViewer {
      */
     getHighlightedObject(): THREE.Object3D | undefined;
     clearHighlight(): void;
+    /**
+     * Adds an object to the current selection set (multi-select).
+     * Does not clear existing selection.
+     */
+    addObjectToSelection(object: THREE.Object3D): void;
+    /** Removes an object from current selection set (multi-select). */
+    removeObjectFromSelection(object: THREE.Object3D): void;
+    /** Returns a shallow copy of current selection set (multi-select). */
+    getSelectedObjects(): THREE.Object3D[];
+    /** True when {@link object} is in the current selection set. */
+    isObjectSelected(object: THREE.Object3D): boolean;
     setDoubleSidedMaterials(): void;
     revertDoubleSidedMaterials(): void;
     clearSelection(): void;

package/dist/types/core/viewers/ViewerEvent.d.ts

@@ -105,5 +105,10 @@ export declare enum ViewerEvent {
     /**
      * Triggered when selected object changed.
      */
-    ObjectDeselected = "objectdeselected"
+    ObjectDeselected = "objectdeselected",
+    /**
+     * Triggered when a selected object's transform (position/rotation/scale) is changed,
+     * either by the transform gizmo or programmatically.
+     */
+    ObjectTransformed = "objecttransformed"
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@x-viewer/core",
-    "version": "0.21.14",
+    "version": "0.21.15",
     "homepage": "https://dwg.thingraph.site/",
     "description": "WebGL-based 2D/3D viewer engine built on Three.js. View DWG/DXF/PDF files in the browser with no server required. Supports glTF, OBJ, FBX, IFC, STL and BimTiles formats.",
     "author": "Thingraph",
@@ -70,7 +70,7 @@
         "2d-polygon-boolean": "^1.0.1",
         "2d-polygon-self-intersections": "^1.3.1",
         "3d-tiles-renderer": "0.3.32",
-        "@mlightcad/libredwg-web": "^0.6.7",
+        "@mlightcad/libredwg-web": "^0.7.1",
         "camera-controls": "^1.37.4",
         "clipper-lib": "^6.4.2",
         "concaveman": "^1.2.1",