forked from Apancore.Studio/simple-makes-complex
Revert "Add some more shitcoding to MapGen"
This reverts commit cf88ccf67f.
This commit is contained in:
@@ -10,6 +10,20 @@ local mathRound, mathHuge
|
||||
= math.round, math.huge
|
||||
|
||||
-- --- MapGen default noises ---
|
||||
---@type ValueNoise
|
||||
local oceanNoise
|
||||
|
||||
---@type NoiseParams
|
||||
local oceanNoiseParams = {
|
||||
offset = -30,
|
||||
scale = 10,
|
||||
spread = vector.new(100, 100, 100),
|
||||
seed = 47,
|
||||
octaves = 8,
|
||||
persistence = 0.4,
|
||||
lacunarity = 2,
|
||||
}
|
||||
|
||||
---@type ValueNoise
|
||||
local rocksNoise
|
||||
|
||||
@@ -23,27 +37,58 @@ local rocksNoiseParams ={
|
||||
persistence = 0.5,
|
||||
lacunarity = 4,
|
||||
}
|
||||
|
||||
---DEBUG NOISES
|
||||
--- TODO удалить, после реализации климата от регионов
|
||||
---@type ValueNoise
|
||||
local humidityNoise
|
||||
|
||||
---@type NoiseParams
|
||||
humidityNoiseParams = {
|
||||
offset = 50,
|
||||
scale = 25,
|
||||
spread = {x = 10, y = 10, z = 10},
|
||||
seed = 47,
|
||||
octaves = 2,
|
||||
persistence = 0.6,
|
||||
lacunarity = 2,
|
||||
}
|
||||
|
||||
---@type ValueNoise
|
||||
local tempNoise
|
||||
|
||||
---@type NoiseParams
|
||||
tempNoiseParams = {
|
||||
offset = 50,
|
||||
scale = 25,
|
||||
spread = {x = 10, y = 10, z = 10},
|
||||
seed = 12,
|
||||
octaves = 2,
|
||||
persistence = 0.6,
|
||||
lacunarity = 2,
|
||||
}
|
||||
|
||||
-- --- End of default noises ---
|
||||
|
||||
|
||||
---@class MapGen
|
||||
---@field layersByName table
|
||||
---@field layersList table
|
||||
---@field biomesList table
|
||||
---@field biomesDiagram table
|
||||
---@field isMultinoiseInitialized boolean Is the fractal noise of the regions initialized? This is necessary for a one-time noise initialization.
|
||||
---@field isRunning boolean A static field that guarantees that only one instance of the `MapGen` class will work.
|
||||
---@field nodeIDs table<string, number>
|
||||
---@field layersByName table
|
||||
---@field layersList table
|
||||
---@field biomesList table
|
||||
---@field biomesDiagram table
|
||||
---@field multinoiseInitialized boolean Is the fractal noise of the regions initialized? This is necessary for a one-time noise initialization.
|
||||
---@field isRunning boolean A static field that guarantees that only one instance of the `MapGen` class will work.
|
||||
---@field nodeIDs table<string, string>
|
||||
local MapGen = {
|
||||
layersByName = {},
|
||||
layersList = {},
|
||||
biomesList = {},
|
||||
biomesDiagram = {},
|
||||
isMultinoiseInitialized = false,
|
||||
isRunning = false,
|
||||
layersByName = {},
|
||||
layersList = {},
|
||||
biomesList = {},
|
||||
biomesDiagram = {},
|
||||
multinoiseInitialized = false,
|
||||
isRunning = false,
|
||||
}
|
||||
|
||||
---@param nodeIDs table<string, number>
|
||||
---@param nodeIDs table<string, string>
|
||||
---@return MapGen
|
||||
function MapGen:new(nodeIDs)
|
||||
---@type MapGen
|
||||
@@ -54,13 +99,23 @@ function MapGen:new(nodeIDs)
|
||||
return instance
|
||||
end
|
||||
|
||||
---Determines which layer a node belongs to based on its height coordinate.
|
||||
---@param yPos number
|
||||
---@return MapGen.Layer?
|
||||
function MapGen:getLayerByHeight(yPos)
|
||||
for _, layer in ipairs(self.layersList) do
|
||||
--- TODO: возможно здесь получится сделать более оптимизированный алгоритм
|
||||
--- учитывая тот факт, что эта функция вызывается для каждой ноды в on_generated
|
||||
--- и может быть даже не один раз
|
||||
--- Можно подумать над тем, чтобы использовать сортированный список
|
||||
|
||||
---@param layer MapGen.Layer
|
||||
for _, layer in ipairs(self.layersList) do
|
||||
|
||||
if yPos >= layer.minY and yPos <= layer.maxY then
|
||||
return layer
|
||||
end
|
||||
|
||||
end
|
||||
return nil
|
||||
end
|
||||
|
||||
---Mark the world area between two heights as a `MapGen.Layer`.
|
||||
@@ -71,7 +126,7 @@ end
|
||||
---@param maxY number
|
||||
function MapGen:RegisterLayer(name, minY, maxY)
|
||||
---Checking if layers overlap
|
||||
if self:getLayerByHeight(minY) ~= nil or self:getLayerByHeight(maxY) ~= nil then
|
||||
if self:getLayerByHeight(minY) ~= nil and self:getLayerByHeight(maxY) ~= nil then
|
||||
error('Registered layers must not overlap!')
|
||||
end
|
||||
|
||||
@@ -113,33 +168,17 @@ end
|
||||
|
||||
---Initialize region noise. This should be called after the map object is loaded.
|
||||
function MapGen:initRegionsMultinoise()
|
||||
-- Generate rocks noise once
|
||||
rocksNoise = core.get_value_noise(rocksNoiseParams)
|
||||
|
||||
---@param layer MapGen.Layer
|
||||
for _, layer in ipairs(self.layersList) do
|
||||
print("INIT DEFAULT NOISES")
|
||||
layer.defaultRegion:initMultinoise()
|
||||
|
||||
|
||||
---@param region MapGen.Region
|
||||
for _, region in ipairs(layer.regionsList) do
|
||||
region:initMultinoise()
|
||||
end
|
||||
end
|
||||
self.isMultinoiseInitialized = true
|
||||
end
|
||||
|
||||
-- Precompute noise for entire chunk
|
||||
local function precomputeNoiseForChunk(noise, minPos, maxPos)
|
||||
local noiseMap = {}
|
||||
local index = 1
|
||||
for z = minPos.z, maxPos.z do
|
||||
for y = minPos.y, maxPos.y do
|
||||
for x = minPos.x, maxPos.x do
|
||||
noiseMap[index] = mathRound(noise:get_3d(vector.new(x, y, z)))
|
||||
index = index + 1
|
||||
end
|
||||
end
|
||||
end
|
||||
return noiseMap
|
||||
|
||||
self.multinoiseInitialized = true
|
||||
end
|
||||
|
||||
---@param name string
|
||||
@@ -153,13 +192,6 @@ function MapGen:RegisterBiome(name, tempPoint, humidityPoint, groundNodes, soilH
|
||||
table.insert(self.biomesList, biome)
|
||||
end
|
||||
|
||||
function MapGen:precomputeNodeIDs()
|
||||
for _, biome in ipairs(self.biomesList) do
|
||||
biome.groundNodes.turf = self.nodeIDs[biome.groundNodes.turf] or biome.groundNodes.turf
|
||||
biome.groundNodes.soil = self.nodeIDs[biome.groundNodes.soil] or biome.groundNodes.soil
|
||||
end
|
||||
end
|
||||
|
||||
function MapGen:initBiomesDiagram()
|
||||
local diagram = self.biomesDiagram
|
||||
|
||||
@@ -185,17 +217,17 @@ function MapGen:initBiomesDiagram()
|
||||
end
|
||||
end
|
||||
|
||||
local function generateSoil(biome, data, index, pos)
|
||||
data[index] = biome.groundNodes.turf
|
||||
local function generateSoil(biome, data, index, x, y, z)
|
||||
data[index] = core.get_content_id(biome.groundNodes.turf) -- TODO: убрать тут get_content_id(), переместить его куда-то "выше"
|
||||
end
|
||||
|
||||
local function generateRock(ids, data, index, pos)
|
||||
local function generateRock(ids, data, index, x, y, z)
|
||||
|
||||
if rocksNoise == nil then
|
||||
rocksNoise = core.get_value_noise(rocksNoiseParams)
|
||||
end
|
||||
|
||||
local noiseRocksValue = mathRound(rocksNoise:get_3d(pos))
|
||||
local noiseRocksValue = mathRound(rocksNoise:get_3d({x = x, y = y, z = z}))
|
||||
if noiseRocksValue == 1 then
|
||||
data[index] = ids.malachite
|
||||
elseif noiseRocksValue == 2 then
|
||||
@@ -215,160 +247,108 @@ local function generateRock(ids, data, index, pos)
|
||||
end
|
||||
end
|
||||
|
||||
function MapGen:generateNode(self, hight, temp, humidity, data, index, pos)
|
||||
local ids = self.nodeIDs
|
||||
local function generateNode(mapGenerator, hight, temp, humidity, data, index, x, y, z)
|
||||
local ids = mapGenerator.nodeIDs
|
||||
|
||||
local biome = self.biomesDiagram[temp][humidity]
|
||||
local biome = mapGenerator.biomesDiagram[temp][humidity]
|
||||
|
||||
if pos.y > hight and pos.y > 0 then
|
||||
if y > hight and y > 0 then
|
||||
data[index] = ids.air
|
||||
elseif pos.y == hight and pos.y > 0 then
|
||||
generateSoil(biome, data, index, pos)
|
||||
elseif pos.y < hight then
|
||||
generateRock(ids, data, index, pos)
|
||||
elseif y == hight and y > 0 then
|
||||
generateSoil(biome, data, index, x, y, z)
|
||||
elseif y < hight then
|
||||
generateRock(ids, data, index, x, y, z)
|
||||
else
|
||||
data[index] = ids.water
|
||||
end
|
||||
end
|
||||
|
||||
---@param mapGenerator MapGen
|
||||
local function generatorHandler3D(mapGenerator, data, index, x, y, z)
|
||||
local layer = mapGenerator:getLayerByHeight(y)
|
||||
if layer == nil then
|
||||
data[index] = mapGenerator.nodeIDs.air
|
||||
return
|
||||
end
|
||||
|
||||
-- Initialize base noises if needed
|
||||
if oceanNoise == nil then oceanNoise = core.get_value_noise(oceanNoiseParams) end
|
||||
if tempNoise == nil then tempNoise = core.get_value_noise(tempNoiseParams) end
|
||||
if humidityNoise == nil then humidityNoise = core.get_value_noise(humidityNoiseParams) end
|
||||
|
||||
-- Base values (outside any region)
|
||||
local baseHeight = oceanNoise:get_3d({x = x, y = y, z = z})
|
||||
local baseTemp = tempNoise:get_3d({x = x, y = y, z = z})
|
||||
local baseHumidity = humidityNoise:get_3d({x = x, y = y, z = z})
|
||||
|
||||
-- КАРОЧИ. Надо оптимизировать вот это говно. Оно срабатывает для каждого блока и поэтому все так лагаетю
|
||||
function MapGen:generateVoxelOptimized(data, index, pos, layer, rocksNoiseMap, area, minPos, maxPos)
|
||||
-- Fast region lookup with spatial partitioning
|
||||
local region = layer:getRegionByPos(pos)
|
||||
|
||||
-- Get base values from default region
|
||||
local defaultRegion = layer:getDefaultRegion()
|
||||
local defaultNoises = defaultRegion:getMultinoise()
|
||||
|
||||
local baseHeight = defaultNoises.landscapeNoise:get_3d(pos)
|
||||
local baseTemp = defaultNoises.tempNoise:get_3d(pos)
|
||||
local baseHumidity = defaultNoises.humidityNoise:get_3d(pos)
|
||||
|
||||
local finalHeight = baseHeight
|
||||
local finalTemp = baseTemp
|
||||
local finalHumidity = baseHumidity
|
||||
|
||||
local region = layer:getRegionByPos(x, y, z)
|
||||
local polyhedron = region:getPolyhedron()
|
||||
local distance = polyhedron:distanceToSurface(vector.new(x, y, z))
|
||||
local bufferZone = region:getBufferZone()
|
||||
|
||||
-- Apply region-specific noises if needed
|
||||
if region ~= defaultRegion then
|
||||
local polyhedron = region:getPolyhedron()
|
||||
local distance = polyhedron:distanceToSurface(pos)
|
||||
local bufferZone = region:getBufferZone()
|
||||
if distance <= bufferZone.thickness then
|
||||
local regionNoises = region:getMultinoise()
|
||||
local blendFactor = InterpolationPresets[region:getInterpolationPreset()](distance, bufferZone.thickness)
|
||||
|
||||
if distance <= bufferZone.thickness then
|
||||
local regionNoises = region:getMultinoise()
|
||||
local blendFactor = InterpolationPresets[region:getInterpolationPreset()](distance, bufferZone.thickness)
|
||||
|
||||
if regionNoises.landscapeNoise then
|
||||
local regionHeight = regionNoises.landscapeNoise:get_3d(pos)
|
||||
finalHeight = baseHeight + (regionHeight - baseHeight) * blendFactor
|
||||
end
|
||||
|
||||
if regionNoises.tempNoise then
|
||||
local regionTemp = regionNoises.tempNoise:get_3d(pos)
|
||||
finalTemp = baseTemp + (regionTemp - baseTemp) * blendFactor
|
||||
end
|
||||
|
||||
if regionNoises.humidityNoise then
|
||||
local regionHumidity = regionNoises.humidityNoise:get_3d(pos)
|
||||
finalHumidity = baseHumidity + (regionHumidity - baseHumidity) * blendFactor
|
||||
end
|
||||
-- 3D noise interpolation
|
||||
if regionNoises.landscapeNoise then
|
||||
local regionHeight = regionNoises.landscapeNoise:get_3d({x = x, y = y, z = z})
|
||||
finalHeight = baseHeight + (regionHeight - baseHeight) * blendFactor
|
||||
end
|
||||
|
||||
if regionNoises.tempNoise then
|
||||
local regionTemp = regionNoises.tempNoise:get_3d({x = x, y = y, z = z})
|
||||
finalTemp = baseTemp + (regionTemp - baseTemp) * blendFactor
|
||||
end
|
||||
|
||||
if regionNoises.humidityNoise then
|
||||
local regionHumidity = regionNoises.humidityNoise:get_3d({x = x, y = y, z = z})
|
||||
finalHumidity = baseHumidity + (regionHumidity - baseHumidity) * blendFactor
|
||||
end
|
||||
end
|
||||
|
||||
-- Generate the actual node
|
||||
self:generateNodeOptimized(mathRound(finalHeight), mathRound(finalTemp),
|
||||
mathRound(finalHumidity), data, index, pos, rocksNoiseMap, minPos, maxPos)
|
||||
end
|
||||
|
||||
function MapGen:generateNodeOptimized(height, temp, humidity, data, index, pos, rocksNoiseMap, minPos, maxPos)
|
||||
local ids = self.nodeIDs
|
||||
local biome = self.biomesDiagram[temp][humidity]
|
||||
|
||||
if pos.y > height and pos.y > 0 then
|
||||
data[index] = ids.air
|
||||
elseif pos.y == height and pos.y > 0 then
|
||||
data[index] = biome.groundNodes.turf
|
||||
elseif pos.y < height then
|
||||
-- Calculate index without creating vectors
|
||||
local noiseIndex = ((pos.z - minPos.z) * (maxPos.y - minPos.y + 1) * (maxPos.x - minPos.x + 1) +
|
||||
(pos.y - minPos.y) * (maxPos.x - minPos.x + 1) +
|
||||
(pos.x - minPos.x)) + 1
|
||||
local noiseValue = rocksNoiseMap[noiseIndex]
|
||||
|
||||
-- Use lookup table for rock types
|
||||
local rockTypes = {
|
||||
[1] = ids.malachite, [2] = ids.hapcoryte, [3] = ids.iyellite,
|
||||
[4] = ids.sylite, [5] = ids.tauitite, [6] = ids.falmyte,
|
||||
[7] = ids.burcite, [8] = ids.felhor
|
||||
}
|
||||
|
||||
data[index] = rockTypes[noiseValue] or ids.stone
|
||||
else
|
||||
data[index] = ids.water
|
||||
end
|
||||
generateNode(mapGenerator, mathRound(finalHeight), mathRound(finalTemp),
|
||||
mathRound(finalHumidity), data, index, x, y, z)
|
||||
end
|
||||
|
||||
---@param minPos table
|
||||
---@param maxPos table
|
||||
---@param blockseed number
|
||||
function MapGen:onMapGenerated(minPos, maxPos, blockseed)
|
||||
print("Stage 1: entering loop")
|
||||
|
||||
-- We obtain a generation area for further manipulations
|
||||
local voxelManip, eMin, eMax = core.get_mapgen_object("voxelmanip")
|
||||
local data = voxelManip:get_data()
|
||||
-- local param2_data = voxelManip:get_param2_data()
|
||||
local area = VoxelArea:new({MinEdge = eMin, MaxEdge = eMax})
|
||||
|
||||
|
||||
print("Stage 2: generating initial landscape")
|
||||
|
||||
-- Cache frequently accessed values
|
||||
local nodeIDs = self.nodeIDs
|
||||
local biomesDiagram = self.biomesDiagram
|
||||
|
||||
-- Precompute rocks noise for entire chunk
|
||||
local rocksNoiseMap = precomputeNoiseForChunk(rocksNoise, minPos, maxPos)
|
||||
|
||||
local vec = vector.zero()
|
||||
local areaIndex = area.index
|
||||
|
||||
-- Process by layers to minimize context switching
|
||||
local a, b, c, d = 0, 0, 0, 0
|
||||
for _, layer in ipairs(self.layersList) do
|
||||
a = a+1
|
||||
b, c, d = 0, 0, 0
|
||||
local layerMinY = math.max(minPos.y, layer.minY)
|
||||
local layerMaxY = math.min(maxPos.y, layer.maxY)
|
||||
|
||||
if layerMinY <= layerMaxY then
|
||||
for z = minPos.z, maxPos.z do
|
||||
b = b+1
|
||||
c, d = 0, 0
|
||||
vec.z = z
|
||||
for y = layerMinY, layerMaxY do
|
||||
c = c+1
|
||||
d = 0
|
||||
vec.y = y
|
||||
local index = areaIndex(area, minPos.x, y, z)
|
||||
|
||||
for x = minPos.x, maxPos.x do
|
||||
d = d+1
|
||||
vec.x = x
|
||||
self:generateVoxelOptimized(data, index, vec, layer, rocksNoiseMap, area, minPos, maxPos)
|
||||
index = index + 1
|
||||
print(a..":"..b..":"..c..":"..d)
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
if not self.multinoiseInitialized then
|
||||
self:initRegionsMultinoise()
|
||||
end
|
||||
|
||||
print("Stage 3: applying changes")
|
||||
local data = voxelManip:get_data()
|
||||
-- local param2_data = voxelManip:get_param2_data()
|
||||
local area = VoxelArea:new({MinEdge = eMin, MaxEdge = eMax})
|
||||
|
||||
-- Initial generation: landscape
|
||||
for z = minPos.z, maxPos.z do
|
||||
for y = minPos.y, maxPos.y do
|
||||
local index = area:index(minPos.x, y, z)
|
||||
|
||||
for x = minPos.x, maxPos.x do
|
||||
generatorHandler3D(self, data, index, x, y, z)
|
||||
|
||||
index = index + 1
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- We make changes back to LVM and recalculate light & liquids
|
||||
voxelManip:set_data(data)
|
||||
-- voxelManip:set_param2_data(param2_data)
|
||||
voxelManip:update_liquids()
|
||||
voxelManip:calc_lighting()
|
||||
|
||||
voxelManip:write_to_map()
|
||||
end
|
||||
|
||||
@@ -380,18 +360,12 @@ function MapGen:run()
|
||||
error('Only one instance of a `MapGen` class can be running.')
|
||||
end
|
||||
|
||||
-- Initialize default systems
|
||||
self:precomputeNodeIDs()
|
||||
self:initBiomesDiagram()
|
||||
|
||||
core.register_on_generated(function(...)
|
||||
if not self.isMultinoiseInitialized then
|
||||
self:initRegionsMultinoise()
|
||||
end
|
||||
|
||||
self:onMapGenerated(...)
|
||||
end)
|
||||
|
||||
self:initBiomesDiagram()
|
||||
|
||||
MapGen.isRunning = true
|
||||
end
|
||||
|
||||
|
||||
@@ -24,28 +24,25 @@ end
|
||||
---@param bufferZone MapGen.Region.BufferZone
|
||||
---@return MapGen.Region
|
||||
function Region:new(polyhedron, multinoiseParams, bufferZone)
|
||||
local _polyhedron = polyhedron
|
||||
local _multinoiseParams = multinoiseParams
|
||||
local _bufferZone = bufferZone
|
||||
local _interpolationPreset = bufferZone.preset or "linear"
|
||||
local _multinoise = {}
|
||||
local _polyhedron = polyhedron
|
||||
local _multinoiseParams = multinoiseParams
|
||||
local _bufferZone = bufferZone
|
||||
local _interpolationPreset = bufferZone.preset or "linear"
|
||||
local _multinoise = {}
|
||||
|
||||
local instance = setmetatable({}, {__index = self})
|
||||
local instance = setmetatable({}, {__index = self})
|
||||
|
||||
function instance:getPolyhedron() return _polyhedron end
|
||||
function instance:getMultinoiseParams() return _multinoiseParams end
|
||||
function instance:getMultinoise() return _multinoise end
|
||||
function instance:getBufferZone() return _bufferZone end
|
||||
function instance:getInterpolationPreset() return _interpolationPreset end
|
||||
|
||||
function instance:initMultinoise()
|
||||
print("WTF:::")
|
||||
print(type(_multinoise))
|
||||
print(dump(_multinoise))
|
||||
_multinoise = multinoiseParamsToMultinoise(_multinoiseParams)
|
||||
end
|
||||
function instance:getPolyhedron() return _polyhedron end
|
||||
function instance:getMultinoiseParams() return _multinoiseParams end
|
||||
function instance:getMultinoise() return _multinoise end
|
||||
function instance:getBufferZone() return _bufferZone end
|
||||
function instance:getInterpolationPreset() return _interpolationPreset end
|
||||
|
||||
function instance:initMultinoise()
|
||||
_multinoise = multinoiseParamsToMultinoise(_multinoiseParams)
|
||||
end
|
||||
|
||||
return instance
|
||||
return instance
|
||||
end
|
||||
|
||||
return Region
|
||||
|
||||
@@ -4,100 +4,73 @@
|
||||
---@field boundingBox {min: vector, max: vector}
|
||||
local Polyhedron = {}
|
||||
|
||||
local mathMin, mathMax, mathHuge, mathAbs
|
||||
= math.min, math.max, math.huge, math.abs
|
||||
local mathMin, mathMax, mathHuge, mathSqrt, mathAbs
|
||||
= math.min, math.max, math.huge, math.sqrt, math.abs
|
||||
|
||||
---Creates a new Polyhedron instance
|
||||
---@param vertices vector[] Array of 3D vertices that define the polyhedron
|
||||
---@param faces integer[][] Array of faces, where each face is an array of vertex indices
|
||||
---@return Polyhedron
|
||||
function Polyhedron:new(vertices, faces)
|
||||
local instance = setmetatable({
|
||||
vertices = vertices,
|
||||
faces = faces,
|
||||
boundingBox = self:calculateBoundingBox(vertices)
|
||||
}, {__index = self})
|
||||
|
||||
-- Precompute face data
|
||||
instance.faceData = {}
|
||||
for i, face in ipairs(faces) do
|
||||
instance.faceData[i] = {
|
||||
plane = instance:computePlane(face),
|
||||
normal = instance:computeFaceNormal(face),
|
||||
edges = instance:computeFaceEdges(face)
|
||||
}
|
||||
end
|
||||
|
||||
return instance
|
||||
end
|
||||
|
||||
function Polyhedron:computeFaceEdges(face)
|
||||
local edges = {}
|
||||
for i = 1, #face do
|
||||
local j = (i % #face) + 1
|
||||
edges[i] = {face[i], face[j]}
|
||||
end
|
||||
return edges
|
||||
local instance = setmetatable({
|
||||
vertices = vertices,
|
||||
faces = faces,
|
||||
boundingBox = self:calculateBoundingBox(vertices)
|
||||
}, {__index = self})
|
||||
return instance
|
||||
end
|
||||
|
||||
---Calculates the axis-aligned bounding box for the polyhedron
|
||||
---@param vertices vector[] Array of vertices to compute bounds for
|
||||
---@return {min: vector, max: vector} Bounding box with min and max corners
|
||||
function Polyhedron:calculateBoundingBox(vertices)
|
||||
local min = vector.new(mathHuge, mathHuge, mathHuge)
|
||||
local max = vector.new(-mathHuge, -mathHuge, -mathHuge)
|
||||
|
||||
for _, vertex in ipairs(vertices) do
|
||||
min.x = mathMin(min.x, vertex.x)
|
||||
min.y = mathMin(min.y, vertex.y)
|
||||
min.z = mathMin(min.z, vertex.z)
|
||||
max.x = mathMax(max.x, vertex.x)
|
||||
max.y = mathMax(max.y, vertex.y)
|
||||
max.z = mathMax(max.z, vertex.z)
|
||||
end
|
||||
|
||||
return {min = min, max = max}
|
||||
local min = vector.new(mathHuge, mathHuge, mathHuge)
|
||||
local max = vector.new(-mathHuge, -mathHuge, -mathHuge)
|
||||
|
||||
for _, vertex in ipairs(vertices) do
|
||||
min.x = mathMin(min.x, vertex.x)
|
||||
min.y = mathMin(min.y, vertex.y)
|
||||
min.z = mathMin(min.z, vertex.z)
|
||||
max.x = mathMax(max.x, vertex.x)
|
||||
max.y = mathMax(max.y, vertex.y)
|
||||
max.z = mathMax(max.z, vertex.z)
|
||||
end
|
||||
|
||||
return {min = min, max = max}
|
||||
end
|
||||
|
||||
---Computes the normal vector for a face using Newell's method
|
||||
---@param face integer[] Array of vertex indices forming the face
|
||||
---@return vector Normalized normal vector for the face
|
||||
function Polyhedron:computeFaceNormal(face)
|
||||
if #face < 3 then
|
||||
error("Face must have at least 3 vertices")
|
||||
end
|
||||
|
||||
local normal = vector.zero()
|
||||
|
||||
for i = 1, #face do
|
||||
local j = (i % #face) + 1
|
||||
local current = self.vertices[face[i]]
|
||||
local next_vert = self.vertices[face[j]]
|
||||
|
||||
-- Newell's method components
|
||||
normal.x = normal.x + (current.y - next_vert.y) * (current.z + next_vert.z)
|
||||
normal.y = normal.y + (current.z - next_vert.z) * (current.x + next_vert.x)
|
||||
normal.z = normal.z + (current.x - next_vert.x) * (current.y + next_vert.y)
|
||||
end
|
||||
|
||||
-- Check for zero normal (degenerate face)
|
||||
local magnitude = vector.length(normal)
|
||||
if magnitude == 0 then
|
||||
return vector.zero() -- Or handle degenerate case appropriately
|
||||
end
|
||||
|
||||
-- Normalize the normal vector
|
||||
return vector.normalize(normal)
|
||||
if #face < 3 then
|
||||
error("Face must have at least 3 vertices")
|
||||
end
|
||||
|
||||
-- Use Newell's method for more robust normal calculation with non-convex polygons
|
||||
local normal = vector.new(0, 0, 0)
|
||||
|
||||
for i = 1, #face do
|
||||
local j = (i % #face) + 1
|
||||
local current = self.vertices[face[i]]
|
||||
local next = self.vertices[face[j]]
|
||||
|
||||
normal.x = normal.x + (current.y - next.y) * (current.z + next.z)
|
||||
normal.y = normal.y + (current.z - next.z) * (current.x + next.x)
|
||||
normal.z = normal.z + (current.x - next.x) * (current.y + next.y)
|
||||
end
|
||||
|
||||
return normal:normalize()
|
||||
end
|
||||
|
||||
---Computes the plane equation for a face
|
||||
---@param face integer[] Array of vertex indices forming the face
|
||||
---@return {normal: vector, point: vector, d: number} Plane equation in form: normal·x + d = 0
|
||||
function Polyhedron:computePlane(face)
|
||||
local normal = self:computeFaceNormal(face)
|
||||
local point = self.vertices[face[1]]
|
||||
local d = -normal:dot(point)
|
||||
return {normal = normal, point = point, d = d}
|
||||
local normal = self:computeFaceNormal(face)
|
||||
local point = self.vertices[face[1]]
|
||||
local d = -normal:dot(point)
|
||||
return {normal = normal, point = point, d = d}
|
||||
end
|
||||
|
||||
---Finds the intersection point between a ray and a plane
|
||||
@@ -106,21 +79,21 @@ end
|
||||
---@param plane {normal: vector, point: vector, d: number} Plane equation
|
||||
---@return vector|nil Intersection point, or nil if no intersection
|
||||
function Polyhedron:rayPlaneIntersection(rayOrigin, rayDir, plane)
|
||||
local denom = plane.normal:dot(rayDir)
|
||||
|
||||
-- Ray is parallel to plane
|
||||
if mathAbs(denom) < 1e-6 then
|
||||
return nil
|
||||
end
|
||||
|
||||
local t = (-plane.normal:dot(rayOrigin) - plane.d) / denom
|
||||
|
||||
-- Intersection is behind ray origin
|
||||
if t < 0 then
|
||||
return nil
|
||||
end
|
||||
|
||||
return rayOrigin + rayDir * t
|
||||
local denom = plane.normal:dot(rayDir)
|
||||
|
||||
-- Ray is parallel to plane
|
||||
if mathAbs(denom) < 1e-6 then
|
||||
return nil
|
||||
end
|
||||
|
||||
local t = (-plane.normal:dot(rayOrigin) - plane.d) / denom
|
||||
|
||||
-- Intersection is behind ray origin
|
||||
if t < 0 then
|
||||
return nil
|
||||
end
|
||||
|
||||
return rayOrigin + rayDir * t
|
||||
end
|
||||
|
||||
---Checks if a 3D point lies within a face (convex or non-convex)
|
||||
@@ -128,34 +101,34 @@ end
|
||||
---@param face integer[] Array of vertex indices forming the face
|
||||
---@return boolean True if point is inside the face, false otherwise
|
||||
function Polyhedron:pointInFace(point, face)
|
||||
if #face < 3 then
|
||||
return false
|
||||
end
|
||||
|
||||
-- Project the face and point to 2D using the face's plane
|
||||
local plane = self:computePlane(face)
|
||||
|
||||
-- Create a 2D coordinate system on the plane
|
||||
local uAxis, vAxis = self:createPlaneBasis(plane.normal)
|
||||
|
||||
-- Project all vertices to 2D
|
||||
local vertices2D = {}
|
||||
for _, vertexIndex in ipairs(face) do
|
||||
local vertex = self.vertices[vertexIndex]
|
||||
local vecToVertex = vertex - plane.point
|
||||
local u = vecToVertex:dot(uAxis)
|
||||
local v = vecToVertex:dot(vAxis)
|
||||
table.insert(vertices2D, {u, v})
|
||||
end
|
||||
|
||||
-- Project the point to 2D
|
||||
local vecToPoint = point - plane.point
|
||||
local pointU = vecToPoint:dot(uAxis)
|
||||
local pointV = vecToPoint:dot(vAxis)
|
||||
local point2D = {pointU, pointV}
|
||||
|
||||
-- Use winding number algorithm for point-in-polygon test (works with non-convex polygons)
|
||||
return self:pointInPolygon2D(point2D, vertices2D)
|
||||
if #face < 3 then
|
||||
return false
|
||||
end
|
||||
|
||||
-- Project the face and point to 2D using the face's plane
|
||||
local plane = self:computePlane(face)
|
||||
|
||||
-- Create a 2D coordinate system on the plane
|
||||
local uAxis, vAxis = self:createPlaneBasis(plane.normal)
|
||||
|
||||
-- Project all vertices to 2D
|
||||
local vertices2D = {}
|
||||
for _, vertexIndex in ipairs(face) do
|
||||
local vertex = self.vertices[vertexIndex]
|
||||
local vecToVertex = vertex - plane.point
|
||||
local u = vecToVertex:dot(uAxis)
|
||||
local v = vecToVertex:dot(vAxis)
|
||||
table.insert(vertices2D, {u, v})
|
||||
end
|
||||
|
||||
-- Project the point to 2D
|
||||
local vecToPoint = point - plane.point
|
||||
local pointU = vecToPoint:dot(uAxis)
|
||||
local pointV = vecToPoint:dot(vAxis)
|
||||
local point2D = {pointU, pointV}
|
||||
|
||||
-- Use winding number algorithm for point-in-polygon test (works with non-convex polygons)
|
||||
return self:pointInPolygon2D(point2D, vertices2D)
|
||||
end
|
||||
|
||||
---Creates an orthonormal basis for a plane defined by its normal
|
||||
@@ -163,18 +136,18 @@ end
|
||||
---@return vector uAxis First basis vector
|
||||
---@return vector vAxis Second basis vector
|
||||
function Polyhedron:createPlaneBasis(normal)
|
||||
-- Choose an arbitrary vector not parallel to normal
|
||||
local temp
|
||||
if mathAbs(normal.x) > mathAbs(normal.y) then
|
||||
temp = vector.new(0, 1, 0)
|
||||
else
|
||||
temp = vector.new(1, 0, 0)
|
||||
end
|
||||
|
||||
local uAxis = normal:cross(temp):normalize()
|
||||
local vAxis = normal:cross(uAxis):normalize()
|
||||
|
||||
return uAxis, vAxis
|
||||
-- Choose an arbitrary vector not parallel to normal
|
||||
local temp
|
||||
if mathAbs(normal.x) > mathAbs(normal.y) then
|
||||
temp = vector.new(0, 1, 0)
|
||||
else
|
||||
temp = vector.new(1, 0, 0)
|
||||
end
|
||||
|
||||
local uAxis = normal:cross(temp):normalize()
|
||||
local vAxis = normal:cross(uAxis):normalize()
|
||||
|
||||
return uAxis, vAxis
|
||||
end
|
||||
|
||||
---Winding number algorithm for 2D point-in-polygon test
|
||||
@@ -182,31 +155,31 @@ end
|
||||
---@param polygon number[][] Array of 2D polygon vertices as {{u,v}, ...}
|
||||
---@return boolean True if point is inside polygon, false otherwise
|
||||
function Polyhedron:pointInPolygon2D(point, polygon)
|
||||
local wn = 0 -- Winding number counter
|
||||
|
||||
for i = 1, #polygon do
|
||||
local j = (i % #polygon) + 1
|
||||
local vi = polygon[i]
|
||||
local vj = polygon[j]
|
||||
|
||||
if vi[2] <= point[2] then
|
||||
if vj[2] > point[2] then
|
||||
-- Upward crossing
|
||||
if self:isLeft(vi, vj, point) > 0 then
|
||||
wn = wn + 1
|
||||
end
|
||||
end
|
||||
else
|
||||
if vj[2] <= point[2] then
|
||||
-- Downward crossing
|
||||
if self:isLeft(vi, vj, point) < 0 then
|
||||
wn = wn - 1
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return wn ~= 0 -- Non-zero means inside
|
||||
local wn = 0 -- Winding number counter
|
||||
|
||||
for i = 1, #polygon do
|
||||
local j = (i % #polygon) + 1
|
||||
local vi = polygon[i]
|
||||
local vj = polygon[j]
|
||||
|
||||
if vi[2] <= point[2] then
|
||||
if vj[2] > point[2] then
|
||||
-- Upward crossing
|
||||
if self:isLeft(vi, vj, point) > 0 then
|
||||
wn = wn + 1
|
||||
end
|
||||
end
|
||||
else
|
||||
if vj[2] <= point[2] then
|
||||
-- Downward crossing
|
||||
if self:isLeft(vi, vj, point) < 0 then
|
||||
wn = wn - 1
|
||||
end
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return wn ~= 0 -- Non-zero means inside
|
||||
end
|
||||
|
||||
---Helper function for winding number algorithm - determines if point is left of edge
|
||||
@@ -215,7 +188,7 @@ end
|
||||
---@param p number[] Point to test {u, v}
|
||||
---@return number Positive if left, negative if right, zero if collinear
|
||||
function Polyhedron:isLeft(a, b, p)
|
||||
return (b[1] - a[1]) * (p[2] - a[2]) - (p[1] - a[1]) * (b[2] - a[2])
|
||||
return (b[1] - a[1]) * (p[2] - a[2]) - (p[1] - a[1]) * (b[2] - a[2])
|
||||
end
|
||||
|
||||
---Checks if a ray intersects with a face
|
||||
@@ -224,14 +197,14 @@ end
|
||||
---@param face integer[] Array of vertex indices forming the face
|
||||
---@return boolean True if ray intersects the face, false otherwise
|
||||
function Polyhedron:rayIntersectsFace(rayOrigin, rayDir, face)
|
||||
local plane = self:computePlane(face)
|
||||
local intersection = self:rayPlaneIntersection(rayOrigin, rayDir, plane)
|
||||
|
||||
if not intersection then
|
||||
return false
|
||||
end
|
||||
|
||||
return self:pointInFace(intersection, face)
|
||||
local plane = self:computePlane(face)
|
||||
local intersection = self:rayPlaneIntersection(rayOrigin, rayDir, plane)
|
||||
|
||||
if not intersection then
|
||||
return false
|
||||
end
|
||||
|
||||
return self:pointInFace(intersection, face)
|
||||
end
|
||||
|
||||
---Calculates the minimum distance from a point to a face
|
||||
@@ -239,37 +212,37 @@ end
|
||||
---@param face integer[] Array of vertex indices forming the face
|
||||
---@return number Minimum distance to the face (0 if point is on the face)
|
||||
function Polyhedron:distanceToFace(point, face)
|
||||
local plane = self:computePlane(face)
|
||||
|
||||
-- First check if projection is inside the face
|
||||
local projection = point - plane.normal * (plane.normal:dot(point) + plane.d)
|
||||
|
||||
if self:pointInFace(projection, face) then
|
||||
-- Point projects inside face, return distance to plane
|
||||
return mathAbs(plane.normal:dot(point) + plane.d)
|
||||
end
|
||||
|
||||
-- Point projects outside face, find minimum distance to edges or vertices
|
||||
local minDistance = mathHuge
|
||||
|
||||
-- Check distance to each edge
|
||||
for i = 1, #face do
|
||||
local j = (i % #face) + 1
|
||||
local v1 = self.vertices[face[i]]
|
||||
local v2 = self.vertices[face[j]]
|
||||
|
||||
local edgeDistance = self:pointToLineSegmentDistance(point, v1, v2)
|
||||
minDistance = mathMin(minDistance, edgeDistance)
|
||||
end
|
||||
|
||||
-- Also check distance to vertices (in case the closest point is a vertex)
|
||||
for _, vertexIndex in ipairs(face) do
|
||||
local vertex = self.vertices[vertexIndex]
|
||||
local vertexDistance = (point - vertex):length()
|
||||
minDistance = mathMin(minDistance, vertexDistance)
|
||||
end
|
||||
|
||||
return minDistance
|
||||
local plane = self:computePlane(face)
|
||||
|
||||
-- First check if projection is inside the face
|
||||
local projection = point - plane.normal * (plane.normal:dot(point) + plane.d)
|
||||
|
||||
if self:pointInFace(projection, face) then
|
||||
-- Point projects inside face, return distance to plane
|
||||
return mathAbs(plane.normal:dot(point) + plane.d)
|
||||
end
|
||||
|
||||
-- Point projects outside face, find minimum distance to edges or vertices
|
||||
local minDistance = mathHuge
|
||||
|
||||
-- Check distance to each edge
|
||||
for i = 1, #face do
|
||||
local j = (i % #face) + 1
|
||||
local v1 = self.vertices[face[i]]
|
||||
local v2 = self.vertices[face[j]]
|
||||
|
||||
local edgeDistance = self:pointToLineSegmentDistance(point, v1, v2)
|
||||
minDistance = mathMin(minDistance, edgeDistance)
|
||||
end
|
||||
|
||||
-- Also check distance to vertices (in case the closest point is a vertex)
|
||||
for _, vertexIndex in ipairs(face) do
|
||||
local vertex = self.vertices[vertexIndex]
|
||||
local vertexDistance = (point - vertex):length()
|
||||
minDistance = mathMin(minDistance, vertexDistance)
|
||||
end
|
||||
|
||||
return minDistance
|
||||
end
|
||||
|
||||
---Calculates the distance from a point to a line segment
|
||||
@@ -278,49 +251,63 @@ end
|
||||
---@param lineEnd vector End point of the line segment
|
||||
---@return number Minimum distance from point to the line segment
|
||||
function Polyhedron:pointToLineSegmentDistance(point, lineStart, lineEnd)
|
||||
local lineVec = lineEnd - lineStart
|
||||
local lineLengthSq = lineVec:dot(lineVec)
|
||||
|
||||
if lineLengthSq == 0 then
|
||||
return (point - lineStart):length()
|
||||
end
|
||||
|
||||
local t = (point - lineStart):dot(lineVec) / lineLengthSq
|
||||
t = mathMax(0, mathMin(1, t))
|
||||
|
||||
local projection = lineStart + lineVec * t
|
||||
return (point - projection):length()
|
||||
local lineVec = lineEnd - lineStart
|
||||
local lineLengthSq = lineVec:dot(lineVec)
|
||||
|
||||
if lineLengthSq == 0 then
|
||||
return (point - lineStart):length()
|
||||
end
|
||||
|
||||
local t = (point - lineStart):dot(lineVec) / lineLengthSq
|
||||
t = mathMax(0, mathMin(1, t))
|
||||
|
||||
local projection = lineStart + lineVec * t
|
||||
return (point - projection):length()
|
||||
end
|
||||
|
||||
---Checks if this polyhedron's bounding box intersects with another's
|
||||
---@param otherPolyhedron Polyhedron The other polyhedron to test against
|
||||
---@return boolean True if bounding boxes intersect, false otherwise
|
||||
function Polyhedron:boundingBoxIntersects(otherPolyhedron)
|
||||
local box1 = self.boundingBox
|
||||
local box2 = otherPolyhedron.boundingBox
|
||||
|
||||
return box1.min.x <= box2.max.x and box1.max.x >= box2.min.x and
|
||||
box1.min.y <= box2.max.y and box1.max.y >= box2.min.y and
|
||||
box1.min.z <= box2.max.z and box1.max.z >= box2.min.z
|
||||
local box1 = self.boundingBox
|
||||
local box2 = otherPolyhedron.boundingBox
|
||||
|
||||
return box1.min.x <= box2.max.x and box1.max.x >= box2.min.x and
|
||||
box1.min.y <= box2.max.y and box1.max.y >= box2.min.y and
|
||||
box1.min.z <= box2.max.z and box1.max.z >= box2.min.z
|
||||
end
|
||||
|
||||
---Checks if any edge of this polyhedron intersects with any face of another polyhedron
|
||||
---@param otherPolyhedron Polyhedron The other polyhedron to test against
|
||||
---@return boolean True if any edge intersects any face, false otherwise
|
||||
function Polyhedron:edgesIntersect(otherPolyhedron)
|
||||
-- Check each edge of this polyhedron against each face of the other
|
||||
for _, face in ipairs(self.faces) do
|
||||
for i = 1, #face do
|
||||
local j = (i % #face) + 1
|
||||
local edgeStart = self.vertices[face[i]]
|
||||
local edgeEnd = self.vertices[face[j]]
|
||||
|
||||
if self:edgeIntersectsPolyhedron(edgeStart, edgeEnd, otherPolyhedron) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
end
|
||||
return false
|
||||
-- Check each edge of this polyhedron against each face of the other
|
||||
for _, face in ipairs(self.faces) do
|
||||
for i = 1, #face do
|
||||
local j = (i % #face) + 1
|
||||
local edgeStart = self.vertices[face[i]]
|
||||
local edgeEnd = self.vertices[face[j]]
|
||||
|
||||
if self:edgeIntersectsPolyhedron(edgeStart, edgeEnd, otherPolyhedron) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
-- Check each edge of the other polyhedron against each face of this
|
||||
for _, face in ipairs(otherPolyhedron.faces) do
|
||||
for i = 1, #face do
|
||||
local j = (i % #face) + 1
|
||||
local edgeStart = otherPolyhedron.vertices[face[i]]
|
||||
local edgeEnd = otherPolyhedron.vertices[face[j]]
|
||||
|
||||
if self:edgeIntersectsPolyhedron(edgeStart, edgeEnd, otherPolyhedron) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return false
|
||||
end
|
||||
|
||||
---Checks if an edge intersects with any face of a polyhedron
|
||||
@@ -329,85 +316,77 @@ end
|
||||
---@param polyhedron Polyhedron The polyhedron to test against
|
||||
---@return boolean True if edge intersects the polyhedron, false otherwise
|
||||
function Polyhedron:edgeIntersectsPolyhedron(edgeStart, edgeEnd, polyhedron)
|
||||
local edgeDir = (edgeEnd - edgeStart):normalize()
|
||||
local edgeLength = (edgeEnd - edgeStart):length()
|
||||
|
||||
for _, face in ipairs(polyhedron.faces) do
|
||||
local plane = polyhedron:computePlane(face)
|
||||
local intersection = self:rayPlaneIntersection(edgeStart, edgeDir, plane)
|
||||
|
||||
if intersection then
|
||||
local t = (intersection - edgeStart):length()
|
||||
|
||||
-- Check if intersection is within edge bounds and inside face
|
||||
if t >= 0 and t <= edgeLength and polyhedron:pointInFace(intersection, face) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return false
|
||||
local edgeDir = (edgeEnd - edgeStart):normalize()
|
||||
local edgeLength = (edgeEnd - edgeStart):length()
|
||||
|
||||
for _, face in ipairs(polyhedron.faces) do
|
||||
local plane = polyhedron:computePlane(face)
|
||||
local intersection = self:rayPlaneIntersection(edgeStart, edgeDir, plane)
|
||||
|
||||
if intersection then
|
||||
local t = (intersection - edgeStart):length()
|
||||
|
||||
-- Check if intersection is within edge bounds and inside face
|
||||
if t >= 0 and t <= edgeLength and polyhedron:pointInFace(intersection, face) then
|
||||
return true
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
return false
|
||||
end
|
||||
|
||||
---Determines if a point is inside the polyhedron using ray-casting
|
||||
---@param point vector The point to test
|
||||
---@return boolean True if point is inside the polyhedron, false otherwise
|
||||
function Polyhedron:containsPoint(point)
|
||||
-- Fast AABB rejection first
|
||||
local bb = self.boundingBox
|
||||
if point.x < bb.min.x or point.x > bb.max.x or
|
||||
point.y < bb.min.y or point.y > bb.max.y or
|
||||
point.z < bb.min.z or point.z > bb.max.z then
|
||||
return false
|
||||
end
|
||||
|
||||
-- Then do ray casting
|
||||
local rayDir = vector.new(1, 0, 0)
|
||||
local intersections = 0
|
||||
|
||||
for i, face in ipairs(self.faces) do
|
||||
if self:rayIntersectsFace(point, rayDir, face) then
|
||||
intersections = intersections + 1
|
||||
end
|
||||
end
|
||||
|
||||
return intersections % 2 == 1
|
||||
-- Ray-casting algorithm for point-in-polyhedron test
|
||||
local rayDir = vector.new(1, 0, 0) -- Simple X-direction ray
|
||||
local intersections = 0
|
||||
|
||||
for _, face in ipairs(self.faces) do
|
||||
if self:rayIntersectsFace(point, rayDir, face) then
|
||||
intersections = intersections + 1
|
||||
end
|
||||
end
|
||||
|
||||
return intersections % 2 == 1 -- Odd number of intersections = inside
|
||||
end
|
||||
|
||||
---Calculates the minimum distance from a point to the surface of the polyhedron
|
||||
---@param point vector The point to measure distance from
|
||||
---@return number Minimum distance to the polyhedron surface
|
||||
function Polyhedron:distanceToSurface(point)
|
||||
local minDistance = mathHuge
|
||||
|
||||
for _, face in ipairs(self.faces) do
|
||||
local distance = self:distanceToFace(point, face)
|
||||
minDistance = mathMin(minDistance, distance)
|
||||
end
|
||||
|
||||
return minDistance
|
||||
local minDistance = mathHuge
|
||||
|
||||
for _, face in ipairs(self.faces) do
|
||||
local distance = self:distanceToFace(point, face)
|
||||
minDistance = mathMin(minDistance, distance)
|
||||
end
|
||||
|
||||
return minDistance
|
||||
end
|
||||
|
||||
---Checks if this polyhedron intersects with another polyhedron
|
||||
---@param otherPolyhedron Polyhedron The other polyhedron to test against
|
||||
---@return boolean True if polyhedrons intersect, false otherwise
|
||||
function Polyhedron:intersects(otherPolyhedron)
|
||||
-- Check if bounding boxes intersect first (optimization)
|
||||
if not self:boundingBoxIntersects(otherPolyhedron) then
|
||||
return false
|
||||
end
|
||||
|
||||
-- Check if any vertex of one is inside the other
|
||||
for _, vertex in ipairs(self.vertices) do
|
||||
if otherPolyhedron:containsPoint(vertex) then return true end
|
||||
end
|
||||
|
||||
for _, vertex in ipairs(otherPolyhedron.vertices) do
|
||||
if self:containsPoint(vertex) then return true end
|
||||
end
|
||||
|
||||
-- Check for edge-face intersections
|
||||
return self:edgesIntersect(otherPolyhedron)
|
||||
-- Check if bounding boxes intersect first (optimization)
|
||||
if not self:boundingBoxIntersects(otherPolyhedron) then
|
||||
return false
|
||||
end
|
||||
|
||||
-- Check if any vertex of one is inside the other
|
||||
for _, vertex in ipairs(self.vertices) do
|
||||
if otherPolyhedron:containsPoint(vertex) then return true end
|
||||
end
|
||||
|
||||
for _, vertex in ipairs(otherPolyhedron.vertices) do
|
||||
if self:containsPoint(vertex) then return true end
|
||||
end
|
||||
|
||||
-- Check for edge-face intersections
|
||||
return self:edgesIntersect(otherPolyhedron)
|
||||
end
|
||||
|
||||
return Polyhedron
|
||||
Reference in New Issue
Block a user