@duet3d/gcodeviewer 3.7.0-alpha.1

package/dist/GCodeParsers/superslicer.d.ts

@@ -0,0 +1,97 @@
+import { default as ProcessorProperties } from '../processorproperties';
+import { default as SlicerBase } from './slicerbase';
+export default class SuperSlicer extends SlicerBase {
+    featureList: {
+        PERIMETER: {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'EXTERNAL PERIMETER': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'INTERNAL INFILL': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'SOLID INFILL': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'TOP SOLID INFILL': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'BRIDGE INFILL': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'GAP FILL': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        SKIRT: {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'SKIRT/BRIM': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'SUPPORTED MATERIAL': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'SUPPORTED MATERIAL INTERFACE': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        CUSTOM: {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        UNKNOWN: {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'SUPPORT MATERIAL': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'SUPPORT MATERIAL INTERFACE': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'OVERHANG PERIMETER': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+        'WIPE TOWER': {
+            color: number[];
+            perimeter: boolean;
+            support: boolean;
+        };
+    };
+    constructor();
+    processComment(comment: string): void;
+    getFeatureColor(): number[];
+    isPerimeter(): boolean;
+    isSupport(): boolean;
+    processHeader(file: string[], props: ProcessorProperties): void;
+}

package/dist/Renderables/axes.d.ts

@@ -0,0 +1,16 @@
+import { Scene } from '@babylonjs/core/scene';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { Vector3 } from '@babylonjs/core/Maths/math.vector';
+export default class Axes {
+    visible: boolean;
+    size: number;
+    debug: boolean;
+    registerClipIgnore: (mesh: Mesh) => void;
+    private scene;
+    private axesMesh;
+    constructor(scene: Scene);
+    show(visible: boolean): void;
+    resize(size: number): void;
+    render(position?: Vector3): void;
+    dispose(): void;
+}

package/dist/Renderables/bed.d.ts

@@ -0,0 +1,53 @@
+import { Scene } from '@babylonjs/core/scene';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { Color4 } from '@babylonjs/core/Maths/math.color';
+import { GridMaterial } from '@babylonjs/materials/grid/gridMaterial';
+export declare enum RenderBedMode {
+    bed = 0,
+    box = 1
+}
+export interface AxisRange {
+    min: number;
+    max: number;
+}
+export interface BuildVolume {
+    x: AxisRange;
+    y: AxisRange;
+    z: AxisRange;
+}
+export default class Bed {
+    buildVolume: BuildVolume;
+    renderMode: RenderBedMode;
+    isDelta: boolean;
+    debug: boolean;
+    registerClipIgnore: (mesh: Mesh) => void;
+    private scene;
+    private bedMesh;
+    private bedLineColor;
+    private planeMaterial;
+    private boxMaterial;
+    private highlightLayer;
+    constructor(scene: Scene);
+    setRenderMode(renderBedMode: RenderBedMode): void;
+    buildBed(): Mesh;
+    setDelta(isDelta: boolean): void;
+    buildFlatBed(): void;
+    getCenter(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    getSize(): {
+        x: number;
+        y: number;
+        z: number;
+    };
+    buildBox(): void;
+    setVisibility(visibility: boolean): void;
+    commitBedSize(): void;
+    buildGridMaterial(): GridMaterial;
+    getBedColor(): string;
+    setBedColor(color: string): void;
+    getBedColor4(): Color4;
+    dispose(): void;
+}

package/dist/Renderables/buildobjects.d.ts

@@ -0,0 +1,35 @@
+import { Scene } from '@babylonjs/core/scene';
+import { Color3 } from '@babylonjs/core/Maths/math.color';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { StandardMaterial } from '@babylonjs/core/Materials/standardMaterial';
+import { PickingInfo } from '@babylonjs/core/Collisions/pickingInfo';
+export default class BuildObjects {
+    scene: Scene;
+    buildObjectMeshes: Mesh[];
+    labels: Mesh[];
+    baseMaterial: StandardMaterial;
+    highlightMaterial: StandardMaterial;
+    cancelledMaterial: StandardMaterial;
+    cancelledHighlightMaterial: StandardMaterial;
+    showCancelObjects: boolean;
+    showLabel: boolean;
+    alphaLevel: number;
+    objectCallback: (metadata: any) => void;
+    renderFailedCallback: () => void;
+    labelCallback: (name: string) => void;
+    registerClipIgnore: (mesh: Mesh) => void;
+    getMaxHeight: () => number;
+    private observableControls;
+    constructor(scene: Scene);
+    setBuildMaterial(name: string, color: Color3, alpha?: number): StandardMaterial;
+    rebuildMaterials(): void;
+    private buildXMarkTexture;
+    loadObjectBoundaries(boundaryObjects: any[]): void;
+    buildObservables(): void;
+    clearObservables(): void;
+    showObjectSelection(visible: boolean): void;
+    setObjectTexture(mesh: Mesh): void;
+    handleClick(pickInfo: PickingInfo): void;
+    handlePointerMove(pickInfo: PickingInfo): void;
+    showLabels(visible: boolean): void;
+}

package/dist/Renderables/nozzle.d.ts

@@ -0,0 +1,81 @@
+import { Scene } from '@babylonjs/core/scene';
+import { Color3 } from '@babylonjs/core/Maths/math.color';
+import { Move } from '../GCodeLines';
+export interface NozzlePosition {
+    x: number;
+    y: number;
+    z: number;
+}
+export interface NozzleMovement {
+    startPos: NozzlePosition;
+    endPos: NozzlePosition;
+    feedRate: number;
+    duration: number;
+    isExtruding: boolean;
+}
+export default class Nozzle {
+    private scene;
+    private nozzleGroup;
+    private nozzleTip;
+    private nozzleBody;
+    private hotEnd;
+    private material;
+    nozzleDiameter: number;
+    nozzleColor: Color3;
+    hotEndColor: Color3;
+    private isVisible;
+    private currentPosition;
+    private currentTween;
+    private isAnimating;
+    private animationSpeed;
+    private tweenGroup;
+    constructor(scene: Scene, diameter?: number);
+    private createNozzleGeometry;
+    private setupMaterial;
+    setDiameter(diameter: number): void;
+    setColor(color: Color3): void;
+    show(): void;
+    hide(): void;
+    toggle(): void;
+    isNozzleVisible(): boolean;
+    setPosition(position: NozzlePosition): void;
+    getCurrentPosition(): NozzlePosition;
+    /**
+     * Calculate movement duration based on feedrate
+     * @param movement The movement to calculate duration for
+     * @returns Duration in milliseconds
+     */
+    private calculateMovementDuration;
+    /**
+     * Create a movement from a G-code Move object
+     */
+    createMovementFromGCode(move: Move, startPos: NozzlePosition): NozzleMovement;
+    /**
+     * Animate nozzle movement with tweening
+     */
+    moveToPosition(movement: NozzleMovement): Promise<void>;
+    /**
+     * Stop current animation
+     */
+    stopAnimation(): void;
+    /**
+     * Force position update (for skipping during animation)
+     */
+    forcePosition(position: NozzlePosition): void;
+    /**
+     * Set animation speed multiplier
+     */
+    setAnimationSpeed(speed: number): void;
+    getAnimationSpeed(): number;
+    isCurrentlyAnimating(): boolean;
+    /**
+     * Update tweens (call this in render loop)
+     */
+    update(): void;
+    /**
+     * Clean up resources
+     */
+    dispose(): void;
+    getDiameter(): number;
+    toString(): string;
+}

package/dist/Renderables/textplane.d.ts

@@ -0,0 +1,3 @@
+import { Scene } from '@babylonjs/core/scene';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+export declare function makeTextPlane(scene: Scene, text: string, textColor: string, backgroundColor: string, width: number, height: number, fontSize?: number): Mesh;

package/dist/Renderables/viewbox.d.ts

@@ -0,0 +1,27 @@
+import { Engine } from '@babylonjs/core/Engines/engine';
+import { ArcRotateCamera } from '@babylonjs/core/Cameras/arcRotateCamera';
+export interface ViewBoxDirection {
+    x: number;
+    y: number;
+    z: number;
+}
+export default class ViewBox {
+    private static readonly FACE_NAMES;
+    private scene;
+    private camera;
+    private mainCamera;
+    private edgeMaterial;
+    visible: boolean;
+    onDirectionSelected: ((direction: ViewBoxDirection) => void) | null;
+    constructor(engine: Engine, mainCamera: ArcRotateCamera);
+    pick(x: number, y: number): ViewBoxDirection | null;
+    private buildPlane;
+    private buildCorner;
+    private buildEdge;
+    render(): void;
+    private lastRenderWidth;
+    private lastRenderHeight;
+    private updateViewport;
+    show(visible: boolean): void;
+    dispose(): void;
+}

package/dist/gpupicker.d.ts

@@ -0,0 +1,22 @@
+import { Engine } from '@babylonjs/core/Engines/engine';
+import { Mesh } from '@babylonjs/core/Meshes/mesh';
+import { Scene } from '@babylonjs/core/scene';
+import { RenderTargetTexture } from '@babylonjs/core/Materials/Textures/renderTargetTexture';
+import { ShaderMaterial } from '@babylonjs/core/Materials/shaderMaterial';
+export default class GPUPicker {
+    scene: Scene;
+    engine: Engine;
+    renderTarget: RenderTargetTexture;
+    width: number;
+    height: number;
+    colorTestCallBack: any;
+    currentPosition: number;
+    renderTargetMeshs: Mesh[];
+    shaderMaterial: ShaderMaterial;
+    constructor(scene: Scene, engine: Engine, width: number, height: number);
+    readTexturePixels(gl: any, texture: any, x: any, y: any, w: any, h: any): Uint8Array<ArrayBuffer>;
+    updateRenderTargetSize(width: any, height: any): void;
+    clearRenderList(): void;
+    addToRenderList(mesh: Mesh): void;
+    updateCurrentPosition(currentPosition: number): void;
+}