338 lines
11 KiB
Rust
338 lines
11 KiB
Rust
use anyhow::Result;
|
|
use cgmath::{ortho, vec2, vec3, InnerSpace, Matrix4, Vector2, Vector3, VectorSpace};
|
|
use rfactor_sm_reader::*;
|
|
use vulkan_rs::prelude::*;
|
|
|
|
use std::{sync::Arc, time::Instant};
|
|
|
|
use super::rendering::PositionOnlyVertex;
|
|
use crate::write_log;
|
|
|
|
fn convert_vec(v: rF2Vec3) -> Vector3<f32> {
|
|
vec3(v.x as f32, v.y as f32, v.z as f32)
|
|
}
|
|
|
|
pub trait RenderObject {
|
|
fn descriptor(&self) -> &Arc<DescriptorSet>;
|
|
fn buffer(&self) -> &Arc<Buffer<PositionOnlyVertex>>;
|
|
}
|
|
|
|
pub struct DataConfig {
|
|
pub radar_scale: f32,
|
|
pub radar_car_distance: f32,
|
|
pub safe_color: Vector3<f32>,
|
|
pub danger_color: Vector3<f32>,
|
|
}
|
|
|
|
pub struct RFactorData {
|
|
// config
|
|
config: DataConfig,
|
|
|
|
// rf2 memory mapped data
|
|
telemetry_reader: TelemetryReader,
|
|
scoring_reader: ScoringReader,
|
|
|
|
// radar objects
|
|
background: RadarObject,
|
|
player_car: RadarObject,
|
|
cars: Vec<RadarObject>,
|
|
|
|
// game info
|
|
player_id: Option<i32>,
|
|
|
|
// math objects
|
|
radar_center: Vector2<f32>,
|
|
ortho: Matrix4<f32>,
|
|
window_width: u32,
|
|
window_height: u32,
|
|
radar_extent: f32,
|
|
car_width: f32,
|
|
car_height: f32,
|
|
|
|
start_time: Instant,
|
|
|
|
device: Arc<Device>,
|
|
descriptor_layout: Arc<DescriptorSetLayout>,
|
|
}
|
|
|
|
impl RFactorData {
|
|
pub fn new(
|
|
config: DataConfig,
|
|
device: Arc<Device>,
|
|
descriptor_layout: &Arc<DescriptorSetLayout>,
|
|
width: u32,
|
|
height: u32,
|
|
) -> Result<Self> {
|
|
write_log!(" =================== create RFactorData ===================");
|
|
|
|
let radar_extent = width as f32 * 0.075 * config.radar_scale;
|
|
let car_height = radar_extent * 0.2;
|
|
let car_width = car_height * 0.5;
|
|
let radar_center = vec2(
|
|
width as f32 / 2.0,
|
|
height as f32 / 2.0 + height as f32 * 0.25,
|
|
);
|
|
|
|
let ortho = ortho(0.0, width as f32, 0.0, height as f32, -1.0, 1.0);
|
|
let start_time = Instant::now();
|
|
|
|
Ok(Self {
|
|
config,
|
|
|
|
telemetry_reader: TelemetryReader::new(start_time.elapsed().as_secs_f32())?,
|
|
scoring_reader: ScoringReader::new(start_time.elapsed().as_secs_f32())?,
|
|
|
|
background: RadarObject::new(
|
|
device.clone(),
|
|
descriptor_layout,
|
|
PositionOnlyVertex::from_2d_corners(
|
|
ortho,
|
|
[
|
|
vec2(radar_center.x - radar_extent, radar_center.y - radar_extent),
|
|
vec2(radar_center.x - radar_extent, radar_center.y + radar_extent),
|
|
vec2(radar_center.x + radar_extent, radar_center.y + radar_extent),
|
|
vec2(radar_center.x + radar_extent, radar_center.y - radar_extent),
|
|
],
|
|
),
|
|
[0.5, 0.5, 0.5, 0.5],
|
|
)?,
|
|
player_car: RadarObject::new(
|
|
device.clone(),
|
|
descriptor_layout,
|
|
PositionOnlyVertex::from_2d_corners(
|
|
ortho,
|
|
[
|
|
vec2(radar_center.x - car_width, radar_center.y - car_height),
|
|
vec2(radar_center.x - car_width, radar_center.y + car_height),
|
|
vec2(radar_center.x + car_width, radar_center.y + car_height),
|
|
vec2(radar_center.x + car_width, radar_center.y - car_height),
|
|
],
|
|
),
|
|
[0.9, 0.9, 0.0, 0.9],
|
|
)?,
|
|
cars: Vec::new(),
|
|
|
|
player_id: None,
|
|
|
|
radar_center,
|
|
ortho,
|
|
window_width: width,
|
|
window_height: height,
|
|
radar_extent,
|
|
car_width,
|
|
car_height,
|
|
|
|
start_time,
|
|
|
|
device,
|
|
descriptor_layout: descriptor_layout.clone(),
|
|
})
|
|
}
|
|
|
|
fn create_car_object(&self, offset: Vector2<f32>, color: [f32; 4]) -> Result<RadarObject> {
|
|
write_log!(" =================== create car object ===================");
|
|
|
|
RadarObject::new(
|
|
self.device.clone(),
|
|
&self.descriptor_layout,
|
|
PositionOnlyVertex::from_2d_corners(
|
|
self.ortho,
|
|
[
|
|
vec2(
|
|
self.radar_center.x - self.car_width + offset.x,
|
|
self.radar_center.y - self.car_height + offset.y,
|
|
),
|
|
vec2(
|
|
self.radar_center.x - self.car_width + offset.x,
|
|
self.radar_center.y + self.car_height + offset.y,
|
|
),
|
|
vec2(
|
|
self.radar_center.x + self.car_width + offset.x,
|
|
self.radar_center.y + self.car_height + offset.y,
|
|
),
|
|
vec2(
|
|
self.radar_center.x + self.car_width + offset.x,
|
|
self.radar_center.y - self.car_height + offset.y,
|
|
),
|
|
],
|
|
),
|
|
color,
|
|
)
|
|
}
|
|
|
|
fn now(&self) -> f32 {
|
|
self.start_time.elapsed().as_secs_f32()
|
|
}
|
|
|
|
pub fn update(&mut self) -> Result<()> {
|
|
write_log!(" =================== update RFactorData ===================");
|
|
|
|
// get scoring info
|
|
if let Some((scoring_info, vehicle_scorings)) =
|
|
self.scoring_reader.vehicle_scoring(self.now())
|
|
{
|
|
write_log!(format!(
|
|
"new scoring info: vehicles: {}",
|
|
scoring_info.mNumVehicles
|
|
));
|
|
|
|
// check for player id
|
|
if scoring_info.mNumVehicles == 0 {
|
|
self.player_id = None;
|
|
} else if self.player_id.is_none() {
|
|
for vehicle_scoring in vehicle_scorings.iter() {
|
|
if vehicle_scoring.mIsPlayer != 0 {
|
|
write_log!(format!("player found: {}", vehicle_scoring.mID));
|
|
self.player_id = Some(vehicle_scoring.mID);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// if player id is set (a map is loaded), check telemetry data
|
|
if let Some(player_id) = &self.player_id {
|
|
write_log!("before telemetry update");
|
|
if let Some(telemetries) = self.telemetry_reader.query_telemetry(self.now()) {
|
|
write_log!("new telemetry update");
|
|
|
|
let mut player_position = CarPosition::default();
|
|
let mut other_positions = Vec::new();
|
|
|
|
for telemetry in telemetries {
|
|
if telemetry.id == *player_id {
|
|
player_position.position = convert_vec(telemetry.position);
|
|
player_position.local_rotation = convert_vec(telemetry.local_rotation);
|
|
} else {
|
|
other_positions.push(CarPosition {
|
|
position: convert_vec(telemetry.position),
|
|
local_rotation: convert_vec(telemetry.local_rotation),
|
|
});
|
|
}
|
|
}
|
|
|
|
// update radar objects
|
|
|
|
// naive way: clear cars and create them new if near enough
|
|
self.cars.clear();
|
|
|
|
for other_position in other_positions {
|
|
let diff = player_position.position - other_position.position;
|
|
let distance = diff.magnitude();
|
|
|
|
// check if car is close enough the players car
|
|
if distance < self.config.radar_car_distance {
|
|
let distance_ratio = distance / self.config.radar_car_distance;
|
|
|
|
let offset =
|
|
diff.truncate() * (self.radar_extent / self.config.radar_car_distance);
|
|
let color = self
|
|
.config
|
|
.danger_color
|
|
.lerp(self.config.safe_color, distance_ratio);
|
|
|
|
self.cars.push(
|
|
self.create_car_object(offset, [color.x, color.y, color.z, 0.9])?,
|
|
);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
pub fn objects(&self) -> Vec<&dyn RenderObject> {
|
|
write_log!(" =================== get objects of RFactorData ===================");
|
|
|
|
let mut objects: Vec<&dyn RenderObject> = Vec::new();
|
|
|
|
// only draw radar when player is loaded into a map
|
|
if let Some(player_id) = &self.player_id {
|
|
// only draw radar when any car is near enough
|
|
if !self.cars.is_empty() {
|
|
objects.push(&self.background);
|
|
|
|
for other_player_cars in &self.cars {
|
|
objects.push(other_player_cars);
|
|
}
|
|
|
|
objects.push(&self.player_car);
|
|
}
|
|
}
|
|
|
|
objects
|
|
}
|
|
}
|
|
|
|
struct RadarObject {
|
|
descriptor_set: Arc<DescriptorSet>,
|
|
|
|
// uniform buffer
|
|
color_buffer: Arc<Buffer<f32>>,
|
|
|
|
// vertex buffer
|
|
position_buffer: Arc<Buffer<PositionOnlyVertex>>,
|
|
}
|
|
|
|
impl RadarObject {
|
|
fn new(
|
|
device: Arc<Device>,
|
|
descriptor_layout: &Arc<DescriptorSetLayout>,
|
|
positions: [PositionOnlyVertex; 6],
|
|
color: [f32; 4],
|
|
) -> Result<Self> {
|
|
let color_buffer = Buffer::builder()
|
|
.set_usage(VK_BUFFER_USAGE_UNIFORM_BUFFER_BIT)
|
|
.set_memory_usage(MemoryUsage::CpuOnly)
|
|
.set_data(&color)
|
|
.build(device.clone())?;
|
|
|
|
let position_buffer = Buffer::builder()
|
|
.set_usage(VK_BUFFER_USAGE_VERTEX_BUFFER_BIT)
|
|
.set_memory_usage(MemoryUsage::CpuOnly)
|
|
.set_data(&positions)
|
|
.build(device.clone())?;
|
|
|
|
let descriptor_pool = DescriptorPool::builder()
|
|
.set_layout(descriptor_layout.clone())
|
|
.build(device.clone())?;
|
|
|
|
let descriptor_set = descriptor_pool.prepare_set().allocate()?;
|
|
descriptor_set.update(&[DescriptorWrite::uniform_buffers(0, &[&color_buffer])])?;
|
|
|
|
Ok(Self {
|
|
descriptor_set,
|
|
color_buffer,
|
|
position_buffer,
|
|
})
|
|
}
|
|
|
|
pub fn update_color(&self, color: [f32; 4]) -> Result<()> {
|
|
self.color_buffer.fill(&color)
|
|
}
|
|
}
|
|
|
|
impl RenderObject for RadarObject {
|
|
fn descriptor(&self) -> &Arc<DescriptorSet> {
|
|
&self.descriptor_set
|
|
}
|
|
|
|
fn buffer(&self) -> &Arc<Buffer<PositionOnlyVertex>> {
|
|
&self.position_buffer
|
|
}
|
|
}
|
|
|
|
struct CarPosition {
|
|
pub position: Vector3<f32>,
|
|
pub local_rotation: Vector3<f32>,
|
|
}
|
|
|
|
impl Default for CarPosition {
|
|
fn default() -> Self {
|
|
Self {
|
|
position: vec3(0.0, 0.0, 0.0),
|
|
local_rotation: vec3(0.0, 0.0, 0.0),
|
|
}
|
|
}
|
|
}
|