mirror of
https://github.com/mwpenny/portal64-still-alive.git
synced 2024-10-20 10:37:37 -04:00
204 lines
6 KiB
Lua
204 lines
6 KiB
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,
|
|
} |