portal64-still-alive/tools/level_scripts/portal_surfaces.lua

local static_export = require('tools.level_scripts.static_export')
local sk_input = require('sk_input')
local sk_math = require('sk_math')
local sk_mesh = require('sk_mesh')
local sk_definition_writer = require('sk_definition_writer')

local portal_surfaces = {}

local portalable_surfaces = {
    concrete_modular_wall001d = true,
    concrete_modular_ceiling001a = true,
    concrete_modular_floor001a = true,
}

local static_to_portable_surface_mapping = {}
local portal_surfaces = {}

local function calculate_surface_basis(mesh)
    local normal = sk_math.vector3(0, 0, 0)

    for _, vertex_normal in pairs(mesh.normals) do
        normal = normal + vertex_normal
    end

    normal = normal:normalized()
    local right;
    local up;

    if (math.abs(normal.z) < 0.7) then
        right = sk_math.vector3(0, 0, 1):cross(normal)
        right = right:normalized()
        up = normal:cross(right)
    else
        right = sk_math.vector3(1, 0, 0):cross(normal)
        right = right:normalized()
        up = normal:cross(right)
    end

    return right, up, normal
end

local FIXED_POINT_PRECISION = 8
local FIXED_POINT_SCALAR = (1 << FIXED_POINT_PRECISION)

local function to_local_coords(origin, edge_a, edge_b, input)
    local relative = input - origin

    return math.floor(relative:dot(edge_a) * FIXED_POINT_SCALAR + 0.5), math.floor(relative:dot(edge_b) * FIXED_POINT_SCALAR + 0.5)
end

local function level_edge_key(a, b)
    return (math.max(a, b) << 8) | math.min(a, b)
end

local function get_edge_index(edges, edge_key)
    local result = edges[edge_key]

    if result then
        return result.edge_index
    end

    return 0xFF
end

local function calculate_portal_single_surface(mesh, mesh_display_list)
    local scale = sk_input.settings.model_scale

    local origin = mesh.bb:lerp(0.5) * scale

    local right, up, normal = calculate_surface_basis(mesh)

    local vertices = {}

    for _, vertex in pairs(mesh.vertices) do
        local x, y = to_local_coords(origin, right, up, vertex * scale)
        table.insert(vertices, {{{x = x, y = y}}})
    end

    sk_definition_writer.add_definition(mesh.name .. '_portal_mesh', 'struct Vector2s16[]', '_geo', vertices)

    local edge_use_count = {}
    local edge_direction = {}
    local edge_order = {}

    for _, face in pairs(mesh.faces) do
        local edge_keys = {}
        local is_reverse_edge = {}

        for index_index, current_index in pairs(face) do
            local next_index = face[index_index % #face + 1]

            local key = level_edge_key(current_index, next_index)
            table.insert(edge_keys, key)

            if (edge_use_count[key]) then
                edge_use_count[key] = edge_use_count[key] + 1
                table.insert(is_reverse_edge, true)
            else
                edge_use_count[key] = 1
                edge_direction[key] = {
                    a = current_index, 
                    b = next_index,
                    edge_index = -1,
                    next_edge_key = -1,
                    prev_edge_key = -1,
                    next_edge_reverse_key = -1,
                    prev_edge_reverse_key = -1,
                }
                table.insert(is_reverse_edge, false)
                table.insert(edge_order, key)
            end
        end

        local prev_key = edge_keys[#edge_keys]

        -- connect faces in a loop
        for index, key in pairs(edge_keys) do
            local next_key = edge_keys[index % #edge_keys + 1]

            local edge = edge_direction[key]

            if (is_reverse_edge[index]) then
                edge.next_edge_reverse_key = next_key
                edge.prev_edge_reverse_key = prev_key
            else
                edge.next_edge_key = next_key
                edge.prev_edge_key = prev_key
            end

            prev_key = key
        end
    end

    -- edges go first
    table.sort(edge_order, function(a, b)
        local edge_diff = edge_use_count[a] - edge_use_count[b]

        if edge_diff ~= 0 then
            return edge_diff < 0
        end

        if edge_direction[a].a ~= edge_direction[b].a then 
            return edge_direction[a].a < edge_direction[b].a
        end

        -- this is an attempt to make edges that are near each other
        -- show up in memory near each other to improve cache
        -- performance
        return edge_direction[a].b < edge_direction[b].b
    end)

    local edge_index = 0

    for _, key in pairs(edge_order) do
        edge_direction[key].edge_index = edge_index
        edge_index = edge_index + 1
    end

    local edges = {}

    for _, key in pairs(edge_order) do
        local indices = edge_direction[key];
        table.insert(edges, {
            indices.a,
            indices.b,
            get_edge_index(edge_direction, indices.next_edge_key),
            get_edge_index(edge_direction, indices.prev_edge_key),
            get_edge_index(edge_direction, indices.next_edge_reverse_key),
            get_edge_index(edge_direction, indices.prev_edge_reverse_key),
        });
    end

    sk_definition_writer.add_definition(mesh.name .. "_portal_edges", "struct SurfaceEdge[]", "_geo", edges)

    return {
        vertices = sk_definition_writer.reference_to(vertices, 1),
        edges = sk_definition_writer.reference_to(edges, 1),
        edgeCount = #edge_order,
        vertexCount = #vertices,
        shouldCleanup = 0,

        right = right,
        up = up,
        corner = corner,

        gfxVertices = sk_mesh.generate_vertex_buffer(mesh, mesh.material, "_geo"),
        triangles = mesh_display_list,
    };
end

for _, surface in pairs(static_export.static_nodes) do
    if (surface.mesh.material and portalable_surfaces[surface.mesh.material.name]) then
        table.insert(portal_surfaces, calculate_portal_single_surface(surface.mesh, surface.display_list))
        table.insert(static_to_portable_surface_mapping, #portal_surfaces)
    else
        table.insert(static_to_portable_surface_mapping, -1)
    end
end

sk_definition_writer.add_definition("portal_surfaces", "struct PortalSurface[]", "_geo", portal_surfaces)

return {
    portal_surfaces = portal_surfaces,
}