Integrating NikNaks library to replace the atmos_outside function?

NikNaks: https://github.com/Nak2/NikNaks

This would help increase performance at least a little bit, and doesn't require much work to integrate.

local oldLeaf
local bsp = NikNaks.Map()
local endPosVector = Vector(0, 0, 32768)

-- NOTE: helper for checking if a position is outside of a building
function atmos_outside(pos)
	if !bsp then bsp = NikNaks.Map() end

	local leaf = bsp:PointInLeafCache(0, pos, oldLeaf)

	oldleaf = leaf -- this shouldn't cause issues even though this is a shared function

	local trace = {}
	trace.start = pos
	trace.endpos = trace.start + endPosVector
	trace.mask = MASK_SOLID

	local tr = util.TraceLine(trace)

	Atmos.HeightMin = (tr.HitPos - pos):Length() -- how do we replicate this in NikNaks without doing a trace?

	return leaf:IsOutsideMap()
end

[looterz]

I think IsOutsideMap is used for checking if a position is outside of the maps bounds, where as with atmos_outside we check if there's technically a building brush above your head to determine when and where to render rain particles from.

[looterz]

Nevermind, looked into this more and it looks like the vis leaf's outside value is what we want.

[looterz]

Maybe something like this,

local oldLeaf
local bsp = NikNaks.Map()

-- Function to determine if a leaf is near an outdoor area, could be improved?
local function isLeafNearOutdoorArea(leaf)
    -- Placeholder logic: check if the leaf has a skybox in its PVS
    return leaf:HasSkyboxInPVS()
end

-- Function to estimate the height to the nearest ceiling or sky
local function estimateCeilingHeight(pos, leaf)
    -- Adjust the maximum trace height based on the context of the leaf
    local maxTraceHeight = isLeafNearOutdoorArea(leaf) and 16384 or 32768

    -- Perform a vertical trace upwards from the player's position
    local trace = {}
    trace.start = pos
    trace.endpos = pos + Vector(0, 0, maxTraceHeight)
    trace.mask = MASK_SOLID

    local tr = util.TraceLine(trace)

    -- Calculate the height based on the hit position
    return tr.Hit and (tr.HitPos - pos):Length() or maxTraceHeight
end

-- Helper function for checking if a position is outside of a building
function atmos_outside(pos)
    if not bsp then bsp = NikNaks.Map() end

    local leaf, leafChanged = bsp:PointInLeafCache(0, pos, oldLeaf)
    oldLeaf = leaf -- Cache the leaf for future queries

    -- Check if the leaf is outside the map
    if leaf:IsOutsideMap() then
        return true
    end

    -- Recompute the height to the ceiling or sky if the leaf has changed
    if leafChanged or not Atmos.HeightMin then
        Atmos.HeightMin = estimateCeilingHeight(pos, leaf)
    end

    return false
end

Nevermind, looked into this more and it looks like the vis leaf's outside value is what we want.

i was wrong, its not the function we're looking for https://github.com/Nak2/NikNaks/blob/main/lua/niknaks/modules/sh_bsp_leafs.lua#L275

[looterz]

Ah alright, I hadn't tested it yet. To be fair the trace isn't too expensive, and if we want we could try performing some caching and optimizing it a bit like below, just not sure if it'd end up being better w/ introduced overhead for cache keys.

-- Constants for the function
local UP_VECTOR = Vector(0, 0, 32768)
local CHECK_INCREMENT = Vector(0, 0, 128)
local GRID_SIZE = 10 -- Size of each grid cell for caching
local CACHE_TIME_LIMIT = 0.1 -- Time limit for cache validity

-- Function to generate a grid-based cache key
local function generateCacheKey(pos)
    local x = math.floor(pos.x / GRID_SIZE)
    local y = math.floor(pos.y / GRID_SIZE)
    local z = math.floor(pos.z / GRID_SIZE)
    return x, y, z
end

-- Cache table
local outsideCache = {}

function atmos_outside(pos)
    local xKey, yKey, zKey = generateCacheKey(pos)
    local cacheKey = xKey * 1000000 + yKey * 1000 + zKey -- Unique integer key

    -- Check cache
    local cacheData = outsideCache[cacheKey]
    if cacheData and (CurTime() - cacheData.time < CACHE_TIME_LIMIT) then
        return cacheData.result
    end

    local trace = {}
    trace.start = pos
    trace.endpos = trace.start + UP_VECTOR
    trace.mask = MASK_SOLID

    local tr = util.TraceLine(trace)

    if tr.StartSolid then 
        outsideCache[cacheKey] = { result = false, time = CurTime() }
        return false 
    end
    if tr.HitSky then 
        outsideCache[cacheKey] = { result = true, time = CurTime() }
        return true 
    end

    -- Check past nodraw, iteratively instead of recursively
    local depth = 0
    while tr.HitNoDraw and depth < 5 do
        trace.start = trace.start + CHECK_INCREMENT
        tr = util.TraceLine(trace)
        depth = depth + 1
    end

    local result = tr.HitSky
    outsideCache[cacheKey] = { result = result, time = CurTime() }
    return result
end

Maybe something like this,

local maxTraceHeight = isLeafNearOutdoorArea(leaf) and 16384 or 32768

that trace below can be thrown out potentially since most weather particles originate from the sky's position (BSP:WorldMax() can get this), and we dont have to calculate DieTime thanks to particles allowing for collision callbacks

1 tick behind because Think comes before this hook, but I did it this way because player position might be inaccurate in Think because pretty much all of the movement hooks come after Think

local endAddPos = Vector(0, 0, 32768)

local function OutsideTraceCheck(pos)
    local trace = {}
    trace.start = pos
    trace.endpos = trace.start + endAddPos
    trace.mask = MASK_SOLID_BRUSHONLY

    local tr = util.TraceLine(trace)
    
    return !tr.HitSky
end

local bsp = NikNaks.CurrentMap
local lastState = false
local lastPos = Vector(0, 0, 0)
local lastLeaf = nil
local hasRan = false

hook.Add("FinishMove", "AtmosOutsideCheck", function(ply, mv)
    local plyPos = mv:GetOrigin()

    if hasRan and plyPos == lastPos then return end

    lastLeaf = bsp:PointInLeafCache(0, plyPos, lastLeaf)

    -- If this returns false, we cannot possibly be outside
    local isOutside = lastLeaf:HasSkyboxInPVS()

    -- We might be outside, check with a trace
    if !isOutside then
        isOutside = OutsideTraceCheck(plyPos)
    end

    lastState = isOutside
    lastPos = plyPos
    hasRan = true
end)

I might write a leaf parser that would probably end up being a lot faster, nak gave me the general method he uses

I might write a leaf parser that would probably end up being a lot faster, nak gave me the general method he uses

mostly finished this, just waiting on feedback from nak https://github.com/barkleygaiden/NikNaks/blob/main/lua/niknaks/modules/sh_bsp_leafs.lua#L507-L585