@synchronized-console/viewer 2.25.71 → 2.31.14

package/dist/modules/extensions/measurements/MeasurementsExtension.d.ts

@@ -5,32 +5,27 @@ import { Measurement } from './Measurement.js';
 import { ExtendedMeshIntersection } from '../../objects/SynchronizedRaycaster.js';
 import { Extension } from '../Extension.js';
 import { CameraController } from '../CameraController.js';
-export declare enum MeasurementType {
-    PERPENDICULAR = 0,
-    POINTTOPOINT = 1,
-    AREA = 2,
-    POINT = 3
+import { MeasurementData, MeasurementOptions } from '@synchronized-console/shared/viewer/state';
+export declare enum MeasurementEvent {
+    CountChanged = "measurement-count-changed",
+    MeasurementsChanged = "measurements-changed"
 }
-export interface MeasurementOptions {
-    visible: boolean;
-    type?: MeasurementType;
-    vertexSnap?: boolean;
-    units?: string;
-    precision?: number;
-    chain?: boolean;
+export interface MeasurementEventPayload {
+    [MeasurementEvent.CountChanged]: number;
+    [MeasurementEvent.MeasurementsChanged]: Measurement[];
 }
 export declare class MeasurementsExtension extends Extension {
     protected cameraProvider: CameraController;
     get inject(): (typeof CameraController)[];
     protected renderer: SynchronizedRenderer;
-    protected measurements: Measurement[];
+    protected _measurements: Measurement[];
     protected _activeMeasurement: Measurement | null;
     protected _selectedMeasurement: Measurement | null;
-    protected raycaster: Raycaster;
     protected _options: MeasurementOptions;
     private _frameLock;
     private _paused;
     private _sceneHit;
+    protected raycaster: Raycaster;
     private pointBuff;
     private normalBuff;
     private screenBuff0;
@@ -41,7 +36,11 @@ export declare class MeasurementsExtension extends Extension {
     set options(options: MeasurementOptions);
     get selectedMeasurement(): Measurement | null;
     get activeMeasurement(): Measurement | null;
+    get measurementCount(): number;
+    get mesurements(): Measurement[];
+    private emitMeasurementCountChanged;
     constructor(viewer: IViewer, cameraProvider: CameraController);
+    on<T extends MeasurementEvent>(eventType: T, listener: (arg: MeasurementEventPayload[T]) => void): void;
     onLateUpdate(): void;
     onResize(): void;
     protected onPointerMove(data: Vector2 & {
@@ -59,7 +58,13 @@ export declare class MeasurementsExtension extends Extension {
     protected startMeasurement(): Measurement;
     protected cancelMeasurement(): void;
     protected finishMeasurement(): void;
-    removeMeasurement(): void;
+    protected pushMeasurement(measurement: Measurement): void;
+    protected findMeasurementFromData(measurementData: MeasurementData): Measurement | undefined;
+    removeMeasurement(measurementData?: MeasurementData): void;
+    /**
+     * Idempotent way of setting measurements
+     */
+    setMeasurements(measurements: MeasurementData[]): void;
     clearMeasurements(): void;
     protected flashMeasurement(): void;
     protected pickMeasurement(data: Vector2): Measurement | null;
@@ -67,5 +72,6 @@ export declare class MeasurementsExtension extends Extension {
     protected snap(intersection: ExtendedMeshIntersection, outPoint: Vector3, outNormal: Vector3): void;
     protected updateClippingPlanes(planes: Plane[]): void;
     protected applyOptions(): void;
-    fromMeasurementData(startPoint: Vector3, endPoint: Vector3): Promise<void>;
+    addMeasurement(measurementData: MeasurementData): void;
+    toMeasurementData(): MeasurementData[];
 }

package/dist/modules/extensions/measurements/PerpendicularMeasurement.d.ts

@@ -1,13 +1,14 @@
 import { Box3, Camera, Plane, Raycaster, Vector2, Vector3, type Intersection } from 'three';
 import { Measurement } from './Measurement.js';
+import { MeasurementData, MeasurementType } from '@synchronized-console/shared/viewer/state';
 export declare class PerpendicularMeasurement extends Measurement {
     private startGizmo;
     private endGizmo;
-    private normalIndicatorPixelSize;
     flipStartNormal: boolean;
     midPoint: Vector3;
     set isVisible(value: boolean);
     get bounds(): Box3;
+    get measurementType(): MeasurementType;
     constructor();
     frameUpdate(camera: Camera, size: Vector2, bounds: Box3): void;
     locationUpdated(point: Vector3, normal: Vector3): void;
@@ -16,4 +17,6 @@ export declare class PerpendicularMeasurement extends Measurement {
     raycast(raycaster: Raycaster, intersects: Array<Intersection>): void;
     highlight(value: boolean): void;
     updateClippingPlanes(planes: Plane[]): void;
+    toMeasurementData(): MeasurementData;
+    fromMeasurementData(data: MeasurementData): void;
 }

package/dist/modules/extensions/measurements/PointMeasurement.d.ts

@@ -1,18 +1,20 @@
 import { Box3, Camera, Plane, Raycaster, Vector2, Vector3, type Intersection } from 'three';
 import { Measurement } from './Measurement.js';
-import { SynchronizedText } from '../../objects/SynchronizedText.js';
+import { TextLabel } from '../../objects/TextLabel.js';
 import { MeasurementPointGizmo } from './MeasurementPointGizmo.js';
+import { MeasurementType } from '@synchronized-console/shared/viewer/state';
 export declare class PointMeasurement extends Measurement {
     protected gizmo: MeasurementPointGizmo;
-    protected xLabel: SynchronizedText;
-    protected yLabel: SynchronizedText;
-    protected zLabel: SynchronizedText;
+    protected xLabel: TextLabel;
+    protected yLabel: TextLabel;
+    protected zLabel: TextLabel;
     protected xLabelPosition: Vector3;
     protected yLabelPosition: Vector3;
     protected zLabelPosition: Vector3;
     protected readonly pixelsOffX: number;
     protected readonly pixelsOffY: number;
     set isVisible(value: boolean);
+    get measurementType(): MeasurementType;
     constructor();
     frameUpdate(camera: Camera, size: Vector2, bounds: Box3): void;
     locationUpdated(point: Vector3, normal: Vector3): void;

package/dist/modules/extensions/measurements/PointToPointMeasurement.d.ts

@@ -1,9 +1,11 @@
 import { Box3, Camera, Plane, Raycaster, Vector2, Vector3, type Intersection } from 'three';
 import { Measurement } from './Measurement.js';
+import { MeasurementType } from '@synchronized-console/shared/viewer/state';
 export declare class PointToPointMeasurement extends Measurement {
     private startGizmo;
     private endGizmo;
     set isVisible(value: boolean);
+    get measurementType(): MeasurementType;
     constructor();
     frameUpdate(camera: Camera, size: Vector2, bounds: Box3): void;
     locationUpdated(point: Vector3, normal: Vector3): void;

package/dist/modules/extensions/sections/SectionTool.d.ts

@@ -1,4 +1,4 @@
-import { Group, Box3, BufferGeometry, Mesh, Vector3, Plane, Raycaster, Object3D, Matrix4, Vector2, Face, PlaneGeometry } from 'three';
+import { Group, Box3, BufferGeometry, Mesh, Vector3, Plane, Raycaster, Quaternion, Object3D, Matrix4, Vector2, Face, PlaneGeometry } from 'three';
 import { TransformControls } from '../TransformControls.js';
 import { OBB } from 'three/examples/jsm/math/OBB.js';
 import { type IViewer } from '../../../IViewer.js';
@@ -20,6 +20,12 @@ export interface SectionToolEventPayload {
 export declare class SectionTool extends Extension {
     protected cameraProvider: CameraController;
     get inject(): (typeof CameraController)[];
+    /** Configurable rotation snap angle in radians. Set to null to disable snapping */
+    rotationSnapAngle: number | null;
+    /** Note: Rotation snapping only applies to mouse interactions via TransformControls.
+     *  Programmatic calls to setBox() will not apply rotation snapping.
+     *  For complete snapping support, programmatic rotations will need to be handled separately.
+     */
     /** This is our data model. All we need is an OBB */
     protected obb: OBB;
     /** The planes that will send out as clipping planes */
@@ -111,6 +117,12 @@ export declare class SectionTool extends Extension {
     /** Hit testing related */
     protected raycaster: Raycaster;
     protected dragging: boolean;
+    protected shiftKeyPressed: boolean;
+    protected keydownHandler: (e: KeyboardEvent) => void;
+    protected keyupHandler: (e: KeyboardEvent) => void;
+    protected sectionBoxHistory: OBB[];
+    protected currentHistoryIndex: number;
+    protected maxHistorySize: number;
     /** Manadatory property for all extensions */
     get enabled(): boolean;
     set enabled(value: boolean);
@@ -155,12 +167,28 @@ export declare class SectionTool extends Extension {
      * Creates the controls and all their gizmos
      */
     protected setupControls(): void;
+    /**
+     * Creates an OBB state from the current OBB
+     */
+    protected createObbState(): OBB;
+    /**
+     * Applies an OBB state to the current OBB
+     */
+    protected applyObbState(state: OBB): void;
+    /**
+     * Saves the current section box state to history
+     */
+    protected saveToHistory(): void;
+    /**
+     * Sets up keyboard event listeners for shift key rotation snapping and undo/redo
+     */
+    protected setupKeyboardListeners(): void;
     /**
      * Controls, outline and hitbox update based on the OBB model
      */
     protected updateVisual(): void;
     /**
-     * Triggers when dragging starts/stops
+     * Triggers when transform interactions start/stop
      * @param event Controls event
      */
     protected draggingHandler(event: any): void;
@@ -216,4 +244,23 @@ export declare class SectionTool extends Extension {
         min: Vector3Like;
         max: Vector3Like;
     } | OBB): box is OBB;
+    /**
+     * Snaps a quaternion to the nearest grid based on rotationSnapAngle.
+     * This is useful for rotation snapping.
+     * @param q The quaternion to snap.
+     * @returns The snapped quaternion.
+     */
+    protected snapQuaternionToGrid(q: Quaternion): Quaternion;
+    /**
+     * Undoes the last section box change
+     */
+    protected undoSectionBox(): void;
+    /**
+     * Redoes the last undone section box change
+     */
+    protected redoSectionBox(): void;
+    /**
+     * Cleanup method to remove event listeners and prevent memory leaks
+     */
+    dispose(): void;
 }

package/dist/modules/input/Input.d.ts

@@ -8,7 +8,9 @@ export declare enum InputEvent {
     Wheel = "wheel",
     Click = "click",
     DoubleClick = "double-click",
-    KeyUp = "key-up"
+    KeyUp = "key-up",
+    KeyDown = "key-down",
+    ContextMenu = "context-menu"
 }
 export interface InputEventPayload {
     [InputEvent.PointerDown]: Vector2 & {
@@ -31,6 +33,8 @@ export interface InputEventPayload {
         multiSelect: boolean;
     };
     [InputEvent.KeyUp]: KeyboardEvent;
+    [InputEvent.KeyDown]: KeyboardEvent;
+    [InputEvent.ContextMenu]: PointerEvent;
 }
 export default class Input extends EventEmitter {
     private static readonly MAX_DOUBLE_CLICK_TIMING;
@@ -40,7 +44,7 @@ export default class Input extends EventEmitter {
     private lastClick;
     private touchLocation;
     private container;
-    constructor(container: HTMLElement);
+    constructor(container: HTMLElement, restrictKeyInput?: boolean);
     on<T extends InputEvent>(eventType: T, listener: (arg: InputEventPayload[T]) => void): void;
     _getNormalisedClickPosition(e: MouseEvent | Touch): Vector2;
     dispose(): void;

package/dist/modules/loaders/Synchronized/SynchronizedConverter.d.ts

@@ -1,7 +1,7 @@
 import { type TreeNode, WorldTree } from '../../tree/WorldTree.js';
 import { type SynchronizedObject } from '../../../index.js';
 import { ObjectLoader2 } from '@synchronized-console/objectloader2';
-export type ConverterResultDelegate = () => Promise<void>;
+export type ConverterResultDelegate = (count: number) => void;
 export type SynchronizedConverterNodeDelegate = ((object: SynchronizedObject, node: TreeNode) => Promise<void>) | null;
 /**
  * Utility class providing some top level conversion methods.
@@ -33,6 +33,8 @@ export default class SynchronizedConverter {
         [id: string]: SynchronizedObject;
     };
     protected instanceCounter: number;
+    protected duplicateCounter: number;
+    private traverseCount;
     protected readonly NodeConverterMapping: {
         [name: string]: SynchronizedConverterNodeDelegate;
     };
@@ -47,6 +49,7 @@ export default class SynchronizedConverter {
      */
     traverse(objectURL: string, obj: SynchronizedObject, callback: ConverterResultDelegate, node?: TreeNode | null): Promise<void>;
     private getNodeId;
+    private addNode;
     /**
      * Takes an array composed of chunked references and dechunks it.
      * @param  {[type]} arr [description]
@@ -74,6 +77,7 @@ export default class SynchronizedConverter {
     private getBlockDefinitionGeometry;
     /** We're wasting a few milis here, but it is what it is */
     private getCompoundId;
+    private getDuplicateId;
     private getEmptyTransformData;
     /**
      *
@@ -115,4 +119,6 @@ export default class SynchronizedConverter {
     private CircleToNode;
     private ArcToNode;
     private EllipseToNode;
+    /** We shouldn't need to work with duplicates */
+    handleDuplicates(): Promise<void>;
 }

package/dist/modules/loaders/Synchronized/SynchronizedGeometryConverter.d.ts

@@ -2,6 +2,8 @@ import { type GeometryData } from '../../converter/Geometry.js';
 import { type NodeData } from '../../tree/WorldTree.js';
 import { Vector2, Vector3 } from 'three';
 import { GeometryConverter, SynchronizedType } from '../GeometryConverter.js';
+import { DataChunk } from '../../../IViewer.js';
+import { ChunkArray } from '../../converter/VirtualArray.js';
 export declare class SynchronizedGeometryConverter extends GeometryConverter {
     typeLookupTable: {
         [type: string]: SynchronizedType;
@@ -104,7 +106,7 @@ export declare class SynchronizedGeometryConverter extends GeometryConverter {
             y: number;
             z: number;
         };
-    }, radius: number, startAngle?: number, endAngle?: number, res?: number): Vector3[];
+    }, radius: number, startAngle?: number, endAngle?: number, resolution?: number): Float64Array<ArrayBuffer>;
     protected PointToVector3(obj: {
         value: Array<number>;
         units: string;
@@ -112,7 +114,7 @@ export declare class SynchronizedGeometryConverter extends GeometryConverter {
         x: number;
         y: number;
         z: number;
-    }, scale?: boolean): Vector3;
+    }, target?: Vector3, scale?: boolean): Vector3;
     protected PointToFloatArray(obj: {
         value: Array<number>;
         units: string;
@@ -122,6 +124,8 @@ export declare class SynchronizedGeometryConverter extends GeometryConverter {
         z: number;
     }): number[];
     protected FlattenVector3Array(input: Vector3[] | Vector2[]): number[];
-    protected unpackColors(int32Colors: number[], tolinear?: boolean): number[];
+    protected unpackColors(int32Colors: ChunkArray, tolinear?: boolean): number[];
     protected srgbToLinear(x: number): number;
+    /** Connectors send empty chunks ಠ_ಠ */
+    protected chunkArrayHasData(chunks: Array<DataChunk>): boolean;
 }

package/dist/modules/loaders/Synchronized/SynchronizedLoader.d.ts

@@ -1,18 +1,20 @@
 import SynchronizedConverter from './SynchronizedConverter.js';
 import { Loader } from '../Loader.js';
 import { WorldTree } from '../../../index.js';
-import { ObjectLoader2 } from '@synchronized-console/objectloader2';
+import { ObjectLoader2, ObjectAttributeMask } from '@synchronized-console/objectloader2';
 export declare class SynchronizedLoader extends Loader {
     protected loader: ObjectLoader2;
     protected converter: SynchronizedConverter;
     protected tree: WorldTree;
     protected isCancelled: boolean;
     protected isFinished: boolean;
+    protected log: (message?: string, ...args: unknown[]) => void;
     get resource(): string;
     get finished(): boolean;
-    constructor(targetTree: WorldTree, resource: string, authToken?: string, enableCaching?: boolean, resourceData?: unknown);
-    protected initObjectLoader(resource: string, authToken?: string, _enableCaching?: boolean, resourceData?: unknown): ObjectLoader2;
+    constructor(targetTree: WorldTree, resource: string, authToken?: string, enableCaching?: boolean, resourceData?: unknown, logger?: (message?: string, ...args: unknown[]) => void, attributeMask?: ObjectAttributeMask, objectTypeMask?: string[]);
+    protected initObjectLoader(resource: string, authToken?: string, _enableCaching?: boolean, resourceData?: unknown, attributeMask?: ObjectAttributeMask, objectTypeMask?: string[]): ObjectLoader2;
     load(): Promise<boolean>;
+    private progressListen;
     cancel(): void;
     dispose(): void;
 }

package/dist/modules/materials/Materials.d.ts

@@ -57,6 +57,7 @@ export default class Materials {
     private pointCloudGradientMaterial;
     private textGhostMaterial;
     private textColoredMaterial;
+    private textGradientMaterial;
     private textHiddenMaterial;
     private defaultGradientTextureData;
     private static readonly NullRenderMaterialHash;

package/dist/modules/materials/SynchronizedBasicMaterial.d.ts

@@ -1,25 +1,26 @@
 import { Material, type IUniform, Vector2, type MeshBasicMaterialParameters, Scene, Camera, BufferGeometry, Object3D } from 'three';
-import { Matrix4 } from 'three';
 import { ExtendedMeshBasicMaterial, type Uniforms } from './SynchronizedMaterial.js';
 import type { SynchronizedWebGLRenderer } from '../objects/SynchronizedWebGLRenderer.js';
+export type BillboardingType = 'world' | 'screen';
 declare class SynchronizedBasicMaterial extends ExtendedMeshBasicMaterial {
-    protected static readonly matBuff: Matrix4;
-    protected static readonly vecBuff: Vector2;
-    private _billboardPixelHeight;
-    private _billboardOffset;
+    protected _billboardPixelSize: Vector2;
+    protected _billboardPixelOffset: Vector2;
     protected get vertexProgram(): string;
     protected get fragmentProgram(): string;
     protected get baseUniforms(): {
         [uniform: string]: IUniform;
     };
     protected get uniformsDef(): Uniforms;
-    set billboardPixelHeight(value: number);
-    set billboardOffset(value: Vector2);
+    get billboardPixelSize(): Vector2;
+    set billboardPixelSize(value: Vector2);
+    get billboardPixeOffset(): Vector2;
+    set billboardPixelOffset(value: Vector2);
     constructor(parameters: MeshBasicMaterialParameters, defines?: string[]);
     /** We need a unique key per program */
     customProgramCacheKey(): string;
     copy(source: Material): this;
     fastCopy(from: Material, to: Material): void;
+    setBillboarding(type: BillboardingType | null): void;
     /** Called by three.js render loop */
     onBeforeRender(_this: SynchronizedWebGLRenderer, _scene: Scene, camera: Camera, _geometry: BufferGeometry, object: Object3D): void;
 }

package/dist/modules/materials/SynchronizedTextColoredMaterial.d.ts

@@ -0,0 +1,8 @@
+import SynchronizedTextMaterial from './SynchronizedTextMaterial.js';
+declare class SynchronizedTextColoredMaterial extends SynchronizedTextMaterial {
+    gradientIndexMap: {
+        [index: number]: number;
+    };
+    updateGradientIndexMap(index: number, value: number): void;
+}
+export default SynchronizedTextColoredMaterial;

package/dist/modules/materials/SynchronizedTextMaterial.d.ts

@@ -1,26 +1,18 @@
-import { type IUniform, Vector2, Material, type MeshBasicMaterialParameters, Scene, Camera, BufferGeometry, Object3D } from 'three';
-import { Matrix4 } from 'three';
-import { ExtendedMeshBasicMaterial, type Uniforms } from './SynchronizedMaterial.js';
-import type { SynchronizedWebGLRenderer } from '../objects/SynchronizedWebGLRenderer.js';
-declare class SynchronizedTextMaterial extends ExtendedMeshBasicMaterial {
-    protected static readonly matBuff: Matrix4;
-    protected static readonly vecBuff: Vector2;
-    private _billboardPixelHeight;
+import { Material, Texture } from 'three';
+import { type Uniforms } from './SynchronizedMaterial.js';
+import SynchronizedBasicMaterial from './SynchronizedBasicMaterial.js';
+declare class SynchronizedTextMaterial extends SynchronizedBasicMaterial {
+    setMatrixTexture: (texture: Texture) => void;
     protected get vertexProgram(): string;
     protected get fragmentProgram(): string;
-    protected get baseUniforms(): {
-        [uniform: string]: IUniform;
-    };
     protected get uniformsDef(): Uniforms;
-    set billboardPixelHeight(value: number);
-    get billboardPixelHeight(): number;
-    constructor(parameters: MeshBasicMaterialParameters, defines?: Array<string>);
     /** We need a unique key per program */
     customProgramCacheKey(): string;
-    copy(source: Material): this;
+    protected copyCustomUniforms(material: Material): void;
     getDerivedMaterial(): any;
+    /** Sadly, troika does not export this for no good reason so we neee to copy it over */
+    getDerivedBatchedMaterial(): any;
     fastCopy(from: Material, to: Material): void;
-    /** Called by three.js render loop */
-    onBeforeRender(_this: SynchronizedWebGLRenderer, _scene: Scene, camera: Camera, _geometry: BufferGeometry, _object: Object3D): void;
+    setGradientTexture(texture: Texture): void;
 }
 export default SynchronizedTextMaterial;

package/dist/modules/materials/shaders/synchronized-basic-vert.d.ts

@@ -1 +1 @@
-export declare const synchronizedBasicVert = "\n#include <common>\n#ifdef USE_RTE\n    // The high component is stored as the default 'position' attribute buffer\n    attribute vec3 position_low;\n    uniform vec3 uViewer_high;\n    uniform vec3 uViewer_low;\n#endif\n\n#ifdef TRANSFORM_STORAGE\n    attribute float objIndex;\n\n    #if TRANSFORM_STORAGE == 0\n        #if __VERSION__ == 300\n            #define TRANSFORM_STRIDE 4\n        #else\n            #define TRANSFORM_STRIDE 4.\n        #endif\n        uniform sampler2D tTransforms;\n        uniform float objCount;\n    #elif TRANSFORM_STORAGE == 1\n        uniform mat4 uTransforms[OBJ_COUNT];\n    #endif\n#endif\n\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n\n#ifdef USE_RTE\n    highp vec4 computeRelativePosition(in highp vec3 position_low, in highp vec3 position_high, in highp vec3 relativeTo_low, in highp vec3 relativeTo_high){\n        /* \n        Source https://github.com/virtualglobebook/OpenGlobe/blob/master/Source/Examples/Chapter05/Jitter/GPURelativeToEyeDSFUN90/Shaders/VS.glsl \n        Note here, we're storing the high part of the position encoding inside three's default 'position' attribute buffer so we avoid redundancy \n        */\n        highp vec3 t1 = position_low.xyz - relativeTo_low.xyz;\n        highp vec3 e = t1 - position_low.xyz;\n        /** This is redunant, but necessary as a workaround for Apple platforms */\n        highp float x = position_high.x - relativeTo_high.x;\n        highp float y = position_high.y - relativeTo_high.y;\n        highp float z = position_high.z - relativeTo_high.z;\n        highp vec3 v = vec3(x, y, z);\n        /** End of redundant part */\n        highp vec3 t2 = ((-relativeTo_low - e) + (position_low.xyz - (t1 - e))) + v;\n        highp vec3 highDifference = t1 + t2;\n        highp vec3 lowDifference = t2 - (highDifference.xyz - t1.xyz);\n        \n        highp vec3 position = highDifference.xyz + lowDifference.xyz;\n        return vec4(position, 1.);\n    }   \n#endif\n\n#ifdef TRANSFORM_STORAGE\n    void objectTransform(out vec4 quaternion, out vec4 pivotLow, out vec4 pivotHigh, out vec4 translation, out vec4 scale){\n        #if TRANSFORM_STORAGE == 0\n            #if __VERSION__ == 300\n                ivec2 uv = ivec2(int(objIndex) * TRANSFORM_STRIDE, 0); \n                vec4 v0 = texelFetch( tTransforms, uv, 0 );\n                vec4 v1 = texelFetch( tTransforms, uv + ivec2(1, 0), 0);\n                vec4 v2 = texelFetch( tTransforms, uv + ivec2(2, 0), 0);\n                vec4 v3 = texelFetch( tTransforms, uv + ivec2(3, 0), 0);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #else\n                float size = objCount * TRANSFORM_STRIDE;\n                vec2 cUv = vec2(0.5/size, 0.5);\n                vec2 dUv = vec2(1./size, 0.);\n                \n                vec2 uv = vec2((objIndex * TRANSFORM_STRIDE)/size + cUv.x, cUv.y);\n                vec4 v0 = texture2D( tTransforms, uv);\n                vec4 v1 = texture2D( tTransforms, uv + dUv);\n                vec4 v2 = texture2D( tTransforms, uv + 2. * dUv);\n                vec4 v3 = texture2D( tTransforms, uv + 3. * dUv);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #endif\n        #elif TRANSFORM_STORAGE == 1\n            mat4 tMatrix = uTransforms[int(objIndex)];\n            quaternion = tMatrix[0];\n            pivotLow = vec4(tMatrix[1].xyz, 1.);\n            pivotHigh = vec4(tMatrix[2].xyz, 1.);\n            translation = vec4(tMatrix[3].xyz, 1.);\n            scale = vec4(tMatrix[1][3], tMatrix[2][3], tMatrix[3][3], 1.);\n        #endif\n    }\n\n    vec3 rotate_vertex_position(vec3 position, vec4 quat)\n    { \n        return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n    }\n\n    /** Another workaround for Apple's stupid compiler */\n    vec4 safeMul(vec4 a, vec4 b) {\n        // Prevents constant folding and optimization\n        return (a + vec4(0.0)) * (b + vec4(1.0)) - a * vec4(1.0);\n    }\n\n    highp vec3 rotate_scaled_vertex_position_delta(highp vec4 v0, highp vec4 v1, highp vec4 scale, highp vec4 quat)\n    {\n        /** !!! WORKAROUND FOR Intel IrisXe CARDS !!! */\n        /** The code below will not produce correct results in intel IrisXE integrated GPUs. \n         *  The geometry will turn mangled, albeit stable\n         *  I can't know for sure what is going on, but rotating the difference seems to \n         *  force the result into a lower precision?\n         */\n        // highp vec4 position = v0 - v1;\n        // return position.xyz + 2.0 * cross(quat.xyz, cross(quat.xyz, position.xyz) + quat.w * position.xyz);\n\n        /** Subtracting the rotated vectors works. */\n        return rotate_vertex_position(safeMul(v0, scale).xyz, quat)  - rotate_vertex_position(safeMul(v1, scale).xyz, quat) ;\n\n        /** An alternate workaround is\n         * highp vec3 position = (v0.xyz * (1. + 1e-7)) - (v1.xyz * (1. + 1e-7));\n           return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n\n           However I'm not such a fan of the (1. + 1e-7) part\n         */\n    }\n\n#endif\n\n#if defined(BILLBOARD) || defined(BILLBOARD_FIXED)\n    uniform vec3 billboardPos;\n    uniform mat4 invProjection;\n#endif\n#ifdef BILLBOARD_FIXED\n    uniform vec2 billboardSize;\n    uniform vec2 billboardOffset;\n#endif\n\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinbase_vertex>\n\t\t#include <skinnormal_vertex>\n\t\t#include <defaultnormal_vertex>\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t// #include <project_vertex> COMMENTED CHUNK\n    #ifdef TRANSFORM_STORAGE\n        vec4 tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale;\n        objectTransform(tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale);\n    #endif\n    #ifdef USE_RTE\n        vec4 position_lowT = vec4(position_low, 1.);\n        vec4 position_highT = vec4(position, 1.);\n        const vec3 ZERO3 = vec3(0., 0., 0.);\n\n        highp vec4 rteLocalPosition = computeRelativePosition(position_lowT.xyz, position_highT.xyz, uViewer_low, uViewer_high);\n        #ifdef TRANSFORM_STORAGE\n            highp vec4 rtePivot = computeRelativePosition(tPivotLow.xyz, tPivotHigh.xyz, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = rotate_scaled_vertex_position_delta(rteLocalPosition, rtePivot, tScale, tQuaternion) + rtePivot.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            vec4 instancePivot = computeRelativePosition(ZERO3, ZERO3, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = (mat3(instanceMatrix) * (rteLocalPosition - instancePivot).xyz) + instancePivot.xyz + instanceMatrix[3].xyz;\n        #endif\n    #endif\n\n    #ifdef USE_RTE\n        vec4 mvPosition = rteLocalPosition;\n    #else\n        vec4 mvPosition = vec4( transformed, 1.0 );\n        #ifdef TRANSFORM_STORAGE\n            mvPosition.xyz = rotate_scaled_vertex_position_delta(mvPosition, tPivotHigh, tScale, tQuaternion) + tPivotHigh.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            mvPosition = instanceMatrix * mvPosition;\n        #endif\n    #endif\n    \n    mvPosition = modelViewMatrix * mvPosition;\n    \n    #if defined(BILLBOARD)\n        float div = 1.;\n        gl_Position = projectionMatrix * (viewMatrix * vec4(billboardPos, 1.0) + vec4(position.x, position.y, 0., 0.0));\n    #elif defined(BILLBOARD_FIXED)\n        gl_Position = projectionMatrix * (viewMatrix * vec4(billboardPos, 1.0));\n        float div = gl_Position.w;\n        gl_Position /= gl_Position.w;\n        gl_Position.xy += (position.xy + billboardOffset) * billboardSize;\n    #else\n        gl_Position = projectionMatrix * mvPosition;\n    #endif\n\n\n\t#include <logdepthbuf_vertex>\n\t// #include <clipping_planes_vertex> COMMENTED CHUNK\n    #if NUM_CLIPPING_PLANES > 0\n        #if defined(BILLBOARD) || defined(BILLBOARD_FIXED)\n            vec4 movelViewProjection = gl_Position * div;\n            vClipPosition = - (invProjection * movelViewProjection).xyz;\n        #else\n\t        vClipPosition = - mvPosition.xyz;\n        #endif\n    #endif\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}\n";
+export declare const synchronizedBasicVert = "\n#include <common>\n#ifdef USE_RTE\n    // The high component is stored as the default 'position' attribute buffer\n    attribute vec3 position_low;\n    uniform vec3 uViewer_high;\n    uniform vec3 uViewer_low;\n#endif\n\n#ifdef TRANSFORM_STORAGE\n    attribute float objIndex;\n\n    #if TRANSFORM_STORAGE == 0\n        #if __VERSION__ == 300\n            #define TRANSFORM_STRIDE 4\n        #else\n            #define TRANSFORM_STRIDE 4.\n        #endif\n        uniform sampler2D tTransforms;\n        uniform float objCount;\n    #elif TRANSFORM_STORAGE == 1\n        uniform mat4 uTransforms[OBJ_COUNT];\n    #endif\n#endif\n\n#include <uv_pars_vertex>\n#include <uv2_pars_vertex>\n#include <envmap_pars_vertex>\n#include <color_pars_vertex>\n#include <fog_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n\n#ifdef USE_RTE\n    highp vec4 computeRelativePosition(in highp vec3 position_low, in highp vec3 position_high, in highp vec3 relativeTo_low, in highp vec3 relativeTo_high){\n        /* \n        Source https://github.com/virtualglobebook/OpenGlobe/blob/master/Source/Examples/Chapter05/Jitter/GPURelativeToEyeDSFUN90/Shaders/VS.glsl \n        Note here, we're storing the high part of the position encoding inside three's default 'position' attribute buffer so we avoid redundancy \n        */\n        highp vec3 t1 = position_low.xyz - relativeTo_low.xyz;\n        highp vec3 e = t1 - position_low.xyz;\n        /** This is redunant, but necessary as a workaround for Apple platforms */\n        highp float x = position_high.x - relativeTo_high.x;\n        highp float y = position_high.y - relativeTo_high.y;\n        highp float z = position_high.z - relativeTo_high.z;\n        highp vec3 v = vec3(x, y, z);\n        /** End of redundant part */\n        highp vec3 t2 = ((-relativeTo_low - e) + (position_low.xyz - (t1 - e))) + v;\n        highp vec3 highDifference = t1 + t2;\n        highp vec3 lowDifference = t2 - (highDifference.xyz - t1.xyz);\n        \n        highp vec3 position = highDifference.xyz + lowDifference.xyz;\n        return vec4(position, 1.);\n    }   \n#endif\n\n#ifdef TRANSFORM_STORAGE\n    void objectTransform(out vec4 quaternion, out vec4 pivotLow, out vec4 pivotHigh, out vec4 translation, out vec4 scale){\n        #if TRANSFORM_STORAGE == 0\n            #if __VERSION__ == 300\n                ivec2 uv = ivec2(int(objIndex) * TRANSFORM_STRIDE, 0); \n                vec4 v0 = texelFetch( tTransforms, uv, 0 );\n                vec4 v1 = texelFetch( tTransforms, uv + ivec2(1, 0), 0);\n                vec4 v2 = texelFetch( tTransforms, uv + ivec2(2, 0), 0);\n                vec4 v3 = texelFetch( tTransforms, uv + ivec2(3, 0), 0);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #else\n                float size = objCount * TRANSFORM_STRIDE;\n                vec2 cUv = vec2(0.5/size, 0.5);\n                vec2 dUv = vec2(1./size, 0.);\n                \n                vec2 uv = vec2((objIndex * TRANSFORM_STRIDE)/size + cUv.x, cUv.y);\n                vec4 v0 = texture2D( tTransforms, uv);\n                vec4 v1 = texture2D( tTransforms, uv + dUv);\n                vec4 v2 = texture2D( tTransforms, uv + 2. * dUv);\n                vec4 v3 = texture2D( tTransforms, uv + 3. * dUv);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #endif\n        #elif TRANSFORM_STORAGE == 1\n            mat4 tMatrix = uTransforms[int(objIndex)];\n            quaternion = tMatrix[0];\n            pivotLow = vec4(tMatrix[1].xyz, 1.);\n            pivotHigh = vec4(tMatrix[2].xyz, 1.);\n            translation = vec4(tMatrix[3].xyz, 1.);\n            scale = vec4(tMatrix[1][3], tMatrix[2][3], tMatrix[3][3], 1.);\n        #endif\n    }\n\n    vec3 rotate_vertex_position(vec3 position, vec4 quat)\n    { \n        return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n    }\n\n    /** Another workaround for Apple's stupid compiler */\n    vec4 safeMul(vec4 a, vec4 b) {\n        // Prevents constant folding and optimization\n        return (a + vec4(0.0)) * (b + vec4(1.0)) - a * vec4(1.0);\n    }\n\n    highp vec3 rotate_scaled_vertex_position_delta(highp vec4 v0, highp vec4 v1, highp vec4 scale, highp vec4 quat)\n    {\n        /** !!! WORKAROUND FOR Intel IrisXe CARDS !!! */\n        /** The code below will not produce correct results in intel IrisXE integrated GPUs. \n         *  The geometry will turn mangled, albeit stable\n         *  I can't know for sure what is going on, but rotating the difference seems to \n         *  force the result into a lower precision?\n         */\n        // highp vec4 position = v0 - v1;\n        // return position.xyz + 2.0 * cross(quat.xyz, cross(quat.xyz, position.xyz) + quat.w * position.xyz);\n\n        /** Subtracting the rotated vectors works. */\n        return rotate_vertex_position(safeMul(v0, scale).xyz, quat)  - rotate_vertex_position(safeMul(v1, scale).xyz, quat) ;\n\n        /** An alternate workaround is\n         * highp vec3 position = (v0.xyz * (1. + 1e-7)) - (v1.xyz * (1. + 1e-7));\n           return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n\n           However I'm not such a fan of the (1. + 1e-7) part\n         */\n    }\n\n#endif\n\n#if defined(BILLBOARD) || defined(BILLBOARD_SCREEN)\n    uniform mat4 invProjection;\n#endif\n\n#ifdef BILLBOARD_SCREEN\n    uniform vec4 billboardPixelOffsetSize;\n#endif\n\nvoid main() {\n\t#include <uv_vertex>\n\t#include <uv2_vertex>\n\t#include <color_vertex>\n\t#include <morphcolor_vertex>\n\t#if defined ( USE_ENVMAP ) || defined ( USE_SKINNING )\n\t\t#include <beginnormal_vertex>\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinbase_vertex>\n\t\t#include <skinnormal_vertex>\n        // #include <defaultnormal_vertex> // COMMENTED CHUNK\n        vec3 transformedNormal = objectNormal;\n        #ifdef USE_INSTANCING\n\n            // this is in lieu of a per-instance normal-matrix\n            // shear transforms in the instance matrix are not supported\n            mat3 m = mat3( instanceMatrix );\n            transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n            transformedNormal = m * transformedNormal;\n            \n            /* If we have negative scaling, we flip the normal */\n            float signDet = sign(dot(m[0], cross(m[1], m[2])));\n            // Optional fallback: treat 0 as +1\n            signDet = signDet + (1.0 - abs(signDet));\n            transformedNormal *= signDet;\n        #endif\n        transformedNormal = normalMatrix * transformedNormal;\n        #ifdef FLIP_SIDED\n            transformedNormal = - transformedNormal;\n        #endif\n        #ifdef USE_TANGENT\n            vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n            #ifdef FLIP_SIDED\n                transformedTangent = - transformedTangent;\n            #endif\n        #endif\n\t#endif\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t// #include <project_vertex> COMMENTED CHUNK\n    #ifdef TRANSFORM_STORAGE\n        vec4 tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale;\n        objectTransform(tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale);\n    #endif\n    #ifdef USE_RTE\n        vec4 position_lowT = vec4(position_low, 1.);\n        vec4 position_highT = vec4(position, 1.);\n        const vec3 ZERO3 = vec3(0., 0., 0.);\n\n        highp vec4 rteLocalPosition = computeRelativePosition(position_lowT.xyz, position_highT.xyz, uViewer_low, uViewer_high);\n        #ifdef TRANSFORM_STORAGE\n            highp vec4 rtePivot = computeRelativePosition(tPivotLow.xyz, tPivotHigh.xyz, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = rotate_scaled_vertex_position_delta(rteLocalPosition, rtePivot, tScale, tQuaternion) + rtePivot.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            vec4 instancePivot = computeRelativePosition(ZERO3, ZERO3, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = (mat3(instanceMatrix) * (rteLocalPosition - instancePivot).xyz) + instancePivot.xyz + instanceMatrix[3].xyz;\n        #endif\n    #endif\n\n    #ifdef USE_RTE\n        vec4 mvPosition = rteLocalPosition;\n    #else\n        vec4 mvPosition = vec4( transformed, 1.0 );\n        #ifdef TRANSFORM_STORAGE\n            mvPosition.xyz = rotate_scaled_vertex_position_delta(mvPosition, tPivotHigh, tScale, tQuaternion) + tPivotHigh.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            mvPosition = instanceMatrix * mvPosition;\n        #endif\n    #endif\n    \n    mvPosition = modelViewMatrix * mvPosition;\n    \n    #if defined(BILLBOARD)\n        float div = 1.;\n        gl_Position = projectionMatrix * (viewMatrix * vec4(modelMatrix[3].xyz, 1.0) + vec4(position.x, position.y, 0., 0.0));\n    #elif defined(BILLBOARD_SCREEN)\n        gl_Position = projectionMatrix * (viewMatrix * vec4(modelMatrix[3].xyz, 1.0));\n        float div = gl_Position.w;\n        gl_Position /= gl_Position.w;\n        gl_Position.xy += position.xy * billboardPixelOffsetSize.zw * 2. + billboardPixelOffsetSize.xy * 2.;\n    #else\n        gl_Position = projectionMatrix * mvPosition;\n    #endif\n\n\n\t#include <logdepthbuf_vertex>\n\t// #include <clipping_planes_vertex> COMMENTED CHUNK\n    #if NUM_CLIPPING_PLANES > 0\n        #if defined(BILLBOARD) || defined(BILLBOARD_SCREEN)\n            vec4 movelViewProjection = gl_Position * div;\n            vClipPosition = - (invProjection * movelViewProjection).xyz;\n        #else\n\t        vClipPosition = - mvPosition.xyz;\n        #endif\n    #endif\n\t#include <worldpos_vertex>\n\t#include <envmap_vertex>\n\t#include <fog_vertex>\n}\n";

package/dist/modules/materials/shaders/synchronized-depth-normal-id-vert.d.ts

@@ -1 +1 @@
-export declare const synchronizedDepthNormalIdVert = "\n#include <common>\n#ifdef USE_RTE\n    // The high component is stored as the default 'position' attribute buffer\n    attribute vec3 position_low;\n    uniform vec3 uViewer_high;\n    uniform vec3 uViewer_low;\n    uniform mat4 rteModelViewMatrix;\n#endif\n\n#if defined( TRANSFORM_STORAGE ) || ( defined( USE_INSTANCING ) && __VERSION__ == 100)\n    attribute float objIndex;\n#endif\n\n#ifdef TRANSFORM_STORAGE\n    #if TRANSFORM_STORAGE == 0\n        #if __VERSION__ == 300\n            #define TRANSFORM_STRIDE 4\n        #else\n            #define TRANSFORM_STRIDE 4.\n        #endif\n        uniform sampler2D tTransforms;\n        uniform float objCount;\n    #elif TRANSFORM_STORAGE == 1\n        uniform mat4 uTransforms[OBJ_COUNT];\n    #endif\n#endif\n\nvarying vec3 vIdColor;\nuniform int batchIndex;\n\n#ifdef LINEAR_DEPTH\n    varying vec4 vViewPosition;\n#endif\nvarying vec3 vNormal;\n\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n// This is used for computing an equivalent of gl_FragCoord.z that is as high precision as possible.\n// Some platforms compute gl_FragCoord at a lower precision which makes the manually computed value better for\n// depth-based postprocessing effects. Reproduced on iPad with A10 processor / iPadOS 13.3.1.\nvarying vec2 vHighPrecisionZW;\n\n#ifdef TRANSFORM_STORAGE\n    void objectTransform(out vec4 quaternion, out vec4 pivotLow, out vec4 pivotHigh, out vec4 translation, out vec4 scale){\n        #if TRANSFORM_STORAGE == 0\n            #if __VERSION__ == 300\n                ivec2 uv = ivec2(int(objIndex) * TRANSFORM_STRIDE, 0); \n                vec4 v0 = texelFetch( tTransforms, uv, 0 );\n                vec4 v1 = texelFetch( tTransforms, uv + ivec2(1, 0), 0);\n                vec4 v2 = texelFetch( tTransforms, uv + ivec2(2, 0), 0);\n                vec4 v3 = texelFetch( tTransforms, uv + ivec2(3, 0), 0);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #else\n                float size = objCount * TRANSFORM_STRIDE;\n                vec2 cUv = vec2(0.5/size, 0.5);\n                vec2 dUv = vec2(1./size, 0.);\n                \n                vec2 uv = vec2((objIndex * TRANSFORM_STRIDE)/size + cUv.x, cUv.y);\n                vec4 v0 = texture2D( tTransforms, uv);\n                vec4 v1 = texture2D( tTransforms, uv + dUv);\n                vec4 v2 = texture2D( tTransforms, uv + 2. * dUv);\n                vec4 v3 = texture2D( tTransforms, uv + 3. * dUv);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #endif\n        #elif TRANSFORM_STORAGE == 1\n            mat4 tMatrix = uTransforms[int(objIndex)];\n            quaternion = tMatrix[0];\n            pivotLow = vec4(tMatrix[1].xyz, 1.);\n            pivotHigh = vec4(tMatrix[2].xyz, 1.);\n            translation = vec4(tMatrix[3].xyz, 1.);\n            scale = vec4(tMatrix[1][3], tMatrix[2][3], tMatrix[3][3], 1.);\n        #endif\n    }\n\n    vec3 rotate_vertex_position(vec3 position, vec4 quat)\n    { \n        return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n    }\n\n    /** Another workaround for Apple's stupid compiler */\n    vec4 safeMul(vec4 a, vec4 b) {\n        // Prevents constant folding and optimization\n        return (a + vec4(0.0)) * (b + vec4(1.0)) - a * vec4(1.0);\n    }\n\n    highp vec3 rotate_scaled_vertex_position_delta(highp vec4 v0, highp vec4 v1, highp vec4 scale, highp vec4 quat)\n    {\n        /** !!! WORKAROUND FOR Intel IrisXe CARDS !!! */\n        /** The code below will not produce correct results in intel IrisXE integrated GPUs. \n         *  The geometry will turn mangled, albeit stable\n         *  I can't know for sure what is going on, but rotating the difference seems to \n         *  force the result into a lower precision?\n         */\n        // highp vec4 position = v0 - v1;\n        // return position.xyz + 2.0 * cross(quat.xyz, cross(quat.xyz, position.xyz) + quat.w * position.xyz);\n\n        /** Subtracting the rotated vectors works. */\n        return rotate_vertex_position(safeMul(v0, scale).xyz, quat)  - rotate_vertex_position(safeMul(v1, scale).xyz, quat) ;\n\n        /** An alternate workaround is\n         * highp vec3 position = (v0.xyz * (1. + 1e-7)) - (v1.xyz * (1. + 1e-7));\n           return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n\n           However I'm not such a fan of the (1. + 1e-7) part\n         */\n    }\n#endif\n\n#ifdef USE_RTE\n    highp vec4 computeRelativePosition(in highp vec3 position_low, in highp vec3 position_high, in highp vec3 relativeTo_low, in highp vec3 relativeTo_high){\n        /* \n        Source https://github.com/virtualglobebook/OpenGlobe/blob/master/Source/Examples/Chapter05/Jitter/GPURelativeToEyeDSFUN90/Shaders/VS.glsl \n        Note here, we're storing the high part of the position encoding inside three's default 'position' attribute buffer so we avoid redundancy \n        */\n        highp vec3 t1 = position_low.xyz - relativeTo_low.xyz;\n        highp vec3 e = t1 - position_low.xyz;\n        /** This is redunant, but necessary as a workaround for Apple platforms */\n        highp float x = position_high.x - relativeTo_high.x;\n        highp float y = position_high.y - relativeTo_high.y;\n        highp float z = position_high.z - relativeTo_high.z;\n        highp vec3 v = vec3(x, y, z);\n        /** End of redundant part */\n        highp vec3 t2 = ((-relativeTo_low - e) + (position_low.xyz - (t1 - e))) + v;\n        highp vec3 highDifference = t1 + t2;\n        highp vec3 lowDifference = t2 - (highDifference.xyz - t1.xyz);\n        \n        highp vec3 position = highDifference.xyz + lowDifference.xyz;\n        return vec4(position, 1.);\n    }\n#endif\n\n\n/** Original glsl100 and glsl300 hash functions. Good outputs but maybe a bit slow? */\n/*\n#if __VERSION__ == 300\n    vec3 hashColor(uint id) {\n        // A simple integer hash function\n        id = (id ^ 61u) ^ (id >> 16u);\n        id = id * 9u;\n        id = id ^ (id >> 4u);\n        id = id * 0x27d4eb2du;\n        id = id ^ (id >> 15u);\n\n        return vec3(\n            float((id >> 16u) & 0xFFu) / 255.0,\n            float((id >> 8u) & 0xFFu) / 255.0,\n            float(id & 0xFFu) / 255.0\n        );\n    }\n#elif __VERSION__ == 100\n    vec3 hashColor(float id) {\n        // Step 1: Simulate XOR by using mod and floating-point arithmetic\n        id = mod(id + 61.0, 4294967296.0);\n        id = mod(id - floor(id / 65536.0), 4294967296.0); // Approximate id ^ (id >> 16)\n        // Step 2: Multiply by 9 (same as original)\n        id = mod(id * 9.0, 4294967296.0);\n        // Step 3: Simulate XOR with division/mod trick\n        id = mod(id - floor(id / 16.0), 4294967296.0); // Approximate id ^ (id >> 4)\n        // Step 4: Multiply by large prime\n        id = mod(id * 666083407.0, 4294967296.0); // Approximate * 0x27d4eb2dU\n        // Step 5: Simulate final XOR\n        id = mod(id - floor(id / 32768.0), 4294967296.0); // Approximate id ^ (id >> 15)\n        // Convert hash to RGB by extracting \"fake\" bit shifts\n        return vec3(\n            mod(floor(id / 65536.0), 256.0) / 255.0, // Simulates (id >> 16) & 0xFF\n            mod(floor(id / 256.0), 256.0) / 255.0,   // Simulates (id >> 8) & 0xFF\n            mod(id, 256.0) / 255.0                   // Simulates id & 0xFF\n        );\n    }\n#endif\n*/\n\n/** Simpler hash function works on both glsl versions */\nhighp vec3 hashColor(float id) {\n    // Large prime multipliers\n    highp float r = mod(id * 127.1, 256.0) / 255.0;\n    highp float g = mod(id * 987.654, 256.0) / 255.0;\n    highp float b = mod(id * 4321.123, 256.0) / 255.0;\n    \n    return vec3(r, g, b);\n}\n\nint szudzikHash(int x, int y) {\n    return (x >= y) ? (x * x + x + y) : (y * y + x);\n}\n\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n    #include <beginnormal_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n    #include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t//#include <project_vertex> // EDITED CHUNK\n    #ifdef TRANSFORM_STORAGE\n        vec4 tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale;\n        objectTransform(tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale);\n    #endif\n    #ifdef USE_RTE\n        vec4 position_lowT = vec4(position_low, 1.);\n        vec4 position_highT = vec4(position, 1.);\n        const vec3 ZERO3 = vec3(0., 0., 0.);\n\n        highp vec4 rteLocalPosition = computeRelativePosition(position_lowT.xyz, position_highT.xyz, uViewer_low, uViewer_high);\n        #ifdef TRANSFORM_STORAGE\n            highp vec4 rtePivot = computeRelativePosition(tPivotLow.xyz, tPivotHigh.xyz, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = rotate_scaled_vertex_position_delta(rteLocalPosition, rtePivot, tScale, tQuaternion) + rtePivot.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            vec4 instancePivot = computeRelativePosition(ZERO3, ZERO3, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = (mat3(instanceMatrix) * (rteLocalPosition - instancePivot).xyz) + instancePivot.xyz + instanceMatrix[3].xyz;\n        #endif\n    #endif\n\n    #ifdef USE_RTE\n        vec4 mvPosition = rteLocalPosition;\n    #else\n        vec4 mvPosition = vec4( transformed, 1.0 );\n        #ifdef TRANSFORM_STORAGE\n            mvPosition.xyz = rotate_scaled_vertex_position_delta(mvPosition, tPivotHigh, tScale, tQuaternion) + tPivotHigh.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            mvPosition = instanceMatrix * mvPosition;\n        #endif\n    #endif\n   \n    #ifdef USE_RTE\n        mvPosition = rteModelViewMatrix * mvPosition;\n    #else\n        mvPosition = modelViewMatrix * mvPosition;\n    #endif\n    \n    #ifdef LINEAR_DEPTH\n        vViewPosition = mvPosition;\n    #endif \n\n    vNormal = normalize( transformedNormal );\n    \n    #ifdef TRANSFORM_STORAGE\n        vIdColor = hashColor(float(szudzikHash(int(objIndex), batchIndex)));\n    #else\n        #if defined( USE_INSTANCING ) \n            #if __VERSION__ == 300\n                vIdColor = hashColor(float(szudzikHash(int(gl_InstanceID), batchIndex)));\n            #elif __VERSION__ == 100\n                vIdColor = hashColor(float(szudzikHash(int(objIndex), batchIndex)));\n            #endif\n        #else\n            vIdColor = vec3(0.);\n        #endif\n    #endif\n\n\n    gl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t// #include <clipping_planes_vertex>\n    #if NUM_CLIPPING_PLANES > 0\n\t    vClipPosition = - mvPosition.xyz;\n    #endif\n\tvHighPrecisionZW = gl_Position.zw;\n}\n";
+export declare const synchronizedDepthNormalIdVert = "\n#include <common>\n#ifdef USE_RTE\n    // The high component is stored as the default 'position' attribute buffer\n    attribute vec3 position_low;\n    uniform vec3 uViewer_high;\n    uniform vec3 uViewer_low;\n    uniform mat4 rteModelViewMatrix;\n#endif\n\n#if defined( TRANSFORM_STORAGE ) || ( defined( USE_INSTANCING ) && __VERSION__ == 100)\n    attribute float objIndex;\n#endif\n\n#ifdef TRANSFORM_STORAGE\n    #if TRANSFORM_STORAGE == 0\n        #if __VERSION__ == 300\n            #define TRANSFORM_STRIDE 4\n        #else\n            #define TRANSFORM_STRIDE 4.\n        #endif\n        uniform sampler2D tTransforms;\n        uniform float objCount;\n    #elif TRANSFORM_STORAGE == 1\n        uniform mat4 uTransforms[OBJ_COUNT];\n    #endif\n#endif\n\nvarying vec3 vIdColor;\nuniform int batchIndex;\n\n#ifdef LINEAR_DEPTH\n    varying vec4 vViewPosition;\n#endif\nvarying vec3 vNormal;\n\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n// This is used for computing an equivalent of gl_FragCoord.z that is as high precision as possible.\n// Some platforms compute gl_FragCoord at a lower precision which makes the manually computed value better for\n// depth-based postprocessing effects. Reproduced on iPad with A10 processor / iPadOS 13.3.1.\nvarying vec2 vHighPrecisionZW;\n\n#ifdef TRANSFORM_STORAGE\n    void objectTransform(out vec4 quaternion, out vec4 pivotLow, out vec4 pivotHigh, out vec4 translation, out vec4 scale){\n        #if TRANSFORM_STORAGE == 0\n            #if __VERSION__ == 300\n                ivec2 uv = ivec2(int(objIndex) * TRANSFORM_STRIDE, 0); \n                vec4 v0 = texelFetch( tTransforms, uv, 0 );\n                vec4 v1 = texelFetch( tTransforms, uv + ivec2(1, 0), 0);\n                vec4 v2 = texelFetch( tTransforms, uv + ivec2(2, 0), 0);\n                vec4 v3 = texelFetch( tTransforms, uv + ivec2(3, 0), 0);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #else\n                float size = objCount * TRANSFORM_STRIDE;\n                vec2 cUv = vec2(0.5/size, 0.5);\n                vec2 dUv = vec2(1./size, 0.);\n                \n                vec2 uv = vec2((objIndex * TRANSFORM_STRIDE)/size + cUv.x, cUv.y);\n                vec4 v0 = texture2D( tTransforms, uv);\n                vec4 v1 = texture2D( tTransforms, uv + dUv);\n                vec4 v2 = texture2D( tTransforms, uv + 2. * dUv);\n                vec4 v3 = texture2D( tTransforms, uv + 3. * dUv);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #endif\n        #elif TRANSFORM_STORAGE == 1\n            mat4 tMatrix = uTransforms[int(objIndex)];\n            quaternion = tMatrix[0];\n            pivotLow = vec4(tMatrix[1].xyz, 1.);\n            pivotHigh = vec4(tMatrix[2].xyz, 1.);\n            translation = vec4(tMatrix[3].xyz, 1.);\n            scale = vec4(tMatrix[1][3], tMatrix[2][3], tMatrix[3][3], 1.);\n        #endif\n    }\n\n    vec3 rotate_vertex_position(vec3 position, vec4 quat)\n    { \n        return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n    }\n\n    /** Another workaround for Apple's stupid compiler */\n    vec4 safeMul(vec4 a, vec4 b) {\n        // Prevents constant folding and optimization\n        return (a + vec4(0.0)) * (b + vec4(1.0)) - a * vec4(1.0);\n    }\n\n    highp vec3 rotate_scaled_vertex_position_delta(highp vec4 v0, highp vec4 v1, highp vec4 scale, highp vec4 quat)\n    {\n        /** !!! WORKAROUND FOR Intel IrisXe CARDS !!! */\n        /** The code below will not produce correct results in intel IrisXE integrated GPUs. \n         *  The geometry will turn mangled, albeit stable\n         *  I can't know for sure what is going on, but rotating the difference seems to \n         *  force the result into a lower precision?\n         */\n        // highp vec4 position = v0 - v1;\n        // return position.xyz + 2.0 * cross(quat.xyz, cross(quat.xyz, position.xyz) + quat.w * position.xyz);\n\n        /** Subtracting the rotated vectors works. */\n        return rotate_vertex_position(safeMul(v0, scale).xyz, quat)  - rotate_vertex_position(safeMul(v1, scale).xyz, quat) ;\n\n        /** An alternate workaround is\n         * highp vec3 position = (v0.xyz * (1. + 1e-7)) - (v1.xyz * (1. + 1e-7));\n           return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n\n           However I'm not such a fan of the (1. + 1e-7) part\n         */\n    }\n#endif\n\n#ifdef USE_RTE\n    highp vec4 computeRelativePosition(in highp vec3 position_low, in highp vec3 position_high, in highp vec3 relativeTo_low, in highp vec3 relativeTo_high){\n        /* \n        Source https://github.com/virtualglobebook/OpenGlobe/blob/master/Source/Examples/Chapter05/Jitter/GPURelativeToEyeDSFUN90/Shaders/VS.glsl \n        Note here, we're storing the high part of the position encoding inside three's default 'position' attribute buffer so we avoid redundancy \n        */\n        highp vec3 t1 = position_low.xyz - relativeTo_low.xyz;\n        highp vec3 e = t1 - position_low.xyz;\n        /** This is redunant, but necessary as a workaround for Apple platforms */\n        highp float x = position_high.x - relativeTo_high.x;\n        highp float y = position_high.y - relativeTo_high.y;\n        highp float z = position_high.z - relativeTo_high.z;\n        highp vec3 v = vec3(x, y, z);\n        /** End of redundant part */\n        highp vec3 t2 = ((-relativeTo_low - e) + (position_low.xyz - (t1 - e))) + v;\n        highp vec3 highDifference = t1 + t2;\n        highp vec3 lowDifference = t2 - (highDifference.xyz - t1.xyz);\n        \n        highp vec3 position = highDifference.xyz + lowDifference.xyz;\n        return vec4(position, 1.);\n    }\n#endif\n\n\n/** Original glsl100 and glsl300 hash functions. Good outputs but maybe a bit slow? */\n/*\n#if __VERSION__ == 300\n    vec3 hashColor(uint id) {\n        // A simple integer hash function\n        id = (id ^ 61u) ^ (id >> 16u);\n        id = id * 9u;\n        id = id ^ (id >> 4u);\n        id = id * 0x27d4eb2du;\n        id = id ^ (id >> 15u);\n\n        return vec3(\n            float((id >> 16u) & 0xFFu) / 255.0,\n            float((id >> 8u) & 0xFFu) / 255.0,\n            float(id & 0xFFu) / 255.0\n        );\n    }\n#elif __VERSION__ == 100\n    vec3 hashColor(float id) {\n        // Step 1: Simulate XOR by using mod and floating-point arithmetic\n        id = mod(id + 61.0, 4294967296.0);\n        id = mod(id - floor(id / 65536.0), 4294967296.0); // Approximate id ^ (id >> 16)\n        // Step 2: Multiply by 9 (same as original)\n        id = mod(id * 9.0, 4294967296.0);\n        // Step 3: Simulate XOR with division/mod trick\n        id = mod(id - floor(id / 16.0), 4294967296.0); // Approximate id ^ (id >> 4)\n        // Step 4: Multiply by large prime\n        id = mod(id * 666083407.0, 4294967296.0); // Approximate * 0x27d4eb2dU\n        // Step 5: Simulate final XOR\n        id = mod(id - floor(id / 32768.0), 4294967296.0); // Approximate id ^ (id >> 15)\n        // Convert hash to RGB by extracting \"fake\" bit shifts\n        return vec3(\n            mod(floor(id / 65536.0), 256.0) / 255.0, // Simulates (id >> 16) & 0xFF\n            mod(floor(id / 256.0), 256.0) / 255.0,   // Simulates (id >> 8) & 0xFF\n            mod(id, 256.0) / 255.0                   // Simulates id & 0xFF\n        );\n    }\n#endif\n*/\n\n/** Simpler hash function works on both glsl versions */\nhighp vec3 hashColor(float id) {\n    // Large prime multipliers\n    highp float r = mod(id * 127.1, 256.0) / 255.0;\n    highp float g = mod(id * 987.654, 256.0) / 255.0;\n    highp float b = mod(id * 4321.123, 256.0) / 255.0;\n    \n    return vec3(r, g, b);\n}\n\nint szudzikHash(int x, int y) {\n    return (x >= y) ? (x * x + x + y) : (y * y + x);\n}\n\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n    #include <beginnormal_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n    // #include <defaultnormal_vertex> // COMMENTED CHUNK\n    vec3 transformedNormal = objectNormal;\n    #ifdef USE_INSTANCING\n\n        // this is in lieu of a per-instance normal-matrix\n        // shear transforms in the instance matrix are not supported\n        mat3 m = mat3( instanceMatrix );\n        transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n        transformedNormal = m * transformedNormal;\n        \n        /* If we have negative scaling, we flip the normal */\n        float signDet = sign(dot(m[0], cross(m[1], m[2])));\n        // Optional fallback: treat 0 as +1\n        signDet = signDet + (1.0 - abs(signDet));\n        transformedNormal *= signDet;\n    #endif\n    transformedNormal = normalMatrix * transformedNormal;\n    #ifdef FLIP_SIDED\n        transformedNormal = - transformedNormal;\n    #endif\n    #ifdef USE_TANGENT\n        vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n        #ifdef FLIP_SIDED\n            transformedTangent = - transformedTangent;\n        #endif\n    #endif\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t//#include <project_vertex> // EDITED CHUNK\n    #ifdef TRANSFORM_STORAGE\n        vec4 tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale;\n        objectTransform(tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale);\n    #endif\n    #ifdef USE_RTE\n        vec4 position_lowT = vec4(position_low, 1.);\n        vec4 position_highT = vec4(position, 1.);\n        const vec3 ZERO3 = vec3(0., 0., 0.);\n\n        highp vec4 rteLocalPosition = computeRelativePosition(position_lowT.xyz, position_highT.xyz, uViewer_low, uViewer_high);\n        #ifdef TRANSFORM_STORAGE\n            highp vec4 rtePivot = computeRelativePosition(tPivotLow.xyz, tPivotHigh.xyz, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = rotate_scaled_vertex_position_delta(rteLocalPosition, rtePivot, tScale, tQuaternion) + rtePivot.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            vec4 instancePivot = computeRelativePosition(ZERO3, ZERO3, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = (mat3(instanceMatrix) * (rteLocalPosition - instancePivot).xyz) + instancePivot.xyz + instanceMatrix[3].xyz;\n        #endif\n    #endif\n\n    #ifdef USE_RTE\n        vec4 mvPosition = rteLocalPosition;\n    #else\n        vec4 mvPosition = vec4( transformed, 1.0 );\n        #ifdef TRANSFORM_STORAGE\n            mvPosition.xyz = rotate_scaled_vertex_position_delta(mvPosition, tPivotHigh, tScale, tQuaternion) + tPivotHigh.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            mvPosition = instanceMatrix * mvPosition;\n        #endif\n    #endif\n   \n    #ifdef USE_RTE\n        mvPosition = rteModelViewMatrix * mvPosition;\n    #else\n        mvPosition = modelViewMatrix * mvPosition;\n    #endif\n    \n    #ifdef LINEAR_DEPTH\n        vViewPosition = mvPosition;\n    #endif \n\n    vNormal = normalize( transformedNormal );\n    \n    #ifdef TRANSFORM_STORAGE\n        vIdColor = hashColor(float(szudzikHash(int(objIndex), batchIndex)));\n    #else\n        #if defined( USE_INSTANCING ) \n            #if __VERSION__ == 300\n                vIdColor = hashColor(float(szudzikHash(int(gl_InstanceID), batchIndex)));\n            #elif __VERSION__ == 100\n                vIdColor = hashColor(float(szudzikHash(int(objIndex), batchIndex)));\n            #endif\n        #else\n            vIdColor = vec3(0.);\n        #endif\n    #endif\n\n\n    gl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t// #include <clipping_planes_vertex>\n    #if NUM_CLIPPING_PLANES > 0\n\t    vClipPosition = - mvPosition.xyz;\n    #endif\n\tvHighPrecisionZW = gl_Position.zw;\n}\n";

package/dist/modules/materials/shaders/synchronized-depth-normal-vert.d.ts

@@ -1 +1 @@
-export declare const synchronizedDepthNormalVert = "\n#include <common>\n#ifdef USE_RTE\n    // The high component is stored as the default 'position' attribute buffer\n    attribute vec3 position_low;\n    uniform vec3 uViewer_high;\n    uniform vec3 uViewer_low;\n    uniform mat4 rteModelViewMatrix;\n#endif\n\n#ifdef TRANSFORM_STORAGE\n    attribute float objIndex;\n\n    #if TRANSFORM_STORAGE == 0\n        #if __VERSION__ == 300\n            #define TRANSFORM_STRIDE 4\n        #else\n            #define TRANSFORM_STRIDE 4.\n        #endif\n        uniform sampler2D tTransforms;\n        uniform float objCount;\n    #elif TRANSFORM_STORAGE == 1\n        uniform mat4 uTransforms[OBJ_COUNT];\n    #endif\n#endif\n\n#ifdef LINEAR_DEPTH\n    varying vec4 vViewPosition;\n#endif\nvarying vec3 vNormal;\n\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n// This is used for computing an equivalent of gl_FragCoord.z that is as high precision as possible.\n// Some platforms compute gl_FragCoord at a lower precision which makes the manually computed value better for\n// depth-based postprocessing effects. Reproduced on iPad with A10 processor / iPadOS 13.3.1.\nvarying vec2 vHighPrecisionZW;\n\n#ifdef TRANSFORM_STORAGE\n    void objectTransform(out vec4 quaternion, out vec4 pivotLow, out vec4 pivotHigh, out vec4 translation, out vec4 scale){\n        #if TRANSFORM_STORAGE == 0\n            #if __VERSION__ == 300\n                ivec2 uv = ivec2(int(objIndex) * TRANSFORM_STRIDE, 0); \n                vec4 v0 = texelFetch( tTransforms, uv, 0 );\n                vec4 v1 = texelFetch( tTransforms, uv + ivec2(1, 0), 0);\n                vec4 v2 = texelFetch( tTransforms, uv + ivec2(2, 0), 0);\n                vec4 v3 = texelFetch( tTransforms, uv + ivec2(3, 0), 0);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #else\n                float size = objCount * TRANSFORM_STRIDE;\n                vec2 cUv = vec2(0.5/size, 0.5);\n                vec2 dUv = vec2(1./size, 0.);\n                \n                vec2 uv = vec2((objIndex * TRANSFORM_STRIDE)/size + cUv.x, cUv.y);\n                vec4 v0 = texture2D( tTransforms, uv);\n                vec4 v1 = texture2D( tTransforms, uv + dUv);\n                vec4 v2 = texture2D( tTransforms, uv + 2. * dUv);\n                vec4 v3 = texture2D( tTransforms, uv + 3. * dUv);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #endif\n        #elif TRANSFORM_STORAGE == 1\n            mat4 tMatrix = uTransforms[int(objIndex)];\n            quaternion = tMatrix[0];\n            pivotLow = vec4(tMatrix[1].xyz, 1.);\n            pivotHigh = vec4(tMatrix[2].xyz, 1.);\n            translation = vec4(tMatrix[3].xyz, 1.);\n            scale = vec4(tMatrix[1][3], tMatrix[2][3], tMatrix[3][3], 1.);\n        #endif\n    }\n\n    vec3 rotate_vertex_position(vec3 position, vec4 quat)\n    { \n        return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n    }\n\n    /** Another workaround for Apple's stupid compiler */\n    vec4 safeMul(vec4 a, vec4 b) {\n        // Prevents constant folding and optimization\n        return (a + vec4(0.0)) * (b + vec4(1.0)) - a * vec4(1.0);\n    }\n\n    highp vec3 rotate_scaled_vertex_position_delta(highp vec4 v0, highp vec4 v1, highp vec4 scale, highp vec4 quat)\n    {\n        /** !!! WORKAROUND FOR Intel IrisXe CARDS !!! */\n        /** The code below will not produce correct results in intel IrisXE integrated GPUs. \n         *  The geometry will turn mangled, albeit stable\n         *  I can't know for sure what is going on, but rotating the difference seems to \n         *  force the result into a lower precision?\n         */\n        // highp vec4 position = v0 - v1;\n        // return position.xyz + 2.0 * cross(quat.xyz, cross(quat.xyz, position.xyz) + quat.w * position.xyz);\n\n        /** Subtracting the rotated vectors works. */\n        return rotate_vertex_position(safeMul(v0, scale).xyz, quat)  - rotate_vertex_position(safeMul(v1, scale).xyz, quat) ;\n\n        /** An alternate workaround is\n         * highp vec3 position = (v0.xyz * (1. + 1e-7)) - (v1.xyz * (1. + 1e-7));\n           return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n\n           However I'm not such a fan of the (1. + 1e-7) part\n         */\n    }\n#endif\n\n#ifdef USE_RTE\n    highp vec4 computeRelativePosition(in highp vec3 position_low, in highp vec3 position_high, in highp vec3 relativeTo_low, in highp vec3 relativeTo_high){\n        /* \n        Source https://github.com/virtualglobebook/OpenGlobe/blob/master/Source/Examples/Chapter05/Jitter/GPURelativeToEyeDSFUN90/Shaders/VS.glsl \n        Note here, we're storing the high part of the position encoding inside three's default 'position' attribute buffer so we avoid redundancy \n        */\n        highp vec3 t1 = position_low.xyz - relativeTo_low.xyz;\n        highp vec3 e = t1 - position_low.xyz;\n        /** This is redunant, but necessary as a workaround for Apple platforms */\n        highp float x = position_high.x - relativeTo_high.x;\n        highp float y = position_high.y - relativeTo_high.y;\n        highp float z = position_high.z - relativeTo_high.z;\n        highp vec3 v = vec3(x, y, z);\n        /** End of redundant part */\n        highp vec3 t2 = ((-relativeTo_low - e) + (position_low.xyz - (t1 - e))) + v;\n        highp vec3 highDifference = t1 + t2;\n        highp vec3 lowDifference = t2 - (highDifference.xyz - t1.xyz);\n        \n        highp vec3 position = highDifference.xyz + lowDifference.xyz;\n        return vec4(position, 1.);\n    }\n#endif\n\n\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n    #include <beginnormal_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n    #include <defaultnormal_vertex>\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t//#include <project_vertex> // EDITED CHUNK\n    #ifdef TRANSFORM_STORAGE\n        vec4 tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale;\n        objectTransform(tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale);\n    #endif\n    #ifdef USE_RTE\n        vec4 position_lowT = vec4(position_low, 1.);\n        vec4 position_highT = vec4(position, 1.);\n        const vec3 ZERO3 = vec3(0., 0., 0.);\n\n        highp vec4 rteLocalPosition = computeRelativePosition(position_lowT.xyz, position_highT.xyz, uViewer_low, uViewer_high);\n        #ifdef TRANSFORM_STORAGE\n            highp vec4 rtePivot = computeRelativePosition(tPivotLow.xyz, tPivotHigh.xyz, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = rotate_scaled_vertex_position_delta(rteLocalPosition, rtePivot, tScale, tQuaternion) + rtePivot.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            vec4 instancePivot = computeRelativePosition(ZERO3, ZERO3, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = (mat3(instanceMatrix) * (rteLocalPosition - instancePivot).xyz) + instancePivot.xyz + instanceMatrix[3].xyz;\n        #endif\n    #endif\n\n    #ifdef USE_RTE\n        vec4 mvPosition = rteLocalPosition;\n    #else\n        vec4 mvPosition = vec4( transformed, 1.0 );\n        #ifdef TRANSFORM_STORAGE\n            mvPosition.xyz = rotate_scaled_vertex_position_delta(mvPosition, tPivotHigh, tScale, tQuaternion) + tPivotHigh.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            mvPosition = instanceMatrix * mvPosition;\n        #endif\n    #endif\n   \n    #ifdef USE_RTE\n        mvPosition = rteModelViewMatrix * mvPosition;\n    #else\n        mvPosition = modelViewMatrix * mvPosition;\n    #endif\n    \n    #ifdef LINEAR_DEPTH\n        vViewPosition = mvPosition;\n    #endif \n    vNormal = normalize( transformedNormal );\n    gl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t// #include <clipping_planes_vertex>\n    #if NUM_CLIPPING_PLANES > 0\n\t    vClipPosition = - mvPosition.xyz;\n    #endif\n\tvHighPrecisionZW = gl_Position.zw;\n}\n";
+export declare const synchronizedDepthNormalVert = "\n#include <common>\n#ifdef USE_RTE\n    // The high component is stored as the default 'position' attribute buffer\n    attribute vec3 position_low;\n    uniform vec3 uViewer_high;\n    uniform vec3 uViewer_low;\n    uniform mat4 rteModelViewMatrix;\n#endif\n\n#ifdef TRANSFORM_STORAGE\n    attribute float objIndex;\n\n    #if TRANSFORM_STORAGE == 0\n        #if __VERSION__ == 300\n            #define TRANSFORM_STRIDE 4\n        #else\n            #define TRANSFORM_STRIDE 4.\n        #endif\n        uniform sampler2D tTransforms;\n        uniform float objCount;\n    #elif TRANSFORM_STORAGE == 1\n        uniform mat4 uTransforms[OBJ_COUNT];\n    #endif\n#endif\n\n#ifdef LINEAR_DEPTH\n    varying vec4 vViewPosition;\n#endif\nvarying vec3 vNormal;\n\n#include <uv_pars_vertex>\n#include <displacementmap_pars_vertex>\n#include <morphtarget_pars_vertex>\n#include <skinning_pars_vertex>\n#include <logdepthbuf_pars_vertex>\n#include <clipping_planes_pars_vertex>\n// This is used for computing an equivalent of gl_FragCoord.z that is as high precision as possible.\n// Some platforms compute gl_FragCoord at a lower precision which makes the manually computed value better for\n// depth-based postprocessing effects. Reproduced on iPad with A10 processor / iPadOS 13.3.1.\nvarying vec2 vHighPrecisionZW;\n\n#ifdef TRANSFORM_STORAGE\n    void objectTransform(out vec4 quaternion, out vec4 pivotLow, out vec4 pivotHigh, out vec4 translation, out vec4 scale){\n        #if TRANSFORM_STORAGE == 0\n            #if __VERSION__ == 300\n                ivec2 uv = ivec2(int(objIndex) * TRANSFORM_STRIDE, 0); \n                vec4 v0 = texelFetch( tTransforms, uv, 0 );\n                vec4 v1 = texelFetch( tTransforms, uv + ivec2(1, 0), 0);\n                vec4 v2 = texelFetch( tTransforms, uv + ivec2(2, 0), 0);\n                vec4 v3 = texelFetch( tTransforms, uv + ivec2(3, 0), 0);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #else\n                float size = objCount * TRANSFORM_STRIDE;\n                vec2 cUv = vec2(0.5/size, 0.5);\n                vec2 dUv = vec2(1./size, 0.);\n                \n                vec2 uv = vec2((objIndex * TRANSFORM_STRIDE)/size + cUv.x, cUv.y);\n                vec4 v0 = texture2D( tTransforms, uv);\n                vec4 v1 = texture2D( tTransforms, uv + dUv);\n                vec4 v2 = texture2D( tTransforms, uv + 2. * dUv);\n                vec4 v3 = texture2D( tTransforms, uv + 3. * dUv);\n                quaternion = v0;\n                pivotLow = vec4(v1.xyz, 1.);\n                pivotHigh = vec4(v2.xyz, 1.);\n                translation = vec4(v3.xyz, 1.);\n                scale = vec4(v1.w, v2.w, v3.w, 1.);\n            #endif\n        #elif TRANSFORM_STORAGE == 1\n            mat4 tMatrix = uTransforms[int(objIndex)];\n            quaternion = tMatrix[0];\n            pivotLow = vec4(tMatrix[1].xyz, 1.);\n            pivotHigh = vec4(tMatrix[2].xyz, 1.);\n            translation = vec4(tMatrix[3].xyz, 1.);\n            scale = vec4(tMatrix[1][3], tMatrix[2][3], tMatrix[3][3], 1.);\n        #endif\n    }\n\n    vec3 rotate_vertex_position(vec3 position, vec4 quat)\n    { \n        return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n    }\n\n    /** Another workaround for Apple's stupid compiler */\n    vec4 safeMul(vec4 a, vec4 b) {\n        // Prevents constant folding and optimization\n        return (a + vec4(0.0)) * (b + vec4(1.0)) - a * vec4(1.0);\n    }\n\n    highp vec3 rotate_scaled_vertex_position_delta(highp vec4 v0, highp vec4 v1, highp vec4 scale, highp vec4 quat)\n    {\n        /** !!! WORKAROUND FOR Intel IrisXe CARDS !!! */\n        /** The code below will not produce correct results in intel IrisXE integrated GPUs. \n         *  The geometry will turn mangled, albeit stable\n         *  I can't know for sure what is going on, but rotating the difference seems to \n         *  force the result into a lower precision?\n         */\n        // highp vec4 position = v0 - v1;\n        // return position.xyz + 2.0 * cross(quat.xyz, cross(quat.xyz, position.xyz) + quat.w * position.xyz);\n\n        /** Subtracting the rotated vectors works. */\n        return rotate_vertex_position(safeMul(v0, scale).xyz, quat)  - rotate_vertex_position(safeMul(v1, scale).xyz, quat) ;\n\n        /** An alternate workaround is\n         * highp vec3 position = (v0.xyz * (1. + 1e-7)) - (v1.xyz * (1. + 1e-7));\n           return position + 2.0 * cross(quat.xyz, cross(quat.xyz, position) + quat.w * position);\n\n           However I'm not such a fan of the (1. + 1e-7) part\n         */\n    }\n#endif\n\n#ifdef USE_RTE\n    highp vec4 computeRelativePosition(in highp vec3 position_low, in highp vec3 position_high, in highp vec3 relativeTo_low, in highp vec3 relativeTo_high){\n        /* \n        Source https://github.com/virtualglobebook/OpenGlobe/blob/master/Source/Examples/Chapter05/Jitter/GPURelativeToEyeDSFUN90/Shaders/VS.glsl \n        Note here, we're storing the high part of the position encoding inside three's default 'position' attribute buffer so we avoid redundancy \n        */\n        highp vec3 t1 = position_low.xyz - relativeTo_low.xyz;\n        highp vec3 e = t1 - position_low.xyz;\n        /** This is redunant, but necessary as a workaround for Apple platforms */\n        highp float x = position_high.x - relativeTo_high.x;\n        highp float y = position_high.y - relativeTo_high.y;\n        highp float z = position_high.z - relativeTo_high.z;\n        highp vec3 v = vec3(x, y, z);\n        /** End of redundant part */\n        highp vec3 t2 = ((-relativeTo_low - e) + (position_low.xyz - (t1 - e))) + v;\n        highp vec3 highDifference = t1 + t2;\n        highp vec3 lowDifference = t2 - (highDifference.xyz - t1.xyz);\n        \n        highp vec3 position = highDifference.xyz + lowDifference.xyz;\n        return vec4(position, 1.);\n    }\n#endif\n\n\nvoid main() {\n\t#include <uv_vertex>\n\t#include <skinbase_vertex>\n    #include <beginnormal_vertex>\n\t#ifdef USE_DISPLACEMENTMAP\n\t\t#include <morphnormal_vertex>\n\t\t#include <skinnormal_vertex>\n\t#endif\n    // #include <defaultnormal_vertex> // COMMENTED CHUNK\n    vec3 transformedNormal = objectNormal;\n    #ifdef USE_INSTANCING\n\n        // this is in lieu of a per-instance normal-matrix\n        // shear transforms in the instance matrix are not supported\n        mat3 m = mat3( instanceMatrix );\n        transformedNormal /= vec3( dot( m[ 0 ], m[ 0 ] ), dot( m[ 1 ], m[ 1 ] ), dot( m[ 2 ], m[ 2 ] ) );\n        transformedNormal = m * transformedNormal;\n        \n        /* If we have negative scaling, we flip the normal */\n        float signDet = sign(dot(m[0], cross(m[1], m[2])));\n        // Optional fallback: treat 0 as +1\n        signDet = signDet + (1.0 - abs(signDet));\n        transformedNormal *= signDet;\n    #endif\n    transformedNormal = normalMatrix * transformedNormal;\n    #ifdef FLIP_SIDED\n        transformedNormal = - transformedNormal;\n    #endif\n    #ifdef USE_TANGENT\n        vec3 transformedTangent = ( modelViewMatrix * vec4( objectTangent, 0.0 ) ).xyz;\n        #ifdef FLIP_SIDED\n            transformedTangent = - transformedTangent;\n        #endif\n    #endif\n\t#include <normal_vertex>\n\t#include <begin_vertex>\n\t#include <morphtarget_vertex>\n\t#include <skinning_vertex>\n\t#include <displacementmap_vertex>\n\t//#include <project_vertex> // EDITED CHUNK\n    #ifdef TRANSFORM_STORAGE\n        vec4 tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale;\n        objectTransform(tQuaternion, tPivotLow, tPivotHigh, tTranslation, tScale);\n    #endif\n    #ifdef USE_RTE\n        vec4 position_lowT = vec4(position_low, 1.);\n        vec4 position_highT = vec4(position, 1.);\n        const vec3 ZERO3 = vec3(0., 0., 0.);\n\n        highp vec4 rteLocalPosition = computeRelativePosition(position_lowT.xyz, position_highT.xyz, uViewer_low, uViewer_high);\n        #ifdef TRANSFORM_STORAGE\n            highp vec4 rtePivot = computeRelativePosition(tPivotLow.xyz, tPivotHigh.xyz, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = rotate_scaled_vertex_position_delta(rteLocalPosition, rtePivot, tScale, tQuaternion) + rtePivot.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            vec4 instancePivot = computeRelativePosition(ZERO3, ZERO3, uViewer_low, uViewer_high);\n            rteLocalPosition.xyz = (mat3(instanceMatrix) * (rteLocalPosition - instancePivot).xyz) + instancePivot.xyz + instanceMatrix[3].xyz;\n        #endif\n    #endif\n\n    #ifdef USE_RTE\n        vec4 mvPosition = rteLocalPosition;\n    #else\n        vec4 mvPosition = vec4( transformed, 1.0 );\n        #ifdef TRANSFORM_STORAGE\n            mvPosition.xyz = rotate_scaled_vertex_position_delta(mvPosition, tPivotHigh, tScale, tQuaternion) + tPivotHigh.xyz + tTranslation.xyz;\n        #endif\n        #ifdef USE_INSTANCING\n            mvPosition = instanceMatrix * mvPosition;\n        #endif\n    #endif\n   \n    #ifdef USE_RTE\n        mvPosition = rteModelViewMatrix * mvPosition;\n    #else\n        mvPosition = modelViewMatrix * mvPosition;\n    #endif\n    \n    #ifdef LINEAR_DEPTH\n        vViewPosition = mvPosition;\n    #endif \n    vNormal = normalize( transformedNormal );\n    gl_Position = projectionMatrix * mvPosition;\n\t#include <logdepthbuf_vertex>\n\t// #include <clipping_planes_vertex>\n    #if NUM_CLIPPING_PLANES > 0\n\t    vClipPosition = - mvPosition.xyz;\n    #endif\n\tvHighPrecisionZW = gl_Position.zw;\n}\n";