357 lines
10 KiB
Lua
357 lines
10 KiB
Lua
|
|
local sk_definition_writer = require('sk_definition_writer')
|
|
local sk_scene = require('sk_scene')
|
|
local sk_mesh = require('sk_mesh')
|
|
local sk_math = require('sk_math')
|
|
local room_export = require('tools.level_scripts.room_export')
|
|
|
|
local COLLISION_GRID_CELL_SIZE = 4
|
|
|
|
local function build_collision_grid(boundaries)
|
|
local x = math.floor(boundaries.min.x)
|
|
local z = math.floor(boundaries.min.z)
|
|
|
|
local span_x = math.ceil((boundaries.max.x - x) / COLLISION_GRID_CELL_SIZE)
|
|
local span_z = math.ceil((boundaries.max.z - z) / COLLISION_GRID_CELL_SIZE)
|
|
|
|
local cells = {}
|
|
|
|
for i = 1,span_x do
|
|
local cell_row = {}
|
|
|
|
for j = 1,span_z do
|
|
table.insert(cell_row, {})
|
|
end
|
|
|
|
table.insert(cells, cell_row)
|
|
end
|
|
|
|
return {
|
|
x = x,
|
|
z = z,
|
|
span_x = span_x,
|
|
span_z = span_z,
|
|
cells = cells,
|
|
}
|
|
end
|
|
|
|
local function add_to_collision_grid(grid, box, value)
|
|
local min_x = math.floor((box.min.x - grid.x) / COLLISION_GRID_CELL_SIZE)
|
|
local max_x = math.floor((box.max.x - grid.x) / COLLISION_GRID_CELL_SIZE)
|
|
local min_z = math.floor((box.min.z - grid.z) / COLLISION_GRID_CELL_SIZE)
|
|
local max_z = math.floor((box.max.z - grid.z) / COLLISION_GRID_CELL_SIZE)
|
|
|
|
if (max_x < 0) then max_x = 0 end
|
|
if (min_x >= grid.span_x) then min_x = grid.span_x - 1 end
|
|
|
|
if (max_z < 0) then max_z = 0 end
|
|
if (min_z >= grid.span_z) then min_z = grid.span_z - 1 end
|
|
|
|
for curr_x = min_x,max_x do
|
|
for curr_z = min_z,max_z do
|
|
if (curr_x >= 0 and curr_x < grid.span_x and curr_z >= 0 and curr_z < grid.span_z) then
|
|
table.insert(grid.cells[curr_x + 1][curr_z + 1], value)
|
|
end
|
|
end
|
|
end
|
|
end
|
|
|
|
local function parse_quad_thickness(node_info)
|
|
local thickness = sk_scene.find_named_argument(node_info.arguments, "thickness")
|
|
|
|
if (thickness) then
|
|
return tonumber(thickness)
|
|
end
|
|
|
|
return 0
|
|
end
|
|
|
|
local collider_nodes = sk_scene.nodes_for_type("@collision")
|
|
|
|
for _, node in pairs(collider_nodes) do
|
|
node.room_index = room_export.node_nearest_room_index(node.node)
|
|
end
|
|
|
|
table.sort(collider_nodes, function (a, b)
|
|
return a.room_index < b.room_index
|
|
end)
|
|
|
|
local SAME_TOLERANCE = 0.00001
|
|
|
|
local function bottom_right_compare(a, b)
|
|
if (math.abs(a.x - b.x) > SAME_TOLERANCE) then
|
|
return a.x < b.x
|
|
end
|
|
|
|
if (math.abs(a.y - b.y) > SAME_TOLERANCE) then
|
|
return a.y < b.y
|
|
end
|
|
|
|
return a.z < b.z
|
|
end
|
|
|
|
local function find_min(array, predicate)
|
|
local result = array[1]
|
|
local result_index = 1
|
|
|
|
for index, current in pairs(array) do
|
|
if (predicate(current, result)) then
|
|
result = current
|
|
result_index = index
|
|
end
|
|
end
|
|
|
|
return result, result_index
|
|
end
|
|
|
|
local function bottom_right_most_index(vertices)
|
|
return find_min(vertices, bottom_right_compare)
|
|
end
|
|
|
|
local function find_most_opposite_edge(from_edge, edges)
|
|
return find_min(edges, function(a, b)
|
|
return a:dot(from_edge) < b:dot(from_edge)
|
|
end)
|
|
end
|
|
|
|
local function find_adjacent_vertices(mesh, corner_index)
|
|
local result = {}
|
|
|
|
for _, face in pairs(mesh.faces) do
|
|
for index_index, index in pairs(face) do
|
|
if (index == corner_index) then
|
|
local next_index = index_index + 1
|
|
|
|
if (next_index > #face) then
|
|
next_index = 1
|
|
end
|
|
|
|
local prev_index = index_index - 1
|
|
|
|
if (prev_index == 0) then
|
|
prev_index = #face
|
|
end
|
|
|
|
result[face[next_index]] = true
|
|
result[face[prev_index]] = true
|
|
end
|
|
end
|
|
end
|
|
|
|
return result
|
|
end
|
|
|
|
local function create_collision_quad(mesh, thickness)
|
|
local bottom_right_most = mesh.vertices[1]
|
|
|
|
local corner_point, corner_index = bottom_right_most_index(mesh.vertices)
|
|
|
|
local adjacent_indices = find_adjacent_vertices(mesh, corner_index)
|
|
|
|
local edges_from_corner = {}
|
|
|
|
for index, _ in pairs(adjacent_indices) do
|
|
table.insert(edges_from_corner, mesh.vertices[index] - corner_point)
|
|
end
|
|
|
|
local edge_a_point = find_most_opposite_edge(edges_from_corner[1], edges_from_corner)
|
|
local edge_b_point = find_most_opposite_edge(edge_a_point, edges_from_corner)
|
|
|
|
local normal_sum = sk_math.vector3(0, 0, 0)
|
|
|
|
for _, normal in pairs(mesh.normals) do
|
|
normal_sum = normal_sum + normal
|
|
end
|
|
|
|
local final_normal = normal_sum:normalized()
|
|
|
|
-- make sure the basis is right handed
|
|
if edge_a_point:cross(edge_b_point):dot(final_normal) < 0 then
|
|
edge_a_point, edge_b_point = edge_b_point, edge_a_point
|
|
end
|
|
|
|
local edge_a_normalized = edge_a_point:normalized()
|
|
local edge_b_normalized = edge_b_point:normalized()
|
|
|
|
|
|
return {
|
|
corner = corner_point,
|
|
edgeA = edge_a_normalized,
|
|
edgeALength = edge_a_point:dot(edge_a_normalized),
|
|
edgeB = edge_b_normalized,
|
|
edgeBLength = edge_b_point:dot(edge_b_normalized),
|
|
plane = {
|
|
normal = final_normal,
|
|
d = -corner_point:dot(final_normal),
|
|
},
|
|
thickness = thickness,
|
|
}
|
|
end
|
|
|
|
local function collision_quad_bb(collision_quad)
|
|
local min = collision_quad.corner
|
|
local max = collision_quad.corner
|
|
|
|
for x = 1,2 do
|
|
for y = 1,2 do
|
|
for z = 1,2 do
|
|
local point = collision_quad.corner
|
|
|
|
if (x == 2) then
|
|
point = point + collision_quad.edgeA * collision_quad.edgeALength
|
|
end
|
|
|
|
if (y == 2) then
|
|
point = point + collision_quad.edgeB * collision_quad.edgeBLength
|
|
end
|
|
|
|
if (z == 2) then
|
|
point = point - collision_quad.plane.normal * collision_quad.thickness
|
|
end
|
|
|
|
min = min:min(point)
|
|
max = max:max(point)
|
|
end
|
|
end
|
|
end
|
|
|
|
return sk_math.box3(min, max)
|
|
end
|
|
|
|
local INSIDE_NORMAL_TOLERANCE = 0.1
|
|
|
|
local function is_coplanar(collision_quad, mesh)
|
|
if sk_math.isVector3(mesh) then
|
|
local offset = mesh - collision_quad.corner
|
|
|
|
local z = offset:dot(collision_quad.plane.normal)
|
|
|
|
if math.abs(z) >= INSIDE_NORMAL_TOLERANCE then
|
|
return false
|
|
end
|
|
|
|
local x = offset:dot(collision_quad.edgeA)
|
|
|
|
if x < -INSIDE_NORMAL_TOLERANCE or x > collision_quad.edgeALength + INSIDE_NORMAL_TOLERANCE then
|
|
return false
|
|
end
|
|
|
|
local y = offset:dot(collision_quad.edgeB)
|
|
|
|
if y < -INSIDE_NORMAL_TOLERANCE or y > collision_quad.edgeBLength + INSIDE_NORMAL_TOLERANCE then
|
|
return false
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
for _, vertex in pairs(mesh.vertices) do
|
|
local offset = vertex - collision_quad.corner
|
|
|
|
local z = offset:dot(collision_quad.plane.normal)
|
|
|
|
if math.abs(z) >= INSIDE_NORMAL_TOLERANCE then
|
|
return false
|
|
end
|
|
end
|
|
|
|
return true
|
|
end
|
|
|
|
local colliders = {}
|
|
local collider_types = {}
|
|
local collision_objects = {}
|
|
local quad_rooms = {}
|
|
|
|
local room_bb = {}
|
|
|
|
local room_grids = {}
|
|
|
|
for index, node in pairs(collider_nodes) do
|
|
local is_transparent = sk_scene.find_flag_argument(node.arguments, "transparent")
|
|
|
|
local collision_layers = {}
|
|
|
|
for _, arg in pairs(node.arguments) do
|
|
if string.sub(arg, 1, #"CL_") == "CL_" then
|
|
table.insert(collision_layers, 'COLLISION_LAYERS_' .. string.sub(arg, #"CL_" + 1))
|
|
end
|
|
end
|
|
|
|
if #collision_layers == 0 then
|
|
table.insert(collision_layers, 'COLLISION_LAYERS_STATIC')
|
|
table.insert(collision_layers, 'COLLISION_LAYERS_BLOCK_BALL')
|
|
table.insert(collision_layers, 'COLLISION_LAYERS_TANGIBLE')
|
|
|
|
if is_transparent then
|
|
table.insert(collision_layers, 'COLLISION_LAYERS_TRANSPARENT')
|
|
end
|
|
end
|
|
|
|
for _, mesh in pairs(node.node.meshes) do
|
|
local global_mesh = mesh:transform(node.node.full_transformation)
|
|
|
|
local collider = create_collision_quad(global_mesh, parse_quad_thickness(node))
|
|
|
|
local named_entry = sk_scene.find_named_argument(node.arguments, "name")
|
|
|
|
if (named_entry) then
|
|
sk_definition_writer.add_macro(named_entry .. "_COLLISION_INDEX", #colliders)
|
|
end
|
|
|
|
local bb = collision_quad_bb(collider)
|
|
|
|
if room_bb[node.room_index + 1] then
|
|
room_bb[node.room_index + 1] = room_bb[node.room_index + 1]:union(bb)
|
|
else
|
|
room_bb[node.room_index + 1] = bb
|
|
end
|
|
|
|
table.insert(colliders, collider)
|
|
table.insert(quad_rooms, node.room_index)
|
|
|
|
local collider_type = {
|
|
sk_definition_writer.raw("CollisionShapeTypeQuad"),
|
|
sk_definition_writer.reference_to(collider),
|
|
0,
|
|
1,
|
|
sk_definition_writer.null_value,
|
|
}
|
|
|
|
table.insert(collider_types, collider_type)
|
|
|
|
table.insert(collision_objects, {
|
|
sk_definition_writer.reference_to(collider_type),
|
|
sk_definition_writer.null_value,
|
|
bb,
|
|
sk_definition_writer.raw(table.concat(collision_layers, ' | '))
|
|
})
|
|
end
|
|
end
|
|
|
|
for i = 1,room_export.room_count do
|
|
if room_bb[i] then
|
|
room_grids[i] = build_collision_grid(room_bb[i])
|
|
end
|
|
end
|
|
|
|
for index, quad in pairs(colliders) do
|
|
local room_grid = room_grids[quad_rooms[index] + 1]
|
|
|
|
if room_grid then
|
|
add_to_collision_grid(room_grid, collision_quad_bb(quad), index - 1)
|
|
end
|
|
end
|
|
|
|
sk_definition_writer.add_definition("quad_colliders", "struct CollisionQuad[]", "_geo", colliders)
|
|
sk_definition_writer.add_definition("collider_types", "struct ColliderTypeData[]", "_geo", collider_types)
|
|
sk_definition_writer.add_definition("collision_objects", "struct CollisionObject[]", "_geo", collision_objects)
|
|
|
|
return {
|
|
is_coplanar = is_coplanar,
|
|
colliders = colliders,
|
|
collision_quad_bb = collision_quad_bb,
|
|
collision_objects = collision_objects,
|
|
create_collision_quad = create_collision_quad,
|
|
room_grids = room_grids,
|
|
} |