Initial import
This commit is contained in:
@@ -0,0 +1,162 @@
|
||||
mod renderer;
|
||||
mod scene;
|
||||
mod socket_api;
|
||||
mod workload;
|
||||
|
||||
use anyhow::Result;
|
||||
use std::sync::{Arc, Mutex};
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
pub enum PreviewScenePreset {
|
||||
DarkArena,
|
||||
BrightWash,
|
||||
MotionStress,
|
||||
StaticInspection,
|
||||
NoiseField,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum PreviewPresentMode {
|
||||
Fifo,
|
||||
Immediate,
|
||||
}
|
||||
|
||||
impl PreviewPresentMode {
|
||||
fn from_env() -> Self {
|
||||
let enabled = std::env::var("MANGOTUNE_PREVIEW_VSYNC")
|
||||
.ok()
|
||||
.map(|value| {
|
||||
matches!(
|
||||
value.trim().to_ascii_lowercase().as_str(),
|
||||
"1" | "true" | "yes" | "on"
|
||||
)
|
||||
})
|
||||
.unwrap_or(false);
|
||||
if enabled {
|
||||
Self::Fifo
|
||||
} else {
|
||||
Self::Immediate
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl PreviewScenePreset {
|
||||
pub fn from_label(value: &str) -> Option<Self> {
|
||||
match value {
|
||||
"dark-arena" | "dark" => Some(Self::DarkArena),
|
||||
"bright-wash" | "bright" => Some(Self::BrightWash),
|
||||
"static-inspection" | "readability" => Some(Self::StaticInspection),
|
||||
"motion-stress" | "motion" => Some(Self::MotionStress),
|
||||
"noise-field" => Some(Self::NoiseField),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn from_env() -> Self {
|
||||
std::env::var("MANGOTUNE_PREVIEW_SCENE")
|
||||
.ok()
|
||||
.as_deref()
|
||||
.and_then(Self::from_label)
|
||||
.unwrap_or(Self::DarkArena)
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct SimState {
|
||||
pub gpu_load_target: f32,
|
||||
pub fps_cap: u32,
|
||||
pub vram_pressure_mb: u32,
|
||||
pub particle_count: u32,
|
||||
pub particle_size: f32,
|
||||
pub gpu_passes: u32,
|
||||
pub interaction_steps: u32,
|
||||
pub present_mode: PreviewPresentMode,
|
||||
pub paused: bool,
|
||||
pub should_quit: bool,
|
||||
pub scene_preset: PreviewScenePreset,
|
||||
}
|
||||
|
||||
impl Default for SimState {
|
||||
fn default() -> Self {
|
||||
let scene_preset = PreviewScenePreset::from_env();
|
||||
let gpu_load_target = std::env::var("MANGOTUNE_PREVIEW_LOAD")
|
||||
.ok()
|
||||
.and_then(|value| value.parse::<f32>().ok())
|
||||
.unwrap_or(0.0)
|
||||
.clamp(0.0, 10.0)
|
||||
/ 10.0;
|
||||
let particle_count = std::env::var("MANGOTUNE_PREVIEW_PARTICLE_COUNT")
|
||||
.ok()
|
||||
.and_then(|value| value.parse::<u32>().ok())
|
||||
.unwrap_or(1_000)
|
||||
.clamp(100, 500_000);
|
||||
let vram_pressure_mb = std::env::var("MANGOTUNE_PREVIEW_VRAM_MB")
|
||||
.ok()
|
||||
.and_then(|value| value.parse::<u32>().ok())
|
||||
.unwrap_or(0)
|
||||
.clamp(0, 65_536);
|
||||
let particle_size = std::env::var("MANGOTUNE_PREVIEW_PARTICLE_SIZE")
|
||||
.ok()
|
||||
.and_then(|value| value.parse::<f32>().ok())
|
||||
.unwrap_or(0.03)
|
||||
.clamp(0.01, 5.0);
|
||||
let gpu_passes = std::env::var("MANGOTUNE_PREVIEW_GPU_PASSES")
|
||||
.ok()
|
||||
.and_then(|value| value.parse::<u32>().ok())
|
||||
.unwrap_or(1)
|
||||
.clamp(1, 64);
|
||||
let interaction_steps = std::env::var("MANGOTUNE_PREVIEW_INTERACTION_STEPS")
|
||||
.ok()
|
||||
.and_then(|value| value.parse::<u32>().ok())
|
||||
.unwrap_or(0)
|
||||
.clamp(0, 256);
|
||||
let fps_cap = std::env::var("MANGOTUNE_PREVIEW_FPS_CAP")
|
||||
.ok()
|
||||
.and_then(|value| value.parse::<u32>().ok())
|
||||
.unwrap_or(120);
|
||||
let present_mode = PreviewPresentMode::from_env();
|
||||
|
||||
Self {
|
||||
gpu_load_target,
|
||||
fps_cap,
|
||||
vram_pressure_mb,
|
||||
particle_count,
|
||||
particle_size,
|
||||
gpu_passes,
|
||||
interaction_steps,
|
||||
present_mode,
|
||||
paused: false,
|
||||
should_quit: false,
|
||||
scene_preset,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn main() -> Result<()> {
|
||||
let mut logger = env_logger::Builder::from_env(
|
||||
env_logger::Env::default().filter_or("MANGOTUNE_LOG", "warn"),
|
||||
);
|
||||
// Newer NVIDIA/Vulkan stacks may advertise extension present modes that this
|
||||
// wgpu release does not recognize by name. We still request plain FIFO, so
|
||||
// these probe-time warnings are just console noise.
|
||||
logger.filter_module("wgpu_hal::vulkan::conv", log::LevelFilter::Error);
|
||||
logger.init();
|
||||
|
||||
log::info!("mangotune-preview starting");
|
||||
log::info!("Control socket: {}", socket_api::socket_path());
|
||||
log::info!(
|
||||
"Config file: {}",
|
||||
std::env::var("MANGOHUD_CONFIGFILE")
|
||||
.unwrap_or_else(|_| "(not set — MangoHud will use its default)".into())
|
||||
);
|
||||
|
||||
let state = Arc::new(Mutex::new(SimState::default()));
|
||||
let state_for_socket = Arc::clone(&state);
|
||||
std::thread::spawn(move || {
|
||||
let rt = tokio::runtime::Runtime::new().expect("tokio runtime");
|
||||
rt.block_on(socket_api::run(state_for_socket))
|
||||
.expect("socket API crashed");
|
||||
});
|
||||
|
||||
renderer::run(state)
|
||||
}
|
||||
@@ -0,0 +1,549 @@
|
||||
use crate::scene::Scene;
|
||||
use crate::workload::Workload;
|
||||
use crate::{PreviewPresentMode, PreviewScenePreset, SimState};
|
||||
use anyhow::Result;
|
||||
use std::sync::{Arc, Mutex};
|
||||
use std::time::Instant;
|
||||
use winit::{
|
||||
dpi::LogicalSize,
|
||||
event::{Event, WindowEvent},
|
||||
event_loop::{ControlFlow, EventLoop},
|
||||
window::Window,
|
||||
};
|
||||
|
||||
const SHADER_SRC: &str = r#"
|
||||
struct Camera {
|
||||
view_proj: mat4x4<f32>,
|
||||
time_pad: vec4<f32>,
|
||||
}
|
||||
@group(0) @binding(0) var<uniform> camera: Camera;
|
||||
|
||||
struct VertIn {
|
||||
@location(0) position: vec3<f32>,
|
||||
@location(1) color: vec4<f32>,
|
||||
@location(2) uv: vec2<f32>,
|
||||
}
|
||||
|
||||
struct VertOut {
|
||||
@builtin(position) clip_pos: vec4<f32>,
|
||||
@location(0) color: vec4<f32>,
|
||||
@location(2) local_uv: vec2<f32>,
|
||||
}
|
||||
|
||||
@vertex
|
||||
fn vs_main(in: VertIn) -> VertOut {
|
||||
var out: VertOut;
|
||||
out.clip_pos = camera.view_proj * vec4<f32>(in.position, 1.0);
|
||||
out.color = in.color;
|
||||
out.local_uv = in.uv;
|
||||
return out;
|
||||
}
|
||||
|
||||
fn hash3(p: vec3<f32>) -> f32 {
|
||||
var p3 = fract(p * 0.1031);
|
||||
p3 = p3 + vec3<f32>(dot(p3, p3.yzx + vec3<f32>(33.33)));
|
||||
return fract((p3.x + p3.y) * p3.z);
|
||||
}
|
||||
|
||||
fn value_noise(p: vec3<f32>) -> f32 {
|
||||
let i = floor(p);
|
||||
let f = fract(p);
|
||||
let u = f * f * (vec3<f32>(3.0) - 2.0 * f);
|
||||
|
||||
return mix(
|
||||
mix(mix(hash3(i + vec3<f32>(0.0, 0.0, 0.0)), hash3(i + vec3<f32>(1.0, 0.0, 0.0)), u.x),
|
||||
mix(hash3(i + vec3<f32>(0.0, 1.0, 0.0)), hash3(i + vec3<f32>(1.0, 1.0, 0.0)), u.x), u.y),
|
||||
mix(mix(hash3(i + vec3<f32>(0.0, 0.0, 1.0)), hash3(i + vec3<f32>(1.0, 0.0, 1.0)), u.x),
|
||||
mix(hash3(i + vec3<f32>(0.0, 1.0, 1.0)), hash3(i + vec3<f32>(1.0, 1.0, 1.0)), u.x), u.y),
|
||||
u.z
|
||||
);
|
||||
}
|
||||
|
||||
@fragment
|
||||
fn fs_main(in: VertOut) -> @location(0) vec4<f32> {
|
||||
let uv = in.local_uv;
|
||||
let r2 = dot(uv, uv);
|
||||
if (r2 > 1.0) {
|
||||
discard;
|
||||
}
|
||||
|
||||
let depth = sqrt(1.0 - r2);
|
||||
let ray_entry = -depth;
|
||||
let ray_exit = depth;
|
||||
let ray_length = 2.0 * depth;
|
||||
let step_size = ray_length / 64.0;
|
||||
var density = 0.0;
|
||||
|
||||
for (var step = 0u; step < 64u; step = step + 1u) {
|
||||
let t = ray_entry + (f32(step) + 0.5) * step_size;
|
||||
let p = vec3<f32>(uv, t);
|
||||
let time = camera.time_pad.x;
|
||||
let n1 = value_noise(p * 3.0 + vec3<f32>(time * 0.3, 0.0, 0.0));
|
||||
let n2 = value_noise(p * 6.0 - vec3<f32>(0.0, time * 0.5, 0.0)) * 0.5;
|
||||
let n3 = value_noise(p * 12.0 + vec3<f32>(time * 0.7, time * 0.2, 0.0)) * 0.25;
|
||||
let sample = (n1 + n2 + n3) / 1.75;
|
||||
density = density + sample * (1.0 / 64.0);
|
||||
}
|
||||
|
||||
return vec4<f32>(in.color.rgb, clamp(density, 0.0, 1.0));
|
||||
}
|
||||
"#;
|
||||
|
||||
type Mat4 = [f32; 16];
|
||||
|
||||
fn mat4_identity() -> Mat4 {
|
||||
[
|
||||
1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1., 0., 0., 0., 0., 1.,
|
||||
]
|
||||
}
|
||||
|
||||
fn mat4_mul(a: &Mat4, b: &Mat4) -> Mat4 {
|
||||
let mut out = [0f32; 16];
|
||||
for row in 0..4 {
|
||||
for col in 0..4 {
|
||||
out[col * 4 + row] = (0..4).map(|k| a[k * 4 + row] * b[col * 4 + k]).sum();
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn perspective(fov_y_rad: f32, aspect: f32, near: f32, far: f32) -> Mat4 {
|
||||
let f = 1.0 / (fov_y_rad * 0.5).tan();
|
||||
[
|
||||
f / aspect,
|
||||
0.,
|
||||
0.,
|
||||
0.,
|
||||
0.,
|
||||
-f,
|
||||
0.,
|
||||
0.,
|
||||
0.,
|
||||
0.,
|
||||
far / (near - far),
|
||||
-1.,
|
||||
0.,
|
||||
0.,
|
||||
near * far / (near - far),
|
||||
0.,
|
||||
]
|
||||
}
|
||||
|
||||
fn look_at(eye: [f32; 3], center: [f32; 3], up: [f32; 3]) -> Mat4 {
|
||||
let sub = |a: [f32; 3], b: [f32; 3]| [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
|
||||
let norm = |v: [f32; 3]| {
|
||||
let l = (v[0] * v[0] + v[1] * v[1] + v[2] * v[2]).sqrt();
|
||||
[v[0] / l, v[1] / l, v[2] / l]
|
||||
};
|
||||
let cross = |a: [f32; 3], b: [f32; 3]| {
|
||||
[
|
||||
a[1] * b[2] - a[2] * b[1],
|
||||
a[2] * b[0] - a[0] * b[2],
|
||||
a[0] * b[1] - a[1] * b[0],
|
||||
]
|
||||
};
|
||||
let dot = |a: [f32; 3], b: [f32; 3]| a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
|
||||
|
||||
let f = norm(sub(center, eye));
|
||||
let s = norm(cross(f, up));
|
||||
let u = cross(s, f);
|
||||
|
||||
let mut m = mat4_identity();
|
||||
m[0] = s[0];
|
||||
m[4] = s[1];
|
||||
m[8] = s[2];
|
||||
m[1] = u[0];
|
||||
m[5] = u[1];
|
||||
m[9] = u[2];
|
||||
m[2] = -f[0];
|
||||
m[6] = -f[1];
|
||||
m[10] = -f[2];
|
||||
m[12] = -dot(s, eye);
|
||||
m[13] = -dot(u, eye);
|
||||
m[14] = dot(f, eye);
|
||||
m
|
||||
}
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, bytemuck::Pod, bytemuck::Zeroable)]
|
||||
struct CameraUniform {
|
||||
view_proj: Mat4,
|
||||
time_pad: [f32; 4],
|
||||
}
|
||||
|
||||
struct GpuState {
|
||||
surface: wgpu::Surface<'static>,
|
||||
device: wgpu::Device,
|
||||
queue: wgpu::Queue,
|
||||
config: wgpu::SurfaceConfiguration,
|
||||
supported_present_modes: Vec<wgpu::PresentMode>,
|
||||
pipeline: wgpu::RenderPipeline,
|
||||
camera_buffer: wgpu::Buffer,
|
||||
camera_bind_group: wgpu::BindGroup,
|
||||
scene: Scene,
|
||||
workload: Workload,
|
||||
}
|
||||
|
||||
impl GpuState {
|
||||
async fn new(window: Arc<Window>) -> Result<Self> {
|
||||
let size = window.inner_size();
|
||||
let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
|
||||
backends: wgpu::Backends::VULKAN,
|
||||
flags: wgpu::InstanceFlags::empty(),
|
||||
..Default::default()
|
||||
});
|
||||
|
||||
let surface = instance.create_surface(Arc::clone(&window))?;
|
||||
let adapter = instance
|
||||
.request_adapter(&wgpu::RequestAdapterOptions {
|
||||
power_preference: wgpu::PowerPreference::HighPerformance,
|
||||
compatible_surface: Some(&surface),
|
||||
force_fallback_adapter: false,
|
||||
})
|
||||
.await
|
||||
.ok_or_else(|| anyhow::anyhow!("No suitable Vulkan adapter found"))?;
|
||||
|
||||
let (device, queue) = adapter
|
||||
.request_device(
|
||||
&wgpu::DeviceDescriptor {
|
||||
label: Some("mangotune_preview"),
|
||||
required_features: wgpu::Features::empty(),
|
||||
required_limits: wgpu::Limits::default(),
|
||||
memory_hints: wgpu::MemoryHints::default(),
|
||||
},
|
||||
None,
|
||||
)
|
||||
.await?;
|
||||
|
||||
let surface_caps = surface.get_capabilities(&adapter);
|
||||
let format = surface_caps
|
||||
.formats
|
||||
.iter()
|
||||
.find(|f| f.is_srgb())
|
||||
.copied()
|
||||
.unwrap_or(surface_caps.formats[0]);
|
||||
|
||||
let config = wgpu::SurfaceConfiguration {
|
||||
usage: wgpu::TextureUsages::RENDER_ATTACHMENT,
|
||||
format,
|
||||
width: size.width,
|
||||
height: size.height,
|
||||
present_mode: choose_present_mode(
|
||||
&surface_caps.present_modes,
|
||||
PreviewPresentMode::from_env(),
|
||||
),
|
||||
alpha_mode: surface_caps.alpha_modes[0],
|
||||
view_formats: vec![],
|
||||
desired_maximum_frame_latency: 2,
|
||||
};
|
||||
surface.configure(&device, &config);
|
||||
|
||||
let camera_buffer = device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: Some("camera_uniform"),
|
||||
size: std::mem::size_of::<CameraUniform>() as u64,
|
||||
usage: wgpu::BufferUsages::UNIFORM | wgpu::BufferUsages::COPY_DST,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
|
||||
let camera_bind_group_layout =
|
||||
device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
|
||||
label: Some("camera_bgl"),
|
||||
entries: &[wgpu::BindGroupLayoutEntry {
|
||||
binding: 0,
|
||||
visibility: wgpu::ShaderStages::VERTEX_FRAGMENT,
|
||||
ty: wgpu::BindingType::Buffer {
|
||||
ty: wgpu::BufferBindingType::Uniform,
|
||||
has_dynamic_offset: false,
|
||||
min_binding_size: None,
|
||||
},
|
||||
count: None,
|
||||
}],
|
||||
});
|
||||
|
||||
let camera_bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
|
||||
label: Some("camera_bg"),
|
||||
layout: &camera_bind_group_layout,
|
||||
entries: &[wgpu::BindGroupEntry {
|
||||
binding: 0,
|
||||
resource: camera_buffer.as_entire_binding(),
|
||||
}],
|
||||
});
|
||||
|
||||
let shader = device.create_shader_module(wgpu::ShaderModuleDescriptor {
|
||||
label: Some("particle_shader"),
|
||||
source: wgpu::ShaderSource::Wgsl(SHADER_SRC.into()),
|
||||
});
|
||||
|
||||
let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
|
||||
label: Some("pipeline_layout"),
|
||||
bind_group_layouts: &[&camera_bind_group_layout],
|
||||
push_constant_ranges: &[],
|
||||
});
|
||||
|
||||
let pipeline = device.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
||||
label: Some("particle_pipeline"),
|
||||
layout: Some(&pipeline_layout),
|
||||
vertex: wgpu::VertexState {
|
||||
module: &shader,
|
||||
entry_point: "vs_main",
|
||||
buffers: &[crate::scene::ParticleVertex::desc()],
|
||||
compilation_options: Default::default(),
|
||||
},
|
||||
fragment: Some(wgpu::FragmentState {
|
||||
module: &shader,
|
||||
entry_point: "fs_main",
|
||||
targets: &[Some(wgpu::ColorTargetState {
|
||||
format: config.format,
|
||||
blend: Some(wgpu::BlendState::ALPHA_BLENDING),
|
||||
write_mask: wgpu::ColorWrites::ALL,
|
||||
})],
|
||||
compilation_options: Default::default(),
|
||||
}),
|
||||
primitive: wgpu::PrimitiveState {
|
||||
topology: wgpu::PrimitiveTopology::TriangleList,
|
||||
..Default::default()
|
||||
},
|
||||
depth_stencil: None,
|
||||
multisample: wgpu::MultisampleState::default(),
|
||||
multiview: None,
|
||||
cache: None,
|
||||
});
|
||||
|
||||
let scene = Scene::new(&device);
|
||||
let workload = Workload::new(&device);
|
||||
|
||||
Ok(Self {
|
||||
surface,
|
||||
device,
|
||||
queue,
|
||||
config,
|
||||
supported_present_modes: surface_caps.present_modes.clone(),
|
||||
pipeline,
|
||||
camera_buffer,
|
||||
camera_bind_group,
|
||||
scene,
|
||||
workload,
|
||||
})
|
||||
}
|
||||
|
||||
fn resize(&mut self, new_size: winit::dpi::PhysicalSize<u32>) {
|
||||
if new_size.width > 0 && new_size.height > 0 {
|
||||
self.config.width = new_size.width;
|
||||
self.config.height = new_size.height;
|
||||
self.surface.configure(&self.device, &self.config);
|
||||
}
|
||||
}
|
||||
|
||||
fn apply_runtime_mode(&mut self, state: &SimState) {
|
||||
let desired = choose_present_mode(&self.supported_present_modes, state.present_mode);
|
||||
if self.config.present_mode != desired {
|
||||
self.config.present_mode = desired;
|
||||
self.surface.configure(&self.device, &self.config);
|
||||
}
|
||||
}
|
||||
|
||||
fn render(&mut self, state: &SimState) -> Result<(), wgpu::SurfaceError> {
|
||||
self.apply_runtime_mode(state);
|
||||
let aspect = self.config.width as f32 / self.config.height as f32;
|
||||
let t = self.scene.time;
|
||||
let eye = match state.scene_preset {
|
||||
PreviewScenePreset::DarkArena => [t.cos() * 5.8, 1.8, t.sin() * 5.8],
|
||||
PreviewScenePreset::BrightWash => [t.cos() * 4.6, 1.6, t.sin() * 4.6],
|
||||
PreviewScenePreset::MotionStress => [
|
||||
(t * 0.95).cos() * 6.8,
|
||||
2.2 + (t * 0.7).sin() * 0.8,
|
||||
(t * 0.95).sin() * 6.8,
|
||||
],
|
||||
PreviewScenePreset::StaticInspection => [0.0, 2.4, 7.2],
|
||||
PreviewScenePreset::NoiseField => [
|
||||
(t * 0.45).cos() * 6.2,
|
||||
1.0 + (t * 0.25).sin() * 0.5,
|
||||
(t * 0.6).sin() * 6.2,
|
||||
],
|
||||
};
|
||||
let view = look_at(eye, [0.0, 0.0, 0.0], [0.0, 1.0, 0.0]);
|
||||
let proj = perspective(std::f32::consts::FRAC_PI_4, aspect, 0.1, 100.0);
|
||||
let view_proj = mat4_mul(&proj, &view);
|
||||
self.queue.write_buffer(
|
||||
&self.camera_buffer,
|
||||
0,
|
||||
bytemuck::bytes_of(&CameraUniform {
|
||||
view_proj,
|
||||
time_pad: [self.scene.time, 0.0, 0.0, 0.0],
|
||||
}),
|
||||
);
|
||||
|
||||
let output = self.surface.get_current_texture()?;
|
||||
let view = output.texture.create_view(&Default::default());
|
||||
|
||||
let clear = match state.scene_preset {
|
||||
PreviewScenePreset::DarkArena => wgpu::Color {
|
||||
r: 0.03,
|
||||
g: 0.04,
|
||||
b: 0.09,
|
||||
a: 1.0,
|
||||
},
|
||||
PreviewScenePreset::BrightWash => wgpu::Color {
|
||||
r: 0.78,
|
||||
g: 0.82,
|
||||
b: 0.82,
|
||||
a: 1.0,
|
||||
},
|
||||
PreviewScenePreset::MotionStress => wgpu::Color {
|
||||
r: 0.08,
|
||||
g: 0.05,
|
||||
b: 0.11,
|
||||
a: 1.0,
|
||||
},
|
||||
PreviewScenePreset::StaticInspection => wgpu::Color {
|
||||
r: 0.10,
|
||||
g: 0.11,
|
||||
b: 0.14,
|
||||
a: 1.0,
|
||||
},
|
||||
PreviewScenePreset::NoiseField => wgpu::Color {
|
||||
r: 0.04,
|
||||
g: 0.08,
|
||||
b: 0.09,
|
||||
a: 1.0,
|
||||
},
|
||||
};
|
||||
|
||||
for pass_index in 0..state.gpu_passes {
|
||||
let mut encoder = self
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor {
|
||||
label: Some("frame_pass"),
|
||||
});
|
||||
|
||||
{
|
||||
let load_op = if pass_index == 0 {
|
||||
wgpu::LoadOp::Clear(clear)
|
||||
} else {
|
||||
wgpu::LoadOp::Load
|
||||
};
|
||||
|
||||
let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: Some("particle_pass"),
|
||||
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
||||
view: &view,
|
||||
resolve_target: None,
|
||||
ops: wgpu::Operations {
|
||||
load: load_op,
|
||||
store: wgpu::StoreOp::Store,
|
||||
},
|
||||
})],
|
||||
depth_stencil_attachment: None,
|
||||
timestamp_writes: None,
|
||||
occlusion_query_set: None,
|
||||
});
|
||||
rpass.set_pipeline(&self.pipeline);
|
||||
rpass.set_bind_group(0, &self.camera_bind_group, &[]);
|
||||
rpass.set_vertex_buffer(0, self.scene.vertex_buffer.slice(..));
|
||||
rpass.draw(0..self.scene.vertex_count(), 0..1);
|
||||
}
|
||||
|
||||
self.queue.submit(std::iter::once(encoder.finish()));
|
||||
}
|
||||
output.present();
|
||||
self.workload.update(&self.device, state);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
|
||||
fn choose_present_mode(
|
||||
supported: &[wgpu::PresentMode],
|
||||
requested: PreviewPresentMode,
|
||||
) -> wgpu::PresentMode {
|
||||
match requested {
|
||||
PreviewPresentMode::Fifo => supported
|
||||
.iter()
|
||||
.copied()
|
||||
.find(|mode| *mode == wgpu::PresentMode::Fifo)
|
||||
.unwrap_or(wgpu::PresentMode::Fifo),
|
||||
PreviewPresentMode::Immediate => supported
|
||||
.iter()
|
||||
.copied()
|
||||
.find(|mode| {
|
||||
matches!(
|
||||
mode,
|
||||
wgpu::PresentMode::Immediate
|
||||
| wgpu::PresentMode::Mailbox
|
||||
| wgpu::PresentMode::AutoNoVsync
|
||||
)
|
||||
})
|
||||
.unwrap_or(wgpu::PresentMode::Fifo),
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(deprecated)]
|
||||
pub fn run(state: Arc<Mutex<SimState>>) -> Result<()> {
|
||||
let event_loop = EventLoop::new()?;
|
||||
event_loop.set_control_flow(ControlFlow::Poll);
|
||||
|
||||
let width = std::env::var("MANGOTUNE_PREVIEW_WIDTH")
|
||||
.ok()
|
||||
.and_then(|value| value.parse::<u32>().ok())
|
||||
.unwrap_or(800);
|
||||
let height = std::env::var("MANGOTUNE_PREVIEW_HEIGHT")
|
||||
.ok()
|
||||
.and_then(|value| value.parse::<u32>().ok())
|
||||
.unwrap_or(600);
|
||||
|
||||
let window = Arc::new(
|
||||
event_loop.create_window(
|
||||
Window::default_attributes()
|
||||
.with_title("MangoTune Preview")
|
||||
.with_inner_size(LogicalSize::new(width, height)),
|
||||
)?,
|
||||
);
|
||||
|
||||
let mut gpu = pollster::block_on(GpuState::new(Arc::clone(&window)))?;
|
||||
let mut last_frame = Instant::now();
|
||||
|
||||
event_loop.run(move |event, elwt| {
|
||||
{
|
||||
let sim = state.lock().expect("preview state");
|
||||
if sim.should_quit {
|
||||
elwt.exit();
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
match event {
|
||||
Event::WindowEvent {
|
||||
event: WindowEvent::CloseRequested,
|
||||
..
|
||||
} => {
|
||||
elwt.exit();
|
||||
}
|
||||
Event::WindowEvent {
|
||||
event: WindowEvent::Resized(size),
|
||||
..
|
||||
} => {
|
||||
gpu.resize(size);
|
||||
}
|
||||
Event::AboutToWait => {
|
||||
let now = Instant::now();
|
||||
let dt = now.duration_since(last_frame).as_secs_f32().min(0.05);
|
||||
last_frame = now;
|
||||
|
||||
let sim = state.lock().expect("preview state").clone();
|
||||
|
||||
gpu.scene.update(dt, sim.particle_size, &sim, &gpu.queue);
|
||||
match gpu.render(&sim) {
|
||||
Ok(_) => {}
|
||||
Err(wgpu::SurfaceError::Lost | wgpu::SurfaceError::Outdated) => {
|
||||
gpu.resize(window.inner_size());
|
||||
}
|
||||
Err(wgpu::SurfaceError::OutOfMemory) => elwt.exit(),
|
||||
Err(err) => log::warn!("Surface error: {}", err),
|
||||
}
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
})?;
|
||||
|
||||
let _ = std::fs::remove_file(crate::socket_api::socket_path());
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,360 @@
|
||||
use crate::SimState;
|
||||
use rayon::prelude::*;
|
||||
|
||||
#[repr(C)]
|
||||
#[derive(Copy, Clone, Debug, bytemuck::Pod, bytemuck::Zeroable)]
|
||||
pub struct ParticleVertex {
|
||||
pub position: [f32; 3],
|
||||
pub color: [f32; 4],
|
||||
pub uv: [f32; 2],
|
||||
}
|
||||
|
||||
impl ParticleVertex {
|
||||
pub fn desc() -> wgpu::VertexBufferLayout<'static> {
|
||||
wgpu::VertexBufferLayout {
|
||||
array_stride: std::mem::size_of::<ParticleVertex>() as wgpu::BufferAddress,
|
||||
step_mode: wgpu::VertexStepMode::Vertex,
|
||||
attributes: &[
|
||||
wgpu::VertexAttribute {
|
||||
offset: 0,
|
||||
shader_location: 0,
|
||||
format: wgpu::VertexFormat::Float32x3,
|
||||
},
|
||||
wgpu::VertexAttribute {
|
||||
offset: std::mem::size_of::<[f32; 3]>() as wgpu::BufferAddress,
|
||||
shader_location: 1,
|
||||
format: wgpu::VertexFormat::Float32x4,
|
||||
},
|
||||
wgpu::VertexAttribute {
|
||||
offset: (std::mem::size_of::<[f32; 3]>() + std::mem::size_of::<[f32; 4]>())
|
||||
as wgpu::BufferAddress,
|
||||
shader_location: 2,
|
||||
format: wgpu::VertexFormat::Float32x2,
|
||||
},
|
||||
],
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
struct Particle {
|
||||
pos: [f32; 3],
|
||||
vel: [f32; 3],
|
||||
phase: f32,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy)]
|
||||
struct SceneProfile {
|
||||
target_radius_base: f32,
|
||||
target_pulse: f32,
|
||||
shell_strength: f32,
|
||||
swirl: f32,
|
||||
z_wave: f32,
|
||||
outer_limit: f32,
|
||||
}
|
||||
|
||||
impl Particle {
|
||||
fn random(r: f32, seed: u64) -> Self {
|
||||
let rng = Lcg::new(seed);
|
||||
let (x, y, z) = rng.point_in_sphere(r);
|
||||
Self {
|
||||
pos: [x, y, z],
|
||||
vel: [
|
||||
rng.range(-0.2, 0.2),
|
||||
rng.range(-0.2, 0.2),
|
||||
rng.range(-0.2, 0.2),
|
||||
],
|
||||
phase: rng.range(0.0, std::f32::consts::TAU),
|
||||
}
|
||||
}
|
||||
|
||||
fn update_with_profile(
|
||||
&mut self,
|
||||
dt: f32,
|
||||
time: f32,
|
||||
interaction_steps: u32,
|
||||
profile: SceneProfile,
|
||||
) {
|
||||
let radius =
|
||||
(self.pos[0] * self.pos[0] + self.pos[1] * self.pos[1] + self.pos[2] * self.pos[2])
|
||||
.sqrt()
|
||||
.max(0.001);
|
||||
let target_radius =
|
||||
profile.target_radius_base + profile.target_pulse * (self.phase + time * 0.15).sin();
|
||||
let shell_force = (target_radius - radius) * profile.shell_strength;
|
||||
let ax = (self.pos[0] / radius) * shell_force;
|
||||
let ay = (self.pos[1] / radius) * shell_force;
|
||||
let az = (self.pos[2] / radius) * shell_force;
|
||||
|
||||
let sx = -self.pos[1] * profile.swirl;
|
||||
let sy = self.pos[0] * profile.swirl;
|
||||
let sz = (time * 0.35 + self.phase).sin() * profile.z_wave;
|
||||
|
||||
self.vel[0] += (ax + sx) * dt;
|
||||
self.vel[1] += (ay + sy) * dt;
|
||||
self.vel[2] += (az + sz) * dt;
|
||||
|
||||
let damp = 0.98f32.powf(dt * 60.0);
|
||||
self.vel[0] *= damp;
|
||||
self.vel[1] *= damp;
|
||||
self.vel[2] *= damp;
|
||||
|
||||
self.pos[0] += self.vel[0] * dt;
|
||||
self.pos[1] += self.vel[1] * dt;
|
||||
self.pos[2] += self.vel[2] * dt;
|
||||
|
||||
let radius_after =
|
||||
(self.pos[0] * self.pos[0] + self.pos[1] * self.pos[1] + self.pos[2] * self.pos[2])
|
||||
.sqrt();
|
||||
if !(0.6..=profile.outer_limit).contains(&radius_after) {
|
||||
let dir_x = self.pos[0] / radius_after.max(0.001);
|
||||
let dir_y = self.pos[1] / radius_after.max(0.001);
|
||||
let dir_z = self.pos[2] / radius_after.max(0.001);
|
||||
let reset_radius = profile.target_radius_base + 0.4 * self.phase.sin();
|
||||
self.pos[0] = dir_x * reset_radius;
|
||||
self.pos[1] = dir_y * reset_radius;
|
||||
self.pos[2] = dir_z * reset_radius;
|
||||
self.vel = [0.0, 0.0, 0.0];
|
||||
}
|
||||
|
||||
for k in 0..interaction_steps {
|
||||
let hash_input =
|
||||
(self.pos[0] * 73.1 + self.pos[1] * 157.3 + self.pos[2] * 43.7 + k as f32)
|
||||
.to_bits();
|
||||
let hashed = hash_input.wrapping_mul(2654435761).wrapping_add(k);
|
||||
let neighbour_x = (hashed as f32 / u32::MAX as f32) * 2.0 - 1.0;
|
||||
let neighbour_y = ((hashed.wrapping_mul(1664525)) as f32 / u32::MAX as f32) * 2.0 - 1.0;
|
||||
let neighbour_z =
|
||||
((hashed.wrapping_mul(22695477)) as f32 / u32::MAX as f32) * 2.0 - 1.0;
|
||||
let dx = neighbour_x - self.pos[0];
|
||||
let dy = neighbour_y - self.pos[1];
|
||||
let dz = neighbour_z - self.pos[2];
|
||||
let dist = (dx * dx + dy * dy + dz * dz).sqrt().max(0.01);
|
||||
self.vel[0] += (dx / dist) * 0.0001;
|
||||
self.vel[1] += (dy / dist) * 0.0001;
|
||||
self.vel[2] += (dz / dist) * 0.0001;
|
||||
}
|
||||
}
|
||||
|
||||
fn to_vertices(&self, size: f32, time: f32) -> [ParticleVertex; 6] {
|
||||
let hue = (time * 0.2 + self.phase) % std::f32::consts::TAU;
|
||||
let color = hsv_to_rgb(hue / std::f32::consts::TAU, 0.8, 1.0);
|
||||
|
||||
let h = size * 0.5;
|
||||
let corners = [
|
||||
([-h, -h], [-1.0, -1.0]),
|
||||
([h, -h], [1.0, -1.0]),
|
||||
([h, h], [1.0, 1.0]),
|
||||
([-h, -h], [-1.0, -1.0]),
|
||||
([h, h], [1.0, 1.0]),
|
||||
([-h, h], [-1.0, 1.0]),
|
||||
];
|
||||
|
||||
let mut verts = [ParticleVertex {
|
||||
position: [0.0; 3],
|
||||
color,
|
||||
uv: [0.0; 2],
|
||||
}; 6];
|
||||
for (i, ([cx, cy], uv)) in corners.iter().enumerate() {
|
||||
verts[i].position = [self.pos[0] + cx, self.pos[1] + cy, self.pos[2]];
|
||||
verts[i].uv = *uv;
|
||||
}
|
||||
verts
|
||||
}
|
||||
}
|
||||
|
||||
const MAX_PARTICLES: usize = 500_000;
|
||||
|
||||
pub struct Scene {
|
||||
particles: Vec<Particle>,
|
||||
vertex_data: Vec<ParticleVertex>,
|
||||
pub vertex_buffer: wgpu::Buffer,
|
||||
pub time: f32,
|
||||
}
|
||||
|
||||
impl Scene {
|
||||
pub fn new(device: &wgpu::Device) -> Self {
|
||||
let initial_count = 50_000usize;
|
||||
let particles: Vec<Particle> = (0..initial_count)
|
||||
.map(|i| {
|
||||
Particle::random(
|
||||
3.0,
|
||||
(i as u64).wrapping_mul(6364136223846793005).wrapping_add(1),
|
||||
)
|
||||
})
|
||||
.collect();
|
||||
|
||||
let vertex_data = vec![
|
||||
ParticleVertex {
|
||||
position: [0.0; 3],
|
||||
color: [0.0; 4],
|
||||
uv: [0.0; 2],
|
||||
};
|
||||
MAX_PARTICLES * 6
|
||||
];
|
||||
|
||||
let vertex_buffer = device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: Some("particle_vertices"),
|
||||
size: (MAX_PARTICLES * 6 * std::mem::size_of::<ParticleVertex>()) as u64,
|
||||
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
|
||||
mapped_at_creation: false,
|
||||
});
|
||||
|
||||
Self {
|
||||
particles,
|
||||
vertex_data,
|
||||
vertex_buffer,
|
||||
time: 0.0,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn update(&mut self, dt: f32, particle_size: f32, state: &SimState, queue: &wgpu::Queue) {
|
||||
if state.paused {
|
||||
return;
|
||||
}
|
||||
|
||||
self.time += dt;
|
||||
let target = (state.particle_count as usize).min(MAX_PARTICLES);
|
||||
|
||||
while self.particles.len() < target {
|
||||
let seed = (self.particles.len() as u64)
|
||||
.wrapping_mul(6364136223846793005)
|
||||
.wrapping_add(1);
|
||||
self.particles.push(Particle::random(3.0, seed));
|
||||
}
|
||||
self.particles.truncate(target);
|
||||
|
||||
let t = self.time;
|
||||
let scene_steps_bonus = match state.scene_preset {
|
||||
crate::PreviewScenePreset::DarkArena => 0,
|
||||
crate::PreviewScenePreset::BrightWash => 0,
|
||||
crate::PreviewScenePreset::MotionStress => 4,
|
||||
crate::PreviewScenePreset::StaticInspection => 0,
|
||||
crate::PreviewScenePreset::NoiseField => 2,
|
||||
};
|
||||
let steps = (state.interaction_steps + scene_steps_bonus).min(256);
|
||||
let profile = match state.scene_preset {
|
||||
crate::PreviewScenePreset::DarkArena => SceneProfile {
|
||||
target_radius_base: 2.2,
|
||||
target_pulse: 0.25,
|
||||
shell_strength: 0.40,
|
||||
swirl: 0.35,
|
||||
z_wave: 0.08,
|
||||
outer_limit: 4.0,
|
||||
},
|
||||
crate::PreviewScenePreset::BrightWash => SceneProfile {
|
||||
target_radius_base: 2.0,
|
||||
target_pulse: 0.18,
|
||||
shell_strength: 0.34,
|
||||
swirl: 0.22,
|
||||
z_wave: 0.06,
|
||||
outer_limit: 3.8,
|
||||
},
|
||||
crate::PreviewScenePreset::MotionStress => SceneProfile {
|
||||
target_radius_base: 2.6,
|
||||
target_pulse: 0.60,
|
||||
shell_strength: 0.65,
|
||||
swirl: 1.15,
|
||||
z_wave: 0.32,
|
||||
outer_limit: 4.8,
|
||||
},
|
||||
crate::PreviewScenePreset::StaticInspection => SceneProfile {
|
||||
target_radius_base: 1.9,
|
||||
target_pulse: 0.06,
|
||||
shell_strength: 0.55,
|
||||
swirl: 0.05,
|
||||
z_wave: 0.02,
|
||||
outer_limit: 3.4,
|
||||
},
|
||||
crate::PreviewScenePreset::NoiseField => SceneProfile {
|
||||
target_radius_base: 3.0,
|
||||
target_pulse: 0.45,
|
||||
shell_strength: 0.28,
|
||||
swirl: 0.65,
|
||||
z_wave: 0.16,
|
||||
outer_limit: 5.0,
|
||||
},
|
||||
};
|
||||
self.particles.par_iter_mut().for_each(|p| {
|
||||
p.update_with_profile(dt, t, steps, profile);
|
||||
});
|
||||
let mut vi = 0;
|
||||
for p in &self.particles {
|
||||
let verts = p.to_vertices(particle_size, t);
|
||||
for v in &verts {
|
||||
self.vertex_data[vi] = *v;
|
||||
vi += 1;
|
||||
}
|
||||
}
|
||||
|
||||
let live_bytes = vi * std::mem::size_of::<ParticleVertex>();
|
||||
if live_bytes > 0 {
|
||||
queue.write_buffer(
|
||||
&self.vertex_buffer,
|
||||
0,
|
||||
bytemuck::cast_slice(&self.vertex_data[..vi]),
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
pub fn vertex_count(&self) -> u32 {
|
||||
(self.particles.len() * 6) as u32
|
||||
}
|
||||
}
|
||||
|
||||
fn hsv_to_rgb(h: f32, s: f32, v: f32) -> [f32; 4] {
|
||||
let i = (h * 6.0).floor() as i32;
|
||||
let f = h * 6.0 - i as f32;
|
||||
let p = v * (1.0 - s);
|
||||
let q = v * (1.0 - f * s);
|
||||
let t = v * (1.0 - (1.0 - f) * s);
|
||||
let (r, g, b) = match i % 6 {
|
||||
0 => (v, t, p),
|
||||
1 => (q, v, p),
|
||||
2 => (p, v, t),
|
||||
3 => (p, q, v),
|
||||
4 => (t, p, v),
|
||||
_ => (v, p, q),
|
||||
};
|
||||
[r, g, b, 1.0]
|
||||
}
|
||||
|
||||
struct Lcg {
|
||||
state: std::cell::Cell<u64>,
|
||||
}
|
||||
|
||||
impl Lcg {
|
||||
fn new(seed: u64) -> Self {
|
||||
Self {
|
||||
state: std::cell::Cell::new(seed),
|
||||
}
|
||||
}
|
||||
|
||||
fn next_u32(&self) -> u32 {
|
||||
let next = self
|
||||
.state
|
||||
.get()
|
||||
.wrapping_mul(6364136223846793005)
|
||||
.wrapping_add(1);
|
||||
self.state.set(next);
|
||||
(next >> 32) as u32
|
||||
}
|
||||
|
||||
fn next_f32(&self) -> f32 {
|
||||
self.next_u32() as f32 / u32::MAX as f32
|
||||
}
|
||||
|
||||
fn range(&self, min: f32, max: f32) -> f32 {
|
||||
min + (max - min) * self.next_f32()
|
||||
}
|
||||
|
||||
fn point_in_sphere(&self, radius: f32) -> (f32, f32, f32) {
|
||||
loop {
|
||||
let x = self.range(-radius, radius);
|
||||
let y = self.range(-radius, radius);
|
||||
let z = self.range(-radius, radius);
|
||||
if x * x + y * y + z * z <= radius * radius {
|
||||
return (x, y, z);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,193 @@
|
||||
use crate::SimState;
|
||||
use anyhow::Result;
|
||||
use serde::{Deserialize, Serialize};
|
||||
use std::sync::{Arc, Mutex};
|
||||
use tokio::io::{AsyncBufReadExt, AsyncWriteExt, BufReader};
|
||||
use tokio::net::UnixListener;
|
||||
|
||||
pub fn socket_path() -> String {
|
||||
std::env::var("MANGOTUNE_SOCKET").unwrap_or_else(|_| "/tmp/mangotune_preview.sock".into())
|
||||
}
|
||||
|
||||
#[derive(Debug, Deserialize)]
|
||||
#[serde(tag = "cmd", rename_all = "snake_case")]
|
||||
enum Command {
|
||||
SetScene { scene: String },
|
||||
SetLoad { gpu_percent: f32 },
|
||||
SetFpsCap { fps: u32 },
|
||||
SetVsync { enabled: bool },
|
||||
SetVramPressure { mb: u32 },
|
||||
SetParticleCount { count: u32 },
|
||||
SetParticleSize { size: f32 },
|
||||
SetGpuPasses { passes: u32 },
|
||||
SetInteractionSteps { steps: u32 },
|
||||
Pause,
|
||||
Resume,
|
||||
GetState,
|
||||
Quit,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
struct StateSnapshot {
|
||||
gpu_load_target: f32,
|
||||
fps_cap: u32,
|
||||
vsync_enabled: bool,
|
||||
vram_pressure_mb: u32,
|
||||
particle_count: u32,
|
||||
particle_size: f32,
|
||||
gpu_passes: u32,
|
||||
interaction_steps: u32,
|
||||
paused: bool,
|
||||
}
|
||||
|
||||
#[derive(Debug, Serialize)]
|
||||
#[serde(untagged)]
|
||||
enum Response {
|
||||
Ok { ok: bool },
|
||||
OkWithState { ok: bool, state: StateSnapshot },
|
||||
Err { ok: bool, error: String },
|
||||
}
|
||||
|
||||
impl Response {
|
||||
fn ok() -> Self {
|
||||
Response::Ok { ok: true }
|
||||
}
|
||||
fn err(msg: impl Into<String>) -> Self {
|
||||
Response::Err {
|
||||
ok: false,
|
||||
error: msg.into(),
|
||||
}
|
||||
}
|
||||
fn with_state(state: StateSnapshot) -> Self {
|
||||
Response::OkWithState { ok: true, state }
|
||||
}
|
||||
}
|
||||
|
||||
pub async fn run(state: Arc<Mutex<SimState>>) -> Result<()> {
|
||||
let path = socket_path();
|
||||
let _ = tokio::fs::remove_file(&path).await;
|
||||
|
||||
let listener = UnixListener::bind(&path)?;
|
||||
log::info!("Socket API listening on {}", path);
|
||||
|
||||
loop {
|
||||
match listener.accept().await {
|
||||
Ok((stream, _addr)) => {
|
||||
let state = Arc::clone(&state);
|
||||
tokio::spawn(async move {
|
||||
if let Err(err) = handle_connection(stream, state).await {
|
||||
log::warn!("Socket connection error: {}", err);
|
||||
}
|
||||
});
|
||||
}
|
||||
Err(err) => {
|
||||
log::error!("Socket accept error: {}", err);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
async fn handle_connection(
|
||||
stream: tokio::net::UnixStream,
|
||||
state: Arc<Mutex<SimState>>,
|
||||
) -> Result<()> {
|
||||
let (read_half, mut write_half) = stream.into_split();
|
||||
let reader = BufReader::new(read_half);
|
||||
let mut lines = reader.lines();
|
||||
|
||||
while let Some(line) = lines.next_line().await? {
|
||||
let line = line.trim().to_string();
|
||||
if line.is_empty() {
|
||||
continue;
|
||||
}
|
||||
|
||||
let response = match serde_json::from_str::<Command>(&line) {
|
||||
Ok(cmd) => dispatch(cmd, &state),
|
||||
Err(err) => Response::err(format!("parse error: {}", err)),
|
||||
};
|
||||
|
||||
let mut bytes = serde_json::to_vec(&response)?;
|
||||
bytes.push(b'\n');
|
||||
write_half.write_all(&bytes).await?;
|
||||
}
|
||||
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn dispatch(cmd: Command, state: &Arc<Mutex<SimState>>) -> Response {
|
||||
let mut sim = match state.lock() {
|
||||
Ok(guard) => guard,
|
||||
Err(_) => return Response::err("state lock poisoned"),
|
||||
};
|
||||
|
||||
match cmd {
|
||||
Command::SetScene { scene } => match crate::PreviewScenePreset::from_label(&scene) {
|
||||
Some(preset) => {
|
||||
sim.scene_preset = preset;
|
||||
Response::ok()
|
||||
}
|
||||
None => Response::err(format!("unknown scene: {scene}")),
|
||||
},
|
||||
Command::SetLoad { gpu_percent } => {
|
||||
sim.gpu_load_target = (gpu_percent / 100.0).clamp(0.0, 1.0);
|
||||
Response::ok()
|
||||
}
|
||||
Command::SetFpsCap { fps } => {
|
||||
sim.fps_cap = fps;
|
||||
Response::ok()
|
||||
}
|
||||
Command::SetVsync { enabled } => {
|
||||
sim.present_mode = if enabled {
|
||||
crate::PreviewPresentMode::Fifo
|
||||
} else {
|
||||
crate::PreviewPresentMode::Immediate
|
||||
};
|
||||
Response::ok()
|
||||
}
|
||||
Command::SetVramPressure { mb } => {
|
||||
sim.vram_pressure_mb = mb;
|
||||
Response::ok()
|
||||
}
|
||||
Command::SetParticleCount { count } => {
|
||||
sim.particle_count = count.clamp(100, 500_000);
|
||||
Response::ok()
|
||||
}
|
||||
Command::SetParticleSize { size } => {
|
||||
sim.particle_size = size.clamp(0.01, 5.0);
|
||||
log::info!("Particle size -> {:.2}", sim.particle_size);
|
||||
Response::ok()
|
||||
}
|
||||
Command::SetGpuPasses { passes } => {
|
||||
sim.gpu_passes = passes.clamp(1, 64);
|
||||
log::info!("GPU passes -> {}", sim.gpu_passes);
|
||||
Response::ok()
|
||||
}
|
||||
Command::SetInteractionSteps { steps } => {
|
||||
sim.interaction_steps = steps.clamp(0, 256);
|
||||
Response::ok()
|
||||
}
|
||||
Command::Pause => {
|
||||
sim.paused = true;
|
||||
Response::ok()
|
||||
}
|
||||
Command::Resume => {
|
||||
sim.paused = false;
|
||||
Response::ok()
|
||||
}
|
||||
Command::GetState => Response::with_state(StateSnapshot {
|
||||
gpu_load_target: sim.gpu_load_target,
|
||||
fps_cap: sim.fps_cap,
|
||||
vsync_enabled: sim.present_mode == crate::PreviewPresentMode::Fifo,
|
||||
vram_pressure_mb: sim.vram_pressure_mb,
|
||||
particle_count: sim.particle_count,
|
||||
particle_size: sim.particle_size,
|
||||
gpu_passes: sim.gpu_passes,
|
||||
interaction_steps: sim.interaction_steps,
|
||||
paused: sim.paused,
|
||||
}),
|
||||
Command::Quit => {
|
||||
sim.should_quit = true;
|
||||
Response::ok()
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,101 @@
|
||||
use crate::SimState;
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
struct PressureBuffer {
|
||||
#[allow(dead_code)]
|
||||
buffer: wgpu::Buffer,
|
||||
size_bytes: u64,
|
||||
}
|
||||
|
||||
pub struct Workload {
|
||||
pressure_buffers: Vec<PressureBuffer>,
|
||||
current_vram_bytes: u64,
|
||||
last_frame: Instant,
|
||||
}
|
||||
|
||||
const CHUNK_SIZE_MB: u64 = 16;
|
||||
const CHUNK_SIZE_BYTES: u64 = CHUNK_SIZE_MB * 1024 * 1024;
|
||||
const MAX_ADD_CHUNKS_PER_FRAME: usize = 8;
|
||||
const MAX_REMOVE_CHUNKS_PER_FRAME: usize = 32;
|
||||
|
||||
impl Workload {
|
||||
pub fn new(_device: &wgpu::Device) -> Self {
|
||||
Self {
|
||||
pressure_buffers: Vec::new(),
|
||||
current_vram_bytes: 0,
|
||||
last_frame: Instant::now(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn update(&mut self, device: &wgpu::Device, state: &SimState) {
|
||||
self.adjust_vram_pressure(device, state.vram_pressure_mb);
|
||||
self.enforce_fps_cap(state.fps_cap);
|
||||
}
|
||||
|
||||
fn adjust_vram_pressure(&mut self, device: &wgpu::Device, target_mb: u32) {
|
||||
let target_bytes = target_mb as u64 * 1024 * 1024;
|
||||
|
||||
let mut added = 0;
|
||||
while added < MAX_ADD_CHUNKS_PER_FRAME
|
||||
&& self.current_vram_bytes + CHUNK_SIZE_BYTES <= target_bytes
|
||||
{
|
||||
self.add_chunk(device);
|
||||
added += 1;
|
||||
}
|
||||
|
||||
let mut removed = 0;
|
||||
while removed < MAX_REMOVE_CHUNKS_PER_FRAME && self.current_vram_bytes > target_bytes {
|
||||
if let Some(chunk) = self.pressure_buffers.pop() {
|
||||
self.current_vram_bytes -= chunk.size_bytes;
|
||||
removed += 1;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn add_chunk(&mut self, device: &wgpu::Device) {
|
||||
let buffer = device.create_buffer(&wgpu::BufferDescriptor {
|
||||
label: Some("vram_pressure"),
|
||||
size: CHUNK_SIZE_BYTES,
|
||||
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
|
||||
mapped_at_creation: true,
|
||||
});
|
||||
|
||||
{
|
||||
let mut mapped = buffer.slice(..).get_mapped_range_mut();
|
||||
for byte in mapped.iter_mut() {
|
||||
*byte = 0xA5;
|
||||
}
|
||||
}
|
||||
buffer.unmap();
|
||||
|
||||
self.pressure_buffers.push(PressureBuffer {
|
||||
buffer,
|
||||
size_bytes: CHUNK_SIZE_BYTES,
|
||||
});
|
||||
self.current_vram_bytes += CHUNK_SIZE_BYTES;
|
||||
}
|
||||
|
||||
fn enforce_fps_cap(&mut self, fps_cap: u32) {
|
||||
if fps_cap == 0 {
|
||||
self.last_frame = Instant::now();
|
||||
return;
|
||||
}
|
||||
|
||||
let frame_budget = Duration::from_secs_f64(1.0 / fps_cap as f64);
|
||||
let elapsed = self.last_frame.elapsed();
|
||||
|
||||
if elapsed < frame_budget {
|
||||
let remaining = frame_budget - elapsed;
|
||||
if fps_cap <= 10 && remaining > Duration::from_millis(2) {
|
||||
std::thread::sleep(remaining - Duration::from_millis(1));
|
||||
}
|
||||
while self.last_frame.elapsed() < frame_budget {
|
||||
std::hint::spin_loop();
|
||||
}
|
||||
}
|
||||
|
||||
self.last_frame = Instant::now();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,47 @@
|
||||
use mangotune::config::parser::Parser;
|
||||
use mangotune::preview::{PreviewController, PreviewScene, PreviewStudioOptions, StudioScene};
|
||||
use std::path::PathBuf;
|
||||
use std::thread;
|
||||
use std::time::Duration;
|
||||
|
||||
fn main() -> anyhow::Result<()> {
|
||||
let mut args = std::env::args().skip(1);
|
||||
let profile = args
|
||||
.next()
|
||||
.map(PathBuf::from)
|
||||
.expect("usage: preview_probe <profile> [studio-scene] [width] [height] [seconds]");
|
||||
let studio_scene = args
|
||||
.next()
|
||||
.as_deref()
|
||||
.and_then(StudioScene::from_label)
|
||||
.unwrap_or(StudioScene::BrightWash);
|
||||
let width = args
|
||||
.next()
|
||||
.and_then(|v| v.parse::<i32>().ok())
|
||||
.unwrap_or(1400);
|
||||
let height = args
|
||||
.next()
|
||||
.and_then(|v| v.parse::<i32>().ok())
|
||||
.unwrap_or(760);
|
||||
let seconds = args.next().and_then(|v| v.parse::<u64>().ok()).unwrap_or(8);
|
||||
|
||||
let config = Parser::read(&profile)?;
|
||||
let controller = PreviewController::new();
|
||||
let studio = PreviewStudioOptions {
|
||||
scene: studio_scene,
|
||||
fps_cap: Some(500),
|
||||
vsync: false,
|
||||
vram_pressure_mb: 64,
|
||||
particle_count: 20_000,
|
||||
particle_size: 0.25,
|
||||
gpu_passes: 2,
|
||||
interaction_steps: 8,
|
||||
paused: false,
|
||||
};
|
||||
|
||||
let pid = controller.start(PreviewScene::Studio, &config, width, height, false, studio)?;
|
||||
eprintln!("preview pid={pid} profile={}", profile.display());
|
||||
thread::sleep(Duration::from_secs(seconds));
|
||||
let _ = controller.stop();
|
||||
Ok(())
|
||||
}
|
||||
Reference in New Issue
Block a user