@benev/math 0.1.0 → 0.2.0-0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@benev/math",
-	"version": "0.1.0",
+	"version": "0.2.0-0",
 	"description": "game math toolkit",
 	"license": "MIT",
 	"author": "Chase Moskal <chasemoskal@gmail.com>",
@@ -21,6 +21,7 @@
 		"count": "find s -path '*/_archive' -prune -o -name '*.ts' -exec wc -l {} +"
 	},
 	"dependencies": {
+		"@e280/stz": "^0.1.0",
 		"simplex-noise": "^4.0.3"
 	},
 	"devDependencies": {

package/s/index.ts

@@ -1,12 +1,28 @@
 
-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 "./primitives/circular.js"
+export * from "./primitives/quat.js"
+export * from "./primitives/scalar.js"
+export * from "./primitives/vec2.js"
+export * from "./primitives/vec3.js"
+export * from "./primitives/vec4.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"
+
+export * from "./utils/angles.js"
+export * from "./utils/noise.js"
+export * from "./utils/randy.js"
+export * as spline from "./utils/spline.js"
 

package/s/optimizers/hash-map.ts

@@ -0,0 +1,67 @@
+
+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()
+	}
+
+	*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,46 @@
+
+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()
+	}
+}
+

package/s/optimizers/zen.ts

@@ -0,0 +1,150 @@
+
+import {MapG} from "@e280/stz"
+import {Rect} from "../shapes/2d/rect.js"
+import {Vec2} from "../primitives/vec2.js"
+import {rectVsRect} from "../physics/2d/collide2d.js"
+
+export class Zen<X> {
+	zones = new Set<ZenZone<X>>()
+
+	constructor(
+		public grid: ZenGrid<X>,
+		public box: Rect,
+		public item: X,
+	) {}
+
+	update() {
+		this.grid.update(this)
+	}
+
+	delete() {
+		this.grid.delete(this)
+	}
+}
+
+export class ZenZone<X> extends Rect {
+	zens = new Set<Zen<X>>()
+
+	constructor(public hash: string, center: Vec2, extent: Vec2) {
+		super(center, extent)
+	}
+}
+
+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(box: Rect, item: X) {
+		const zen = new Zen<X>(this, box, item)
+		this.update(zen)
+		return zen
+	}
+
+	update(zen: Zen<X>) {
+		const wantedZones = this.#selectZones(zen.box)
+
+		// 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(box: Rect) {
+		const zones = this.#selectZones(box)
+
+		for (const zone of zones)
+			for (const zen of zone.zens)
+				if (rectVsRect(box, zen.box))
+					return true
+
+		return false
+	}
+
+	/** return all zens that touch the given box */
+	query(box: Rect) {
+		const zones = this.#selectZones(box)
+		const selected: Zen<X>[] = []
+
+		for (const zone of zones)
+			for (const zen of zone.zens)
+				if (rectVsRect(box, zen.box) && !selected.includes(zen))
+					selected.push(zen)
+
+		return selected
+	}
+
+	/** return all zen items that touch the given box */
+	queryItems(box: Rect) {
+		return this.query(box).map(zen => zen.item)
+	}
+
+	/** return all zen boxes that touch the given box */
+	queryBoxes(box: Rect) {
+		return this.query(box).map(zen => zen.box)
+	}
+
+	#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(box: Rect) {
+		const zones = new Set<ZenZone<X>>()
+		const minZoneCorner = this.#calculateZoneCorner(box.min)
+		const maxZoneCorner = this.#calculateZoneCorner(box.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 "../../primitives/vec2.js"
+import {Rect} from "../../shapes/2d/rect.js"
+import {Scalar} from "../../primitives/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,77 @@
+
+import {Vec2} from "../../primitives/vec2.js"
+import {Rect} from "../../shapes/2d/rect.js"
+import {Scalar} from "../../primitives/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 contactPoint = new Vec2(
+		Scalar.clamp((a.center.x + b.center.x) / 2, b.min.x, b.max.x),
+		Scalar.clamp((a.center.y + b.center.y) / 2, b.min.y, b.max.y)
+	)
+
+	const normalA = depth === overlapX
+		? new Vec2(b.center.x > a.center.x ? -1 : 1, 0)
+		: new Vec2(0, b.center.y > a.center.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,25 @@
+
+import {Rect} from "./rect.js"
+import {Vec2} from "../../primitives/vec2.js"
+
+export class Circle {
+	constructor(
+		public center: Vec2,
+		public radius: number,
+	) {}
+
+	offset(delta: Vec2) {
+		this.center.add(delta)
+		return this
+	}
+
+	boundingBox() {
+		const extent = Vec2.all(this.radius * 2)
+		return new Rect(this.center, extent)
+	}
+
+	clone() {
+		return new Circle(this.center.clone(), this.radius)
+	}
+}
+

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,45 @@
+
+import {Vec2} from "../../primitives/vec2.js"
+import {pointVsRect} from "../../physics/2d/collide2d.js"
+
+export class Rect {
+	constructor(
+			public center: Vec2,
+			public extent: Vec2,
+		) {
+		if (extent.x < 0 || extent.y < 0)
+			throw new Error(`invalid negative extent, ${extent.toString()}`)
+	}
+
+	static fromCorner(min: Vec2, extent: Vec2) {
+		return new this(min.add(extent.clone().half()), extent)
+	}
+
+	get min() {
+		return this.center.clone()
+			.subtract(this.extent.clone().half())
+	}
+
+	get max() {
+		return this.center.clone()
+			.add(this.extent.clone().half())
+	}
+
+	offset(delta: Vec2) {
+		this.center.add(delta)
+		return this
+	}
+
+	boundingBox() {
+		return this
+	}
+
+	contains(point: Vec2) {
+		return pointVsRect(point, this)
+	}
+
+	clone() {
+		return new Rect(this.center.clone(), this.extent.clone())
+	}
+}
+

package/s/shapes/3d/box.ts

@@ -0,0 +1,39 @@
+
+import {Vec3} from "../../primitives/vec3.js"
+
+export class Box {
+	constructor(
+			public center: Vec3,
+			public extent: Vec3,
+		) {
+		if (extent.x < 0 || extent.y < 0 || extent.z < 0)
+			throw new Error(`invalid negative extent, ${extent.toString()}`)
+	}
+
+	static fromCorner(min: Vec3, extent: Vec3) {
+		return new this(
+			min.clone().add(extent.clone().half()),
+			extent,
+		)
+	}
+
+	get min() {
+		return this.center.clone()
+			.subtract(this.extent.clone().half())
+	}
+
+	get max() {
+		return this.center.clone()
+			.add(this.extent.clone().half())
+	}
+
+	clone() {
+		return new Box(this.center.clone(), this.extent.clone())
+	}
+
+	grow(increase: number) {
+		this.extent.addBy(increase)
+		return this
+	}
+}
+

package/s/shapes/3d/capsule.ts

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

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

@@ -0,0 +1,6 @@
+
+export * from "./box.js"
+export * from "./capsule.js"
+export * from "./segment.js"
+export * from "./sphere.js"
+

package/s/shapes/3d/segment.ts

@@ -0,0 +1,46 @@
+
+import {Vec3} from "../../primitives/vec3.js"
+
+export class Segment {
+	constructor(
+		public start: Vec3,
+		public end: Vec3,
+	) {}
+
+	get vector() {
+		return this.end.clone().subtract(this.start)
+	}
+
+	get length() {
+		return this.start.distance(this.end)
+	}
+
+	get center() {
+		return this.start.clone()
+			.add(this.end)
+			.divideBy(2)
+	}
+
+	clone() {
+		return new Segment(
+			this.start.clone(),
+			this.end.clone(),
+		)
+	}
+
+	fromStart(length: number) {
+		const direction = this.vector.normalize()
+		return this.start.clone().add(direction.multiplyBy(length))
+	}
+
+	point(fraction: number) {
+		return this.start.clone().add(this.vector.multiplyBy(fraction))
+	}
+
+	scale(fraction: number) {
+		const newHalfVector = this.vector.multiplyBy(fraction / 2)
+		this.start.set(this.center.subtract(newHalfVector))
+		this.end.set(this.center.add(newHalfVector))
+	}
+}
+

package/s/shapes/3d/sphere.ts

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

package/s/utils/angles.ts

@@ -0,0 +1,43 @@
+
+import {Scalar} from "../primitives/scalar.js"
+
+const pi = Math.PI
+
+export const Radians = {
+	circle: 2 * pi,
+	halfcircle: pi,
+
+	toDegrees(r: number) {
+		return r * (180 / pi)
+	},
+	toArcseconds(r: number) {
+		return Radians.toDegrees(r) * 3600
+	},
+	toTurns(r: number) {
+		return r / Radians.circle
+	},
+
+	circleDistance(radiansA: number, radiansB: number): number {
+		const diff = Math.abs(Scalar.wrap(radiansA - radiansB, 0, Radians.circle))
+		return Math.min(diff, Radians.circle - diff)
+	},
+}
+
+export const Turns = {
+	toRadians(t: number) {
+		return t * Radians.circle
+	},
+}
+
+export const Arcseconds = {
+	toRadians(a: number) {
+		return Degrees.toRadians(a / 3600)
+	},
+}
+
+export const Degrees = {
+	toRadians(d: number) {
+		return d * (pi / 180)
+	},
+}
+