@benev/math 0.1.0 → 0.2.0-1

package/s/{concepts → core}/vec4.ts

@@ -1,7 +1,5 @@
 
-import {Xyzw} from "./quat.js"
-
-export type Vec4Array = [number, number, number, number]
+import {Xyzw, XyzwArray} from "./quat.js"
 
 export class Vec4 {
 	constructor(
@@ -19,21 +17,24 @@ export class Vec4 {
 		return new this(0, 0, 0, 0)
 	}
 
-	static array(v: Vec4Array) {
-		return new this(...v)
+	static from(v: XyzwArray | Xyzw) {
+		return Array.isArray(v)
+			? new this(...v)
+			: new this(v.x, v.y, v.z, v.w)
 	}
 
-	static import({x, y, z, w}: Xyzw) {
-		return new this(x, y, z, w)
+	clone() {
+		return new Vec4(this.x, this.y, this.z, this.w)
 	}
 
-	static from(v: Vec4Array | Xyzw) {
-		return Array.isArray(v)
-			? this.array(v)
-			: this.import(v)
+	*[Symbol.iterator]() {
+		yield this.x
+		yield this.y
+		yield this.z
+		yield this.w
 	}
 
-	array(): Vec4Array {
+	toJSON(): XyzwArray {
 		const {x, y, z, w} = this
 		return [x, y, z, w]
 	}
@@ -42,10 +43,6 @@ export class Vec4 {
 		return `(Vec4 x${this.x.toFixed(2)}, y${this.y.toFixed(2)}, z${this.z.toFixed(2)}, w${this.w.toFixed(2)})`
 	}
 
-	clone() {
-		return new Vec4(...this.array())
-	}
-
 	set_(x: number, y: number, z: number, w: number) {
 		this.x = x
 		this.y = y

package/s/index.ts

@@ -1,12 +1,27 @@
 
-export * from "./concepts/angles.js"
-export * from "./concepts/circular.js"
-export * from "./concepts/noise.js"
-export * from "./concepts/quat.js"
-export * from "./concepts/randy.js"
-export * from "./concepts/scalar.js"
-export * as spline from "./concepts/spline.js"
-export * from "./concepts/vec2.js"
-export * from "./concepts/vec3.js"
-export * from "./concepts/vec4.js"
+export * from "./core/quat.js"
+export * from "./core/vec2.js"
+export * from "./core/vec3.js"
+export * from "./core/vec4.js"
+
+export * from "./tools/angles.js"
+export * from "./tools/circular.js"
+export * from "./tools/noise.js"
+export * from "./tools/randy.js"
+export * from "./tools/scalar.js"
+export * as spline from "./tools/spline.js"
+
+export * from "./optimizers/hash-map.js"
+export * from "./optimizers/hash-set.js"
+export * from "./optimizers/zen.js"
+
+export * from "./physics/2d/collide2d.js"
+export * as collide2d from "./physics/2d/collide2d.js"
+export * from "./physics/2d/intersect2d.js"
+export * as intersect2d from "./physics/2d/intersect2d.js"
+
+export * from "./shapes/2d/index.js"
+export * as shapes2d from "./shapes/2d/index.js"
+export * from "./shapes/3d/index.js"
+export * as shapes3d from "./shapes/3d/index.js"
 

package/s/optimizers/hash-map.ts

@@ -0,0 +1,71 @@
+
+import {MapG} from "@e280/stz"
+
+export class HashMap<Key, Value> {
+	#map = new MapG<string, [Key, Value]>
+
+	constructor(
+			private hash: (x: Key) => string,
+			entries: [Key, Value][] = [],
+		) {
+		for (const [key, value] of entries)
+			this.set(key, value)
+	}
+
+	get size() {
+		return this.#map.size
+	}
+
+	get(key: Key) {
+		const result = this.#map.get(this.hash(key))
+		if (result)
+			return result[1]
+	}
+
+	require(key: Key) {
+		return this.#map.require(this.hash(key))[1]
+	}
+
+	has(key: Key) {
+		return this.#map.has(this.hash(key))
+	}
+
+	set(key: Key, value: Value) {
+		this.#map.set(this.hash(key), [key, value])
+		return this
+	}
+
+	delete(...keys: Key[]) {
+		for (const key of keys)
+			this.#map.delete(this.hash(key))
+		return this
+	}
+
+	entries() {
+		return this.#map.values()
+	}
+
+	[Symbol.iterator]() {
+		return this.entries()
+	}
+
+	*keys() {
+		for (const [key] of this.#map.values())
+			yield key
+	}
+
+	*values() {
+		for (const [,value] of this.#map.values())
+			yield value
+	}
+
+	array() {
+		return [...this.entries()]
+	}
+
+	guarantee(key: Key, fn: () => Value) {
+		const [,value] = this.#map.guarantee(this.hash(key), () => [key, fn()])
+		return value
+	}
+}
+

package/s/optimizers/hash-set.ts

@@ -0,0 +1,50 @@
+
+export class HashSet<Value> {
+	#map = new Map<string, Value>
+
+	constructor(
+			private hash: (value: Value) => string,
+			values: Value[] = [],
+		) {
+		this.add(...values)
+	}
+
+	get size() {
+		return this.#map.size
+	}
+
+	get(value: Value) {
+		return this.#map.get(this.hash(value))
+	}
+
+	has(value: Value) {
+		return this.#map.has(this.hash(value))
+	}
+
+	add(...values: Value[]) {
+		for (const value of values) {
+			const key = this.hash(value)
+			this.#map.set(key, value)
+		}
+		return this
+	}
+
+	delete(...values: Value[]) {
+		for (const value of values)
+			this.#map.delete(this.hash(value))
+		return this
+	}
+
+	array() {
+		return [...this.#map.values()]
+	}
+
+	values() {
+		return this.#map.values()
+	}
+
+	[Symbol.iterator]() {
+		return this.values()
+	}
+}
+

package/s/optimizers/zen.ts

@@ -0,0 +1,151 @@
+
+import {MapG} from "@e280/stz"
+import {Vec2} from "../core/vec2.js"
+import {Rect} from "../shapes/2d/rect.js"
+import {rectVsRect} from "../physics/2d/collide2d.js"
+
+export class Zen<X> {
+	zones = new Set<ZenZone<X>>()
+
+	constructor(
+		public grid: ZenGrid<X>,
+		public rect: Rect,
+		public item: X,
+	) {}
+
+	update() {
+		this.grid.update(this)
+	}
+
+	delete() {
+		this.grid.delete(this)
+	}
+}
+
+export class ZenZone<X> {
+	rect: Rect
+	zens = new Set<Zen<X>>()
+
+	constructor(public hash: string, center: Vec2, size: Vec2) {
+		this.rect = Rect.fromCenter(center, size)
+	}
+}
+
+export class ZenGrid<X> {
+	#zones = new MapG<string, ZenZone<X>>()
+
+	constructor(private zoneExtent: Vec2) {}
+
+	count() {
+		let n = 0
+		for (const zone of this.#zones.values())
+			n += zone.zens.size
+		return n
+	}
+
+	create(rect: Rect, item: X) {
+		const zen = new Zen<X>(this, rect, item)
+		this.update(zen)
+		return zen
+	}
+
+	update(zen: Zen<X>) {
+		const wantedZones = this.#selectZones(zen.rect)
+
+		// delete stale zones
+		for (const zone of zen.zones) {
+			if (!wantedZones.has(zone)) {
+				zen.zones.delete(zone)
+				zone.zens.delete(zen)
+			}
+		}
+
+		// add fresh zones
+		for (const zone of wantedZones) {
+			if (!zen.zones.has(zone)) {
+				zone.zens.add(zen)
+				zen.zones.add(zone)
+			}
+		}
+	}
+
+	delete(zen: Zen<X>) {
+		const emptyZones: ZenZone<X>[] = []
+
+		for (const zone of zen.zones) {
+			zone.zens.delete(zen)
+			if (zone.zens.size === 0)
+				emptyZones.push(zone)
+		}
+
+		for (const emptyZone of emptyZones)
+			this.#zones.delete(emptyZone.hash)
+	}
+
+	check(rect: Rect) {
+		const zones = this.#selectZones(rect)
+
+		for (const zone of zones)
+			for (const zen of zone.zens)
+				if (rectVsRect(rect, zen.rect))
+					return true
+
+		return false
+	}
+
+	/** return set of zens that touch the given rect */
+	query(rect: Rect) {
+		const zones = this.#selectZones(rect)
+		const selected = new Set<Zen<X>>()
+
+		for (const zone of zones)
+			for (const zen of zone.zens)
+				if (!selected.has(zen) && rectVsRect(rect, zen.rect))
+					selected.add(zen)
+
+		return selected
+	}
+
+	/** return all zen items that touch the given rect */
+	queryItems(rect: Rect) {
+		return [...this.query(rect)].map(zen => zen.item)
+	}
+
+	/** return all zen rects that touch the given rect */
+	queryRects(rect: Rect) {
+		return [...this.query(rect)].map(zen => zen.rect)
+	}
+
+	#hash(v: Vec2) {
+		return `${v.x},${v.y}`
+	}
+
+	#calculateZoneCorner(point: Vec2) {
+		return new Vec2(
+			Math.floor(point.x / this.zoneExtent.x),
+			Math.floor(point.y / this.zoneExtent.y),
+		).multiply(this.zoneExtent)
+	}
+
+	#obtainZone(zoneCorner: Vec2) {
+		const hash = this.#hash(zoneCorner)
+		return this.#zones.guarantee(hash, () => new ZenZone(
+			hash,
+			zoneCorner.clone().add(this.zoneExtent.clone().half()),
+			this.zoneExtent,
+		))
+	}
+
+	#selectZones(rect: Rect) {
+		const zones = new Set<ZenZone<X>>()
+		const minZoneCorner = this.#calculateZoneCorner(rect.min)
+		const maxZoneCorner = this.#calculateZoneCorner(rect.max)
+
+		for (let x = minZoneCorner.x; x <= maxZoneCorner.x; x += this.zoneExtent.x)
+			for (let y = minZoneCorner.y; y <= maxZoneCorner.y; y += this.zoneExtent.y)
+				zones.add(this.#obtainZone(new Vec2(x, y)))
+
+		return zones
+	}
+}
+

package/s/physics/2d/collide2d.ts

@@ -0,0 +1,51 @@
+
+import {Vec2} from "../../core/vec2.js"
+import {Rect} from "../../shapes/2d/rect.js"
+import {Scalar} from "../../tools/scalar.js"
+import {Circle} from "../../shapes/2d/circle.js"
+
+export function pointVsRect(point: Vec2, box: Rect) {
+	const {min, max} = box
+	return (
+		point.x >= min.x &&
+		point.x <= max.x &&
+		point.y >= min.y &&
+		point.y <= max.y
+	)
+}
+
+export function pointVsCircle(point: Vec2, circle: Circle) {
+	const dx = point.x - circle.center.x
+	const dy = point.y - circle.center.y
+	const distanceSquared = (dx ** 2) + (dy ** 2)
+	return distanceSquared <= (circle.radius ** 2)
+}
+
+export function rectVsRect(a: Rect, b: Rect) {
+	return !(
+		a.max.x <= b.min.x ||
+		a.min.x >= b.max.x ||
+		a.max.y <= b.min.y ||
+		a.min.y >= b.max.y
+	)
+}
+
+export function rectVsCircle(rect: Rect, circle: Circle) {
+	const clamped = new Vec2(
+		Scalar.clamp(circle.center.x, rect.min.x, rect.max.x),
+		Scalar.clamp(circle.center.y, rect.min.y, rect.max.y),
+	)
+	const difference = circle.center.clone().subtract(clamped)
+	const distanceSquared = (difference.x ** 2) + (difference.y ** 2)
+	const radiusSquared = circle.radius ** 2
+	return distanceSquared <= radiusSquared
+}
+
+export function circleVsCircle(circleA: Circle, circleB: Circle) {
+	const dx = circleB.center.x - circleA.center.x
+	const dy = circleB.center.y - circleA.center.y
+	const distanceSquared = (dx ** 2) + (dy ** 2)
+	const radiusSum = circleA.radius + circleB.radius
+	return distanceSquared <= (radiusSum ** 2)
+}
+

package/s/physics/2d/intersect2d.ts

@@ -0,0 +1,80 @@
+
+import {Vec2} from "../../core/vec2.js"
+import {Rect} from "../../shapes/2d/rect.js"
+import {Scalar} from "../../tools/scalar.js"
+import {Circle} from "../../shapes/2d/circle.js"
+import {rectVsCircle, rectVsRect} from "./collide2d.js"
+
+export class Intersection {
+	constructor(
+		public contactPoint: Vec2,
+		public depth: number,
+		public normalA: Vec2,
+		public normalB: Vec2,
+	) {}
+}
+
+export function intersectRectVsRect(a: Rect, b: Rect) {
+	if (!rectVsRect(a, b)) return null
+
+	const overlapX = Math.min(a.max.x - b.min.x, b.max.x - a.min.x)
+	const overlapY = Math.min(a.max.y - b.min.y, b.max.y - a.min.y)
+	const depth = Math.min(overlapX, overlapY)
+
+	const aCenter = a.center()
+	const bCenter = b.center()
+
+	const contactPoint = new Vec2(
+		Scalar.clamp((aCenter.x + bCenter.x) / 2, b.min.x, b.max.x),
+		Scalar.clamp((aCenter.y + bCenter.y) / 2, b.min.y, b.max.y)
+	)
+
+	const normalA = depth === overlapX
+		? new Vec2(bCenter.x > aCenter.x ? -1 : 1, 0)
+		: new Vec2(0, bCenter.y > aCenter.y ? -1 : 1)
+
+	const normalB = normalA.clone().multiplyBy(-1)
+
+	return new Intersection(contactPoint, depth, normalA, normalB)
+}
+
+export function intersectRectVsCircle(rect: Rect, circle: Circle) {
+	if (!rectVsCircle(rect, circle)) return null
+
+	const clamped = new Vec2(
+		Scalar.clamp(circle.center.x, rect.min.x, rect.max.x),
+		Scalar.clamp(circle.center.y, rect.min.y, rect.max.y),
+	)
+	const difference = circle.center.clone().subtract(clamped)
+	const distance = difference.magnitude()
+	const depth = circle.radius - distance
+
+	const contactPoint = clamped
+	const normalA = difference.normalize()
+	const normalB = normalA.clone().multiplyBy(-1)
+
+	return new Intersection(contactPoint, depth, normalA, normalB)
+}
+
+export function intersectCircleVsCircle(a: Circle, b: Circle) {
+	const dx = b.center.x - a.center.x
+	const dy = b.center.y - a.center.y
+	const distance = Math.sqrt(dx ** 2 + dy ** 2)
+	if (distance >= a.radius + b.radius) return null
+
+	const depth = Math.max(0, a.radius + b.radius - distance)
+
+	const normalA = distance === 0
+		? new Vec2(1, 0) // fallback for perfectly overlapping circles
+		: new Vec2(dx / distance, dy / distance)
+
+	const normalB = normalA.clone().multiplyBy(-1)
+
+	const contactPoint = new Vec2(
+		(a.center.x + b.center.x) / 2,
+		(a.center.y + b.center.y) / 2
+	)
+
+	return new Intersection(contactPoint, depth, normalA, normalB)
+}
+

package/s/shapes/2d/circle.ts

@@ -0,0 +1,43 @@
+
+import {Rect} from "./rect.js"
+import {Vec2, XyArray, Xy} from "../../core/vec2.js"
+
+export type CircleJson = [center: XyArray, radius: number]
+export type CircleLike = {center: Xy, radius: number}
+
+export class Circle {
+	constructor(
+		public center: Vec2,
+		public radius: number,
+	) {}
+
+	static from(data: CircleJson | CircleLike) {
+		return Array.isArray(data)
+			? new this(Vec2.from(data[0]), data[1])
+			: new this(Vec2.from(data.center), data.radius)
+	}
+
+	toJSON(): CircleJson {
+		return [this.center.clone().toJSON(), this.radius]
+	}
+
+	clone() {
+		return new Circle(this.center.clone(), this.radius)
+	}
+
+	set(circle: CircleLike) {
+		this.center.set(circle.center)
+		this.radius = circle.radius
+	}
+
+	translate(delta: Vec2) {
+		this.center.add(delta)
+		return this
+	}
+
+	boundingBox() {
+		const size = Vec2.all(this.radius * 2)
+		return Rect.fromCenter(this.center.clone(), size)
+	}
+}
+

package/s/shapes/2d/edge.ts

@@ -0,0 +1,3 @@
+
+// TODO
+

package/s/shapes/2d/index.ts

@@ -0,0 +1,6 @@
+
+export * from "./circle.js"
+export * from "./edge.js"
+export * from "./pill.js"
+export * from "./rect.js"
+

package/s/shapes/2d/pill.ts

@@ -0,0 +1,3 @@
+
+// TODO
+

package/s/shapes/2d/rect.ts

@@ -0,0 +1,74 @@
+
+import {Vec2, XyArray, Xy} from "../../core/vec2.js"
+import {pointVsRect} from "../../physics/2d/collide2d.js"
+
+export type RectJson = [min: XyArray, max: XyArray]
+export type RectLike = {min: Xy, max: Xy}
+
+export class Rect {
+	constructor(
+		public min: Vec2,
+		public max: Vec2,
+	) {}
+
+	static from(data: RectJson | RectLike) {
+		return Array.isArray(data)
+			? new this(Vec2.from(data[0]), Vec2.from(data[1]))
+			: new this(Vec2.from(data.min), Vec2.from(data.max))
+	}
+
+	static fromCorner(min: Vec2, size: Vec2) {
+		const max = min.clone().add(size)
+		return new this(min, max)
+	}
+
+	static fromCenter(center: Vec2, size: Vec2) {
+		const halfSize = size.clone().half()
+		const min = center.clone().subtract(halfSize)
+		const max = center.clone().add(halfSize)
+		return new this(min, max)
+	}
+
+	clone() {
+		return new Rect(this.min.clone(), this.max.clone())
+	}
+
+	toJSON(): RectJson {
+		return [this.min.toJSON(), this.max.toJSON()]
+	}
+
+	set(rect: RectLike) {
+		this.min.set(rect.min)
+		this.max.set(rect.max)
+	}
+
+	normalize() {
+		const {min, max} = this
+		this.min.set(Vec2.min(min, max))
+		this.max.set(Vec2.max(min, max))
+		return this
+	}
+
+	size() {
+		return this.max.clone().subtract(this.min)
+	}
+
+	center() {
+		return this.min.clone().add(this.size().half())
+	}
+
+	translate(delta: Vec2) {
+		this.min.add(delta)
+		this.max.add(delta)
+		return this
+	}
+
+	contains(point: Vec2) {
+		return pointVsRect(point, this)
+	}
+
+	boundingBox() {
+		return this.clone()
+	}
+}
+