diff --git a/mods/CORE/MapGen/src/MapGen.lua b/mods/CORE/MapGen/src/MapGen.lua index a21dbda..fafeeba 100644 --- a/mods/CORE/MapGen/src/MapGen.lua +++ b/mods/CORE/MapGen/src/MapGen.lua @@ -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 +---@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 local MapGen = { - layersByName = {}, - layersList = {}, - biomesList = {}, - biomesDiagram = {}, - isMultinoiseInitialized = false, - isRunning = false, + layersByName = {}, + layersList = {}, + biomesList = {}, + biomesDiagram = {}, + multinoiseInitialized = false, + isRunning = false, } ----@param nodeIDs table +---@param nodeIDs table ---@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 diff --git a/mods/CORE/MapGen/src/MapGen/Region.lua b/mods/CORE/MapGen/src/MapGen/Region.lua index 8e1af19..f8cb85f 100644 --- a/mods/CORE/MapGen/src/MapGen/Region.lua +++ b/mods/CORE/MapGen/src/MapGen/Region.lua @@ -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 diff --git a/mods/CORE/Polyhedron/src/Polyhedron.lua b/mods/CORE/Polyhedron/src/Polyhedron.lua index 5acc585..f81b5e6 100644 --- a/mods/CORE/Polyhedron/src/Polyhedron.lua +++ b/mods/CORE/Polyhedron/src/Polyhedron.lua @@ -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 \ No newline at end of file