Faster wire rendering

[Fasteroid]

It's not perfect, but it's certainly better that what we had before. Cleaned up a bunch of old code that doesn't do anything and added some micro-optimizations where doable (but they didn't have much of an impact in my testing)

The big change with this PR is that entities with stupid amounts of wires will no longer drop your FPS provided they remain stationary. This is thanks to a new LocalToWorld result caching system, which avoids creating new vector objects for repeated calls with the same input vector.

This LocalToWorld cache system is now a part of WireLib so it can be used in other files where applicable. The more it's used, the better the global performance should become.

[thegrb93]

The only problem I see is the wire used to render even if ent was Invalid, which I guess would correspond to world entity. If ent is Invalid then it uses world offsets for the wire instead of entity local offsets. We might still want that behavior.

[Fasteroid]

The only problem I see is the wire used to render even if ent was Invalid, which I guess would correspond to world entity. If ent is Invalid then it uses world offsets for the wire instead of entity local offsets. We might still want that behavior.

The wire tool itself doesn't even let you attach wires to the world so this probably isn't an issue.

[thegrb93]

Could this be generalized to something cleaner like

local ents_computed_data = setmetatable({}, {__index=function(t,k) local r=setmetatable({}, {__index=function(t,k) local r={pos = Vector(math.huge), ang = Angle()} t[k]=r return r end}) t[k]=r end})
function WireLib.ComputeIfEntityTransformDirty(ent, key, compute)
    local data = ents_computed_data[ent][key]

    local pos, ang = ent:GetPos(), ent:GetAngles()
    if not (rawequal(orientation[1], data.pos) and rawequal(orientation[2], data.ang)) then
        data.pos = pos
        data.ang = ang
        data.computed = compute(ent)
    end
    return data.computed
end

-- Example usage
local wires = WireLib.ComputeIfEntityTransformDirty(ent, "wires", function(ent)
    return {<list of transformed vectors>}
end)

[thegrb93]

This should also prevent memory leaking caused by the vector lookup table

[thegrb93]

Even better:

function WireLib.GetComputeIfEntityTransformDirty(compute)
    local ents_computed_data = setmetatable({}, {__index=function(t,k) local r={pos = Vector(math.huge), ang = Angle()} t[k]=r return r end})

    return function(ent, ...)
        local data = ents_computed_data[ent]

        local pos, ang = ent:GetPos(), ent:GetAngles()
        if not (rawequal(orientation[1], data.pos) and rawequal(orientation[2], data.ang)) then
            data.pos = pos
            data.ang = ang
            data.computed = compute(ent, ...)
        end
        return data.computed
    end
end

-- Example usage
local wireTransformer = WireLib.GetComputeIfEntityTransformDirty(function(ent, local_wires)
    return {<list of transformed vectors>}
end)

local wirePositions = wireTransformer(ent, local_wires)

[Fasteroid]

Good idea to put it on the entity itself. Will look into doing it like that this weekend.

[Fasteroid]

I meant to do this much longer ago. Gonna actually do it now.

Also, fuck off github-actions bot.

[Fasteroid]

data.computed = compute(ent, ...)

Varargs are not jittable, going to avoid this

[github-actions]

This pull request has been marked as stale as there haven't been any changes in the past month. It will be closed in 15 days.

[Fasteroid]

@thegrb93 With all due respect, while your code is cleaner, it looks like it might be really really expensive to use in practice. I will not be implementing your requested changes at this time.

[thegrb93]

Improved the implementation to cache vectors like yours and did more optimization. If its still slow then we can revert to the simpler method, but this should be as fast as if not faster.

https://github.com/wiremod/wire/pull/2955/files/ae6dedf29ed8a7667051d2e8c239ce5f8492b519..6de760bda40e2fbb01909b513b2e4a01038ec775

[thegrb93]

Can be simplified further

function WireLib.GetComputeIfEntityTransformDirty(compute)
	return setmetatable({}, {
		__index=function(t,ent) local r={Vector(math.huge), Angle()} t[ent]=r return r end,
		__call=function(t,ent)
			local data = t[ent]
			local pos, ang = GetPos(ent), GetAngles(ent)
			if pos~=data[1] or ang~=data[2] then
				data[1] = pos
				data[2] = ang
				data[3] = compute(ent)
			end
			return data[3]
		end
	})
end

[thegrb93]

Seems to be working