@daneren2005/shared-memory-objects 0.0.10 → 0.0.11

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

@@ -1,23 +0,0 @@
-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

@@ -1,18 +0,0 @@
-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/float32-atomics.ts

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

package/src/utils/pointer.ts

@@ -1,40 +0,0 @@
-// 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.js

@@ -1,162 +0,0 @@
-// 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

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