4aiman/Shining-in-the-Darkness-Lua-Remake-abandoned
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Initial

Browse source
This commit is contained in:
ezwrk 2024-06-05 14:16:51 +03:00
commit b8d1a8022c
649 changed files with 171549 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

486
g3d/collisions.lua Normal file
View file

@ -0,0 +1,486 @@
-- written by groverbuger for g3d
-- september 2021
-- MIT license
local vectors = require(g3d.path .. "/vectors")
local fastSubtract = vectors.subtract
local vectorAdd = vectors.add
local vectorCrossProduct = vectors.crossProduct
local vectorDotProduct = vectors.dotProduct
local vectorNormalize = vectors.normalize
local vectorMagnitude = vectors.magnitude
----------------------------------------------------------------------------------------------------
-- collision detection functions
----------------------------------------------------------------------------------------------------
--
-- none of these functions are required for developing 3D games
-- however these collision functions are very frequently used in 3D games
--
-- be warned! a lot of this code is butt-ugly
-- using a table per vector would create a bazillion tables and lots of used memory
-- so instead all vectors are all represented using three number variables each
-- this approach ends up making the code look terrible, but collision functions need to be efficient
local collisions = {}
-- finds the closest point to the source point on the given line segment
local function closestPointOnLineSegment(
a_x,a_y,a_z, -- point one of line segment
b_x,b_y,b_z, -- point two of line segment
x,y,z -- source point
)
local ab_x, ab_y, ab_z = b_x - a_x, b_y - a_y, b_z - a_z
local t = vectorDotProduct(x - a_x, y - a_y, z - a_z, ab_x, ab_y, ab_z) / (ab_x^2 + ab_y^2 + ab_z^2)
t = math.min(1, math.max(0, t))
return a_x + t*ab_x, a_y + t*ab_y, a_z + t*ab_z
end
-- model - ray intersection
-- based off of triangle - ray collision from excessive's CPML library
-- does a triangle - ray collision for every face in the model to find the shortest collision
--
-- sources:
-- https://github.com/excessive/cpml/blob/master/modules/intersect.lua
-- http://www.lighthouse3d.com/tutorials/maths/ray-triangle-intersection/
local tiny = 2.2204460492503131e-16 -- the smallest possible value for a double, "double epsilon"
local function triangleRay(
tri_0_x, tri_0_y, tri_0_z,
tri_1_x, tri_1_y, tri_1_z,
tri_2_x, tri_2_y, tri_2_z,
n_x, n_y, n_z,
src_x, src_y, src_z,
dir_x, dir_y, dir_z
)
-- cache these variables for efficiency
local e11,e12,e13 = fastSubtract(tri_1_x,tri_1_y,tri_1_z, tri_0_x,tri_0_y,tri_0_z)
local e21,e22,e23 = fastSubtract(tri_2_x,tri_2_y,tri_2_z, tri_0_x,tri_0_y,tri_0_z)
local h1,h2,h3 = vectorCrossProduct(dir_x,dir_y,dir_z, e21,e22,e23)
local a = vectorDotProduct(h1,h2,h3, e11,e12,e13)
-- if a is too close to 0, ray does not intersect triangle
if math.abs(a) <= tiny then
return
end
local s1,s2,s3 = fastSubtract(src_x,src_y,src_z, tri_0_x,tri_0_y,tri_0_z)
local u = vectorDotProduct(s1,s2,s3, h1,h2,h3) / a
-- ray does not intersect triangle
if u < 0 or u > 1 then
return
end
local q1,q2,q3 = vectorCrossProduct(s1,s2,s3, e11,e12,e13)
local v = vectorDotProduct(dir_x,dir_y,dir_z, q1,q2,q3) / a
-- ray does not intersect triangle
if v < 0 or u + v > 1 then
return
end
-- at this stage we can compute t to find out where
-- the intersection point is on the line
local thisLength = vectorDotProduct(q1,q2,q3, e21,e22,e23) / a
-- if hit this triangle and it's closer than any other hit triangle
if thisLength >= tiny and (not finalLength or thisLength < finalLength) then
--local norm_x, norm_y, norm_z = vectorCrossProduct(e11,e12,e13, e21,e22,e23)
return thisLength, src_x + dir_x*thisLength, src_y + dir_y*thisLength, src_z + dir_z*thisLength, n_x,n_y,n_z
end
end
-- detects a collision between a triangle and a sphere
--
-- sources:
-- https://wickedengine.net/2020/04/26/capsule-collision-detection/
local function triangleSphere(
tri_0_x, tri_0_y, tri_0_z,
tri_1_x, tri_1_y, tri_1_z,
tri_2_x, tri_2_y, tri_2_z,
tri_n_x, tri_n_y, tri_n_z,
src_x, src_y, src_z, radius
)
-- recalculate surface normal of this triangle
local side1_x, side1_y, side1_z = tri_1_x - tri_0_x, tri_1_y - tri_0_y, tri_1_z - tri_0_z
local side2_x, side2_y, side2_z = tri_2_x - tri_0_x, tri_2_y - tri_0_y, tri_2_z - tri_0_z
local n_x, n_y, n_z = vectorNormalize(vectorCrossProduct(side1_x, side1_y, side1_z, side2_x, side2_y, side2_z))
-- distance from src to a vertex on the triangle
local dist = vectorDotProduct(src_x - tri_0_x, src_y - tri_0_y, src_z - tri_0_z, n_x, n_y, n_z)
-- collision not possible, just return
if dist < -radius or dist > radius then
return
end
-- itx stands for intersection
local itx_x, itx_y, itx_z = src_x - n_x * dist, src_y - n_y * dist, src_z - n_z * dist
-- determine whether itx is inside the triangle
-- project it onto the triangle and return if this is the case
local c0_x, c0_y, c0_z = vectorCrossProduct(itx_x - tri_0_x, itx_y - tri_0_y, itx_z - tri_0_z, tri_1_x - tri_0_x, tri_1_y - tri_0_y, tri_1_z - tri_0_z)
local c1_x, c1_y, c1_z = vectorCrossProduct(itx_x - tri_1_x, itx_y - tri_1_y, itx_z - tri_1_z, tri_2_x - tri_1_x, tri_2_y - tri_1_y, tri_2_z - tri_1_z)
local c2_x, c2_y, c2_z = vectorCrossProduct(itx_x - tri_2_x, itx_y - tri_2_y, itx_z - tri_2_z, tri_0_x - tri_2_x, tri_0_y - tri_2_y, tri_0_z - tri_2_z)
if vectorDotProduct(c0_x, c0_y, c0_z, n_x, n_y, n_z) <= 0
and vectorDotProduct(c1_x, c1_y, c1_z, n_x, n_y, n_z) <= 0
and vectorDotProduct(c2_x, c2_y, c2_z, n_x, n_y, n_z) <= 0 then
n_x, n_y, n_z = src_x - itx_x, src_y - itx_y, src_z - itx_z
-- the sphere is inside the triangle, so the normal is zero
-- instead, just return the triangle's normal
if n_x == 0 and n_y == 0 and n_z == 0 then
return vectorMagnitude(n_x, n_y, n_z), itx_x, itx_y, itx_z, tri_n_x, tri_n_y, tri_n_z
end
return vectorMagnitude(n_x, n_y, n_z), itx_x, itx_y, itx_z, n_x, n_y, n_z
end
-- itx is outside triangle
-- find points on all three line segments that are closest to itx
-- if distance between itx and one of these three closest points is in range, there is an intersection
local radiussq = radius * radius
local smallestDist
local line1_x, line1_y, line1_z = closestPointOnLineSegment(tri_0_x, tri_0_y, tri_0_z, tri_1_x, tri_1_y, tri_1_z, src_x, src_y, src_z)
local dist = (src_x - line1_x)^2 + (src_y - line1_y)^2 + (src_z - line1_z)^2
if dist <= radiussq then
smallestDist = dist
itx_x, itx_y, itx_z = line1_x, line1_y, line1_z
end
local line2_x, line2_y, line2_z = closestPointOnLineSegment(tri_1_x, tri_1_y, tri_1_z, tri_2_x, tri_2_y, tri_2_z, src_x, src_y, src_z)
local dist = (src_x - line2_x)^2 + (src_y - line2_y)^2 + (src_z - line2_z)^2
if (smallestDist and dist < smallestDist or not smallestDist) and dist <= radiussq then
smallestDist = dist
itx_x, itx_y, itx_z = line2_x, line2_y, line2_z
end
local line3_x, line3_y, line3_z = closestPointOnLineSegment(tri_2_x, tri_2_y, tri_2_z, tri_0_x, tri_0_y, tri_0_z, src_x, src_y, src_z)
local dist = (src_x - line3_x)^2 + (src_y - line3_y)^2 + (src_z - line3_z)^2
if (smallestDist and dist < smallestDist or not smallestDist) and dist <= radiussq then
smallestDist = dist
itx_x, itx_y, itx_z = line3_x, line3_y, line3_z
end
if smallestDist then
n_x, n_y, n_z = src_x - itx_x, src_y - itx_y, src_z - itx_z
-- the sphere is inside the triangle, so the normal is zero
-- instead, just return the triangle's normal
if n_x == 0 and n_y == 0 and n_z == 0 then
return vectorMagnitude(n_x, n_y, n_z), itx_x, itx_y, itx_z, tri_n_x, tri_n_y, tri_n_z
end
return vectorMagnitude(n_x, n_y, n_z), itx_x, itx_y, itx_z, n_x, n_y, n_z
end
end
-- finds the closest point on the triangle from the source point given
--
-- sources:
-- https://wickedengine.net/2020/04/26/capsule-collision-detection/
local function trianglePoint(
tri_0_x, tri_0_y, tri_0_z,
tri_1_x, tri_1_y, tri_1_z,
tri_2_x, tri_2_y, tri_2_z,
tri_n_x, tri_n_y, tri_n_z,
src_x, src_y, src_z
)
-- recalculate surface normal of this triangle
local side1_x, side1_y, side1_z = tri_1_x - tri_0_x, tri_1_y - tri_0_y, tri_1_z - tri_0_z
local side2_x, side2_y, side2_z = tri_2_x - tri_0_x, tri_2_y - tri_0_y, tri_2_z - tri_0_z
local n_x, n_y, n_z = vectorNormalize(vectorCrossProduct(side1_x, side1_y, side1_z, side2_x, side2_y, side2_z))
-- distance from src to a vertex on the triangle
local dist = vectorDotProduct(src_x - tri_0_x, src_y - tri_0_y, src_z - tri_0_z, n_x, n_y, n_z)
-- itx stands for intersection
local itx_x, itx_y, itx_z = src_x - n_x * dist, src_y - n_y * dist, src_z - n_z * dist
-- determine whether itx is inside the triangle
-- project it onto the triangle and return if this is the case
local c0_x, c0_y, c0_z = vectorCrossProduct(itx_x - tri_0_x, itx_y - tri_0_y, itx_z - tri_0_z, tri_1_x - tri_0_x, tri_1_y - tri_0_y, tri_1_z - tri_0_z)
local c1_x, c1_y, c1_z = vectorCrossProduct(itx_x - tri_1_x, itx_y - tri_1_y, itx_z - tri_1_z, tri_2_x - tri_1_x, tri_2_y - tri_1_y, tri_2_z - tri_1_z)
local c2_x, c2_y, c2_z = vectorCrossProduct(itx_x - tri_2_x, itx_y - tri_2_y, itx_z - tri_2_z, tri_0_x - tri_2_x, tri_0_y - tri_2_y, tri_0_z - tri_2_z)
if vectorDotProduct(c0_x, c0_y, c0_z, n_x, n_y, n_z) <= 0
and vectorDotProduct(c1_x, c1_y, c1_z, n_x, n_y, n_z) <= 0
and vectorDotProduct(c2_x, c2_y, c2_z, n_x, n_y, n_z) <= 0 then
n_x, n_y, n_z = src_x - itx_x, src_y - itx_y, src_z - itx_z
-- the sphere is inside the triangle, so the normal is zero
-- instead, just return the triangle's normal
if n_x == 0 and n_y == 0 and n_z == 0 then
return vectorMagnitude(n_x, n_y, n_z), itx_x, itx_y, itx_z, tri_n_x, tri_n_y, tri_n_z
end
return vectorMagnitude(n_x, n_y, n_z), itx_x, itx_y, itx_z, n_x, n_y, n_z
end
-- itx is outside triangle
-- find points on all three line segments that are closest to itx
-- if distance between itx and one of these three closest points is in range, there is an intersection
local line1_x, line1_y, line1_z = closestPointOnLineSegment(tri_0_x, tri_0_y, tri_0_z, tri_1_x, tri_1_y, tri_1_z, src_x, src_y, src_z)
local dist = (src_x - line1_x)^2 + (src_y - line1_y)^2 + (src_z - line1_z)^2
local smallestDist = dist
itx_x, itx_y, itx_z = line1_x, line1_y, line1_z
local line2_x, line2_y, line2_z = closestPointOnLineSegment(tri_1_x, tri_1_y, tri_1_z, tri_2_x, tri_2_y, tri_2_z, src_x, src_y, src_z)
local dist = (src_x - line2_x)^2 + (src_y - line2_y)^2 + (src_z - line2_z)^2
if smallestDist and dist < smallestDist then
smallestDist = dist
itx_x, itx_y, itx_z = line2_x, line2_y, line2_z
end
local line3_x, line3_y, line3_z = closestPointOnLineSegment(tri_2_x, tri_2_y, tri_2_z, tri_0_x, tri_0_y, tri_0_z, src_x, src_y, src_z)
local dist = (src_x - line3_x)^2 + (src_y - line3_y)^2 + (src_z - line3_z)^2
if smallestDist and dist < smallestDist then
smallestDist = dist
itx_x, itx_y, itx_z = line3_x, line3_y, line3_z
end
if smallestDist then
n_x, n_y, n_z = src_x - itx_x, src_y - itx_y, src_z - itx_z
-- the sphere is inside the triangle, so the normal is zero
-- instead, just return the triangle's normal
if n_x == 0 and n_y == 0 and n_z == 0 then
return vectorMagnitude(n_x, n_y, n_z), itx_x, itx_y, itx_z, tri_n_x, tri_n_y, tri_n_z
end
return vectorMagnitude(n_x, n_y, n_z), itx_x, itx_y, itx_z, n_x, n_y, n_z
end
end
-- finds the collision point between a triangle and a capsule
-- capsules are defined with two points and a radius
--
-- sources:
-- https://wickedengine.net/2020/04/26/capsule-collision-detection/
local function triangleCapsule(
tri_0_x, tri_0_y, tri_0_z,
tri_1_x, tri_1_y, tri_1_z,
tri_2_x, tri_2_y, tri_2_z,
n_x, n_y, n_z,
tip_x, tip_y, tip_z,
base_x, base_y, base_z,
a_x, a_y, a_z,
b_x, b_y, b_z,
capn_x, capn_y, capn_z,
radius
)
-- find the normal of this triangle
-- tbd if necessary, this sometimes fixes weird edgecases
local side1_x, side1_y, side1_z = tri_1_x - tri_0_x, tri_1_y - tri_0_y, tri_1_z - tri_0_z
local side2_x, side2_y, side2_z = tri_2_x - tri_0_x, tri_2_y - tri_0_y, tri_2_z - tri_0_z
local n_x, n_y, n_z = vectorNormalize(vectorCrossProduct(side1_x, side1_y, side1_z, side2_x, side2_y, side2_z))
local dotOfNormals = math.abs(vectorDotProduct(n_x, n_y, n_z, capn_x, capn_y, capn_z))
-- default reference point to an arbitrary point on the triangle
-- for when dotOfNormals is 0, because then the capsule is parallel to the triangle
local ref_x, ref_y, ref_z = tri_0_x, tri_0_y, tri_0_z
if dotOfNormals > 0 then
-- capsule is not parallel to the triangle's plane
-- find where the capsule's normal vector intersects the triangle's plane
local t = vectorDotProduct(n_x, n_y, n_z, (tri_0_x - base_x) / dotOfNormals, (tri_0_y - base_y) / dotOfNormals, (tri_0_z - base_z) / dotOfNormals)
local plane_itx_x, plane_itx_y, plane_itx_z = base_x + capn_x*t, base_y + capn_y*t, base_z + capn_z*t
local _
-- then clamp that plane intersect point onto the triangle itself
-- this is the new reference point
_, ref_x, ref_y, ref_z = trianglePoint(
tri_0_x, tri_0_y, tri_0_z,
tri_1_x, tri_1_y, tri_1_z,
tri_2_x, tri_2_y, tri_2_z,
n_x, n_y, n_z,
plane_itx_x, plane_itx_y, plane_itx_z
)
end
-- find the closest point on the capsule line to the reference point
local c_x, c_y, c_z = closestPointOnLineSegment(a_x, a_y, a_z, b_x, b_y, b_z, ref_x, ref_y, ref_z)
-- do a sphere cast from that closest point to the triangle and return the result
return triangleSphere(
tri_0_x, tri_0_y, tri_0_z,
tri_1_x, tri_1_y, tri_1_z,
tri_2_x, tri_2_y, tri_2_z,
n_x, n_y, n_z,
c_x, c_y, c_z, radius
)
end
----------------------------------------------------------------------------------------------------
-- function appliers
----------------------------------------------------------------------------------------------------
-- these functions apply the collision test functions on the given list of triangles
-- runs a given intersection function on all of the triangles made up of a given vert table
local function findClosest(self, verts, func, ...)
-- declare the variables that will be returned by the function
local finalLength, where_x, where_y, where_z, norm_x, norm_y, norm_z
-- cache references to this model's properties for efficiency
local translation_x, translation_y, translation_z, scale_x, scale_y, scale_z = 0, 0, 0, 1, 1, 1
if self then
if self.translation then
translation_x = self.translation[1]
translation_y = self.translation[2]
translation_z = self.translation[3]
end
if self.scale then
scale_x = self.scale[1]
scale_y = self.scale[2]
scale_z = self.scale[3]
end
end
for v=1, #verts, 3 do
-- apply the function given with the arguments given
-- also supply the points of the current triangle
local n_x, n_y, n_z = vectorNormalize(
verts[v][6]*scale_x,
verts[v][7]*scale_x,
verts[v][8]*scale_x
)
local length, wx,wy,wz, nx,ny,nz = func(
verts[v][1]*scale_x + translation_x,
verts[v][2]*scale_y + translation_y,
verts[v][3]*scale_z + translation_z,
verts[v+1][1]*scale_x + translation_x,
verts[v+1][2]*scale_y + translation_y,
verts[v+1][3]*scale_z + translation_z,
verts[v+2][1]*scale_x + translation_x,
verts[v+2][2]*scale_y + translation_y,
verts[v+2][3]*scale_z + translation_z,
n_x,
n_y,
n_z,
...
)
-- if something was hit
-- and either the finalLength is not yet defined or the new length is closer
-- then update the collision information
if length and (not finalLength or length < finalLength) then
finalLength = length
where_x = wx
where_y = wy
where_z = wz
norm_x = nx
norm_y = ny
norm_z = nz
end
end
-- normalize the normal vector before it is returned
if finalLength then
norm_x, norm_y, norm_z = vectorNormalize(norm_x, norm_y, norm_z)
end
-- return all the information in a standardized way
return finalLength, where_x, where_y, where_z, norm_x, norm_y, norm_z
end
-- runs a given intersection function on all of the triangles made up of a given vert table
local function findAny(self, verts, func, ...)
-- cache references to this model's properties for efficiency
local translation_x, translation_y, translation_z, scale_x, scale_y, scale_z = 0, 0, 0, 1, 1, 1
if self then
if self.translation then
translation_x = self.translation[1]
translation_y = self.translation[2]
translation_z = self.translation[3]
end
if self.scale then
scale_x = self.scale[1]
scale_y = self.scale[2]
scale_z = self.scale[3]
end
end
for v=1, #verts, 3 do
-- apply the function given with the arguments given
-- also supply the points of the current triangle
local n_x, n_y, n_z = vectorNormalize(
verts[v][6]*scale_x,
verts[v][7]*scale_x,
verts[v][8]*scale_x
)
local length = func(
verts[v][1]*scale_x + translation_x,
verts[v][2]*scale_y + translation_y,
verts[v][3]*scale_z + translation_z,
verts[v+1][1]*scale_x + translation_x,
verts[v+1][2]*scale_y + translation_y,
verts[v+1][3]*scale_z + translation_z,
verts[v+2][1]*scale_x + translation_x,
verts[v+2][2]*scale_y + translation_y,
verts[v+2][3]*scale_z + translation_z,
n_x,
n_y,
n_z,
...
)
-- if something was hit
-- and either the finalLength is not yet defined or the new length is closer
-- then update the collision information
if length then return true end
end
return false
end
----------------------------------------------------------------------------------------------------
-- collision functions that apply on lists of vertices
----------------------------------------------------------------------------------------------------
function collisions.rayIntersection(verts, transform, src_x, src_y, src_z, dir_x, dir_y, dir_z)
return findClosest(transform, verts, triangleRay, src_x, src_y, src_z, dir_x, dir_y, dir_z)
end
function collisions.isPointInside(verts, transform, x, y, z)
return findAny(transform, verts, triangleRay, x, y, z, 0, 0, 1)
end
function collisions.sphereIntersection(verts, transform, src_x, src_y, src_z, radius)
return findClosest(transform, verts, triangleSphere, src_x, src_y, src_z, radius)
end
function collisions.closestPoint(verts, transform, src_x, src_y, src_z)
return findClosest(transform, verts, trianglePoint, src_x, src_y, src_z)
end
function collisions.capsuleIntersection(verts, transform, tip_x, tip_y, tip_z, base_x, base_y, base_z, radius)
-- the normal vector coming out the tip of the capsule
local norm_x, norm_y, norm_z = vectorNormalize(tip_x - base_x, tip_y - base_y, tip_z - base_z)
-- the base and tip, inset by the radius
-- these two coordinates are the actual extent of the capsule sphere line
local a_x, a_y, a_z = base_x + norm_x*radius, base_y + norm_y*radius, base_z + norm_z*radius
local b_x, b_y, b_z = tip_x - norm_x*radius, tip_y - norm_y*radius, tip_z - norm_z*radius
return findClosest(
transform,
verts,
triangleCapsule,
tip_x, tip_y, tip_z,
base_x, base_y, base_z,
a_x, a_y, a_z,
b_x, b_y, b_z,
norm_x, norm_y, norm_z,
radius
)
end
return collisions