@viamrobotics/motion-tools 1.15.8 → 1.18.0

package/dist/attribute.d.ts

@@ -1,3 +1,4 @@
 import { BufferGeometry } from 'three';
-export declare const createBufferGeometry: (positions: Float32Array, colors?: Uint8Array | null) => BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
-export declare const updateBufferGeometry: (geometry: BufferGeometry, positions: Float32Array, colors?: Uint8Array | null) => void;
+import type { Metadata } from './metadata';
+export declare const createBufferGeometry: (positions: Float32Array, metadata?: Metadata) => BufferGeometry<import("three").NormalBufferAttributes, import("three").BufferGeometryEventMap>;
+export declare const updateBufferGeometry: (geometry: BufferGeometry, positions: Float32Array, metadata: Metadata) => void;

package/dist/attribute.js

@@ -1,20 +1,18 @@
 import { BufferAttribute, BufferGeometry } from 'three';
-import { STRIDE } from './buffer';
-const colorStride = (colors, positions) => {
-    const numVertices = positions.length / STRIDE.POSITIONS;
-    const stride = colors.length / numVertices;
-    return stride === STRIDE.COLORS_RGBA ? STRIDE.COLORS_RGBA : STRIDE.COLORS_RGB;
-};
-export const createBufferGeometry = (positions, colors) => {
+import { colorStride } from './buffer';
+export const createBufferGeometry = (positions, metadata) => {
     const geometry = new BufferGeometry();
     geometry.setAttribute('position', new BufferAttribute(positions, 3));
-    if (colors) {
-        const stride = colorStride(colors, positions);
-        geometry.setAttribute('color', new BufferAttribute(colors, stride, true));
+    if (metadata?.colors) {
+        const stride = colorStride(metadata.colorFormat);
+        geometry.setAttribute('color', new BufferAttribute(metadata.colors, stride, true));
+    }
+    if (metadata?.opacities) {
+        geometry.setAttribute('opacity', new BufferAttribute(metadata.opacities, 1, true));
     }
     return geometry;
 };
-export const updateBufferGeometry = (geometry, positions, colors) => {
+export const updateBufferGeometry = (geometry, positions, metadata) => {
     const positionAttr = geometry.getAttribute('position');
     if (positionAttr && positionAttr.array.length >= positions.length) {
         positionAttr.array.set(positions, 0);
@@ -24,15 +22,25 @@ export const updateBufferGeometry = (geometry, positions, colors) => {
     else {
         geometry.setAttribute('position', new BufferAttribute(positions, 3));
     }
-    if (colors) {
+    if (metadata.colors) {
+        const stride = colorStride(metadata.colorFormat);
         const colorAttr = geometry.getAttribute('color');
-        if (colorAttr && colorAttr.array.length >= colors.length) {
-            colorAttr.array.set(colors, 0);
+        if (colorAttr && colorAttr.array.length >= metadata.colors.length) {
+            colorAttr.array.set(metadata.colors, 0);
             colorAttr.needsUpdate = true;
         }
         else {
-            const stride = colorStride(colors, positions);
-            geometry.setAttribute('color', new BufferAttribute(colors, stride, true));
+            geometry.setAttribute('color', new BufferAttribute(metadata.colors, stride, true));
+        }
+    }
+    if (metadata.opacities) {
+        const opacityAttr = geometry.getAttribute('opacity');
+        if (opacityAttr && opacityAttr.array.length >= metadata.opacities.length) {
+            opacityAttr.array.set(metadata.opacities, 0);
+            opacityAttr.needsUpdate = true;
+        }
+        else {
+            geometry.setAttribute('opacity', new BufferAttribute(metadata.opacities, 1, true));
         }
     }
 };

package/dist/buf/draw/v1/drawing_pb.d.ts

@@ -5,9 +5,11 @@ import { Metadata } from "./metadata_pb";
 /**
  * Arrows represents a set of arrows in 3D space
  * Metadata:
- * - colors: []uint8 of a single color: [r, g, b, a]
- *   or a color per arrow: [r, g, b, a, ...]
- *   defaults to [0, 255, 0, 180] (green)
+ * - colors: []uint8 of a single color or a color per arrow
+ *   defaults to [0, 128, 0] (green)
+ * - color format: the format of the colors field, defaults to COLOR_FORMAT_RGB
+ * - opacities: []uint8 of a single opacity or a opacity per arrow
+ *   defaults to [255] (fully opaque)
  *
  * @generated from message draw.v1.Arrows
  */
@@ -31,15 +33,17 @@ export declare class Arrows extends Message<Arrows> {
 /**
  * Line represents a line in 3D space
  * Metadata:
- * - colors: []uint8 of a single color: [r, g, b, a]
- *   or two colors for lines and points: [r, g, b, a, r, g, b, a]
- *   defaults to [0, 128, 255, 180] (blue) for lines, [0, 77, 204, 180] (darker blue) for points
+ * - colors: []uint8 of a single color or a color per line point
+ *   defaults to [0, 0, 255] (blue)
+ * - color format: the format of the colors field, defaults to COLOR_FORMAT_RGB
+ * - opacities: []uint8 of a single opacity or a opacity per line point
+ *   defaults to [255] (fully opaque)
  *
  * @generated from message draw.v1.Line
  */
 export declare class Line extends Message<Line> {
     /**
-     * The positions of the line points
+     * The positions of the line dots
      * float32 array of positions: [x, y, z, ...]
      *
      * @generated from field: bytes positions = 1;
@@ -52,11 +56,19 @@ export declare class Line extends Message<Line> {
      */
     lineWidth?: number;
     /**
-     * optional size of the points in millimeters, defaults to 10
+     * optional size of the dots in millimeters, defaults to 10
      *
-     * @generated from field: optional float point_size = 3;
+     * @generated from field: optional float dot_size = 3;
      */
-    pointSize?: number;
+    dotSize?: number;
+    /**
+     * optional colors for the line dots
+     * []uint8 of a single color: [r, g, b, a]
+     * or one color per dot: [r, g, b, a, ...]
+     *
+     * @generated from field: optional bytes dot_colors = 4;
+     */
+    dotColors?: Uint8Array;
     constructor(data?: PartialMessage<Line>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "draw.v1.Line";
@@ -69,9 +81,11 @@ export declare class Line extends Message<Line> {
 /**
  * Points represents a set of points in 3D space
  * Metadata:
- * - colors: []uint8 of a single color: [r, g, b, a]
- *   or a color per point: [r, g, b, a, ...]
- *   defaults to [51, 51, 51, 180] (gray)
+ * - colors: []uint8 of a single color or a color per point
+ *   defaults to [128, 128, 128] (gray)
+ * - color format: the format of the colors field, defaults to COLOR_FORMAT_RGB
+ * - opacities: []uint8 of a single opacity or a opacity per point
+ *   defaults to [255] (fully opaque)
  *
  * @generated from message draw.v1.Points
  */
@@ -171,7 +185,7 @@ export declare class Model extends Message<Model> {
      */
     scale?: Vector3;
     /**
-     * Name of the animation to play, defaults to empty string (no animation)
+     * Name ofI the animation to play, defaults to empty string (no animation)
      *
      * @generated from field: optional string animation_name = 3;
      */
@@ -188,8 +202,11 @@ export declare class Model extends Message<Model> {
 /**
  * Nurbs represents a NURBS curve in 3D space
  * Metadata:
- * - colors: []uint8 of a single color: [r, g, b, a]
- *   defaults to [0, 255, 255, 180] (cyan)
+ * - colors: []uint8 of a single color or a color per NURBS control point
+ *   defaults to [0, 255, 255] (cyan)
+ * - color format: the format of the colors field, defaults to COLOR_FORMAT_RGB
+ * - opacities: []uint8 of a single opacity or a opacity per NURBS control point
+ *   defaults to [255] (fully opaque)
  *
  * @generated from message draw.v1.Nurbs
  */

package/dist/buf/draw/v1/drawing_pb.js

@@ -8,9 +8,11 @@ import { Metadata } from "./metadata_pb";
 /**
  * Arrows represents a set of arrows in 3D space
  * Metadata:
- * - colors: []uint8 of a single color: [r, g, b, a]
- *   or a color per arrow: [r, g, b, a, ...]
- *   defaults to [0, 255, 0, 180] (green)
+ * - colors: []uint8 of a single color or a color per arrow
+ *   defaults to [0, 128, 0] (green)
+ * - color format: the format of the colors field, defaults to COLOR_FORMAT_RGB
+ * - opacities: []uint8 of a single opacity or a opacity per arrow
+ *   defaults to [255] (fully opaque)
  *
  * @generated from message draw.v1.Arrows
  */
@@ -47,15 +49,17 @@ export class Arrows extends Message {
 /**
  * Line represents a line in 3D space
  * Metadata:
- * - colors: []uint8 of a single color: [r, g, b, a]
- *   or two colors for lines and points: [r, g, b, a, r, g, b, a]
- *   defaults to [0, 128, 255, 180] (blue) for lines, [0, 77, 204, 180] (darker blue) for points
+ * - colors: []uint8 of a single color or a color per line point
+ *   defaults to [0, 0, 255] (blue)
+ * - color format: the format of the colors field, defaults to COLOR_FORMAT_RGB
+ * - opacities: []uint8 of a single opacity or a opacity per line point
+ *   defaults to [255] (fully opaque)
  *
  * @generated from message draw.v1.Line
  */
 export class Line extends Message {
     /**
-     * The positions of the line points
+     * The positions of the line dots
      * float32 array of positions: [x, y, z, ...]
      *
      * @generated from field: bytes positions = 1;
@@ -68,11 +72,19 @@ export class Line extends Message {
      */
     lineWidth;
     /**
-     * optional size of the points in millimeters, defaults to 10
+     * optional size of the dots in millimeters, defaults to 10
      *
-     * @generated from field: optional float point_size = 3;
+     * @generated from field: optional float dot_size = 3;
      */
-    pointSize;
+    dotSize;
+    /**
+     * optional colors for the line dots
+     * []uint8 of a single color: [r, g, b, a]
+     * or one color per dot: [r, g, b, a, ...]
+     *
+     * @generated from field: optional bytes dot_colors = 4;
+     */
+    dotColors;
     constructor(data) {
         super();
         proto3.util.initPartial(data, this);
@@ -82,7 +94,8 @@ export class Line extends Message {
     static fields = proto3.util.newFieldList(() => [
         { no: 1, name: "positions", kind: "scalar", T: 12 /* ScalarType.BYTES */ },
         { no: 2, name: "line_width", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
-        { no: 3, name: "point_size", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
+        { no: 3, name: "dot_size", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
+        { no: 4, name: "dot_colors", kind: "scalar", T: 12 /* ScalarType.BYTES */, opt: true },
     ]);
     static fromBinary(bytes, options) {
         return new Line().fromBinary(bytes, options);
@@ -100,9 +113,11 @@ export class Line extends Message {
 /**
  * Points represents a set of points in 3D space
  * Metadata:
- * - colors: []uint8 of a single color: [r, g, b, a]
- *   or a color per point: [r, g, b, a, ...]
- *   defaults to [51, 51, 51, 180] (gray)
+ * - colors: []uint8 of a single color or a color per point
+ *   defaults to [128, 128, 128] (gray)
+ * - color format: the format of the colors field, defaults to COLOR_FORMAT_RGB
+ * - opacities: []uint8 of a single opacity or a opacity per point
+ *   defaults to [255] (fully opaque)
  *
  * @generated from message draw.v1.Points
  */
@@ -213,7 +228,7 @@ export class Model extends Message {
      */
     scale;
     /**
-     * Name of the animation to play, defaults to empty string (no animation)
+     * Name ofI the animation to play, defaults to empty string (no animation)
      *
      * @generated from field: optional string animation_name = 3;
      */
@@ -245,8 +260,11 @@ export class Model extends Message {
 /**
  * Nurbs represents a NURBS curve in 3D space
  * Metadata:
- * - colors: []uint8 of a single color: [r, g, b, a]
- *   defaults to [0, 255, 255, 180] (cyan)
+ * - colors: []uint8 of a single color or a color per NURBS control point
+ *   defaults to [0, 255, 255] (cyan)
+ * - color format: the format of the colors field, defaults to COLOR_FORMAT_RGB
+ * - opacities: []uint8 of a single opacity or a opacity per NURBS control point
+ *   defaults to [255] (fully opaque)
  *
  * @generated from message draw.v1.Nurbs
  */

package/dist/buf/draw/v1/metadata_pb.d.ts

@@ -1,17 +1,58 @@
 import type { BinaryReadOptions, FieldList, JsonReadOptions, JsonValue, PartialMessage, PlainMessage } from "@bufbuild/protobuf";
 import { Message, proto3 } from "@bufbuild/protobuf";
+/**
+ * ColorFormat describes the encoding of the colors bytes field.
+ *
+ * @generated from enum draw.v1.ColorFormat
+ */
+export declare enum ColorFormat {
+    /**
+     * @generated from enum value: COLOR_FORMAT_UNSPECIFIED = 0;
+     */
+    UNSPECIFIED = 0,
+    /**
+     * @generated from enum value: COLOR_FORMAT_RGB = 1;
+     */
+    RGB = 1
+}
 /**
  * @generated from message draw.v1.Metadata
  */
 export declare class Metadata extends Message<Metadata> {
     /**
-     * Uint8Array of colors: [r, g, b, a, ...]
-     * For simple objects, this is a single color of [r, g, b, a]
-     * For complex objects, this is an array of colors of [r, g, b, a, ...]
+     * Uint8Array of color values (0-255) based on the color format.
+     * Can be a single set of values for a uniform color, or an array of values for per-vertex colors.
      *
      * @generated from field: optional bytes colors = 1;
      */
     colors?: Uint8Array;
+    /**
+     * Describes the encoding of the colors field. Defaults to COLOR_FORMAT_RGB when set by this API.
+     *
+     * @generated from field: draw.v1.ColorFormat color_format = 2;
+     */
+    colorFormat: ColorFormat;
+    /**
+     * Uint8Array of opacity values (0-255) corresponding to colors.
+     * Can be a single set of values for a uniform opacity, or an array of values for per-vertex opacity.
+     *
+     * @generated from field: optional bytes opacities = 3;
+     */
+    opacities?: Uint8Array;
+    /**
+     * Whether to show the axes helper (RGB XYZ indicator) on the entity.
+     * Defaults to false.
+     *
+     * @generated from field: optional bool show_axes_helper = 4;
+     */
+    showAxesHelper?: boolean;
+    /**
+     * Whether the entity is invisible (not rendered) by default.
+     * Defaults to false.
+     *
+     * @generated from field: optional bool invisible = 5;
+     */
+    invisible?: boolean;
     constructor(data?: PartialMessage<Metadata>);
     static readonly runtime: typeof proto3;
     static readonly typeName = "draw.v1.Metadata";

package/dist/buf/draw/v1/metadata_pb.js

@@ -3,18 +3,65 @@
 /* eslint-disable */
 // @ts-nocheck
 import { Message, proto3 } from "@bufbuild/protobuf";
+/**
+ * ColorFormat describes the encoding of the colors bytes field.
+ *
+ * @generated from enum draw.v1.ColorFormat
+ */
+export var ColorFormat;
+(function (ColorFormat) {
+    /**
+     * @generated from enum value: COLOR_FORMAT_UNSPECIFIED = 0;
+     */
+    ColorFormat[ColorFormat["UNSPECIFIED"] = 0] = "UNSPECIFIED";
+    /**
+     * @generated from enum value: COLOR_FORMAT_RGB = 1;
+     */
+    ColorFormat[ColorFormat["RGB"] = 1] = "RGB";
+})(ColorFormat || (ColorFormat = {}));
+// Retrieve enum metadata with: proto3.getEnumType(ColorFormat)
+proto3.util.setEnumType(ColorFormat, "draw.v1.ColorFormat", [
+    { no: 0, name: "COLOR_FORMAT_UNSPECIFIED" },
+    { no: 1, name: "COLOR_FORMAT_RGB" },
+]);
 /**
  * @generated from message draw.v1.Metadata
  */
 export class Metadata extends Message {
     /**
-     * Uint8Array of colors: [r, g, b, a, ...]
-     * For simple objects, this is a single color of [r, g, b, a]
-     * For complex objects, this is an array of colors of [r, g, b, a, ...]
+     * Uint8Array of color values (0-255) based on the color format.
+     * Can be a single set of values for a uniform color, or an array of values for per-vertex colors.
      *
      * @generated from field: optional bytes colors = 1;
      */
     colors;
+    /**
+     * Describes the encoding of the colors field. Defaults to COLOR_FORMAT_RGB when set by this API.
+     *
+     * @generated from field: draw.v1.ColorFormat color_format = 2;
+     */
+    colorFormat = ColorFormat.UNSPECIFIED;
+    /**
+     * Uint8Array of opacity values (0-255) corresponding to colors.
+     * Can be a single set of values for a uniform opacity, or an array of values for per-vertex opacity.
+     *
+     * @generated from field: optional bytes opacities = 3;
+     */
+    opacities;
+    /**
+     * Whether to show the axes helper (RGB XYZ indicator) on the entity.
+     * Defaults to false.
+     *
+     * @generated from field: optional bool show_axes_helper = 4;
+     */
+    showAxesHelper;
+    /**
+     * Whether the entity is invisible (not rendered) by default.
+     * Defaults to false.
+     *
+     * @generated from field: optional bool invisible = 5;
+     */
+    invisible;
     constructor(data) {
         super();
         proto3.util.initPartial(data, this);
@@ -23,6 +70,10 @@ export class Metadata extends Message {
     static typeName = "draw.v1.Metadata";
     static fields = proto3.util.newFieldList(() => [
         { no: 1, name: "colors", kind: "scalar", T: 12 /* ScalarType.BYTES */, opt: true },
+        { no: 2, name: "color_format", kind: "enum", T: proto3.getEnumType(ColorFormat) },
+        { no: 3, name: "opacities", kind: "scalar", T: 12 /* ScalarType.BYTES */, opt: true },
+        { no: 4, name: "show_axes_helper", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
+        { no: 5, name: "invisible", kind: "scalar", T: 8 /* ScalarType.BOOL */, opt: true },
     ]);
     static fromBinary(bytes, options) {
         return new Metadata().fromBinary(bytes, options);

package/dist/buf/draw/v1/scene_pb.d.ts

@@ -190,25 +190,25 @@ export declare class SceneMetadata extends Message<SceneMetadata> {
     pointSize?: number;
     /**
      * The color of the points if not defined by a transform's metadata
-     * defaults to [51, 51, 51, 255] (gray)
+     * defaults to [51, 51, 51] (gray)
      *
      * @generated from field: optional bytes point_color = 7;
      */
     pointColor?: Uint8Array;
     /**
      * The width of the lines if not defined by a transform's metadata
-     * defaults to 5 (millimeters)
+     * defaults to 5mm
      *
      * @generated from field: optional float line_width = 8;
      */
     lineWidth?: number;
     /**
-     * The size of the points of the lines if not defined by a transform's
-     * metadata defaults to 10 (millimeters)
+     * The size of the dots of the lines if not defined by a transform's
+     * metadata defaults to 10mm
      *
-     * @generated from field: optional float line_point_size = 9;
+     * @generated from field: optional float line_dot_size = 9;
      */
-    linePointSize?: number;
+    lineDotSize?: number;
     /**
      * The models to render
      * defaults to COLLIDERS_AND_MODEL

package/dist/buf/draw/v1/scene_pb.js

@@ -237,25 +237,25 @@ export class SceneMetadata extends Message {
     pointSize;
     /**
      * The color of the points if not defined by a transform's metadata
-     * defaults to [51, 51, 51, 255] (gray)
+     * defaults to [51, 51, 51] (gray)
      *
      * @generated from field: optional bytes point_color = 7;
      */
     pointColor;
     /**
      * The width of the lines if not defined by a transform's metadata
-     * defaults to 5 (millimeters)
+     * defaults to 5mm
      *
      * @generated from field: optional float line_width = 8;
      */
     lineWidth;
     /**
-     * The size of the points of the lines if not defined by a transform's
-     * metadata defaults to 10 (millimeters)
+     * The size of the dots of the lines if not defined by a transform's
+     * metadata defaults to 10mm
      *
-     * @generated from field: optional float line_point_size = 9;
+     * @generated from field: optional float line_dot_size = 9;
      */
-    linePointSize;
+    lineDotSize;
     /**
      * The models to render
      * defaults to COLLIDERS_AND_MODEL
@@ -285,7 +285,7 @@ export class SceneMetadata extends Message {
         { no: 6, name: "point_size", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
         { no: 7, name: "point_color", kind: "scalar", T: 12 /* ScalarType.BYTES */, opt: true },
         { no: 8, name: "line_width", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
-        { no: 9, name: "line_point_size", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
+        { no: 9, name: "line_dot_size", kind: "scalar", T: 2 /* ScalarType.FLOAT */, opt: true },
         { no: 10, name: "render_arm_models", kind: "enum", T: proto3.getEnumType(RenderArmModels), opt: true },
         { no: 11, name: "render_shapes", kind: "enum", T: proto3.getEnumType(RenderShapes), repeated: true },
     ]);

package/dist/buffer.d.ts

@@ -1,44 +1,36 @@
-/**
- * Zero-copy buffer utilities for converting protobuf bytes to Three.js typed arrays.
- *
- * Proto messages pack float32 data as `Uint8Array` (bytes fields). These utilities
- * provide efficient conversion to `Float32Array` for Three.js BufferAttributes.
- */
 import { Color } from 'three';
-/**
- * Stride constants for proto binary data formats.
- * Each value represents the number of float32 elements per item.
- */
+import { ColorFormat } from './buf/draw/v1/metadata_pb';
 export declare const STRIDE: {
-    /** Arrows: [x, y, z, ox, oy, oz] per arrow */
+    /** Arrows: [x, y, z, ox, oy, oz, ...] */
     readonly ARROWS: 6;
-    /** Line/Points: [x, y, z] per point */
+    /** Line/Points: [x, y, z, ...] */
     readonly POSITIONS: 3;
-    /** Nurbs control points: [x, y, z, ox, oy, oz, theta] per point */
+    /** Nurbs control points: [x, y, z, ox, oy, oz, theta, ...] */
     readonly NURBS_CONTROL_POINTS: 7;
-    /** Nurbs knots/weights: single float per element */
+    /** Nurbs knots/weights: [w, ...] */
     readonly NURBS_KNOTS: 1;
-    /** Colors: [r, g, b, a] per color (uint8) */
-    readonly COLORS_RGBA: 4;
-    /** Colors: [r, g, b] */
+    /** Colors: [r, g, b, ...] */
     readonly COLORS_RGB: 3;
 };
 /**
  * Creates a Float32Array view over a Uint8Array without copying data.
  * Falls back to a copy if the buffer is not 4-byte aligned (rare with protobuf).
  *
+ * An optional `transform` applies a per-element function during conversion.
+ *
  * @param bytes - The raw bytes from a protobuf bytes field
+ * @param transform - Optional function applied to every float element
  * @returns A Float32Array view or copy of the data
  *
  * @example
  * ```ts
  * const positions = asFloat32Array(line.positions)
- * geometry.setAttribute('position', new BufferAttribute(positions, 3))
+ * const meterPositions = asFloat32Array(line.positions, inMeters)
  * ```
  */
-export declare const asFloat32Array: (bytes: Uint8Array<ArrayBuffer>) => Float32Array<ArrayBuffer>;
+export declare const asFloat32Array: (bytes: Uint8Array, transform?: (value: number) => number) => Float32Array;
 /**
- * Sets a Three.js Color from 3 bytes of a uint8 color array starting at `offset`.
+ * Sets a Three.js Color from 3 bytes of a uint8 RGB color array starting at `offset`.
  * Mutates and returns `target` — pass a pre-allocated Color to avoid allocations
  * in hot paths.
  *
@@ -50,52 +42,69 @@ export declare const asFloat32Array: (bytes: Uint8Array<ArrayBuffer>) => Float32
  * @example
  * ```ts
  * asColor(colors.current, material.color)
- * asColor(colors.current, pointColorUtil, stride) // read second color
+ * asColor(colors.current, pointColorUtil, STRIDE.COLORS_RGB) // read second color
  * ```
  */
-export declare const asColor: (bytes: Uint8Array<ArrayBuffer>, target: Color, offset?: number) => Color;
+export declare const asColor: (bytes: Uint8Array, target: Color, offset?: number) => Color;
+export declare const asRGB: (bytes: Uint8Array, target: {
+    r: number;
+    g: number;
+    b: number;
+}, offset?: number) => {
+    r: number;
+    g: number;
+    b: number;
+};
 /**
- * Creates a Uint8Array from a Three.js Color.
+ * Reads a byte from a uint8 opacities array at `index` and normalizes it to 0-1.
+ * Returns `fallback` when the array is absent or shorter than `index + 1`.
  *
- * @param color - The Three.js Color to convert
- * @returns A Uint8Array with the RGBA values
+ * @param opacities - Uint8Array of opacity values (0-255). Length 1 = uniform. Length N = per-vertex.
+ * @param fallback - Value to return when no opacity byte is available (default 1)
+ * @param index - Index into the opacities array (default 0)
+ * @returns Normalized opacity in 0-1 range, or the fallback value
  *
  * @example
  * ```ts
- * const color = fromColor(new Color(0, 1, 0))
+ * material.opacity = asOpacity(metadata.opacities)
  * ```
  */
-export declare const fromColor: (color: Color) => Uint8Array<ArrayBuffer>;
+export declare const asOpacity: (opacities: Uint8Array | undefined, fallback?: number, index?: number) => number;
 /**
- * Reads a byte from a uint8 color array at `offset` and normalizes it to 0-1.
- * Returns `fallback` when the array has fewer than `offset + 1` elements.
- *
- * @param bytes - ArrayLike of uint8 color values
- * @param fallback - Value to return when no alpha byte is present (default 1)
- * @param offset - Byte index to read from (default 3, the alpha channel of the first color)
- * @returns Normalized opacity in 0-1 range, or the fallback value
+ * Returns true when `colors` contains exactly one color (RGB or RGBA),
+ * as opposed to a per-vertex color array.
  *
  * @example
  * ```ts
- * material.opacity = asOpacity(colors.current)
- * material.opacity = asOpacity(colors.current, 1, stride + 3) // alpha of second color
+ * if (isSingleColor(colors)) {
+ *   material.color = asColor(colors, colorUtil)
+ * }
  * ```
  */
-export declare const asOpacity: (bytes: Uint8Array<ArrayBuffer>, fallback?: number, offset?: number) => number;
+export declare const isSingleColor: (colors: Uint8Array) => boolean;
 /**
- * Returns true when `colors` contains exactly one color entry per point (RGB or RGBA).
- * Use this to distinguish per-vertex color buffers from a single uniform color.
+ * Returns true when `colors` contains per-vertex color data rather than a
+ * single uniform color.
  *
- * @param colors - Uint8Array of packed color bytes
- * @param numVertex - Number of points/vertices the color buffer should cover
+ * @param colors - Uint8Array of packed RGB bytes (stride of 3)
  *
  * @example
  * ```ts
- * if (isPerVertexColors(colors, positions.length / STRIDE.POSITIONS)) {
+ * if (isVertexColors(colors, positions.length / 3)) {
  *   // treat as per-vertex
- * } else {
- *   addColorTraits(entityTraits, colors)
  * }
  * ```
  */
-export declare const isPerVertexColors: (colors: Uint8Array<ArrayBuffer>, numVertex: number) => boolean;
+export declare const isVertexColors: (colors: Uint8Array | undefined) => colors is Uint8Array;
+/**
+ * Per-element transform that converts a millimeter value to meters.
+ * Pass to {@link asFloat32Array} to fuse the conversion into a single pass.
+ *
+ * @example
+ * ```ts
+ * const positions = asFloat32Array(line.positions, inMeters)
+ * ```
+ */
+export declare const inMeters: (v: number) => number;
+/** Returns the byte stride for a given color format. */
+export declare const colorStride: (format?: ColorFormat) => number;