typegpu 0.10.1 → 0.11.0-rc.1

package/data/vectorOps.js

@@ -0,0 +1,681 @@
+import { vec2b as vec2b$1, vec2f as vec2f$1, vec2h as vec2h$1, vec2i as vec2i$1, vec2u as vec2u$1, vec3b as vec3b$1, vec3f as vec3f$1, vec3h as vec3h$1, vec3i as vec3i$1, vec3u as vec3u$1, vec4b as vec4b$1, vec4f as vec4f$1, vec4h as vec4h$1, vec4i as vec4i$1, vec4u as vec4u$1 } from "./vector.js";
+import { mat2x2f, mat3x3f, mat4x4f } from "./matrix.js";
+import { bitcastU32toF32Impl, bitcastU32toI32Impl, clamp, divInteger, smoothstepScalar } from "./numberOps.js";
+//#region src/data/vectorOps.ts
+const vec2b = vec2b$1;
+const vec2f = vec2f$1;
+const vec2h = vec2h$1;
+const vec2i = vec2i$1;
+const vec2u = vec2u$1;
+const vec3b = vec3b$1;
+const vec3f = vec3f$1;
+const vec3h = vec3h$1;
+const vec3i = vec3i$1;
+const vec3u = vec3u$1;
+const vec4b = vec4b$1;
+const vec4f = vec4f$1;
+const vec4h = vec4h$1;
+const vec4i = vec4i$1;
+const vec4u = vec4u$1;
+const lengthVec2 = (v) => Math.sqrt(v.x ** 2 + v.y ** 2);
+const lengthVec3 = (v) => Math.sqrt(v.x ** 2 + v.y ** 2 + v.z ** 2);
+const lengthVec4 = (v) => Math.sqrt(v.x ** 2 + v.y ** 2 + v.z ** 2 + v.w ** 2);
+const dotVec2 = (lhs, rhs) => lhs.x * rhs.x + lhs.y * rhs.y;
+const dotVec3 = (lhs, rhs) => lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z;
+const dotVec4 = (lhs, rhs) => lhs.x * rhs.x + lhs.y * rhs.y + lhs.z * rhs.z + lhs.w * rhs.w;
+const unary2f = (op) => (a) => vec2f(op(a.x), op(a.y));
+const unary2h = (op) => (a) => vec2h(op(a.x), op(a.y));
+const unary2i = (op) => (a) => vec2i(op(a.x), op(a.y));
+const unary2u = (op) => (a) => vec2u(op(a.x), op(a.y));
+const unary3f = (op) => (a) => vec3f(op(a.x), op(a.y), op(a.z));
+const unary3h = (op) => (a) => vec3h(op(a.x), op(a.y), op(a.z));
+const unary3i = (op) => (a) => vec3i(op(a.x), op(a.y), op(a.z));
+const unary3u = (op) => (a) => vec3u(op(a.x), op(a.y), op(a.z));
+const unary4f = (op) => (a) => vec4f(op(a.x), op(a.y), op(a.z), op(a.w));
+const unary4h = (op) => (a) => vec4h(op(a.x), op(a.y), op(a.z), op(a.w));
+const unary4i = (op) => (a) => vec4i(op(a.x), op(a.y), op(a.z), op(a.w));
+const unary4u = (op) => (a) => vec4u(op(a.x), op(a.y), op(a.z), op(a.w));
+const unary2x2f = (op) => (a) => {
+	const a_ = a.columns;
+	return mat2x2f(unary2f(op)(a_[0]), unary2f(op)(a_[1]));
+};
+const unary3x3f = (op) => (a) => {
+	const a_ = a.columns;
+	return mat3x3f(unary3f(op)(a_[0]), unary3f(op)(a_[1]), unary3f(op)(a_[2]));
+};
+const unary4x4f = (op) => (a) => {
+	const a_ = a.columns;
+	return mat4x4f(unary4f(op)(a_[0]), unary4f(op)(a_[1]), unary4f(op)(a_[2]), unary4f(op)(a_[3]));
+};
+const binaryComponentWise2f = (op) => (a, b) => vec2f(op(a.x, b.x), op(a.y, b.y));
+const binaryComponentWise2h = (op) => (a, b) => vec2h(op(a.x, b.x), op(a.y, b.y));
+const binaryComponentWise2i = (op) => (a, b) => vec2i(op(a.x, b.x), op(a.y, b.y));
+const binaryComponentWise2u = (op) => (a, b) => vec2u(op(a.x, b.x), op(a.y, b.y));
+const binaryComponentWise3f = (op) => (a, b) => vec3f(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z));
+const binaryComponentWise3h = (op) => (a, b) => vec3h(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z));
+const binaryComponentWise3i = (op) => (a, b) => vec3i(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z));
+const binaryComponentWise3u = (op) => (a, b) => vec3u(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z));
+const binaryComponentWise4f = (op) => (a, b) => vec4f(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z), op(a.w, b.w));
+const binaryComponentWise4h = (op) => (a, b) => vec4h(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z), op(a.w, b.w));
+const binaryComponentWise4i = (op) => (a, b) => vec4i(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z), op(a.w, b.w));
+const binaryComponentWise4u = (op) => (a, b) => vec4u(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z), op(a.w, b.w));
+const binaryComponentWise2i2u = (op) => (a, b) => vec2i(op(a.x, b.x), op(a.y, b.y));
+const binaryComponentWise3i3u = (op) => (a, b) => vec3i(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z));
+const binaryComponentWise4i4u = (op) => (a, b) => vec4i(op(a.x, b.x), op(a.y, b.y), op(a.z, b.z), op(a.w, b.w));
+const binaryComponentWise2x2f = (op) => (a, b) => {
+	const a_ = a.columns;
+	const b_ = b.columns;
+	return mat2x2f(binaryComponentWise2f(op)(a_[0], b_[0]), binaryComponentWise2f(op)(a_[1], b_[1]));
+};
+const binaryComponentWise3x3f = (op) => (a, b) => {
+	const a_ = a.columns;
+	const b_ = b.columns;
+	return mat3x3f(binaryComponentWise3f(op)(a_[0], b_[0]), binaryComponentWise3f(op)(a_[1], b_[1]), binaryComponentWise3f(op)(a_[2], b_[2]));
+};
+const binaryComponentWise4x4f = (op) => (a, b) => {
+	const a_ = a.columns;
+	const b_ = b.columns;
+	return mat4x4f(binaryComponentWise4f(op)(a_[0], b_[0]), binaryComponentWise4f(op)(a_[1], b_[1]), binaryComponentWise4f(op)(a_[2], b_[2]), binaryComponentWise4f(op)(a_[3], b_[3]));
+};
+const ternaryComponentWise2f = (op) => (a, b, c) => vec2f(op(a.x, b.x, c.x), op(a.y, b.y, c.y));
+const ternaryComponentWise2h = (op) => (a, b, c) => vec2h(op(a.x, b.x, c.x), op(a.y, b.y, c.y));
+const ternaryComponentWise3f = (op) => (a, b, c) => vec3f(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z));
+const ternaryComponentWise3h = (op) => (a, b, c) => vec3h(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z));
+const ternaryComponentWise4f = (op) => (a, b, c) => vec4f(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z), op(a.w, b.w, c.w));
+const ternaryComponentWise4h = (op) => (a, b, c) => vec4h(op(a.x, b.x, c.x), op(a.y, b.y, c.y), op(a.z, b.z, c.z), op(a.w, b.w, c.w));
+const VectorOps = {
+	eq: {
+		vec2f: (e1, e2) => vec2b(e1.x === e2.x, e1.y === e2.y),
+		vec2h: (e1, e2) => vec2b(e1.x === e2.x, e1.y === e2.y),
+		vec2i: (e1, e2) => vec2b(e1.x === e2.x, e1.y === e2.y),
+		vec2u: (e1, e2) => vec2b(e1.x === e2.x, e1.y === e2.y),
+		"vec2<bool>": (e1, e2) => vec2b(e1.x === e2.x, e1.y === e2.y),
+		vec3f: (e1, e2) => vec3b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z),
+		vec3h: (e1, e2) => vec3b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z),
+		vec3i: (e1, e2) => vec3b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z),
+		vec3u: (e1, e2) => vec3b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z),
+		"vec3<bool>": (e1, e2) => vec3b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z),
+		vec4f: (e1, e2) => vec4b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z, e1.w === e2.w),
+		vec4h: (e1, e2) => vec4b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z, e1.w === e2.w),
+		vec4i: (e1, e2) => vec4b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z, e1.w === e2.w),
+		vec4u: (e1, e2) => vec4b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z, e1.w === e2.w),
+		"vec4<bool>": (e1, e2) => vec4b(e1.x === e2.x, e1.y === e2.y, e1.z === e2.z, e1.w === e2.w)
+	},
+	lt: {
+		vec2f: (e1, e2) => vec2b(e1.x < e2.x, e1.y < e2.y),
+		vec2h: (e1, e2) => vec2b(e1.x < e2.x, e1.y < e2.y),
+		vec2i: (e1, e2) => vec2b(e1.x < e2.x, e1.y < e2.y),
+		vec2u: (e1, e2) => vec2b(e1.x < e2.x, e1.y < e2.y),
+		vec3f: (e1, e2) => vec3b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z),
+		vec3h: (e1, e2) => vec3b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z),
+		vec3i: (e1, e2) => vec3b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z),
+		vec3u: (e1, e2) => vec3b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z),
+		vec4f: (e1, e2) => vec4b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z, e1.w < e2.w),
+		vec4h: (e1, e2) => vec4b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z, e1.w < e2.w),
+		vec4i: (e1, e2) => vec4b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z, e1.w < e2.w),
+		vec4u: (e1, e2) => vec4b(e1.x < e2.x, e1.y < e2.y, e1.z < e2.z, e1.w < e2.w)
+	},
+	or: {
+		"vec2<bool>": (e1, e2) => vec2b(e1.x || e2.x, e1.y || e2.y),
+		"vec3<bool>": (e1, e2) => vec3b(e1.x || e2.x, e1.y || e2.y, e1.z || e2.z),
+		"vec4<bool>": (e1, e2) => vec4b(e1.x || e2.x, e1.y || e2.y, e1.z || e2.z, e1.w || e2.w)
+	},
+	all: {
+		"vec2<bool>": (e) => e.x && e.y,
+		"vec3<bool>": (e) => e.x && e.y && e.z,
+		"vec4<bool>": (e) => e.x && e.y && e.z && e.w
+	},
+	abs: {
+		vec2f: unary2f(Math.abs),
+		vec2h: unary2h(Math.abs),
+		vec2i: unary2i(Math.abs),
+		vec2u: unary2u(Math.abs),
+		vec3f: unary3f(Math.abs),
+		vec3h: unary3h(Math.abs),
+		vec3i: unary3i(Math.abs),
+		vec3u: unary3u(Math.abs),
+		vec4f: unary4f(Math.abs),
+		vec4h: unary4h(Math.abs),
+		vec4i: unary4i(Math.abs),
+		vec4u: unary4u(Math.abs)
+	},
+	atan2: {
+		vec2f: binaryComponentWise2f(Math.atan2),
+		vec2h: binaryComponentWise2h(Math.atan2),
+		vec3f: binaryComponentWise3f(Math.atan2),
+		vec3h: binaryComponentWise3h(Math.atan2),
+		vec4f: binaryComponentWise4f(Math.atan2),
+		vec4h: binaryComponentWise4h(Math.atan2)
+	},
+	acos: {
+		vec2f: unary2f(Math.acos),
+		vec2h: unary2h(Math.acos),
+		vec2i: unary2i(Math.acos),
+		vec2u: unary2u(Math.acos),
+		vec3f: unary3f(Math.acos),
+		vec3h: unary3h(Math.acos),
+		vec3i: unary3i(Math.acos),
+		vec3u: unary3u(Math.acos),
+		vec4f: unary4f(Math.acos),
+		vec4h: unary4h(Math.acos),
+		vec4i: unary4i(Math.acos),
+		vec4u: unary4u(Math.acos)
+	},
+	acosh: {
+		vec2f: unary2f(Math.acosh),
+		vec2h: unary2h(Math.acosh),
+		vec3f: unary3f(Math.acosh),
+		vec3h: unary3h(Math.acosh),
+		vec4f: unary4f(Math.acosh),
+		vec4h: unary4h(Math.acosh)
+	},
+	asin: {
+		vec2f: unary2f(Math.asin),
+		vec2h: unary2h(Math.asin),
+		vec3f: unary3f(Math.asin),
+		vec3h: unary3h(Math.asin),
+		vec4f: unary4f(Math.asin),
+		vec4h: unary4h(Math.asin)
+	},
+	asinh: {
+		vec2f: unary2f(Math.asinh),
+		vec2h: unary2h(Math.asinh),
+		vec3f: unary3f(Math.asinh),
+		vec3h: unary3h(Math.asinh),
+		vec4f: unary4f(Math.asinh),
+		vec4h: unary4h(Math.asinh)
+	},
+	atan: {
+		vec2f: unary2f(Math.atan),
+		vec2h: unary2h(Math.atan),
+		vec3f: unary3f(Math.atan),
+		vec3h: unary3h(Math.atan),
+		vec4f: unary4f(Math.atan),
+		vec4h: unary4h(Math.atan)
+	},
+	atanh: {
+		vec2f: unary2f(Math.atanh),
+		vec2h: unary2h(Math.atanh),
+		vec3f: unary3f(Math.atanh),
+		vec3h: unary3h(Math.atanh),
+		vec4f: unary4f(Math.atanh),
+		vec4h: unary4h(Math.atanh)
+	},
+	ceil: {
+		vec2f: unary2f(Math.ceil),
+		vec2h: unary2h(Math.ceil),
+		vec3f: unary3f(Math.ceil),
+		vec3h: unary3h(Math.ceil),
+		vec4f: unary4f(Math.ceil),
+		vec4h: unary4h(Math.ceil)
+	},
+	clamp: {
+		vec2f: (v, low, high) => vec2f(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y)),
+		vec2h: (v, low, high) => vec2h(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y)),
+		vec2i: (v, low, high) => vec2i(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y)),
+		vec2u: (v, low, high) => vec2u(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y)),
+		vec3f: (v, low, high) => vec3f(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z)),
+		vec3h: (v, low, high) => vec3h(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z)),
+		vec3i: (v, low, high) => vec3i(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z)),
+		vec3u: (v, low, high) => vec3u(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z)),
+		vec4f: (v, low, high) => vec4f(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z), clamp(v.w, low.w, high.w)),
+		vec4h: (v, low, high) => vec4h(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z), clamp(v.w, low.w, high.w)),
+		vec4i: (v, low, high) => vec4i(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z), clamp(v.w, low.w, high.w)),
+		vec4u: (v, low, high) => vec4u(clamp(v.x, low.x, high.x), clamp(v.y, low.y, high.y), clamp(v.z, low.z, high.z), clamp(v.w, low.w, high.w))
+	},
+	length: {
+		vec2f: lengthVec2,
+		vec2h: lengthVec2,
+		vec3f: lengthVec3,
+		vec3h: lengthVec3,
+		vec4f: lengthVec4,
+		vec4h: lengthVec4
+	},
+	add: {
+		vec2f: binaryComponentWise2f((a, b) => a + b),
+		vec2h: binaryComponentWise2h((a, b) => a + b),
+		vec2i: binaryComponentWise2i((a, b) => a + b),
+		vec2u: binaryComponentWise2u((a, b) => a + b),
+		vec3f: binaryComponentWise3f((a, b) => a + b),
+		vec3h: binaryComponentWise3h((a, b) => a + b),
+		vec3i: binaryComponentWise3i((a, b) => a + b),
+		vec3u: binaryComponentWise3u((a, b) => a + b),
+		vec4f: binaryComponentWise4f((a, b) => a + b),
+		vec4h: binaryComponentWise4h((a, b) => a + b),
+		vec4i: binaryComponentWise4i((a, b) => a + b),
+		vec4u: binaryComponentWise4u((a, b) => a + b),
+		mat2x2f: binaryComponentWise2x2f((a, b) => a + b),
+		mat3x3f: binaryComponentWise3x3f((a, b) => a + b),
+		mat4x4f: binaryComponentWise4x4f((a, b) => a + b)
+	},
+	smoothstep: {
+		vec2f: ternaryComponentWise2f(smoothstepScalar),
+		vec2h: ternaryComponentWise2h(smoothstepScalar),
+		vec3f: ternaryComponentWise3f(smoothstepScalar),
+		vec3h: ternaryComponentWise3h(smoothstepScalar),
+		vec4f: ternaryComponentWise4f(smoothstepScalar),
+		vec4h: ternaryComponentWise4h(smoothstepScalar)
+	},
+	addMixed: {
+		vec2f: (a, b) => unary2f((e) => e + b)(a),
+		vec2h: (a, b) => unary2h((e) => e + b)(a),
+		vec2i: (a, b) => unary2i((e) => e + b)(a),
+		vec2u: (a, b) => unary2u((e) => e + b)(a),
+		vec3f: (a, b) => unary3f((e) => e + b)(a),
+		vec3h: (a, b) => unary3h((e) => e + b)(a),
+		vec3i: (a, b) => unary3i((e) => e + b)(a),
+		vec3u: (a, b) => unary3u((e) => e + b)(a),
+		vec4f: (a, b) => unary4f((e) => e + b)(a),
+		vec4h: (a, b) => unary4h((e) => e + b)(a),
+		vec4i: (a, b) => unary4i((e) => e + b)(a),
+		vec4u: (a, b) => unary4u((e) => e + b)(a),
+		mat2x2f: (a, b) => unary2x2f((e) => e + b)(a),
+		mat3x3f: (a, b) => unary3x3f((e) => e + b)(a),
+		mat4x4f: (a, b) => unary4x4f((e) => e + b)(a)
+	},
+	mulSxV: {
+		vec2f: (s, v) => unary2f((e) => s * e)(v),
+		vec2h: (s, v) => unary2h((e) => s * e)(v),
+		vec2i: (s, v) => unary2i((e) => s * e)(v),
+		vec2u: (s, v) => unary2u((e) => s * e)(v),
+		vec3f: (s, v) => unary3f((e) => s * e)(v),
+		vec3h: (s, v) => unary3h((e) => s * e)(v),
+		vec3i: (s, v) => unary3i((e) => s * e)(v),
+		vec3u: (s, v) => unary3u((e) => s * e)(v),
+		vec4f: (s, v) => unary4f((e) => s * e)(v),
+		vec4h: (s, v) => unary4h((e) => s * e)(v),
+		vec4i: (s, v) => unary4i((e) => s * e)(v),
+		vec4u: (s, v) => unary4u((e) => s * e)(v),
+		mat2x2f: (s, m) => unary2x2f((e) => s * e)(m),
+		mat3x3f: (s, m) => unary3x3f((e) => s * e)(m),
+		mat4x4f: (s, m) => unary4x4f((e) => s * e)(m)
+	},
+	mulVxV: {
+		vec2f: binaryComponentWise2f((a, b) => a * b),
+		vec2h: binaryComponentWise2h((a, b) => a * b),
+		vec2i: binaryComponentWise2i((a, b) => a * b),
+		vec2u: binaryComponentWise2u((a, b) => a * b),
+		vec3f: binaryComponentWise3f((a, b) => a * b),
+		vec3h: binaryComponentWise3h((a, b) => a * b),
+		vec3i: binaryComponentWise3i((a, b) => a * b),
+		vec3u: binaryComponentWise3u((a, b) => a * b),
+		vec4f: binaryComponentWise4f((a, b) => a * b),
+		vec4h: binaryComponentWise4h((a, b) => a * b),
+		vec4i: binaryComponentWise4i((a, b) => a * b),
+		vec4u: binaryComponentWise4u((a, b) => a * b),
+		mat2x2f: (a, b) => {
+			const a_ = a.columns;
+			const b_ = b.columns;
+			return mat2x2f(a_[0].x * b_[0].x + a_[1].x * b_[0].y, a_[0].y * b_[0].x + a_[1].y * b_[0].y, a_[0].x * b_[1].x + a_[1].x * b_[1].y, a_[0].y * b_[1].x + a_[1].y * b_[1].y);
+		},
+		mat3x3f: (a, b) => {
+			const a_ = a.columns;
+			const b_ = b.columns;
+			return mat3x3f(a_[0].x * b_[0].x + a_[1].x * b_[0].y + a_[2].x * b_[0].z, a_[0].y * b_[0].x + a_[1].y * b_[0].y + a_[2].y * b_[0].z, a_[0].z * b_[0].x + a_[1].z * b_[0].y + a_[2].z * b_[0].z, a_[0].x * b_[1].x + a_[1].x * b_[1].y + a_[2].x * b_[1].z, a_[0].y * b_[1].x + a_[1].y * b_[1].y + a_[2].y * b_[1].z, a_[0].z * b_[1].x + a_[1].z * b_[1].y + a_[2].z * b_[1].z, a_[0].x * b_[2].x + a_[1].x * b_[2].y + a_[2].x * b_[2].z, a_[0].y * b_[2].x + a_[1].y * b_[2].y + a_[2].y * b_[2].z, a_[0].z * b_[2].x + a_[1].z * b_[2].y + a_[2].z * b_[2].z);
+		},
+		mat4x4f: (a, b) => {
+			const a_ = a.columns;
+			const b_ = b.columns;
+			return mat4x4f(a_[0].x * b_[0].x + a_[1].x * b_[0].y + a_[2].x * b_[0].z + a_[3].x * b_[0].w, a_[0].y * b_[0].x + a_[1].y * b_[0].y + a_[2].y * b_[0].z + a_[3].y * b_[0].w, a_[0].z * b_[0].x + a_[1].z * b_[0].y + a_[2].z * b_[0].z + a_[3].z * b_[0].w, a_[0].w * b_[0].x + a_[1].w * b_[0].y + a_[2].w * b_[0].z + a_[3].w * b_[0].w, a_[0].x * b_[1].x + a_[1].x * b_[1].y + a_[2].x * b_[1].z + a_[3].x * b_[1].w, a_[0].y * b_[1].x + a_[1].y * b_[1].y + a_[2].y * b_[1].z + a_[3].y * b_[1].w, a_[0].z * b_[1].x + a_[1].z * b_[1].y + a_[2].z * b_[1].z + a_[3].z * b_[1].w, a_[0].w * b_[1].x + a_[1].w * b_[1].y + a_[2].w * b_[1].z + a_[3].w * b_[1].w, a_[0].x * b_[2].x + a_[1].x * b_[2].y + a_[2].x * b_[2].z + a_[3].x * b_[2].w, a_[0].y * b_[2].x + a_[1].y * b_[2].y + a_[2].y * b_[2].z + a_[3].y * b_[2].w, a_[0].z * b_[2].x + a_[1].z * b_[2].y + a_[2].z * b_[2].z + a_[3].z * b_[2].w, a_[0].w * b_[2].x + a_[1].w * b_[2].y + a_[2].w * b_[2].z + a_[3].w * b_[2].w, a_[0].x * b_[3].x + a_[1].x * b_[3].y + a_[2].x * b_[3].z + a_[3].x * b_[3].w, a_[0].y * b_[3].x + a_[1].y * b_[3].y + a_[2].y * b_[3].z + a_[3].y * b_[3].w, a_[0].z * b_[3].x + a_[1].z * b_[3].y + a_[2].z * b_[3].z + a_[3].z * b_[3].w, a_[0].w * b_[3].x + a_[1].w * b_[3].y + a_[2].w * b_[3].z + a_[3].w * b_[3].w);
+		}
+	},
+	mulMxV: {
+		mat2x2f: (m, v) => {
+			const m_ = m.columns;
+			return vec2f(m_[0].x * v.x + m_[1].x * v.y, m_[0].y * v.x + m_[1].y * v.y);
+		},
+		mat3x3f: (m, v) => {
+			const m_ = m.columns;
+			return vec3f(m_[0].x * v.x + m_[1].x * v.y + m_[2].x * v.z, m_[0].y * v.x + m_[1].y * v.y + m_[2].y * v.z, m_[0].z * v.x + m_[1].z * v.y + m_[2].z * v.z);
+		},
+		mat4x4f: (m, v) => {
+			const m_ = m.columns;
+			return vec4f(m_[0].x * v.x + m_[1].x * v.y + m_[2].x * v.z + m_[3].x * v.w, m_[0].y * v.x + m_[1].y * v.y + m_[2].y * v.z + m_[3].y * v.w, m_[0].z * v.x + m_[1].z * v.y + m_[2].z * v.z + m_[3].z * v.w, m_[0].w * v.x + m_[1].w * v.y + m_[2].w * v.z + m_[3].w * v.w);
+		}
+	},
+	mulVxM: {
+		mat2x2f: (v, m) => {
+			const m_ = m.columns;
+			return vec2f(v.x * m_[0].x + v.y * m_[0].y, v.x * m_[1].x + v.y * m_[1].y);
+		},
+		mat3x3f: (v, m) => {
+			const m_ = m.columns;
+			return vec3f(v.x * m_[0].x + v.y * m_[0].y + v.z * m_[0].z, v.x * m_[1].x + v.y * m_[1].y + v.z * m_[1].z, v.x * m_[2].x + v.y * m_[2].y + v.z * m_[2].z);
+		},
+		mat4x4f: (v, m) => {
+			const m_ = m.columns;
+			return vec4f(v.x * m_[0].x + v.y * m_[0].y + v.z * m_[0].z + v.w * m_[0].w, v.x * m_[1].x + v.y * m_[1].y + v.z * m_[1].z + v.w * m_[1].w, v.x * m_[2].x + v.y * m_[2].y + v.z * m_[2].z + v.w * m_[2].w, v.x * m_[3].x + v.y * m_[3].y + v.z * m_[3].z + v.w * m_[3].w);
+		}
+	},
+	div: {
+		vec2f: binaryComponentWise2f((a, b) => a / b),
+		vec2h: binaryComponentWise2h((a, b) => a / b),
+		vec2i: binaryComponentWise2i(divInteger),
+		vec2u: binaryComponentWise2u(divInteger),
+		vec3f: binaryComponentWise3f((a, b) => a / b),
+		vec3h: binaryComponentWise3h((a, b) => a / b),
+		vec3i: binaryComponentWise3i(divInteger),
+		vec3u: binaryComponentWise3u(divInteger),
+		vec4f: binaryComponentWise4f((a, b) => a / b),
+		vec4h: binaryComponentWise4h((a, b) => a / b),
+		vec4i: binaryComponentWise4i(divInteger),
+		vec4u: binaryComponentWise4u(divInteger)
+	},
+	dot: {
+		vec2f: dotVec2,
+		vec2h: dotVec2,
+		vec2i: dotVec2,
+		vec2u: dotVec2,
+		vec3f: dotVec3,
+		vec3h: dotVec3,
+		vec3i: dotVec3,
+		vec3u: dotVec3,
+		vec4f: dotVec4,
+		vec4h: dotVec4,
+		vec4i: dotVec4,
+		vec4u: dotVec4
+	},
+	normalize: {
+		vec2f: (v) => {
+			const len = lengthVec2(v);
+			return vec2f(v.x / len, v.y / len);
+		},
+		vec2h: (v) => {
+			const len = lengthVec2(v);
+			return vec2h(v.x / len, v.y / len);
+		},
+		vec2i: (v) => {
+			const len = lengthVec2(v);
+			return vec2i(v.x / len, v.y / len);
+		},
+		vec2u: (v) => {
+			const len = lengthVec2(v);
+			return vec2u(v.x / len, v.y / len);
+		},
+		vec3f: (v) => {
+			const len = lengthVec3(v);
+			return vec3f(v.x / len, v.y / len, v.z / len);
+		},
+		vec3h: (v) => {
+			const len = lengthVec3(v);
+			return vec3h(v.x / len, v.y / len, v.z / len);
+		},
+		vec3i: (v) => {
+			const len = lengthVec3(v);
+			return vec3i(v.x / len, v.y / len, v.z / len);
+		},
+		vec3u: (v) => {
+			const len = lengthVec3(v);
+			return vec3u(v.x / len, v.y / len, v.z / len);
+		},
+		vec4f: (v) => {
+			const len = lengthVec4(v);
+			return vec4f(v.x / len, v.y / len, v.z / len, v.w / len);
+		},
+		vec4h: (v) => {
+			const len = lengthVec4(v);
+			return vec4h(v.x / len, v.y / len, v.z / len, v.w / len);
+		},
+		vec4i: (v) => {
+			const len = lengthVec4(v);
+			return vec4i(v.x / len, v.y / len, v.z / len, v.w / len);
+		},
+		vec4u: (v) => {
+			const len = lengthVec4(v);
+			return vec4u(v.x / len, v.y / len, v.z / len, v.w / len);
+		}
+	},
+	cross: {
+		vec3f: (a, b) => {
+			return vec3f(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+		},
+		vec3h: (a, b) => {
+			return vec3h(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x);
+		}
+	},
+	mod: {
+		vec2f: binaryComponentWise2f((a, b) => a % b),
+		vec2h: binaryComponentWise2h((a, b) => a % b),
+		vec2i: binaryComponentWise2i((a, b) => a % b),
+		vec2u: binaryComponentWise2u((a, b) => a % b),
+		vec3f: binaryComponentWise3f((a, b) => a % b),
+		vec3h: binaryComponentWise3h((a, b) => a % b),
+		vec3i: binaryComponentWise3i((a, b) => a % b),
+		vec3u: binaryComponentWise3u((a, b) => a % b),
+		vec4f: binaryComponentWise4f((a, b) => a % b),
+		vec4h: binaryComponentWise4h((a, b) => a % b),
+		vec4i: binaryComponentWise4i((a, b) => a % b),
+		vec4u: binaryComponentWise4u((a, b) => a % b)
+	},
+	floor: {
+		vec2f: unary2f(Math.floor),
+		vec2h: unary2h(Math.floor),
+		vec3f: unary3f(Math.floor),
+		vec3h: unary3h(Math.floor),
+		vec4f: unary4f(Math.floor),
+		vec4h: unary4h(Math.floor)
+	},
+	max: {
+		vec2f: binaryComponentWise2f(Math.max),
+		vec2h: binaryComponentWise2h(Math.max),
+		vec2i: binaryComponentWise2i(Math.max),
+		vec2u: binaryComponentWise2u(Math.max),
+		vec3f: binaryComponentWise3f(Math.max),
+		vec3h: binaryComponentWise3h(Math.max),
+		vec3i: binaryComponentWise3i(Math.max),
+		vec3u: binaryComponentWise3u(Math.max),
+		vec4f: binaryComponentWise4f(Math.max),
+		vec4h: binaryComponentWise4h(Math.max),
+		vec4i: binaryComponentWise4i(Math.max),
+		vec4u: binaryComponentWise4u(Math.max)
+	},
+	min: {
+		vec2f: binaryComponentWise2f(Math.min),
+		vec2h: binaryComponentWise2h(Math.min),
+		vec2i: binaryComponentWise2i(Math.min),
+		vec2u: binaryComponentWise2u(Math.min),
+		vec3f: binaryComponentWise3f(Math.min),
+		vec3h: binaryComponentWise3h(Math.min),
+		vec3i: binaryComponentWise3i(Math.min),
+		vec3u: binaryComponentWise3u(Math.min),
+		vec4f: binaryComponentWise4f(Math.min),
+		vec4h: binaryComponentWise4h(Math.min),
+		vec4i: binaryComponentWise4i(Math.min),
+		vec4u: binaryComponentWise4u(Math.min)
+	},
+	pow: {
+		vec2f: (base, exponent) => vec2f(base.x ** exponent.x, base.y ** exponent.y),
+		vec2h: (base, exponent) => vec2h(base.x ** exponent.x, base.y ** exponent.y),
+		vec3f: (base, exponent) => vec3f(base.x ** exponent.x, base.y ** exponent.y, base.z ** exponent.z),
+		vec3h: (base, exponent) => vec3h(base.x ** exponent.x, base.y ** exponent.y, base.z ** exponent.z),
+		vec4f: (base, exponent) => vec4f(base.x ** exponent.x, base.y ** exponent.y, base.z ** exponent.z, base.w ** exponent.w),
+		vec4h: (base, exponent) => vec4h(base.x ** exponent.x, base.y ** exponent.y, base.z ** exponent.z, base.w ** exponent.w)
+	},
+	sign: {
+		vec2f: unary2f(Math.sign),
+		vec2h: unary2h(Math.sign),
+		vec2i: unary2i(Math.sign),
+		vec3f: unary3f(Math.sign),
+		vec3h: unary3h(Math.sign),
+		vec3i: unary3i(Math.sign),
+		vec4f: unary4f(Math.sign),
+		vec4h: unary4h(Math.sign),
+		vec4i: unary4i(Math.sign)
+	},
+	sqrt: {
+		vec2f: unary2f(Math.sqrt),
+		vec2h: unary2h(Math.sqrt),
+		vec3f: unary3f(Math.sqrt),
+		vec3h: unary3h(Math.sqrt),
+		vec4f: unary4f(Math.sqrt),
+		vec4h: unary4h(Math.sqrt)
+	},
+	mix: {
+		vec2f: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec2f(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3);
+			return vec2f(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y);
+		},
+		vec2h: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec2h(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3);
+			return vec2h(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y);
+		},
+		vec3f: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec3f(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3, e1.z * (1 - e3) + e2.z * e3);
+			return vec3f(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y, e1.z * (1 - e3.z) + e2.z * e3.z);
+		},
+		vec3h: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec3h(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3, e1.z * (1 - e3) + e2.z * e3);
+			return vec3h(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y, e1.z * (1 - e3.z) + e2.z * e3.z);
+		},
+		vec4f: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec4f(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3, e1.z * (1 - e3) + e2.z * e3, e1.w * (1 - e3) + e2.w * e3);
+			return vec4f(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y, e1.z * (1 - e3.z) + e2.z * e3.z, e1.w * (1 - e3.w) + e2.w * e3.w);
+		},
+		vec4h: (e1, e2, e3) => {
+			if (typeof e3 === "number") return vec4h(e1.x * (1 - e3) + e2.x * e3, e1.y * (1 - e3) + e2.y * e3, e1.z * (1 - e3) + e2.z * e3, e1.w * (1 - e3) + e2.w * e3);
+			return vec4h(e1.x * (1 - e3.x) + e2.x * e3.x, e1.y * (1 - e3.y) + e2.y * e3.y, e1.z * (1 - e3.z) + e2.z * e3.z, e1.w * (1 - e3.w) + e2.w * e3.w);
+		}
+	},
+	sin: {
+		vec2f: unary2f(Math.sin),
+		vec2h: unary2h(Math.sin),
+		vec3f: unary3f(Math.sin),
+		vec3h: unary3h(Math.sin),
+		vec4f: unary4f(Math.sin),
+		vec4h: unary4h(Math.sin)
+	},
+	cos: {
+		vec2f: unary2f(Math.cos),
+		vec2h: unary2h(Math.cos),
+		vec3f: unary3f(Math.cos),
+		vec3h: unary3h(Math.cos),
+		vec4f: unary4f(Math.cos),
+		vec4h: unary4h(Math.cos)
+	},
+	cosh: {
+		vec2f: unary2f(Math.cosh),
+		vec2h: unary2h(Math.cosh),
+		vec3f: unary3f(Math.cosh),
+		vec3h: unary3h(Math.cosh),
+		vec4f: unary4f(Math.cosh),
+		vec4h: unary4h(Math.cosh)
+	},
+	exp: {
+		vec2f: unary2f(Math.exp),
+		vec2h: unary2h(Math.exp),
+		vec3f: unary3f(Math.exp),
+		vec3h: unary3h(Math.exp),
+		vec4f: unary4f(Math.exp),
+		vec4h: unary4h(Math.exp)
+	},
+	exp2: {
+		vec2f: unary2f((val) => 2 ** val),
+		vec2h: unary2h((val) => 2 ** val),
+		vec3f: unary3f((val) => 2 ** val),
+		vec3h: unary3h((val) => 2 ** val),
+		vec4f: unary4f((val) => 2 ** val),
+		vec4h: unary4h((val) => 2 ** val)
+	},
+	log: {
+		vec2f: unary2f(Math.log),
+		vec2h: unary2h(Math.log),
+		vec3f: unary3f(Math.log),
+		vec3h: unary3h(Math.log),
+		vec4f: unary4f(Math.log),
+		vec4h: unary4h(Math.log)
+	},
+	log2: {
+		vec2f: unary2f(Math.log2),
+		vec2h: unary2h(Math.log2),
+		vec3f: unary3f(Math.log2),
+		vec3h: unary3h(Math.log2),
+		vec4f: unary4f(Math.log2),
+		vec4h: unary4h(Math.log2)
+	},
+	fract: {
+		vec2f: unary2f((value) => value - Math.floor(value)),
+		vec2h: unary2h((value) => value - Math.floor(value)),
+		vec3f: unary3f((value) => value - Math.floor(value)),
+		vec3h: unary3h((value) => value - Math.floor(value)),
+		vec4f: unary4f((value) => value - Math.floor(value)),
+		vec4h: unary4h((value) => value - Math.floor(value))
+	},
+	isCloseToZero: {
+		vec2f: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n,
+		vec2h: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n,
+		vec3f: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n && Math.abs(v.z) <= n,
+		vec3h: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n && Math.abs(v.z) <= n,
+		vec4f: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n && Math.abs(v.z) <= n && Math.abs(v.w) <= n,
+		vec4h: (v, n) => Math.abs(v.x) <= n && Math.abs(v.y) <= n && Math.abs(v.z) <= n && Math.abs(v.w) <= n
+	},
+	neg: {
+		vec2f: unary2f((value) => -value),
+		vec2h: unary2h((value) => -value),
+		vec2i: unary2i((value) => -value),
+		vec2u: unary2u((value) => -value),
+		"vec2<bool>": (e) => vec2b(!e.x, !e.y),
+		vec3f: unary3f((value) => -value),
+		vec3h: unary3h((value) => -value),
+		vec3i: unary3i((value) => -value),
+		vec3u: unary3u((value) => -value),
+		"vec3<bool>": (e) => vec3b(!e.x, !e.y, !e.z),
+		vec4f: unary4f((value) => -value),
+		vec4h: unary4h((value) => -value),
+		vec4i: unary4i((value) => -value),
+		vec4u: unary4u((value) => -value),
+		"vec4<bool>": (e) => vec4b(!e.x, !e.y, !e.z, !e.w)
+	},
+	select: {
+		vec2f: (f, t, c) => vec2f(c.x ? t.x : f.x, c.y ? t.y : f.y),
+		vec2h: (f, t, c) => vec2h(c.x ? t.x : f.x, c.y ? t.y : f.y),
+		vec2i: (f, t, c) => vec2i(c.x ? t.x : f.x, c.y ? t.y : f.y),
+		vec2u: (f, t, c) => vec2u(c.x ? t.x : f.x, c.y ? t.y : f.y),
+		"vec2<bool>": (f, t, c) => vec2b(c.x ? t.x : f.x, c.y ? t.y : f.y),
+		vec3f: (f, t, c) => vec3f(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z),
+		vec3h: (f, t, c) => vec3h(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z),
+		vec3i: (f, t, c) => vec3i(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z),
+		vec3u: (f, t, c) => vec3u(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z),
+		"vec3<bool>": (f, t, c) => vec3b(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z),
+		vec4f: (f, t, c) => vec4f(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z, c.w ? t.w : f.w),
+		vec4h: (f, t, c) => vec4h(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z, c.w ? t.w : f.w),
+		vec4i: (f, t, c) => vec4i(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z, c.w ? t.w : f.w),
+		vec4u: (f, t, c) => vec4u(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z, c.w ? t.w : f.w),
+		"vec4<bool>": (f, t, c) => vec4b(c.x ? t.x : f.x, c.y ? t.y : f.y, c.z ? t.z : f.z, c.w ? t.w : f.w)
+	},
+	tanh: {
+		vec2f: unary2f(Math.tanh),
+		vec2h: unary2h(Math.tanh),
+		vec3f: unary3f(Math.tanh),
+		vec3h: unary3h(Math.tanh),
+		vec4f: unary4f(Math.tanh),
+		vec4h: unary4h(Math.tanh)
+	},
+	bitShiftLeft: {
+		vec2i: binaryComponentWise2i2u((a, b) => a << b),
+		vec2u: binaryComponentWise2u((a, b) => a << b),
+		vec3i: binaryComponentWise3i3u((a, b) => a << b),
+		vec3u: binaryComponentWise3u((a, b) => a << b),
+		vec4i: binaryComponentWise4i4u((a, b) => a << b),
+		vec4u: binaryComponentWise4u((a, b) => a << b)
+	},
+	bitShiftRight: {
+		vec2i: binaryComponentWise2i2u((a, b) => a >> b),
+		vec2u: binaryComponentWise2u((a, b) => a >> b),
+		vec3i: binaryComponentWise3i3u((a, b) => a >> b),
+		vec3u: binaryComponentWise3u((a, b) => a >> b),
+		vec4i: binaryComponentWise4i4u((a, b) => a >> b),
+		vec4u: binaryComponentWise4u((a, b) => a >> b)
+	},
+	bitcastU32toF32: {
+		vec2u: (n) => vec2f(bitcastU32toF32Impl(n.x), bitcastU32toF32Impl(n.y)),
+		vec3u: (n) => vec3f(bitcastU32toF32Impl(n.x), bitcastU32toF32Impl(n.y), bitcastU32toF32Impl(n.z)),
+		vec4u: (n) => vec4f(bitcastU32toF32Impl(n.x), bitcastU32toF32Impl(n.y), bitcastU32toF32Impl(n.z), bitcastU32toF32Impl(n.w))
+	},
+	bitcastU32toI32: {
+		vec2u: (n) => vec2i(bitcastU32toI32Impl(n.x), bitcastU32toI32Impl(n.y)),
+		vec3u: (n) => vec3i(bitcastU32toI32Impl(n.x), bitcastU32toI32Impl(n.y), bitcastU32toI32Impl(n.z)),
+		vec4u: (n) => vec4i(bitcastU32toI32Impl(n.x), bitcastU32toI32Impl(n.y), bitcastU32toI32Impl(n.z), bitcastU32toI32Impl(n.w))
+	}
+};
+//#endregion
+export { VectorOps };