diff --git a/mods/CORE/MapGen/src/MapGen.lua b/mods/CORE/MapGen/src/MapGen.lua index fafeeba..a21dbda 100644 --- a/mods/CORE/MapGen/src/MapGen.lua +++ b/mods/CORE/MapGen/src/MapGen.lua @@ -10,20 +10,6 @@ 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 @@ -37,58 +23,27 @@ 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 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 +---@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 local MapGen = { - layersByName = {}, - layersList = {}, - biomesList = {}, - biomesDiagram = {}, - multinoiseInitialized = false, - isRunning = false, + layersByName = {}, + layersList = {}, + biomesList = {}, + biomesDiagram = {}, + isMultinoiseInitialized = false, + isRunning = false, } ----@param nodeIDs table +---@param nodeIDs table ---@return MapGen function MapGen:new(nodeIDs) ---@type MapGen @@ -99,23 +54,13 @@ 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) - --- TODO: возможно здесь получится сделать более оптимизированный алгоритм - --- учитывая тот факт, что эта функция вызывается для каждой ноды в on_generated - --- и может быть даже не один раз - --- Можно подумать над тем, чтобы использовать сортированный список - - ---@param layer MapGen.Layer - for _, layer in ipairs(self.layersList) do - + 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`. @@ -126,7 +71,7 @@ end ---@param maxY number function MapGen:RegisterLayer(name, minY, maxY) ---Checking if layers overlap - if self:getLayerByHeight(minY) ~= nil and self:getLayerByHeight(maxY) ~= nil then + if self:getLayerByHeight(minY) ~= nil or self:getLayerByHeight(maxY) ~= nil then error('Registered layers must not overlap!') end @@ -168,17 +113,33 @@ end ---Initialize region noise. This should be called after the map object is loaded. function MapGen:initRegionsMultinoise() - ---@param layer MapGen.Layer + -- Generate rocks noise once + rocksNoise = core.get_value_noise(rocksNoiseParams) + for _, layer in ipairs(self.layersList) do - - ---@param region MapGen.Region + print("INIT DEFAULT NOISES") + layer.defaultRegion:initMultinoise() + for _, region in ipairs(layer.regionsList) do region:initMultinoise() end - end + self.isMultinoiseInitialized = true +end - self.multinoiseInitialized = true +-- 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 end ---@param name string @@ -192,6 +153,13 @@ 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 @@ -217,17 +185,17 @@ function MapGen:initBiomesDiagram() end end -local function generateSoil(biome, data, index, x, y, z) - data[index] = core.get_content_id(biome.groundNodes.turf) -- TODO: убрать тут get_content_id(), переместить его куда-то "выше" +local function generateSoil(biome, data, index, pos) + data[index] = biome.groundNodes.turf end -local function generateRock(ids, data, index, x, y, z) +local function generateRock(ids, data, index, pos) if rocksNoise == nil then rocksNoise = core.get_value_noise(rocksNoiseParams) end - local noiseRocksValue = mathRound(rocksNoise:get_3d({x = x, y = y, z = z})) + local noiseRocksValue = mathRound(rocksNoise:get_3d(pos)) if noiseRocksValue == 1 then data[index] = ids.malachite elseif noiseRocksValue == 2 then @@ -247,108 +215,160 @@ local function generateRock(ids, data, index, x, y, z) end end -local function generateNode(mapGenerator, hight, temp, humidity, data, index, x, y, z) - local ids = mapGenerator.nodeIDs +function MapGen:generateNode(self, hight, temp, humidity, data, index, pos) + local ids = self.nodeIDs - local biome = mapGenerator.biomesDiagram[temp][humidity] + local biome = self.biomesDiagram[temp][humidity] - if y > hight and y > 0 then + if pos.y > hight and pos.y > 0 then data[index] = ids.air - 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) + elseif pos.y == hight and pos.y > 0 then + generateSoil(biome, data, index, pos) + elseif pos.y < hight then + generateRock(ids, data, index, pos) 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() - if distance <= bufferZone.thickness then - local regionNoises = region:getMultinoise() - local blendFactor = InterpolationPresets[region:getInterpolationPreset()](distance, bufferZone.thickness) + -- Apply region-specific noises if needed + if region ~= defaultRegion then + local polyhedron = region:getPolyhedron() + local distance = polyhedron:distanceToSurface(pos) + local bufferZone = region:getBufferZone() - -- 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 + 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 end end + + -- Generate the actual node + self:generateNodeOptimized(mathRound(finalHeight), mathRound(finalTemp), + mathRound(finalHumidity), data, index, pos, rocksNoiseMap, minPos, maxPos) +end - generateNode(mapGenerator, mathRound(finalHeight), mathRound(finalTemp), - mathRound(finalHumidity), data, index, x, y, z) +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 end ---@param minPos table ---@param maxPos table ---@param blockseed number function MapGen:onMapGenerated(minPos, maxPos, blockseed) - -- We obtain a generation area for further manipulations + print("Stage 1: entering loop") + local voxelManip, eMin, eMax = core.get_mapgen_object("voxelmanip") - - if not self.multinoiseInitialized then - self:initRegionsMultinoise() - end - local data = voxelManip:get_data() - -- local param2_data = voxelManip:get_param2_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) + + print("Stage 2: generating initial landscape") - for x = minPos.x, maxPos.x do - generatorHandler3D(self, data, index, x, y, z) + -- Cache frequently accessed values + local nodeIDs = self.nodeIDs + local biomesDiagram = self.biomesDiagram - index = index + 1 + -- 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 end - end - -- We make changes back to LVM and recalculate light & liquids + print("Stage 3: applying changes") voxelManip:set_data(data) -- voxelManip:set_param2_data(param2_data) voxelManip:update_liquids() voxelManip:calc_lighting() - voxelManip:write_to_map() end @@ -360,12 +380,18 @@ 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 diff --git a/mods/CORE/MapGen/src/MapGen/Region.lua b/mods/CORE/MapGen/src/MapGen/Region.lua index f8cb85f..8e1af19 100644 --- a/mods/CORE/MapGen/src/MapGen/Region.lua +++ b/mods/CORE/MapGen/src/MapGen/Region.lua @@ -24,25 +24,28 @@ 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() - _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() + print("WTF:::") + print(type(_multinoise)) + print(dump(_multinoise)) + _multinoise = multinoiseParamsToMultinoise(_multinoiseParams) + end - return instance + return instance end return Region diff --git a/mods/CORE/Polyhedron/src/Polyhedron.lua b/mods/CORE/Polyhedron/src/Polyhedron.lua index f81b5e6..5acc585 100644 --- a/mods/CORE/Polyhedron/src/Polyhedron.lua +++ b/mods/CORE/Polyhedron/src/Polyhedron.lua @@ -4,73 +4,100 @@ ---@field boundingBox {min: vector, max: vector} local Polyhedron = {} -local mathMin, mathMax, mathHuge, mathSqrt, mathAbs - = math.min, math.max, math.huge, math.sqrt, math.abs +local mathMin, mathMax, mathHuge, mathAbs + = math.min, math.max, math.huge, 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}) - return instance + 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 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 - - -- 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() + 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) 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 @@ -79,21 +106,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) @@ -101,34 +128,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 @@ -136,18 +163,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 @@ -155,31 +182,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 @@ -188,7 +215,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 @@ -197,14 +224,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 @@ -212,37 +239,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 @@ -251,63 +278,49 @@ 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 - - -- 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 + -- 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 end ---Checks if an edge intersects with any face of a polyhedron @@ -316,77 +329,85 @@ 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) - -- 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 + -- 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 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 \ No newline at end of file