@equinor/videx-3d 1.0.3 → 1.1.1

package/dist/types/components/EventEmitter/EventEmitterContext.d.ts

@@ -1,4 +1,4 @@
-import { Camera, Object3D } from 'three';
+import { Camera, Material, Object3D } from 'three';
 import { Vec2, Vec3 } from '../../sdk';
 export type KeysPressed = {
     altKey: boolean;
@@ -22,6 +22,7 @@ export type Listener = {
     ref?: any;
     threshold?: number;
     handlers: Record<string, EventEmitterCallback>;
+    customMaterial?: Material;
 };
 export type Emitter = {
     source: Object3D;

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

@@ -1,3 +1,4 @@
 export * from './EventEmitter';
 export * from './EventEmitterContext';
 export * from './picking-helper';
+export * from './picking-material';

package/dist/types/components/EventEmitter/picking-helper.d.ts

@@ -20,6 +20,9 @@ export declare class PickingHelper {
     private _pbo;
     private _buffer;
     private _material;
+    private _listeners;
+    private _emitters;
+    private _currentObjectMap;
     constructor(options?: {});
     private traverseObject;
     updateListeners: () => void;

package/dist/types/components/EventEmitter/picking-material.d.ts

@@ -1,11 +1,14 @@
-import { Camera, Object3D, Scene, ShaderMaterial, WebGLRenderer } from 'three';
+import { Camera, Object3D, Scene, ShaderMaterial, Uniform, WebGLRenderer } from 'three';
 import { BufferGeometry } from 'three/webgpu';
-import { Emitter, Listener } from './EventEmitterContext';
+export declare const pickingMaterialUniforms: {
+    emitterId: Uniform<number>;
+    side: Uniform<number>;
+};
 export declare class PickingMaterial extends ShaderMaterial {
-    listeners: Map<number, Listener>;
-    emitters: Map<number, Emitter>;
-    currentObjectMap: Array<number> | null;
     constructor();
     dispose(): void;
     onBeforeRender(_renderer: WebGLRenderer, _scene: Scene, _camera: Camera, _geometry: BufferGeometry, object: Object3D): void;
 }
+export declare class CustomPickingMaterial extends PickingMaterial {
+    constructor(vertexShader?: string, uniforms?: Record<string, Uniform>);
+}

package/dist/types/components/Wellbores/Casings/CasingEmitterMaterial.d.ts

@@ -0,0 +1,16 @@
+import { CustomPickingMaterial } from '../../EventEmitter/picking-material';
+export declare class CasingEmitterMaterial extends CustomPickingMaterial {
+    constructor();
+    get sizeMultiplier(): number;
+    set sizeMultiplier(v: number);
+    get radius(): number;
+    set radius(v: number);
+    get innerRadius(): number;
+    set innerRadius(v: number);
+    get sliceOffset(): number;
+    set sliceOffset(v: number);
+    get sliceAngle(): number;
+    set sliceAngle(v: number);
+    get autoSlicePosition(): boolean;
+    set autoSlicePosition(v: boolean);
+}

package/dist/types/components/Wellbores/Casings/CasingSection.d.ts

@@ -1,3 +1,4 @@
+import { PointerEvents } from '../../../main';
 import { CasingSectionMaterialOptions } from './Casings';
 import { CasingSectionType } from './casings-defs';
 type CasingSectionProps = {
@@ -10,6 +11,6 @@ type CasingSectionProps = {
     autoSlicePosition?: boolean;
     opacity?: number;
     renderOrder?: number;
-};
-export declare const CasingSection: ({ section, materialOptions, radialSegments, sizeMultiplier, sliceAngle, sliceOffset, autoSlicePosition, opacity, renderOrder, }: CasingSectionProps) => import("react/jsx-runtime").JSX.Element;
+} & PointerEvents;
+export declare const CasingSection: ({ section, materialOptions, radialSegments, sizeMultiplier, sliceAngle, sliceOffset, autoSlicePosition, opacity, renderOrder, onPointerClick, onPointerEnter, onPointerLeave, onPointerMove, }: CasingSectionProps) => import("react/jsx-runtime").JSX.Element;
 export {};

package/dist/types/components/Wellbores/Casings/Casings.d.ts

@@ -1,6 +1,7 @@
 import { ReactElement } from 'react';
 import { Group, MeshStandardMaterialParameters, Object3D } from 'three';
 import { CommonComponentProps } from '../../../common/types';
+import { PointerEvents } from '../../../main';
 import { CasingSectionType } from './casings-defs';
 /**
  * CasingSectionMaterialOptions
@@ -20,7 +21,7 @@ export type MaterialOptions = (section: CasingSectionType) => CasingSectionMater
  * Casing props
  * @expand
  */
-export type CasingProps = CommonComponentProps & {
+export type CasingProps = PointerEvents & CommonComponentProps & {
     fallback?: () => ReactElement<Object3D>;
     radialSegments?: number;
     sliceAngle?: number;
@@ -55,7 +56,7 @@ export type CasingProps = CommonComponentProps & {
  *
  * @group Components
  */
-export declare const Casings: import('react').ForwardRefExoticComponent<CommonComponentProps & {
+export declare const Casings: import('react').ForwardRefExoticComponent<PointerEvents & CommonComponentProps & {
     fallback?: () => ReactElement<Object3D>;
     radialSegments?: number;
     sliceAngle?: number;

package/dist/types/sdk/geometries/planar-geometry.d.ts

@@ -0,0 +1,69 @@
+import { Shape, Vector2 } from 'three';
+import { Vec2 } from '../types/common';
+export type PlanarGeometryType = 'point2d' | 'line2d' | 'polygon2d';
+export type Coordinates2D = Vec2[];
+export type PlanarPointCoordinates = Coordinates2D;
+export type PlanarLineCoordinates = Coordinates2D[];
+export type PlanarPolygonCoordinates = Coordinates2D[][];
+export type PlanarGeometryCoordinates = PlanarPointCoordinates | PlanarLineCoordinates | PlanarPolygonCoordinates;
+export type CoordinatesTransformFunction = (coord: Vec2) => Vec2;
+/**
+ * A simple abstraction for defining 2D points, lines or polygons,
+ * primarily for making it easier to work with GeoJson in videx-3d.
+ */
+export declare abstract class PlanarGeometry {
+    type: PlanarGeometryType;
+    coordinates: PlanarGeometryCoordinates;
+    private _min;
+    private _max;
+    private _size;
+    protected _offset: Vec2;
+    constructor(type: PlanarGeometryType, coordinates: PlanarGeometryCoordinates, offset?: Vec2);
+    static fromPointCoordinates(coordinates: PlanarPointCoordinates, transform?: CoordinatesTransformFunction): PlanarPointGeometry;
+    static fromLineCoordinates(coordinates: PlanarLineCoordinates, transform?: CoordinatesTransformFunction): PlanarLineGeometry;
+    static fromPolygonCoordinates(coordinates: PlanarPolygonCoordinates, transform?: CoordinatesTransformFunction): PlanarPolygonGeometry;
+    abstract forEachCoordinate(callback: (pos: Vec2) => void): void;
+    private _calculateBounds;
+    get min(): Vec2;
+    get max(): Vec2;
+    get center(): Vec2;
+    get size(): Vec2;
+    get offset(): Vec2;
+    setOffset(offset: Vec2): void;
+    removeOffset(): void;
+    centralize(): void;
+    normalize(scale?: Vec2, offset?: Vec2): void;
+    transform(transformFunc: CoordinatesTransformFunction): void;
+    abstract clone(): PlanarGeometry;
+    toObject(): {
+        type: string;
+        coordinates: PlanarGeometryCoordinates;
+        offset: Vec2;
+    };
+    abstract getPoints(): Vector2[][];
+    getPointsFlattened(): Vector2[];
+    getBounds(): {
+        min: Vec2;
+        max: Vec2;
+        size: Vec2;
+    };
+}
+export declare class PlanarPointGeometry extends PlanarGeometry {
+    constructor(coordinates: PlanarPointCoordinates, offset?: Vec2);
+    forEachCoordinate(callback: (pos: Vec2) => void): void;
+    getPoints(): Vector2[][];
+    clone(): PlanarPointGeometry;
+}
+export declare class PlanarLineGeometry extends PlanarGeometry {
+    constructor(coordinates: PlanarLineCoordinates, offset?: Vec2);
+    forEachCoordinate(callback: (pos: Vec2) => void): void;
+    getPoints(): Vector2[][];
+    clone(): PlanarLineGeometry;
+}
+export declare class PlanarPolygonGeometry extends PlanarGeometry {
+    constructor(coordinates: PlanarPolygonCoordinates, offset?: Vec2);
+    forEachCoordinate(callback: (pos: Vec2) => void): void;
+    getPoints(): Vector2[][];
+    clone(): PlanarPolygonGeometry;
+    toShapes(): Shape[];
+}

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

@@ -11,7 +11,9 @@ export * from './geometries/curve/curve-3d';
 export * from './geometries/curve/tube-geometry';
 export * from './geometries/delatin';
 export * from './geometries/fence';
+export * from './geometries/geometry';
 export * from './geometries/packing';
+export * from './geometries/planar-geometry';
 export * from './geometries/triangulate-grid';
 export * from './geometries/triangulate-grid-delaunay';
 export * from './managers/CameraManager';

package/dist/types/sdk/utils/geojson.d.ts

@@ -0,0 +1,15 @@
+import { CoordinatesTransformFunction, PlanarGeometry } from '../geometries/planar-geometry';
+export type GeoJsonFeature = {
+    properties: Record<string, any>;
+    geometry: PlanarGeometry;
+};
+/**
+ * Simple helper function to parse a GeoJSON feature into a videx-3d GeoJsonFeature type,
+ * where the geometry is represented as an instance of PlanarGeometry.
+ * @param feature GeoJSON feature object
+ * @param transform Coordinate conversion function (i.e. from wgs84 to 3D world coordinates)
+ * @returns GeoJsonFeature type
+ *
+ * @see PlanarGeometry
+ */
+export declare function parseGeoJsonFeature(feature: any, transform?: CoordinatesTransformFunction): GeoJsonFeature;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@equinor/videx-3d",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "private": false,
   "type": "module",
   "license": "MIT",