use std::{
fs,
io::{Error as IoError, ErrorKind, Result as IoResult},
path::Path,
sync::{Arc, Mutex, OnceLock, RwLock},
time::Instant,
};
use glam::Vec3A;
use log::{info, warn};
use rustc_hash::FxHashMap;
use crate::{
bullet::collision::shapes::bvh_triangle_mesh_shape::BvhTriangleMeshShape,
logging,
sim::{
GameMode,
collision_mesh_file::{
COLLISION_MESH_BASE_PATH, COLLISION_MESH_FILE_EXTENSION, CollisionMeshFile,
},
},
};
static HAS_INITIALIZED_LOCK: OnceLock<()> = OnceLock::new();
static INITIALIZING_MUTEX: Mutex<()> = Mutex::new(());
#[derive(Clone)]
pub(crate) struct ArenaCollisionMesh {
pub shape: Arc<BvhTriangleMeshShape>,
pub translation: Vec3A,
}
pub(crate) static ARENA_COLLISION_SHAPES: RwLock<
Option<FxHashMap<GameMode, Vec<ArenaCollisionMesh>>>,
> = RwLock::new(None);
pub(crate) static ARENA_COLLISION_MESH_FILES: RwLock<
Option<FxHashMap<GameMode, Vec<CollisionMeshFile>>>,
> = RwLock::new(None);
pub fn is_initialized() -> bool {
HAS_INITIALIZED_LOCK.get().is_some()
}
pub fn get_arena_collision_mesh_files(game_mode: GameMode) -> Vec<CollisionMeshFile> {
let collision_mesh_files = ARENA_COLLISION_MESH_FILES.read().unwrap();
let meshes_mode = match game_mode {
GameMode::Hoops => game_mode,
GameMode::Dropshot => game_mode,
GameMode::TheVoid => return Vec::new(),
_ => GameMode::Soccar,
};
collision_mesh_files.as_ref().unwrap()[&meshes_mode].clone()
}
pub fn init_from_default(silent: bool) -> IoResult<()> {
init(COLLISION_MESH_BASE_PATH, silent)
}
pub fn init<P: AsRef<Path>>(collision_meshes_folder: P, silent: bool) -> IoResult<()> {
init_from_path(collision_meshes_folder.as_ref(), silent)
}
fn init_from_path(collision_meshes_folder: &Path, silent: bool) -> IoResult<()> {
const GAMEMODES_WITH_UNIQUE_MESHES: [GameMode; 3] =
[GameMode::Soccar, GameMode::Hoops, GameMode::Dropshot];
if !collision_meshes_folder.exists() {
let working_dir = std::env::current_dir().expect("Could not get working directory");
return Err(IoError::new(
ErrorKind::NotFound,
format!(
"{} does not exist (from: {})",
collision_meshes_folder.display(),
working_dir.display()
),
));
}
if !collision_meshes_folder.is_dir() {
return Err(IoError::new(
ErrorKind::NotADirectory,
format!("{} is not a directory", collision_meshes_folder.display()),
));
}
let mut mesh_file_map = FxHashMap::default();
for game_mode in GAMEMODES_WITH_UNIQUE_MESHES {
let folder = collision_meshes_folder.join(game_mode.name());
if !folder.exists() {
continue;
}
let mut files = Vec::new();
for entry in fs::read_dir(folder)? {
let p = entry?.path();
if !p.is_file()
|| p.extension()
.is_none_or(|ext| ext != COLLISION_MESH_FILE_EXTENSION)
{
continue;
}
files.push(fs::read(p)?);
}
mesh_file_map.insert(game_mode, files);
}
init_from_mem(mesh_file_map, silent)
}
pub fn init_from_mem<I, V, B>(byte_mesh_file_map: I, silent: bool) -> IoResult<()>
where
I: IntoIterator<Item = (GameMode, V)>,
V: IntoIterator<Item = B>,
B: AsRef<[u8]>,
{
if !silent {
let _ = logging::try_init();
}
let _initializing_lock = INITIALIZING_MUTEX
.lock()
.unwrap_or_else(|poisoned| poisoned.into_inner());
if is_initialized() {
warn!("RocketSim initialized again, ignoring...");
return Ok(());
}
info!("Initializing RocketSim, originally by ZealanL and ported to Rust by VirxEC...");
let start_time = Instant::now();
let mut arena_collision_mesh_files = FxHashMap::default();
for (game_mode, byte_mesh_files) in byte_mesh_file_map {
let game_mode = match game_mode {
GameMode::Heatseeker | GameMode::Snowday => GameMode::Soccar,
GameMode::TheVoid => continue,
mode => mode,
};
if arena_collision_mesh_files.contains_key(&game_mode) {
return Err(IoError::new(
ErrorKind::InvalidInput,
format!("{} mesh set was supplied more than once", game_mode.name()),
));
}
info!("Loading arena meshes for {}...", game_mode.name());
let mut mesh_files = Vec::new();
let mut target_hashes = game_mode.get_hashes();
for (i, entry) in byte_mesh_files.into_iter().enumerate() {
let mesh_file = CollisionMeshFile::read_from_bytes(entry.as_ref())?;
let hash = mesh_file.get_hash();
let Some(hash_count) = target_hashes.get_mut(&hash) else {
warn!(
"Collision mesh [{i}] does not match any known {} collision mesh ({hash:#x}), \
make sure they were dumped form a normal {} arena.",
game_mode.name(),
game_mode.name()
);
continue;
};
if *hash_count > 0 {
return Err(IoError::new(
ErrorKind::InvalidData,
format!(
"duplicate {} collision mesh component at index {i} ({hash:#010x})",
game_mode.name()
),
));
}
*hash_count += 1;
mesh_files.push(mesh_file);
}
let mut missing: Vec<_> = target_hashes
.into_iter()
.filter_map(|(hash, count)| (count == 0).then_some(hash))
.collect();
if !missing.is_empty() {
missing.sort_unstable();
let hashes = missing
.iter()
.map(|hash| format!("{hash:#010x}"))
.collect::<Vec<_>>()
.join(", ");
return Err(IoError::new(
ErrorKind::InvalidData,
format!(
"incomplete {} collision mesh set: missing {} component(s): {hashes}",
game_mode.name(),
missing.len()
),
));
}
if game_mode == GameMode::Soccar {
mesh_files.sort_by_key(|mesh| {
GameMode::soccar_component_order(mesh.get_hash())
.expect("validated Soccar mesh hash has a native order")
});
}
arena_collision_mesh_files.insert(game_mode, mesh_files);
}
let mut arena_collision_shapes = FxHashMap::default();
for (&game_mode, mesh_files) in &arena_collision_mesh_files {
let meshes = mesh_files
.iter()
.map(|mesh_file| ArenaCollisionMesh {
shape: Arc::new(BvhTriangleMeshShape::new(
mesh_file.make_bullet_mesh_local(),
)),
translation: mesh_file.component_translation(),
})
.collect();
arena_collision_shapes.insert(game_mode, meshes);
}
{
info!("Finished loading arena collision meshes:");
info!(
"\tSoccar: {}",
arena_collision_shapes
.get(&GameMode::Soccar)
.map_or(0, Vec::len)
);
info!(
"\tHoops: {}",
arena_collision_shapes
.get(&GameMode::Hoops)
.map_or(0, Vec::len)
);
info!(
"\tDropshot: {}",
arena_collision_shapes
.get(&GameMode::Dropshot)
.map_or(0, Vec::len)
);
let elapsed_time = Instant::now().duration_since(start_time);
info!(
"Finished initializing RocketSim in {:.3}s!",
elapsed_time.as_secs_f32()
);
}
{
let mut arena_collision_shapes_lock = ARENA_COLLISION_SHAPES.write().unwrap();
let mut arena_collision_mesh_files_lock = ARENA_COLLISION_MESH_FILES.write().unwrap();
assert!(
arena_collision_shapes_lock.is_none(),
"RocketSim initialization called twice"
);
*arena_collision_shapes_lock = Some(arena_collision_shapes);
*arena_collision_mesh_files_lock = Some(arena_collision_mesh_files);
}
HAS_INITIALIZED_LOCK
.set(())
.expect("RocketSim readiness was already published");
Ok(())
}