@gcode-viewer/plugins 0.3.0

package/dist/types/axis-gizmo/AxisGizmoPlugin.d.ts

@@ -0,0 +1,25 @@
+import { BaseViewer, Plugin, PluginConfig } from "@gcode-viewer/core";
+/**
+ * AxisGizmo plugin config.
+ */
+export interface AxisGizmoPluginConfig extends Partial<PluginConfig> {
+    /**
+     * UI element id to contain the plugin.
+     */
+    containerId?: string;
+    /**
+     * Ignores z-axis. It is useful for Viewer2d.
+     */
+    ignoreZAxis?: boolean;
+}
+/**
+ * This renderer monitors the host renderer's camera, and keeps a coordinate axes
+ * the same direction as host renderer's
+ */
+export declare class AxisGizmoPlugin extends Plugin {
+    static readonly DEFAULT_ID = "AxisGizmoPlugin";
+    constructor(viewer: BaseViewer, cfg?: AxisGizmoPluginConfig);
+    setVisible(visible: boolean): void;
+    isVisible(): boolean;
+    destroy(): void;
+}

package/dist/types/axis-gizmo/CoordinateAxes.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/axis-gizmo/index.d.ts

@@ -0,0 +1,2 @@
+import "./axisgizmo.scss";
+export * from "./AxisGizmoPlugin";

package/dist/types/bottom-bar/BottomBarPlugin.d.ts

@@ -0,0 +1,36 @@
+import { IconClass, BaseViewer, Plugin } from "@gcode-viewer/core";
+import { Tooltip } from "@gcode-viewer/ui";
+declare enum BottomBarItemId {
+    statistics = "gcode-viewer-threejs-statistics",
+    cameraCfg = "gcode-viewer-threejs-cameraCfg",
+    tips = "gcode-viewer-threejs-tips"
+}
+interface BottomBarItemConfig {
+    icon: IconClass;
+    mutexIds?: BottomBarItemId[];
+    onActive?: (item: BottomBarItem) => void;
+    onDeactive?: (item: BottomBarItem) => void;
+    onClick?: (item: BottomBarItem) => void;
+    onUpdate?: (item: BottomBarItem) => void;
+}
+/**
+ * Bottom bar plugin is a debug tool for developers.
+ */
+export declare class BottomBarPlugin extends Plugin {
+    itemList: Map<string, BottomBarItem>;
+    constructor(viewer: BaseViewer);
+    update(): void;
+}
+declare class BottomBarItem {
+    readonly viewer: BaseViewer;
+    private readonly bottomBar;
+    protected readonly menuId: string;
+    protected cfg: BottomBarItemConfig;
+    tooltip: Tooltip;
+    element: HTMLElement;
+    active: boolean;
+    constructor(viewer: BaseViewer, bottomBar: BottomBarPlugin, menuId: string, cfg: BottomBarItemConfig);
+    setActive(active: boolean): void;
+    update(): void;
+}
+export {};

package/dist/types/bottom-bar/index.d.ts

@@ -0,0 +1,2 @@
+import "./bottombar.scss";
+export * from "./BottomBarPlugin";

package/dist/types/context-menu/Constants.d.ts

@@ -0,0 +1,34 @@
+import type { BaseViewer } from "@gcode-viewer/core";
+import type { AxisPlaneSection, ObjectsBoxSection, PickPlaneSection } from "../sections";
+import type { Toolbar } from "../toolbars";
+/**
+ * Context for ContextMenu
+ * @hidden
+ */
+export interface Context {
+    viewer: BaseViewer;
+    hit?: any;
+    instanceId?: number;
+    batchId?: number;
+    /**
+     * For Viewer3d
+     * @hidden
+     */
+    section?: ObjectsBoxSection | PickPlaneSection | AxisPlaneSection;
+    toolbar?: Toolbar;
+}
+/**
+ * @hidden
+ */
+/**
+ * @hidden
+ */
+export interface ContextMenuItem {
+    title?: string;
+    enabled?: boolean;
+    shown?: boolean;
+    getTitle?: (context: Context) => string;
+    getEnabled?: (context: Context) => boolean;
+    getShown?: (context: Context) => boolean;
+    doAction?: (context: Context) => void;
+}

package/dist/types/context-menu/ContextMenu.config.d.ts

@@ -0,0 +1,2 @@
+import { ContextMenuItem } from "./Constants";
+export declare const ContextMenuItems: ContextMenuItem[][];

package/dist/types/context-menu/ContextMenuPlugin.d.ts

@@ -0,0 +1,23 @@
+import { type BaseViewer, Plugin, PluginConfig } from "@gcode-viewer/core";
+import { Context, ContextMenuItem } from "./Constants";
+/**
+ * Context menu plugin config.
+ */
+export type ContextMenuPluginConfig = Partial<PluginConfig>;
+/**
+ * Context menu plugin.
+ * Can be used by Viewer3d.
+ */
+export declare class ContextMenuPlugin extends Plugin {
+    static readonly DEFAULT_ID = "ContextMenuPlugin";
+    protected cfg: ContextMenuPluginConfig;
+    protected container: HTMLElement;
+    protected element: HTMLDivElement;
+    protected context: Context;
+    protected itemList: [ContextMenuItem, HTMLElement][];
+    constructor(viewer: BaseViewer, cfg?: ContextMenuPluginConfig);
+    protected handleClick: () => void;
+    show(pageX: number, pageY: number): void;
+    hide(): void;
+    destroy(): void;
+}

package/dist/types/context-menu/Locale.d.ts

@@ -0,0 +1,51 @@
+import { i18n } from "@gcode-viewer/core";
+export declare const en: {
+    viewFitAll: string;
+    hideAll: string;
+    showAll: string;
+    xRayAll: string;
+    xRayNone: string;
+    selectNone: string;
+    resetView: string;
+    viewFitEntity: string;
+    hideEntity: string;
+    hideOthers: string;
+    xRayEntity: string;
+    xRayOthers: string;
+    select: string;
+    deselect: string;
+    showSectionPlane: string;
+    showSectionBox: string;
+    showAxisSection: string;
+    hideSectionPlane: string;
+    hideSectionBox: string;
+    hideAxisSection: string;
+    undoSection: string;
+};
+export declare const zh: {
+    viewFitAll: string;
+    hideAll: string;
+    showAll: string;
+    xRayAll: string;
+    xRayNone: string;
+    selectNone: string;
+    resetView: string;
+    viewFitEntity: string;
+    hideEntity: string;
+    hideOthers: string;
+    xRayEntity: string;
+    xRayOthers: string;
+    select: string;
+    deselect: string;
+    showSectionPlane: string;
+    showSectionBox: string;
+    showAxisSection: string;
+    hideSectionPlane: string;
+    hideSectionBox: string;
+    hideAxisSection: string;
+    undoSection: string;
+};
+export declare const CONTEXT_MENU_I18N_NAMESPACE: "contextMenu";
+export { i18n };
+export type ContextMenuTranslationKey = keyof typeof en;
+export declare function t(translateKey: ContextMenuTranslationKey | string): string;

package/dist/types/context-menu/index.d.ts

@@ -0,0 +1,4 @@
+import "./contextmenu.scss";
+export * from "./Constants";
+export * from "./ContextMenuPlugin";
+export * from "./ContextMenu.config";

package/dist/types/dat-gui/Viewer3dDatGui.d.ts

@@ -0,0 +1,69 @@
+import { Plugin, Viewer3d } from "@gcode-viewer/core";
+import * as dat from "dat.gui";
+/**
+ * Can be used by Viewer3d.
+ * @hidden
+ */
+export declare class Viewer3dDatGuiPlugin extends Plugin {
+    protected viewer: Viewer3d;
+    gui?: dat.GUI;
+    /**
+     *
+     * @param viewer pass in the Viewer3D, so we can reference its data members
+     */
+    constructor(viewer: Viewer3d);
+    /**
+     * Defined all controls here, which will be displyed in dat.GUI
+     * Color should follow these formats:
+     * '#ffffff', [0, 0, 0], [0, 0, 0, 0.5], \{ h: 100, s: 0.9, v: 0.3 \}
+     */
+    readonly controls: {
+        showGroundGrid: boolean;
+        environments: string[];
+        homeView: () => void;
+        views: string[];
+        OrthographicCamera: boolean;
+        viewpoints: boolean;
+        annotations: boolean;
+        takeSnapshot: () => void;
+        takeSnapshotForViewerBBox: () => void;
+        fullScreen: () => void;
+        webcam: boolean;
+        uploadFile: () => void;
+        showTreeView: boolean;
+        showPropertyPanel: boolean;
+        transparentMode: boolean;
+        enableOutline: boolean;
+        doubleSidedMaterial: boolean;
+        showVertexNormals: boolean;
+        explode: number;
+        sectionMode: string[];
+        alVisible: boolean;
+        alColor: string;
+        alIntensity: number;
+        dlColor: string;
+        showDlHelper: boolean;
+        hlVisible: boolean;
+        hlIntensity: number;
+        hlColor: number[];
+        hlGroundColor: number[];
+        fogEnabled: boolean;
+        fogColor: number;
+        fogNearDistance: number;
+        fogFarDistance: number;
+        distanceCullingFactor: number;
+        errorTarget: number;
+        ssao_output: string;
+        ssao_kernelRadius: number;
+        ssao_minDistance: number;
+        ssao_maxDistance: number;
+        ssao_enable: boolean;
+    };
+    /**
+     * Init dat.GUI
+     */
+    init(): void;
+    open(): void;
+    close(): void;
+    destroy(): void;
+}

package/dist/types/dat-gui/index.d.ts

@@ -0,0 +1 @@
+export * from "./Viewer3dDatGui";

package/dist/types/explode/ExplodePlugin.d.ts

@@ -0,0 +1,46 @@
+import { THREE, BaseViewer, Plugin, PluginConfig } from "@gcode-viewer/core";
+import { ObjectExploder } from "./ObjectExploder";
+export interface ExplodePluginConfig extends Partial<PluginConfig> {
+    /**
+     * Explode center.
+     * If specified, each object explode based on this position. Otherwise,
+     * each object explode based on its own center.
+     */
+    explodeCenter?: THREE.Vector3;
+    /**
+     * By default, it explodes to every direction. In some scenarios, user may want to
+     * explode only in up/down direction.
+     */
+    explodeUp?: boolean;
+}
+/**
+ * Exploder class is used to explode objects in a viewer.
+ * Can be used by Viewer3d.
+ * @hidden
+ */
+export declare class ExplodePlugin extends Plugin {
+    static readonly DEFAULT_ID = "ExplodePlugin";
+    protected cfg: ExplodePluginConfig;
+    protected exploders: ObjectExploder[];
+    constructor(viewer: BaseViewer, cfg?: ExplodePluginConfig);
+    get scene(): THREE.Scene;
+    /**
+     * Initialize the
+     */
+    init(): void;
+    /**
+     * Explode objects
+     * @param scale 1 means do not explode at all, recommended value between 1-5.
+     */
+    explode(scale: number): void;
+    /**
+     * Unexplode objects
+     */
+    unexplode(): void;
+    protected onModelLoaded: () => void;
+    /**
+     * Checks if exploder already exists for a model/object.
+     */
+    protected hasExploderForModel(modelObjectId: number): boolean;
+    destroy(): void;
+}

package/dist/types/explode/ObjectExploder.d.ts

@@ -0,0 +1,48 @@
+import { THREE } from "@gcode-viewer/core";
+/**
+ * ObjectExploder class is used to explode an object
+ * @hidden
+ */
+export declare class ObjectExploder {
+    private scene;
+    objectId: number;
+    explodeCenter: THREE.Vector3;
+    private scale;
+    private explodeUp;
+    /**
+     * Constructor of Explode
+     * @param objectId target object id, that is going to be exploded
+     * @param explodeCenter if undefined, will explode object by its center
+     * @param scale scale factor, 1 means 1 time farer away from exploder's position
+     */
+    constructor(scene: THREE.Scene, objectId: number, explodeCenter?: THREE.Vector3 | undefined);
+    /**
+     * Explodes the object
+     */
+    explode(scale: number): void;
+    /**
+     * Explodes a parent or leaf object.
+     * If an object has both geometry and children, we'll move itself
+     * and we shouldn't move its children again.
+     */
+    private explodeObject;
+    /**
+     * Explodes a leaf object (that has geometry, and ususally no children).
+     * It doesn't support THREE.InstancedMesh.
+     */
+    private explodeLeafObject;
+    /**
+     * Unexplodes the object
+     */
+    unexplode(): void;
+    /**
+     * Unexplodes a parent or leaf object
+     */
+    private unexplodeObject;
+    /**
+     * Unexplodes a leaf object
+     */
+    private unexplodeLeafObject;
+    setExplodeUp(explodeUp: boolean): void;
+    private getObjectCenter;
+}

package/dist/types/explode/index.d.ts

@@ -0,0 +1 @@
+export * from "./ExplodePlugin";

package/dist/types/export/ExportPlugin.d.ts

@@ -0,0 +1,57 @@
+import { THREE, BaseViewer, Plugin, PluginConfig, Viewer3d, THREEAddons } from "@gcode-viewer/core";
+import { BasePanel } from "@gcode-viewer/ui";
+export declare enum ExportFormats {
+    Glb = "glb",
+    Gltf = "gltf",
+    Obj = "obj",
+    Stl = "stl",
+    Ply = "ply"
+}
+/**
+ * Export plugin config.
+ */
+export type ExportPluginConfig = Partial<PluginConfig>;
+/**
+ * Export plugin is used to export scene to a 3d model.
+ * @description
+ */
+export declare class ExportPlugin extends Plugin {
+    static readonly DEFAULT_ID = "ExportPlugin";
+    protected cfg: ExportPluginConfig;
+    protected basePanel?: BasePanel;
+    protected viewer3d: Viewer3d;
+    constructor(viewer: BaseViewer, cfg?: ExportPluginConfig);
+    private readonly onLanguageChange;
+    private applyLocalizedChrome;
+    /**
+     * Exports to gltf or glb format.
+     * @param filename pure filename without extension.
+     * @param options GLTFExporter options.
+     * @param targetObject optional specific object to export; defaults to all loaded models.
+     * @param quantize when true, geometry attributes are quantized via KHR_mesh_quantization
+     *   (POSITION→Int16, NORMAL→Int8, UV→Uint16) to reduce file size by ~30–50 %.
+     *   Forces `trs: false` (matrix mode) so per-mesh decode matrices are written correctly.
+     */
+    exportGltf(filename: string, options?: THREEAddons.GLTFExporterOptions, targetObject?: THREE.Object3D | null, quantize?: boolean): void;
+    /**
+     * Exports to OBJ format.
+     * @param filename pure filename without extension.
+     */
+    exportObj(filename: string, targetObject?: THREE.Object3D | null): void;
+    exportStl(filename: string, targetObject?: THREE.Object3D | null): void;
+    exportPly(filename: string, binary?: boolean, targetObject?: THREE.Object3D | null): void;
+    /**
+     * Shows the export options panel.
+     */
+    showExportPanel(targetFormat?: ExportFormats, filename?: string, targetObject?: THREE.Object3D | null): void;
+    private normalizeExportBaseName;
+    /**
+     * Saves/downloads a blob as a file.
+     * @param blob The blob to save.
+     * @param filename The filename (with extension) to save as.
+     */
+    saveBlobAsFile(blob: Blob, filename: string): void;
+    saveStringAsFile(text: string, filename: string): void;
+    saveArrayBufferAsFile: (buffer: ArrayBuffer, filename: string) => void;
+    destroy(): void;
+}

package/dist/types/export/Locale.d.ts

@@ -0,0 +1,41 @@
+import { i18n } from "@gcode-viewer/core";
+export declare const en: {
+    export: string;
+    format: string;
+    fileName: string;
+    embedTextures: string;
+    embedGeometry: string;
+    useTrsTransforms: string;
+    visibleObjects: string;
+    customExtensions: string;
+    quantizeGeometry: string;
+    binary: string;
+    exportButton: string;
+    formatObj: string;
+    formatStl: string;
+    formatPly: string;
+    formatGltf: string;
+    formatGlb: string;
+};
+export declare const zh: {
+    export: string;
+    format: string;
+    fileName: string;
+    embedTextures: string;
+    embedGeometry: string;
+    useTrsTransforms: string;
+    visibleObjects: string;
+    customExtensions: string;
+    quantizeGeometry: string;
+    binary: string;
+    exportButton: string;
+    formatObj: string;
+    formatStl: string;
+    formatPly: string;
+    formatGltf: string;
+    formatGlb: string;
+};
+export declare const EXPORT_I18N_NAMESPACE: "export";
+export { i18n };
+export type ExportTranslationKey = keyof typeof en;
+export declare function t(key: ExportTranslationKey): string;

package/dist/types/export/gltf/GltfExporter.d.ts

@@ -0,0 +1,32 @@
+import { THREE, THREEAddons } from "@gcode-viewer/core";
+export declare const DefaultGltfExportOptions: THREEAddons.GLTFExporterOptions;
+/**
+ * Wraps `THREEAddons.GLTFExporter` with optional KHR_mesh_quantization pre-processing.
+ */
+export declare class GltfExporter {
+    /**
+     * Exports `objects` to GLB / GLTF.
+     *
+     * When `quantize` is true, geometry attributes are converted before export:
+     *   - POSITION  : Float32 → Int16 normalized; decode matrix is baked into each
+     *                 mesh's node matrix (requires `trs: false`, enforced automatically).
+     *   - NORMAL    : Float32 → Int8 normalized  (75 % smaller per vertex)
+     *   - UV attrs  : Float32 → Uint16 normalized (50 % smaller, [0,1] range only)
+     *
+     * Geometry deduplication is preserved: meshes that shared the same BufferGeometry
+     * will still share the same quantized clone, so shared geometry is only written once.
+     */
+    parse(objects: THREE.Object3D[], options: THREEAddons.GLTFExporterOptions, onDone: (result: ArrayBuffer | object) => void, onError: (error: ErrorEvent) => void, quantize?: boolean): void;
+}
+/**
+ * Clone `objects` and quantize their geometry attributes.
+ * Returns `{ clones, dispose }`.  Call `dispose()` after the export finishes.
+ *
+ * Geometry deduplication is preserved: meshes that shared the same BufferGeometry
+ * before cloning will still share the same quantized BufferGeometry afterward,
+ * so the GLTFExporter writes each unique geometry only once.
+ */
+export declare function quantizeObjectsForGltf(objects: THREE.Object3D[]): {
+    clones: THREE.Object3D[];
+    dispose: () => void;
+};

package/dist/types/export/gltf/index.d.ts

@@ -0,0 +1 @@
+export * from "./GltfExporter";

package/dist/types/export/index.d.ts

@@ -0,0 +1,2 @@
+import "./ExportPlugin.scss";
+export * from "./ExportPlugin";

package/dist/types/export/obj/ObjZipExporter.d.ts

@@ -0,0 +1,14 @@
+import { THREE } from "@gcode-viewer/core";
+import { type ExportedTextureFile } from "./textures";
+export type ObjZipExportResult = {
+    objFilename: string;
+    objText: string;
+    mtlFilename: string | null;
+    mtlText: string | null;
+    textureFiles: ExportedTextureFile[];
+};
+export declare class ObjZipExporter {
+    exportSync(root: THREE.Object3D, _baseName: string): string;
+    export(root: THREE.Object3D, baseName: string): Promise<ObjZipExportResult>;
+    private injectMtllib;
+}

package/dist/types/export/obj/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./ObjZipExporter";
+export * from "./mtl";
+export * from "./textures";

package/dist/types/export/obj/mtl.d.ts

@@ -0,0 +1,9 @@
+import { THREE } from "@gcode-viewer/core";
+import type { ExportedTextureFile } from "./textures";
+export type MtlTextureBindings = Partial<Record<"map_Kd", ExportedTextureFile>>;
+export declare function getMaterialName(material: THREE.Material, fallbackIndex: number): string;
+/**
+ * Minimal MTL writer: writes Kd (color), opacity (d) and optional map_Kd.
+ * Writes fields only if source data exists.
+ */
+export declare function writeMtl(materials: THREE.Material[], materialToTextures: Map<THREE.Material, MtlTextureBindings>): string;

package/dist/types/export/obj/textures.d.ts

@@ -0,0 +1,15 @@
+import { THREE } from "@gcode-viewer/core";
+export type TextureUsage = "map" | "normalMap" | "alphaMap" | "emissiveMap" | "roughnessMap" | "metalnessMap";
+export type CollectedTexture = {
+    usage: TextureUsage;
+    texture: THREE.Texture;
+};
+export type ExportedTextureFile = {
+    key: string;
+    usage: TextureUsage;
+    filename: string;
+    blob: Blob;
+};
+export declare function collectTexturesFromObject(root: THREE.Object3D): CollectedTexture[];
+export declare function textureToBlob(texture: THREE.Texture, preferMime?: string): Promise<Blob | null>;
+export declare function exportTextureFiles(textures: CollectedTexture[], baseDir?: string): Promise<ExportedTextureFile[]>;

package/dist/types/gcode-layer-bar/GCodeLayerBarPlugin.d.ts

@@ -0,0 +1,66 @@
+import { BaseViewer, Plugin, PluginConfig } from "@gcode-viewer/core";
+export interface GCodeLayerBarPluginConfig extends Partial<PluginConfig> {
+    /**
+     * UI element id to contain the plugin. When omitted, the viewer widget container is used.
+     */
+    containerId?: string;
+}
+/**
+ * Vertical layer range bar for {@link GCodeViewer}.
+ */
+export declare class GCodeLayerBarPlugin extends Plugin {
+    static readonly DEFAULT_ID = "GCodeLayerBarPlugin";
+    private readonly cfg;
+    private readonly gcodeViewer?;
+    private root?;
+    private maxLabel?;
+    private minLabel?;
+    private slider?;
+    private fill?;
+    private startThumb?;
+    private endThumb?;
+    private startHintLayer?;
+    private startHintHeight?;
+    private endHintLayer?;
+    private endHintHeight?;
+    private modeButton?;
+    private estRoot?;
+    private estBubble?;
+    private minLayer;
+    private maxLayer;
+    private startLayer;
+    private endLayer;
+    private singleLayerMode;
+    private previousStartLayer;
+    private dragThumb?;
+    constructor(viewer: BaseViewer, cfg?: GCodeLayerBarPluginConfig);
+    private init;
+    private hostContainer;
+    private buildDom;
+    private createBound;
+    private createThumb;
+    private createHint;
+    private onModelsChanged;
+    private onLanguageChange;
+    private onLayerRangeChanged;
+    private refreshFromViewer;
+    private setVisible;
+    private applyLocalizedTitles;
+    private onToggleMode;
+    private onWheel;
+    private onSliderPointerDown;
+    private onSliderPointerMove;
+    private onSliderPointerUp;
+    private onSliderHoverMove;
+    private onSliderHoverLeave;
+    private updateEstimatedHover;
+    private hideEstimatedHover;
+    private nearestThumb;
+    private valueFromPointer;
+    private applyPointerValue;
+    private setRange;
+    private fillHint;
+    private percent;
+    private render;
+    destroy(): void;
+}

package/dist/types/gcode-layer-bar/Locale.d.ts

@@ -0,0 +1,13 @@
+import { i18n } from "@gcode-viewer/core";
+export declare const en: {
+    singleLayer: string;
+    multiLayer: string;
+};
+export declare const zh: {
+    singleLayer: string;
+    multiLayer: string;
+};
+export declare const GCODE_LAYER_BAR_I18N_NAMESPACE: "gcodeLayerBar";
+export { i18n };
+export type GCodeLayerBarTranslationKey = keyof typeof en;
+export declare function t(key: GCodeLayerBarTranslationKey | string): string;

package/dist/types/gcode-layer-bar/index.d.ts

@@ -0,0 +1,2 @@
+import "./gcode-layer-bar.scss";
+export * from "./GCodeLayerBarPlugin";