@daneren2005/shared-memory-objects 0.0.0 → 0.0.1

package/src/utils/16-from-32-array.ts

@@ -0,0 +1,23 @@
+const buffer = new ArrayBuffer(4);
+const uint32Array = new Uint32Array(buffer);
+const uint16Array = new Uint16Array(buffer);
+
+export function load16From32(data: Uint32Array, index: number): [number, number] {
+	return convert32To16(Atomics.load(data, index));
+}
+
+export function store16In32(data: Uint32Array, index: number, value1: number, value2: number) {
+	Atomics.store(data, index, convert16To32(value1, value2));
+}
+
+export function convert32To16(value: number): [number, number] {
+	uint32Array[0] = value;
+
+	return [uint16Array[0], uint16Array[1]];
+}
+export function convert16To32(value1: number, value2: number): number {
+	uint16Array[0] = value1;
+	uint16Array[1] = value2;
+
+	return uint32Array[0];
+}

package/src/utils/16-from-64-array.ts

@@ -0,0 +1,18 @@
+const buffer = new ArrayBuffer(8);
+const uint64Array = new BigUint64Array(buffer);
+const uint16Array = new Uint16Array(buffer);
+
+export function load16From64(data: BigUint64Array, index: number): [number, number, number, number] {
+	uint64Array[0] = Atomics.load(data, index);
+	
+	return [uint16Array[0], uint16Array[1], uint16Array[2], uint16Array[3]];
+}
+
+export function store16In64(data: BigUint64Array, index: number, value1: number, value2: number, value3: number, value4: number = 0) {
+	uint16Array[0] = value1;
+	uint16Array[1] = value2;
+	uint16Array[2] = value3;
+	uint16Array[3] = value4;
+
+	Atomics.store(data, index, uint64Array[0]);
+}

package/src/utils/__tests__/pointer.spec.ts

@@ -0,0 +1,18 @@
+import { MAX_BYTE_OFFSET_LENGTH, MAX_POSITION_LENGTH, createPointer, getPointer } from '../pointer';
+
+describe('pointer', () => {
+	it('check all numbers', () => {
+		const SKIP_POSITIONS = 10;
+		const SKIP_BYTE_OFFSETS = 10;
+
+		for(let position = 0; position < MAX_POSITION_LENGTH; position += SKIP_POSITIONS) {
+			for(let byteOffset = 1; byteOffset < MAX_BYTE_OFFSET_LENGTH; byteOffset *= SKIP_BYTE_OFFSETS) {
+				let pointer = createPointer(position, byteOffset);
+
+				let { bufferPosition, bufferByteOffset } = getPointer(pointer);
+				expect(bufferPosition).toEqual(position);
+				expect(bufferByteOffset).toEqual(byteOffset);
+			}
+		}
+	});
+});

package/src/utils/float32-atomics.ts

@@ -0,0 +1,24 @@
+// For doing Atomic operations on floats in SharedArrayBuffers
+const buffer = new ArrayBuffer(4);
+const float32 = new Float32Array(buffer);
+const int32 = new Int32Array(buffer);
+
+function loadFloat32(data: Int32Array, index: number) {
+	return convertInt32ToFloat32(Atomics.load(data, index));
+}
+function storeFloat32(data: Int32Array, index: number, value: number) {
+	Atomics.store(data, index, convertFloat32ToInt32(value));
+}
+
+function convertInt32ToFloat32(value: number) {
+	int32[0] = value;
+
+	return float32[0];
+}
+function convertFloat32ToInt32(value: number) {
+	float32[0] = value;
+
+	return int32[0];
+}
+
+export { loadFloat32, storeFloat32, convertInt32ToFloat32, convertFloat32ToInt32 };

package/src/utils/pointer.ts

@@ -0,0 +1,40 @@
+// bottom 12 bits (4096) for bufferPosition
+// top 20 bits (1MB) for bufferByteOffset
+const BYTE_OFFSET_BIT_COUNT = 20;
+const POSITION_BIT_COUNT = 32 - BYTE_OFFSET_BIT_COUNT;
+const MAX_BYTE_OFFSET_LENGTH = Math.pow(2, BYTE_OFFSET_BIT_COUNT);
+const MAX_POSITION_LENGTH = Math.pow(2, POSITION_BIT_COUNT);
+
+export function loadPointer(data: Uint32Array, index: number = 0) {
+	return getPointer(Atomics.load(data, index));
+}
+export function loadRawPointer(data: Uint32Array, index: number = 0) {
+	return Atomics.load(data, index);
+}
+
+export function storePointer(data: Uint32Array, index: number = 0, bufferPosition: number, bufferByteOffset: number) {
+	Atomics.store(data, index, createPointer(bufferPosition, bufferByteOffset));
+}
+export function storeRawPointer(data: Uint32Array, index: number = 0, pointer: number) {
+	Atomics.store(data, index, pointer);
+}
+
+export function replacePointer(data: Uint32Array, index: number, newBufferPosition: number, newBufferByteOffset: number, oldBufferPosition: number, oldBufferByteOffset: number) {
+	let oldPointer = createPointer(oldBufferPosition, oldBufferByteOffset);
+	return Atomics.compareExchange(data, index, oldPointer, createPointer(newBufferPosition, newBufferByteOffset)) === oldPointer;
+}
+export function replaceRawPointer(data: Uint32Array, index: number, newPointer: number, oldPointer: number): boolean {
+	return Atomics.compareExchange(data, index, oldPointer, newPointer) === oldPointer;
+}
+
+export function getPointer(value: number) {
+	return {
+		bufferPosition: value & 0b00000000000000000000111111111111,
+		bufferByteOffset: value >>> POSITION_BIT_COUNT
+	};
+}
+export function createPointer(bufferPosition: number, bufferByteOffset: number) {
+	return bufferPosition + (bufferByteOffset << POSITION_BIT_COUNT);
+}
+
+export { BYTE_OFFSET_BIT_COUNT, POSITION_BIT_COUNT, MAX_BYTE_OFFSET_LENGTH, MAX_POSITION_LENGTH };

package/src/utils/typedarray.d.ts

@@ -0,0 +1,279 @@
+export type ArrayLikeIterable<T> = ArrayLike<T> & Iterable<T>;
+export type NumericArray = number[] | TypedArray;
+export type TypedArray = Float32Array | Float64Array | Int8Array | Int16Array | Int32Array | Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
+export type BigTypedArray = BigInt64Array | BigUint64Array;
+export type FloatArray = Float32Array | Float64Array;
+export type IntArray = Int8Array | Int16Array | Int32Array;
+export type UIntArray = Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array;
+export type FloatArrayConstructor = Float32ArrayConstructor | Float64ArrayConstructor;
+export type IntArrayConstructor = Int8ArrayConstructor | Int16ArrayConstructor | Int32ArrayConstructor;
+export type UIntArrayConstructor = Uint8ArrayConstructor | Uint8ClampedArrayConstructor | Uint16ArrayConstructor | Uint32ArrayConstructor;
+export type BigIntArrayConstructor = BigInt64ArrayConstructor | BigUint64ArrayConstructor;
+export type TypedArrayConstructor = FloatArrayConstructor | IntArrayConstructor | UIntArrayConstructor;
+/**
+ * Type IDs for typed array backed buffers and generally describing binary data
+ * values.
+ *
+ * {@link GLType} {@link GL2TYPE} {@link TYPE2GL}
+ */
+export type Type = 'u8' | 'u8c' | 'i8' | 'u16' | 'i16' | 'u32' | 'i32' | 'f32' | 'f64';
+export type BigType = 'i64' | 'u64';
+export type UintType = 'u8' | 'u8c' | 'u16' | 'u32';
+export type IntType = 'i8' | 'i16' | 'i32';
+export type FloatType = 'f32' | 'f64';
+/**
+ * WebGL numeric type constants. Use {@link GL2TYPE} to convert, if needed.
+ *
+ * {@link Type}
+ * {@link GL2TYPE}
+ * {@link TYPE2GL}
+ */
+export declare enum GLType {
+    I8 = 5120,
+    U8 = 5121,
+    I16 = 5122,
+    U16 = 5123,
+    I32 = 5124,
+    U32 = 5125,
+    F32 = 5126
+}
+/**
+ * Conversion from {@link GLType} to {@link Type} enums.
+ */
+export declare const GL2TYPE: Record<GLType, Type>;
+/**
+ * Potentially lossy conversion from {@link Type} to {@link GLType} enums.
+ *
+ * Not all enums are mappable:
+ *
+ * - `F64` maps to `undefined`, since unsupported by WebGL
+ * - `U8C` maps to "u8"
+ */
+export declare const TYPE2GL: Record<Type, GLType | undefined>;
+/**
+ * Size information (in bytes) for {@link Type} and {@link BigType}. Also see
+ * {@link sizeOf}.
+ */
+export declare const SIZEOF: {
+    u8: number;
+    u8c: number;
+    i8: number;
+    u16: number;
+    i16: number;
+    u32: number;
+    i32: number;
+    i64: number;
+    u64: number;
+    f32: number;
+    f64: number;
+};
+/**
+ * Bit shift values to convert byte addresses into array indices for all
+ * {@link Type}s and {@link BigType}s.
+ */
+export declare const BIT_SHIFTS: {
+    i8: number;
+    u8: number;
+    u8c: number;
+    i16: number;
+    u16: number;
+    i32: number;
+    u32: number;
+    i64: number;
+    u64: number;
+    f32: number;
+    f64: number;
+};
+export declare const FLOAT_ARRAY_CTORS: Record<FloatType, FloatArrayConstructor>;
+export declare const INT_ARRAY_CTORS: Record<IntType, IntArrayConstructor>;
+export declare const UINT_ARRAY_CTORS: Record<UintType, UIntArrayConstructor>;
+export declare const BIGINT_ARRAY_CTORS: Record<BigType, BigIntArrayConstructor>;
+export declare const TYPEDARRAY_CTORS: Record<Type, TypedArrayConstructor>;
+export interface TypedArrayTypeMap extends Record<Type | GLType, TypedArray> {
+    u8: Uint8Array;
+    u8c: Uint8ClampedArray;
+    i8: Int8Array;
+    u16: Uint16Array;
+    i16: Int16Array;
+    u32: Uint32Array;
+    i32: Int32Array;
+    f32: Float32Array;
+    f64: Float64Array;
+    [GLType.U8]: Uint8Array;
+    [GLType.I8]: Int8Array;
+    [GLType.U16]: Uint16Array;
+    [GLType.I16]: Int16Array;
+    [GLType.U32]: Uint32Array;
+    [GLType.I32]: Int32Array;
+    [GLType.F32]: Float32Array;
+}
+export interface BigTypedArrayTypeMap extends Record<BigType, BigTypedArray> {
+    i64: BigInt64Array;
+    u64: BigUint64Array;
+}
+/**
+ * Returns canonical {@link Type} value of `type` by first
+ * attempting to resolve it as {@link GLType} enum.
+ *
+ * @example
+ * ```ts
+ * asNativeType(GLType.F32) => "f32"
+ * asNativeType("f32") => "f32"
+ * ```
+ *
+ * @param type -
+ */
+export declare const asNativeType: (type: GLType | Type) => Type;
+/**
+ * Returns suitable {@link GLType} enum of `type`.
+ *
+ * @example
+ * ```ts
+ * asGLType("f32") => GLType.F32
+ * asGLType(GLType.F32) => GLType.F32
+ * ```
+ *
+ * @param type -
+ */
+export declare const asGLType: (type: GLType | Type) => GLType;
+/**
+ * Coerces given numeric args to integer values.
+ */
+export declare const asInt: (...args: number[]) => number[];
+/**
+ * Returns byte size for given {@link Type} ID or {@link GLType} enum.
+ *
+ * @param type -
+ */
+export declare const sizeOf: (type: Type | BigType | GLType) => number;
+/**
+ * Constructs new typed array of given {@link Type}, {@link GLType} or
+ * {@link BigType}. Supports all arities of standard typed array ctors.
+ *
+ * @param type - array type enum
+ */
+export declare function typedArray<T extends Type | GLType>(type: T, length: number): TypedArrayTypeMap[T];
+export declare function typedArray<T extends Type | GLType>(type: T, src: ArrayLike<number> | ArrayBufferLike): TypedArrayTypeMap[T];
+export declare function typedArray<T extends Type | GLType>(type: T, buf: ArrayBufferLike, byteOffset: number, length?: number): TypedArrayTypeMap[T];
+export declare function typedArray<T extends BigType>(type: T, length: number): BigTypedArrayTypeMap[T];
+export declare function typedArray<T extends BigType>(type: T, src: ArrayLike<bigint> | ArrayBufferLike): BigTypedArrayTypeMap[T];
+export declare function typedArray<T extends BigType>(type: T, buf: ArrayBufferLike, byteOffset: number, length?: number): BigTypedArrayTypeMap[T];
+/**
+ * Constructs a typed array for given `type` and populates it with given vector
+ * values.
+ *
+ * @remarks
+ * The size of the array will be `data.length * stride`, where `stride` is the
+ * number of elements per item and defaulting to the size of the first data
+ * item/vector given.
+ *
+ * @example
+ * ```ts
+ * // inferred stride=2 (2d vectors)
+ * typedArrayOfVec("f32", [[1,2], [3,4], [-10,20]]);
+ * // Float32Array(6) [ 1, 2, 3, 4, -10, 20 ]
+ *
+ * // with custom stride=4
+ * typedArrayOfVec("f32", [[1,2], [3,4], [-10,20]], 4);
+ * // Float32Array(12) [ 1, 2, 0, 0, 3,4, 0, 0, -10, 20, 0, 0 ]
+ * ```
+ *
+ * @param type
+ * @param data
+ * @param stride
+ */
+export declare function typedArrayOfVec<T extends Type | GLType>(type: T, data: Iterable<ArrayLike<number>>, stride?: number): TypedArrayTypeMap[T];
+export declare function typedArrayOfVec<T extends BigType>(type: T, data: Iterable<ArrayLike<bigint>>, stride?: number): BigTypedArrayTypeMap[T];
+/**
+ * Takes an {@link NumericArray} and returns its corresponding {@link Type} ID.
+ * Standard JS arrays will default to {@link "f64"}.
+ *
+ * @param x -
+ */
+export declare const typedArrayType: (x: NumericArray) => Type;
+/**
+ * Returns the smallest possible *unsigned* int type enum for given `x`.
+ * E.g. if `x <= 256`, the function returns `"u8"`.
+ *
+ * @param x - value to classify
+ */
+export declare const uintTypeForSize: (x: number) => UintType;
+/**
+ * Returns the smallest possible *signed* int type enum for given `x`.
+ * E.g. if `x >= -128 && x < 128`, the function returns `"i8"`.
+ *
+ * @param x - value to classify
+ */
+export declare const intTypeForSize: (x: number) => IntType;
+/**
+ * Returns suitable {@link UintType} for given bit size (`[0,32]` range)
+ *
+ * @param x -
+ */
+export declare const uintTypeForBits: (x: number) => UintType;
+/**
+ * Returns suitable {@link IntType} for given bit size (`[0,32]` range)
+ *
+ * @param x -
+ */
+export declare const intTypeForBits: (x: number) => IntType;
+/**
+ * Returns the next smaller {@link IntType} for given type (or the same type if
+ * already the narrowest).
+ *
+ * @param t
+ */
+export declare const narrowInt: (t: IntType | 'i64') => 'i8' | 'i16' | 'i32';
+/**
+ * Returns the next larger {@link IntType} for given type (or the same type if
+ * already the widest).
+ *
+ * @param t
+ */
+export declare const widenInt: (t: IntType) => 'i16' | 'i32' | 'i64';
+/**
+ * Returns the next smaller {@link UintType} for given type (or the same type if
+ * already the narrowest).
+ *
+ * @remarks
+ * If type is `u8c`, returns `u8`.
+ *
+ * @param t
+ */
+export declare const narrowUint: (t: UintType | 'u64') => 'u8' | 'u16' | 'u32';
+/**
+ * Returns the next larger {@link UintType} for given type (or the same type if
+ * already the widest).
+ *
+ * @param t
+ */
+export declare const widenUint: (t: UintType) => 'u16' | 'u32' | 'u64';
+/**
+ * Returns the next smaller {@link FloatType} for given type (or the same type
+ * if already the narrowest).
+ *
+ * @param t
+ */
+export declare const narrowFloat: (t: FloatType) => string;
+/**
+ * Returns the next larger {@link FloatType} for given type (or the same type if
+ * already the widest).
+ *
+ * @param t
+ */
+export declare const widenFloat: (t: FloatType) => string;
+/**
+ * Returns the next smaller type (i.e. {@link IntType}, {@link UintType} or
+ * {@link FloatType}) for given type (or the same type if already the smallest).
+ *
+ * @param t
+ */
+export declare const narrowType: (t: Type | BigType) => string;
+/**
+ * Returns the next larger type (i.e. {@link IntType}, {@link UintType} or
+ * {@link FloatType}) for given type (or the same type if already the widest).
+ *
+ * @param t
+ */
+export declare const widenType: (t: Type | BigType) => string;
+//# sourceMappingURL=typedarray.d.ts.map

package/src/utils/typedarray.js

@@ -0,0 +1,162 @@
+// Copied from @thi.ng/api/typedarray
+// TODO: rewrite without this but for now just forked in order to add Atomics to base library
+
+var GLType = /* @__PURE__ */ ((GLType2) => {
+	GLType2[GLType2['I8'] = 5120] = 'I8';
+	GLType2[GLType2['U8'] = 5121] = 'U8';
+	GLType2[GLType2['I16'] = 5122] = 'I16';
+	GLType2[GLType2['U16'] = 5123] = 'U16';
+	GLType2[GLType2['I32'] = 5124] = 'I32';
+	GLType2[GLType2['U32'] = 5125] = 'U32';
+	GLType2[GLType2['F32'] = 5126] = 'F32';
+	return GLType2;
+})(GLType || {});
+const GL2TYPE = {
+	[5120 /* I8 */]: 'i8',
+	[5121 /* U8 */]: 'u8',
+	[5122 /* I16 */]: 'i16',
+	[5123 /* U16 */]: 'u16',
+	[5124 /* I32 */]: 'i32',
+	[5125 /* U32 */]: 'u32',
+	[5126 /* F32 */]: 'f32'
+};
+const TYPE2GL = {
+	i8: 5120 /* I8 */,
+	u8: 5121 /* U8 */,
+	u8c: 5121 /* U8 */,
+	i16: 5122 /* I16 */,
+	u16: 5123 /* U16 */,
+	i32: 5124 /* I32 */,
+	u32: 5125 /* U32 */,
+	f32: 5126 /* F32 */,
+	f64: void 0
+};
+const SIZEOF = {
+	u8: 1,
+	u8c: 1,
+	i8: 1,
+	u16: 2,
+	i16: 2,
+	u32: 4,
+	i32: 4,
+	i64: 8,
+	u64: 8,
+	f32: 4,
+	f64: 8
+};
+const BIT_SHIFTS = {
+	i8: 0,
+	u8: 0,
+	u8c: 0,
+	i16: 1,
+	u16: 1,
+	i32: 2,
+	u32: 2,
+	i64: 3,
+	u64: 3,
+	f32: 2,
+	f64: 3
+};
+const FLOAT_ARRAY_CTORS = {
+	f32: Float32Array,
+	f64: Float64Array
+};
+const INT_ARRAY_CTORS = {
+	i8: Int8Array,
+	i16: Int16Array,
+	i32: Int32Array
+};
+const UINT_ARRAY_CTORS = {
+	u8: Uint8Array,
+	u8c: Uint8ClampedArray,
+	u16: Uint16Array,
+	u32: Uint32Array
+};
+const BIGINT_ARRAY_CTORS = {
+	// eslint-disable-next-line
+	i64: BigInt64Array,
+	// eslint-disable-next-line
+	u64: BigUint64Array
+};
+const TYPEDARRAY_CTORS = {
+	...FLOAT_ARRAY_CTORS,
+	...INT_ARRAY_CTORS,
+	...UINT_ARRAY_CTORS
+};
+const asNativeType = (type) => {
+	const t = GL2TYPE[type];
+	return t !== void 0 ? t : type;
+};
+const asGLType = (type) => {
+	const t = TYPE2GL[type];
+	return t !== void 0 ? t : type;
+};
+const asInt = (...args) => args.map((x) => x | 0);
+const sizeOf = (type) => SIZEOF[type] || SIZEOF[asNativeType(type)];
+function typedArray(type, ...xs) {
+	const ctor = BIGINT_ARRAY_CTORS[type];
+	return new (ctor || TYPEDARRAY_CTORS[asNativeType(type)])(...xs);
+}
+function typedArrayOfVec(type, data, stride) {
+	const $data = Array.isArray(data) ? data : [...data];
+	if(stride === void 0)
+		stride = $data[0].length;
+	const num = $data.length;
+	const res = typedArray(type, num * stride);
+	for(let i = 0, j = 0; i < num; i++, j += stride) {
+		res.set($data[i], j);
+	}
+	return res;
+}
+const typedArrayType = (x) => {
+	if(Array.isArray(x))
+		return 'f64';
+	for(let id in TYPEDARRAY_CTORS) {
+		if(x instanceof TYPEDARRAY_CTORS[id])
+			return id;
+	}
+	return 'f64';
+};
+const uintTypeForSize = (x) => x <= 256 ? 'u8' : x <= 65536 ? 'u16' : 'u32';
+const intTypeForSize = (x) => x >= -128 && x < 128 ? 'i8' : x >= -32768 && x < 32768 ? 'i16' : 'i32';
+const uintTypeForBits = (x) => x > 16 ? 'u32' : x > 8 ? 'u16' : 'u8';
+const intTypeForBits = (x) => x > 16 ? 'i32' : x > 8 ? 'i16' : 'i8';
+const narrowInt = (t) => t === 'i64' ? 'i32' : t === 'i32' ? 'i16' : t === 'i16' ? 'i8' : 'i8';
+const widenInt = (t) => t === 'i8' ? 'i16' : t === 'i16' ? 'i32' : t === 'i32' ? 'i64' : 'i64';
+const narrowUint = (t) => t === 'u64' ? 'u32' : t === 'u32' ? 'u16' : t === 'u16' ? 'u8' : 'u8';
+const widenUint = (t) => t === 'u8' || t === 'u8c' ? 'u16' : t === 'u16' ? 'u32' : t === 'u32' ? 'u64' : 'u64';
+const narrowFloat = (t) => t === 'f64' ? 'f32' : 'f32';
+const widenFloat = (t) => t === 'f32' ? 'f64' : 'f64';
+const narrowType = (t) => t[0] === 'i' ? narrowInt(t) : t[0] === 'u' ? narrowUint(t) : narrowFloat(t);
+const widenType = (t) => t[0] === 'i' ? widenInt(t) : t[0] === 'u' ? widenUint(t) : widenFloat(t);
+export {
+	BIGINT_ARRAY_CTORS,
+	BIT_SHIFTS,
+	FLOAT_ARRAY_CTORS,
+	GL2TYPE,
+	GLType,
+	INT_ARRAY_CTORS,
+	SIZEOF,
+	TYPE2GL,
+	TYPEDARRAY_CTORS,
+	UINT_ARRAY_CTORS,
+	asGLType,
+	asInt,
+	asNativeType,
+	intTypeForBits,
+	intTypeForSize,
+	narrowFloat,
+	narrowInt,
+	narrowType,
+	narrowUint,
+	sizeOf,
+	typedArray,
+	typedArrayOfVec,
+	typedArrayType,
+	uintTypeForBits,
+	uintTypeForSize,
+	widenFloat,
+	widenInt,
+	widenType,
+	widenUint
+};

package/src/vite-env.d.ts

@@ -0,0 +1 @@
+/// <reference types="vite/client" />