Merge branch 'feature/minmax-vector-ops-and-aabb-collisions'

intersect.lua

@@ -242,12 +242,40 @@ function intersect.aabb_point_overlap(pos, hs, v)
 	return _apo_delta.x < hs.x and _apo_delta.y < hs.y
 end
 
+-- discrete displacement
+-- return msv to push point to closest edge of aabb
+local _apo_delta_c = vec2:zero()
+local _apo_delta_c_abs = vec2:zero()
+function intersect.aabb_point_collide(pos, hs, v, into)
+	--separation between centres
+	_apo_delta_c
+		:vset(v)
+		:vsubi(pos)
+	--absolute separation
+	_apo_delta_c_abs
+		:vset(_apo_delta_c)
+		:absi()
+	if _apo_delta_c_abs.x < hs.x and _apo_delta_c_abs.y < hs.y then
+		return (into or vec2:zero())
+			--separating offset in both directions
+			:vset(hs)
+			:vsubi(_apo_delta_c_abs)
+			--minimum separating distance
+			:minori()
+			--in the right direction
+			:vmuli(_apo_delta_c:signi())
+			--from the aabb's point of view
+			:smuli(-1)
+	end
+	return false
+end
+
 --return true on overlap, false otherwise
 local _aao_abs_delta = vec2:zero()
 local _aao_total_size = vec2:zero()
-function intersect.aabb_aabb_overlap(pos, hs, opos, ohs)
-	_aao_abs_delta:vset(pos):vsubi(opos):absi()
-	_aao_total_size:vset(hs):vaddi(ohs)
+function intersect.aabb_aabb_overlap(a_pos, a_hs, b_pos, b_hs)
+	_aao_abs_delta:vset(a_pos):vsubi(b_pos):absi()
+	_aao_total_size:vset(a_hs):vaddi(b_hs)
 	return _aao_abs_delta.x < _aao_total_size.x and _aao_abs_delta.y < _aao_total_size.y
 end
 
@@ -257,11 +285,11 @@ local _aac_delta = vec2:zero()
 local _aac_abs_delta = vec2:zero()
 local _aac_size = vec2:zero()
 local _aac_abs_amount = vec2:zero()
-function intersect.aabb_aabb_collide(apos, ahs, bpos, bhs, into)
+function intersect.aabb_aabb_collide(a_pos, a_hs, b_pos, b_hs, into)
 	if not into then into = vec2:zero() end
-	_aac_delta:vset(apos):vsubi(bpos)
+	_aac_delta:vset(a_pos):vsubi(b_pos)
 	_aac_abs_delta:vset(_aac_delta):absi()
-	_aac_size:vset(ahs):vaddi(bhs)
+	_aac_size:vset(a_hs):vaddi(b_hs)
 	_aac_abs_amount:vset(_aac_size):vsubi(_aac_abs_delta)
 	if _aac_abs_amount.x > COLLIDE_EPS and _aac_abs_amount.y > COLLIDE_EPS then
 		--actually collided
@@ -287,8 +315,8 @@ end
 --return normal and fraction of dt encountered on collision, false otherwise
 --TODO: re-pool storage here
 function intersect.aabb_aabb_collide_continuous(
-	a_startpos, a_endpos, ahs,
-	b_startpos, b_endpos, bhs,
+	a_startpos, a_endpos, a_hs,
+	b_startpos, b_endpos, b_hs,
 	into
 )
 	if not into then into = vec2:zero() end
@@ -301,11 +329,11 @@ function intersect.aabb_aabb_collide_continuous(
 	do
 		local _self_half_delta = _self_delta_motion:smul(0.5)
 		local _self_bounds_pos = _self_half_delta:vadd(a_endpos)
-		local _self_bounds_hs = _self_half_delta:vadd(ahs)
+		local _self_bounds_hs = _self_half_delta:vadd(a_hs)
 
 		local _other_half_delta = _other_delta_motion:smul(0.5)
 		local _other_bounds_pos = _other_half_delta:vadd(b_endpos)
-		local _other_bounds_hs = _other_half_delta:vadd(bhs)
+		local _other_bounds_hs = _other_half_delta:vadd(b_hs)
 
 		if not body._overlap_raw(
 			_self_bounds_pos, _self_bounds_hs,
@@ -318,7 +346,7 @@ function intersect.aabb_aabb_collide_continuous(
 	--get ccd minkowski box
 	--this is a relative-space box
 	local _relative_delta_motion = _self_delta_motion:vsub(_other_delta_motion)
-	local _minkowski_halfsize = ahs:vadd(bhs)
+	local _minkowski_halfsize = a_hs:vadd(b_hs)
 	local _minkowski_pos = b_startpos:vsub(a_startpos)
 
 	--if a line seg from our relative motion hits the minkowski box, we're in luck
@@ -407,6 +435,46 @@ function intersect.aabb_aabb_collide_continuous(
 	return false
 end
 
+-- helper function to clamp point to aabb
+function intersect.aabb_point_clamp(pos, hs, v, into)
+	local v_min = pos:pooled_copy():vsubi(hs)
+	local v_max = pos:pooled_copy():vaddi(hs)
+	into = into or vec2:zero()
+	into:vset(v):clampi(v_min, v_max)
+	vec2.release(v_min, v_max)
+	return into
+end
+
+-- return true on overlap, false otherwise
+function intersect.aabb_circle_overlap(a_pos, a_hs, b_pos, b_rad)
+	local clamped = intersect.aabb_point_clamp(a_pos, a_hs, b_pos, vec2:pooled())
+	local edge_distance_squared = clamped:distance_squared(b_pos)
+	clamped:release()
+	return edge_distance_squared < (b_rad * b_rad)
+end
+
+-- return msv on collision, false otherwise
+function intersect.aabb_circle_collide(a_pos, a_hs, b_pos, b_rad, into)
+	local abs_delta = a_pos:pooled_copy():vsub(b_pos):absi()
+	--circle centre within aabb-like bounds, collide as an aabb
+	local like_aabb = abs_delta.x < a_hs.x or abs_delta.y < a_hs.y
+	--(clean up)
+	abs_delta:release()
+	--
+	local result
+	if like_aabb then
+		local pretend_hs = vec2:pooled():sset(b_rad)
+		result = intersect.aabb_aabb_collide(a_pos, a_hs, b_pos, pretend_hs, into)
+		pretend_hs:release()
+	else
+		--outside aabb-like bounds so we need to collide with the nearest clamped corner point
+		local clamped = intersect.aabb_point_clamp(a_pos, a_hs, b_pos, vec2:pooled())
+		result = intersect.circle_circle_collide(clamped, 0, b_pos, b_rad, into)
+		clamped:release()
+	end
+	return result
+end
+
 --check if a point is in a polygon
 --point is the point to test
 --poly is a list of points in order

vec2.lua

@@ -92,10 +92,13 @@ function vec2:pooled_copy()
 end
 
 --release a vector to the pool
-function vec2:release()
+function vec2:release(...)
 	if vec2.pool_size() < _vec2_pool_limit then
 		table.insert(_vec2_pool, self)
 	end
+	if ... then
+		vec2.release(...)
+	end
 end
 
 --unpack for multi-args
@@ -448,6 +451,20 @@ function vec2:abs()
 	return self:copy():absi()
 end
 
+-----------------------------------------------------------
+-- sign
+-----------------------------------------------------------
+
+function vec2:signi()
+	self.x = math.sign(self.x)
+	self.y = math.sign(self.y)
+	return self
+end
+
+function vec2:sign()
+	return self:copy():signi()
+end
+
 -----------------------------------------------------------
 -- truncation/rounding
 -----------------------------------------------------------
@@ -599,4 +616,42 @@ function vec2:apply_friction_xy(mu_x, mu_y, dt)
 	return self
 end
 
+--minimum/maximum components
+function vec2:mincomp()
+	return math.min(self.x, self.y)
+end
+
+function vec2:maxcomp()
+	return math.max(self.x, self.y)
+end
+
+-- mask out min component, with preference to keep x
+function vec2:majori()
+	if self.x > self.y then
+		self.y = 0
+	else
+		self.x = 0
+	end
+	return self
+end
+-- mask out max component, with preference to keep x
+function vec2:minori()
+	if self.x < self.y then
+		self.y = 0
+	else
+		self.x = 0
+	end
+	return self
+end
+
+
+--garbage generating versions
+function vec2:major(axis)
+	return self:copy():majori(axis)
+end
+
+function vec2:minor(axis)
+	return self:copy():minori(axis)
+end
+
 return vec2