@equinor/videx-3d 5.1.0-beta

package/dist/shaderLib/glyphs.glsl

@@ -0,0 +1,78 @@
+uniform vec2 size;
+uniform sampler2D glyphAtlas;
+
+uniform float in_bias;
+uniform float out_bias;
+
+uniform GlyphData {
+  vec4 glyphPosition[GLYPHS_LENGTH];
+  vec3 glyphOffset[GLYPHS_LENGTH];
+  vec2 glyphTextureSize;
+  float glyphFontSize;
+  float glyphPixelRange;
+  float glyphLineHeight;
+  float glyphBaseLine;
+};
+
+//varying vec2 vUv;
+
+struct GlyphParams {
+  vec2 position;
+  uint index;
+};
+
+uint _numDigits(float number) {
+  float log10 = 0.4342944819032518 * log(number);
+  return uint(max(trunc(log10), 0.0) + 1.0);
+}
+
+uint _getDigit(float number, uint position) {
+  return uint(trunc(mod(number / pow(10.0, float(position - 1u)), 10.0)));
+  //return uint(floor(fract(number / pow(10.0, float(position))) * 10.0));
+}
+
+float _median(float r, float g, float b) {
+  return max(min(r, g), min(max(r, g), b));
+}
+
+vec2 _calcGlyphUv(vec2 texPos) {
+  vec2 glyphUv = vec2(texPos.x / glyphTextureSize.x, (glyphTextureSize.y - texPos.y) / glyphTextureSize.y);
+
+  return clamp(glyphUv, 0.0, 1.0);
+}
+
+float _calculateGlyphVerticalOffset(float vAlign) {
+  float pxRangeOffset = floor(glyphPixelRange / 2.0);
+  float lineHightOffset = glyphLineHeight / 2.0;
+  float vAlignOffset = (glyphFontSize / 2.0) * vAlign;
+  //float vAlignOffset = vAlign != 0.0 ? mix(mix(BOTTOM, 0.0, vAlign + 1.0), mix(0.0, TOP, vAlign), step(0.0, vAlign)) : 0.0;
+  return lineHightOffset + pxRangeOffset + vAlignOffset;
+}
+
+float _screenPixelRange(float scale) {
+  vec2 scaledSize = size * scale;
+  vec2 screenPxRange = glyphPixelRange / fwidth(vUv * scaledSize);
+  return max(min(screenPxRange.x, screenPxRange.y), 1.0);
+}
+
+float _sdfGlyph(vec2 p, uint glyphId) {
+  vec2 offset = vec2(p.x - glyphOffset[glyphId].x, p.y - glyphOffset[glyphId].y);
+  vec2 uv = glyphPosition[glyphId].xy + offset;
+  float sigDist = -0.5;
+
+  if(offset.x >= 0.0 && offset.y >= 0.0 && offset.x <= glyphPosition[glyphId].z && offset.y <= glyphPosition[glyphId].w) {
+    vec2 TexCoord = _calcGlyphUv(uv);
+    vec3 mdf = texture2D(glyphAtlas, TexCoord).rgb;
+    sigDist = _median(mdf.r, mdf.g, mdf.b);
+  }
+  return sigDist;
+}
+
+void renderGlyph(inout vec3 outColor, vec2 position, uint glyphId, vec3 glyphColor, float pxRange) {
+  float dist = _sdfGlyph(position, glyphId);
+  float e = pxRange * (dist - 0.5 + in_bias) + 0.5 + out_bias;
+
+  float contour = clamp(e, 0.0, 1.0);
+
+  outColor = mix(outColor, glyphColor, contour);
+}

package/dist/shaderLib/random.glsl

@@ -0,0 +1,3 @@
+float rand(vec2 co) {
+  return fract(sin(dot(co, vec2(12.9898, 78.233))) * 43758.5453);
+}

package/dist/shaderLib/remap.glsl

@@ -0,0 +1,13 @@
+float inverseLerp(float v, float minValue, float maxValue) {
+  return (v - minValue) / (maxValue - minValue);
+}
+
+float remap(float v, float inMin, float inMax, float outMin, float outMax) {
+  float t = inverseLerp(v, inMin, inMax); 
+  return mix(outMin, outMax, t);
+}
+
+float inverseSmoothstep(float y)
+{
+    return 0.5 - sin(asin(1.0- 2.0 * y) / 3.0);
+}

package/dist/shaderLib/render-number.glsl

@@ -0,0 +1,74 @@
+uniform uint digits[12];
+
+float renderNumber(
+  inout vec3 outColor,
+  vec2 position,
+  float number,
+  uint decimals,
+  float verticalAlign,
+  float horizontalAlign,
+  vec3 textColor,
+  float spacing,
+  float scale
+) {
+  
+  float width = 0.0;
+  float totalWidth = 0.0;
+  float offset = 0.0;
+
+  // store glyphId and width during calculation of total width so we don't need to re-calculate these values
+  uvec2 temp[30]; 
+
+  uint glyphId;
+  uint nDigits;
+
+  vec2 pos = position.xy;
+  uint c = 0u;
+  
+  if (number < 0.0) {
+    glyphId = digits[11];
+    width = glyphOffset[glyphId].z + spacing;
+    offset = width;
+    temp[c++] = uvec2(glyphId, width);
+    number = -number;
+  }
+
+  float intPart;
+  float fractPart = modf(number, intPart);
+  fractPart *= pow(10.0, float(decimals));
+  nDigits = _numDigits(intPart);
+
+  for(uint n = 0u; n < nDigits; n++) {
+    glyphId = digits[_getDigit(intPart, nDigits - n)];
+    width = glyphOffset[glyphId].z + spacing;
+    temp[c++] = uvec2(glyphId, width);
+    totalWidth += width;
+  }
+
+  if(decimals > 0u) {
+    glyphId = digits[10];
+    width = glyphOffset[glyphId].z + spacing;
+    temp[c++] = uvec2(glyphId, width);
+    totalWidth += width;
+    
+    nDigits = _numDigits(fractPart);
+    for(uint n = 0u; n < decimals; n++) {
+      glyphId = digits[_getDigit(fractPart, nDigits - n)];
+      width = glyphOffset[glyphId].z + spacing;
+      temp[c++] = uvec2(glyphId, width);
+      totalWidth += width;
+    }
+  }
+
+  if(c > 0u) {
+    pos.x += (totalWidth - spacing) * horizontalAlign + offset;
+    pos.y += _calculateGlyphVerticalOffset(verticalAlign);
+
+    uint n = 0u;
+
+    while (n < c && pos.x > float(temp[n].y)) pos.x -= float(temp[n++].y);
+    if (n < c) renderGlyph(outColor, pos, temp[n].x, textColor, _screenPixelRange(scale));  
+  }
+
+  return totalWidth;
+}

package/dist/shaderLib/render-text.glsl

@@ -0,0 +1,66 @@
+uniform usampler2D textTexture;
+uniform uint textPointersCount;
+uniform uint textPointersOffset;
+
+uint _readGlyphIdFromTexture(uint index) {
+  uint value = texelFetch(textTexture, ivec2(index, 0), 0).r;
+  return value;
+}
+
+GlyphParams _findGlyph(vec2 pixelCoords, uvec3 textPointer, float spacing) {
+
+  uint id = _readGlyphIdFromTexture(textPointer.x);
+  float width = glyphOffset[id].z + spacing;
+  vec2 position = pixelCoords.xy;
+
+  uint i = textPointer.x;
+
+  while(position.x >= width && i++ < textPointer.y - 1u) {
+    position.x -= width;
+    uint j = _readGlyphIdFromTexture(i);
+
+    id = j;
+    width = glyphOffset[id].z + spacing;
+  };
+
+  return GlyphParams(position, id);
+}
+
+uvec3 readTextPointerFromTexture(uint index) {
+  uvec3 pointer = uvec3(0u);
+  uint pos = (index * 3u) + textPointersOffset;
+  pointer.x = texelFetch(textTexture, ivec2(pos, 0), 0).r;
+  pointer.y = texelFetch(textTexture, ivec2(pos + 1u, 0), 0).r;
+  pointer.z = texelFetch(textTexture, ivec2(pos + 2u, 0), 0).r;
+
+  return pointer;
+}
+
+void renderText(
+  inout vec3 outColor,
+  vec2 position,
+  uvec3 textPointer,
+  float verticalAlign,
+  float horizontalAlign,
+  vec3 textColor,
+  float spacing,
+  float scale
+) {
+  // do nothing if the text widht is 0
+  if(textPointer.z == 0u)
+    return;
+
+  float spacingWidth = spacing * float(textPointer.y - textPointer.x - 1u);
+  position.x += (float(textPointer.z) + spacingWidth) * horizontalAlign;
+
+  //if (position.y > glyphLineHeight / 2.0 || position.y < -glyphLineHeight / 2.0) return;
+  
+  vec2 pos = position;
+  pos.y += _calculateGlyphVerticalOffset(verticalAlign);
+  
+  if(pos.x < 0.0)
+    return;
+
+  GlyphParams params = _findGlyph(pos, textPointer, spacing);
+  renderGlyph(outColor, params.position, params.index, textColor, _screenPixelRange(scale));
+}

package/dist/shaderLib/rotation.glsl

@@ -0,0 +1,19 @@
+mat2 rotation2d(float angle) {
+  float s = sin(angle);
+  float c = cos(angle);
+  return mat2(c, -s, s, c);
+}
+
+mat4 rotation3d(vec3 axis, float angle) {
+  axis = normalize(axis);
+  float s = sin(angle);
+  float c = cos(angle);
+  float oc = 1.0 - c;
+
+  return mat4(
+    oc * axis.x * axis.x + c,           oc * axis.x * axis.y - axis.z * s,  oc * axis.z * axis.x + axis.y * s,  0.0,
+    oc * axis.x * axis.y + axis.z * s,  oc * axis.y * axis.y + c,           oc * axis.y * axis.z - axis.x * s,  0.0,
+    oc * axis.z * axis.x - axis.y * s,  oc * axis.y * axis.z + axis.x * s,  oc * axis.z * axis.z + c,          0.0,
+    0.0,                               0.0,                               0.0,                               1.0
+  );
+}

package/dist/shaderLib/sdf-functions.glsl

@@ -0,0 +1,18 @@
+// SDF functions
+
+float sdfLine(vec2 p, vec2 a, vec2 b) {
+  vec2 pa = p - a;
+  vec2 ba = b - a;
+  float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
+
+  return length(pa - ba * h);
+}
+
+float sdfBox(vec2 p, vec2 b) {
+  vec2 d = abs(p) - b;
+  return length(max(d, 0.0)) + min(max(d.x, d.y), 0.0);
+}
+
+float sdfCircle(vec2 p, float r) {
+  return length(p) - r;
+}

package/dist/types/common/color-ramps.d.ts

@@ -0,0 +1,5 @@
+import { CanvasTexture } from 'three';
+export type RampFunction = (ctx: CanvasRenderingContext2D, y: number) => void;
+export declare function createColorRamps(ramps: RampFunction[], width: number): HTMLCanvasElement;
+export declare const colorRamps: RampFunction[];
+export declare const colorRampTexture: CanvasTexture<HTMLCanvasElement>;

package/dist/types/common/types.d.ts

@@ -0,0 +1,25 @@
+import { Layers } from '@react-three/fiber';
+import { Material } from 'three';
+import { Vec3 } from '../sdk';
+/**
+ * Common props for 3d components
+ */
+export type CommonComponentProps = {
+    name?: string;
+    visible?: boolean;
+    userData?: Record<string, any>;
+    position?: Vec3;
+    castShadow?: boolean;
+    receiveShadow?: boolean;
+    renderOrder?: number;
+    layers?: Layers;
+};
+/**
+ * Common props for 3d components that allow overriding shader materials
+ */
+export type CustomMaterialProps = {
+    customMaterial?: Material | Material[];
+    customDepthMaterial?: Material;
+    customDistanceMaterial?: Material;
+    onMaterialPropertiesChange?: (props: Record<string, any>, material: Material | Material[]) => void;
+};

package/dist/types/components/Annotations/Annotations.d.ts

@@ -0,0 +1,42 @@
+import { ReactNode } from 'react';
+/**
+ * Annotations provider component props
+ * @expand
+ */
+export type AnnotationsProviderProps = {
+    autoUpdate?: boolean;
+    maxVisible?: number;
+    children?: ReactNode;
+};
+/**
+ * The Annotations component is special provider component responsible for managing
+ * and updating annotation layers and instances.
+ *
+ * It allow you to register layers, using the AnnotationLayer component, and set a
+ * global max visible annotations.
+ *
+ * Annotations adds point-feature labeling support, where labels are rendered as
+ * regular React HTML components. Anchors and connector lines are drawn to the frame buffer
+ * after the 3D scene frame is completed.
+ *
+ * Annotations are processed globally to support label collision, occlusion and
+ * ordering tests. Priority and visibillity distances can be set in the AnnotationLayer
+ * component and/or int the individual annotation elements.
+ *
+ * @example
+ * <Annotations>
+ *  <AnnotationLayer id="casings_annotations" name="Casing Annotations" />
+ * </Annotations>
+ *
+ * @remarks
+ * This component sets up a global state and takes control over the render loop!
+ * It's therefore important that only a single instance of this component is mounted
+ * at any time in your project. Using this compoent with an EffectsComposer may cause issues,
+ * and we will likely convert it from being a component into being a post-processing pass at some point.
+ *
+ * @see [Storybook](/videx-3d/?path=/docs/components-misc-annotations--docs)
+ * @see {@link AnnotationsLayer}
+ *
+ * @group Components
+ */
+export declare const Annotations: ({ maxVisible, autoUpdate, children, }: AnnotationsProviderProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Annotations/AnnotationsHMTL.d.ts

@@ -0,0 +1 @@
+export declare const AnnotationsHTML: () => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Annotations/AnnotationsLayer.d.ts

@@ -0,0 +1,46 @@
+import { PropsWithChildren } from 'react';
+import { AnnotationLayer } from './types';
+/**
+ * AnnotationsLayer props
+ * @expand
+ */
+export type AnnotationsLayerProps = Partial<AnnotationLayer> & {
+    id: string;
+    name: string;
+};
+/**
+ * Use the AnnotationsLayer component to register and configure a layer for adding
+ * annotations. This needs to be added as a child of the `Annotations` component.
+ *
+ * @example
+ * <Annotations>
+ *  <AnnotationsLayer
+ *   id="wellbore-labels"
+ *   name="Wellbore Labels"
+ *   priority={4}
+ *   anchorSize={5}
+ *   anchorColor='cyan'
+ *   connectorWidth={1.5}
+ *   distanceFactor={1000}
+ *   labelOffset={50}
+ *   minDistance={1}
+ *   maxDistance={10000}
+ *   anchorOcclusionRadius={20}
+ *   labelComponent={WellboreAnnotationLabel}
+ *   onClick={(annotation: AnnotationComponentProps) => {
+ *     dispatchEvent(new CameraFocusAtPointEvent({ point: annotation.position, distance: 500 }))
+ *   }}
+ *  />
+ * </Annotations>
+ *
+ * @remarks
+ * The AnnotationsLayer component is for adding and configuring a layer. Annotations are added to a layer
+ * using the `useAnnotations` hook with a layer id and a user defined scope.
+ *
+ * @see [Storybook](/videx-3d/?path=/docs/components-misc-annotations--docs)
+ * @see {@link Annotations}
+ * @see {@link useAnnotations}
+ *
+ * @group Components
+ */
+export declare const AnnotationsLayer: ({ id, name, priority, visible, distanceFactor, minDistance, maxDistance, anchorOcclusionRadius, anchorSize, anchorColor, connectorWidth, connectorColor, labelOffset, labelComponent, onClick, children, }: PropsWithChildren<AnnotationsLayerProps>) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Annotations/AutoUpdate.d.ts

@@ -0,0 +1,3 @@
+export declare const AutoUpdate: ({ maxVisible }: {
+    maxVisible: number;
+}) => null;

package/dist/types/components/Annotations/DefaultLabelComponent.d.ts

@@ -0,0 +1,11 @@
+import { AnnotationComponentProps } from './types';
+/**
+ * The default component for rendering annotation labels. You can override this by
+ * supplying a custom component in the `AnnotationsLayer` component.
+ *
+ * @see [Storybook](/path=/docs/components-misc-annotations--docs)
+ * @see {@link AnnotationsLayer}
+ *
+ * @group Components
+ */
+export declare const DefaultLabelComponent: ({ id, name, }: AnnotationComponentProps) => import("react/jsx-runtime").JSX.Element;

package/dist/types/components/Annotations/TestAnnotations.d.ts

@@ -0,0 +1,12 @@
+import { Vec3 } from '../../sdk';
+type Props = {
+    layer: string;
+    count?: number;
+    position?: Vec3;
+    radius?: number;
+};
+/**
+ * @interal for testing purposes
+ */
+export declare const TestAnnotations: ({ layer, count, radius, position, }: Props) => null;
+export {};

package/dist/types/components/Annotations/annotations-renderer.d.ts

@@ -0,0 +1,26 @@
+import { Camera, CanvasTexture, Clock, PerspectiveCamera, ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { FullscreenRenderer } from '../../rendering/fullscreen-renderer';
+import { AnnotationInstance } from './types';
+export declare class AnnotationsRenderer {
+    maxVisible: number;
+    camera: PerspectiveCamera;
+    clock: Clock;
+    pointer: Vector2;
+    ctx: CanvasRenderingContext2D;
+    overlayTexture: CanvasTexture | null;
+    annotationsTexSize: number;
+    annotationsRenderTarget: WebGLRenderTarget;
+    annotationsBuffer: Uint8Array;
+    annotationsMaterial: ShaderMaterial;
+    fullscreenRenderer: FullscreenRenderer;
+    annotationsData: AnnotationInstance[];
+    isBusy: boolean;
+    dataTextureNeedsUpdate: boolean;
+    unsubscribeListeners: () => void;
+    constructor(camera: Camera, clock: Clock, pointer: Vector2, maxVisible?: number);
+    updateAnnotationsData(buffer: Uint8Array): void;
+    updateOverlayTexture(inViewSpace: AnnotationInstance[]): void;
+    updateDataTexture(): void;
+    dispose(): void;
+    render(renderer: WebGLRenderer, buffer: WebGLRenderTarget | null): void;
+}

package/dist/types/components/Annotations/annotations-state.d.ts

@@ -0,0 +1,88 @@
+import { AnnotationInstance, AnnotationLayer, AnnotationProps } from './types';
+export type AnnotationsState = {
+    visible: boolean;
+    update: {
+        required: boolean;
+        ref: ReturnType<typeof setTimeout> | null;
+        setRef: (v: ReturnType<typeof setTimeout>) => void;
+    };
+    layers: Record<string, AnnotationLayer>;
+    annotations: Record<string, AnnotationProps[]>;
+    instances: AnnotationInstance[];
+    toggleVisibility: () => void;
+    clear: () => void;
+    createLayer: (newLayer: AnnotationLayer) => () => void;
+    updateLayer: (id: string, updatedLayer: Partial<AnnotationLayer>) => void;
+    layerExist: (id: string) => boolean;
+    addLayerAnnotations: (layerId: string, scope: string, annotations: AnnotationProps[]) => void;
+    removeLayerAnnotations: (layerId: string, scope?: string) => void;
+    setInstances: (newInstances: AnnotationInstance[]) => void;
+};
+/**
+ * Get access to annotations global state.
+ * This is used internally and should not be used by other components. Use the `useAnnotations` hook instead.
+ * @internal
+ *
+ * @see {@link useAnnotations}
+ *
+ * @group Hooks
+ */
+export declare const useAnnotationsState: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<AnnotationsState>, "subscribe"> & {
+    subscribe: {
+        (listener: (selectedState: AnnotationsState, previousSelectedState: AnnotationsState) => void): () => void;
+        <U>(selector: (state: AnnotationsState) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+            equalityFn?: ((a: U, b: U) => boolean) | undefined;
+            fireImmediately?: boolean;
+        } | undefined): () => void;
+    };
+}>;
+/**
+ * This hook allow you to add annotations to an exisiting `AnnotationsLayer`.
+ * A scope is a user defined string, which should uniquely tie the added anotations to your component.
+ * If your annotations belong to a specific wellbore, the wellbore name or id would work well as a scope.
+ *
+ * A single function `addAnnotations` is returned, which you can call from within a `useEffect`
+ * hook to set annotations. Annotations must be an array of `AnnotationProps`.
+ * The `addAnnotations` function will return a dispose function when invoked, which you should
+ * call within the effect dispose function.
+ *
+ * @example
+ * const { addAnnotations } = useAnnotations('casings', scope)
+ *
+ * @remarks
+ * Note that annotation positions needs to be in world space. You can optionally provide a matrixWorld to
+ * the annotation props that can be used to transform the local postion to world position. In the components
+ * using annotations, this is done by rendering a "dummy" Object3D and passing its matrixWorld instance to the
+ * annotation props.
+ *
+ * @example
+ * useEffect(() => {
+ *   let dispose: (() => void) | null = null
+ *   if (generator && id) {
+ *     const v = new Vector3()
+ *     generator(id).then(response => {
+ *       if (response && positionRef.current) {
+ *         response.forEach((d, i) => {
+ *           v.set(...d.position)
+ *           positionRef.current.localToWorld(v)
+ *           d.position = v.toArray()
+ *           d.id = i.toString()
+ *         })
+ *         dispose = addAnnotations(response || [])
+ *       }
+ *     })
+ *   }
+ *
+ *   return () => {
+ *     if (dispose) dispose()
+ *   }
+ * }, [addAnnotations, id, generator, positionRef])
+ *
+ * @see {@link AnnotationsLayer}
+ * @see {@link Annotations}
+ *
+ * @group Hooks
+ */
+export declare const useAnnotations: (layer: string, scope: string) => {
+    addAnnotations: (annotations: AnnotationProps[]) => (() => void) | undefined;
+};

package/dist/types/components/Annotations/helpers.d.ts

@@ -0,0 +1,11 @@
+import { PerspectiveCamera } from 'three';
+import { Vec2, Vec3 } from '../../sdk';
+export declare const labelAngles: number[];
+/**
+ * 0 = [-] annotation is pointing approx. horizontally
+ * 1 = [/] annotation is pointing approx. diagonally (from lower left to upper right)
+ * 2 = [|] annotation is pointing approx. vertically
+ * 3 = [\] annotation is pointing approx. diagonally (from upper left to lower right)
+ */
+export declare const labelAnglesMap: number[][];
+export declare const getLabelQuadrant: (originScreen: Vec2, origin3d: Vec3, direction3d: Vec3, camera: PerspectiveCamera) => number;

package/dist/types/components/Annotations/index.d.ts

@@ -0,0 +1,8 @@
+import { Vec3 } from '../../sdk';
+import { AnnotationProps } from './types';
+export * from './Annotations';
+export * from './annotations-renderer';
+export * from './annotations-state';
+export * from './AnnotationsLayer';
+export * from './types';
+export declare const getAnnotationPosition: (annotation: AnnotationProps) => Vec3;

package/dist/types/components/Annotations/types.d.ts

@@ -0,0 +1,80 @@
+import { RefObject } from 'react';
+import { Matrix4 } from 'three';
+import { Vec2, Vec3 } from '../../sdk';
+export type AnnotationProps = {
+    id: string;
+    name: string;
+    position: Vec3;
+    matrixWorld?: Matrix4;
+    scope?: string;
+    data?: any;
+    priority?: number;
+    direction?: Vec3;
+};
+export type AnnotationComponentProps = AnnotationProps & {
+    instanceId: string;
+};
+export type AnnotationLayer = {
+    id: string;
+    name: string;
+    visible: boolean;
+    priority: number;
+    distanceFactor: number;
+    minDistance: number;
+    maxDistance: number;
+    labelOffset: number;
+    anchorOcclusionRadius: number;
+    anchorSize: number;
+    anchorColor: string;
+    connectorWidth: number;
+    connectorColor: string;
+    onClick?: (annotation: AnnotationComponentProps) => void;
+    labelComponent?: (props: AnnotationComponentProps) => React.JSX.Element;
+};
+export type AnnotationInstanceState = {
+    visible: boolean;
+    health: number;
+    distance: number;
+    position: Vec3;
+    inViewSpace?: boolean;
+    occluded?: boolean;
+    inTransition?: boolean;
+    transitionTime?: number;
+    quadrant?: number;
+    positionSlot?: number;
+    screenPosition: Vec2;
+    labelPosition?: Vec2;
+    scaledOffset?: Vec2;
+    anchorPosition?: Vec2;
+    prevAnchorPosition?: Vec2;
+    prevLabelPosition?: Vec2;
+    prevQuadrant?: number;
+    scaleFactor?: number;
+    labelHovered?: boolean;
+    boost?: boolean;
+    kill?: boolean;
+    cooldown?: number;
+    opacity?: number;
+    labelWidht: number;
+    labelHeight: number;
+    labelX?: number;
+    labelY?: number;
+    anchorX?: number;
+    anchorY?: number;
+    zIndex: number;
+    capped?: boolean;
+    _visibility?: string;
+    _opacity?: string;
+    _zIndex?: string;
+    _transform?: string;
+    _needsUpdate?: boolean;
+};
+export type AnnotationInstance = {
+    id: string;
+    ref: RefObject<HTMLDivElement | null> | null;
+    layer: AnnotationLayer;
+    annotation: AnnotationProps;
+    priority: number;
+    rank: number;
+    state: AnnotationInstanceState;
+};

package/dist/types/components/Annotations/update-annotations.d.ts

@@ -0,0 +1,12 @@
+import { Clock, PerspectiveCamera } from 'three';
+import { Vec2 } from '../../sdk';
+import { AnnotationInstance } from './types';
+/**
+ * PRE-PROCESS INSTANCES
+ */
+export declare function preprocessInstances(instances: AnnotationInstance[], camera: PerspectiveCamera, clock: Clock, maxVisible: number): AnnotationInstance[];
+/**
+ * POST PROCESS INSTANCES
+ */
+export declare function postProcessInstances(instances: AnnotationInstance[], size: Vec2): void;
+export declare function updateInstanceDOMElements(instances: AnnotationInstance[]): void;