Sanae6/touhou-reimpl
1
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

starting on enemies

Browse source
This commit is contained in:
Aubrey 2024-11-03 14:23:47 -06:00
parent be77983922
commit eee2951a8a
No known key found for this signature in database
31 changed files with 1171 additions and 630 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

92
Cargo.lock generated
View file

@ -586,7 +586,9 @@ dependencies = [
"async-std", "async-std",
"bytemuck", "bytemuck",
"crossbeam", "crossbeam",
"csv",
"env_logger", "env_logger",
"futures",
"glam", "glam",
"identconv", "identconv",
"log", "log",
@ -600,6 +602,7 @@ dependencies = [
"paste", "paste",
"rand", "rand",
"rodio", "rodio",
"serde",
"sfsm", "sfsm",
"truth", "truth",
"wgpu", "wgpu",
@ -874,6 +877,27 @@ version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7" checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
[[package]]
name = "csv"
version = "1.3.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "ac574ff4d437a7b5ad237ef331c17ccca63c46479e5b5453eb8e10bb99a759fe"
dependencies = [
"csv-core",
"itoa",
"ryu",
"serde",
]
[[package]]
name = "csv-core"
version = "0.1.11"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "5efa2b3d7902f4b634a20cae3c9c4e6209dc4779feb6863329607560143efa70"
dependencies = [
"memchr",
]
[[package]] [[package]]
name = "cursor-icon" name = "cursor-icon"
version = "1.1.0" version = "1.1.0"
@ -1126,6 +1150,21 @@ version = "0.3.1"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b" checksum = "aa9a19cbb55df58761df49b23516a86d432839add4af60fc256da840f66ed35b"
[[package]]
name = "futures"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "65bc07b1a8bc7c85c5f2e110c476c7389b4554ba72af57d8445ea63a576b0876"
dependencies = [
"futures-channel",
"futures-core",
"futures-executor",
"futures-io",
"futures-sink",
"futures-task",
"futures-util",
]
[[package]] [[package]]
name = "futures-channel" name = "futures-channel"
version = "0.3.31" version = "0.3.31"
@ -1133,6 +1172,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10" checksum = "2dff15bf788c671c1934e366d07e30c1814a8ef514e1af724a602e8a2fbe1b10"
dependencies = [ dependencies = [
"futures-core", "futures-core",
"futures-sink",
] ]
[[package]] [[package]]
@ -1141,6 +1181,17 @@ version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index" source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e" checksum = "05f29059c0c2090612e8d742178b0580d2dc940c837851ad723096f87af6663e"
[[package]]
name = "futures-executor"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "1e28d1d997f585e54aebc3f97d39e72338912123a67330d723fdbb564d646c9f"
dependencies = [
"futures-core",
"futures-task",
"futures-util",
]
[[package]] [[package]]
name = "futures-io" name = "futures-io"
version = "0.3.31" version = "0.3.31"
@ -1160,6 +1211,47 @@ dependencies = [
"pin-project-lite", "pin-project-lite",
] ]
[[package]]
name = "futures-macro"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "162ee34ebcb7c64a8abebc059ce0fee27c2262618d7b60ed8faf72fef13c3650"
dependencies = [
"proc-macro2",
"quote",
"syn 2.0.87",
]
[[package]]
name = "futures-sink"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "e575fab7d1e0dcb8d0c7bcf9a63ee213816ab51902e6d244a95819acacf1d4f7"
[[package]]
name = "futures-task"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f90f7dce0722e95104fcb095585910c0977252f286e354b5e3bd38902cd99988"
[[package]]
name = "futures-util"
version = "0.3.31"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "9fa08315bb612088cc391249efdc3bc77536f16c91f6cf495e6fbe85b20a4a81"
dependencies = [
"futures-channel",
"futures-core",
"futures-io",
"futures-macro",
"futures-sink",
"futures-task",
"memchr",
"pin-project-lite",
"pin-utils",
"slab",
]
[[package]] [[package]]
name = "gethostname" name = "gethostname"
version = "0.4.3" version = "0.4.3"

5
Cargo.toml
View file

@ -27,3 +27,8 @@ identconv = "0.2.0"
paste = "1.0.15" paste = "1.0.15"
crossbeam = "0.8.4" crossbeam = "0.8.4"
async-std = { version = "1.13.0" } async-std = { version = "1.13.0" }
futures = "0.3.31"
[dev-dependencies]
csv = "1.3.0"
serde = { version = "1.0.214", features = ["derive"] }

83
examples/inst_search.rs Normal file
View file

@ -0,0 +1,83 @@
use std::{
collections::HashMap, fs::{read_dir, read_to_string, File}
};
use serde::Serialize;
use truth::{context::RootEmitter, io::BinReader, AnmFile, Game, Mapfile, StdFile};
// #[derive(Serialize)]
// struct Count {
// name: String,
// count: u32
// }
fn parse_files(
map_file_name: &str,
ext: &str,
csv_path: &str,
hit_file: impl Fn(&mut BinReader) -> Vec<u16>,
) {
let map_file = Mapfile::load(map_file_name, Some(Game::Th11), &RootEmitter::new_stderr(), |path| {
Ok((None, read_to_string(map_file_name).unwrap()))
})
.unwrap();
let dir = read_dir("assets").unwrap();
let mut map = HashMap::new();
for file in dir {
let file = file.unwrap();
if file.path().extension().unwrap_or_default() != ext {
continue;
}
log::info!("file: {file:?}");
for op in hit_file(
&mut BinReader::from_reader(
&RootEmitter::new_stderr(),
&file.file_name().to_string_lossy().to_owned(),
&File::open(file.path()).unwrap(),
),
) {
*map.entry(op).or_insert(0) += 1;
};
}
let mut csv = csv::Writer::from_path(csv_path).unwrap();
let mut vec = map.into_iter().collect::<Vec<_>>();
vec.sort_by_key(|c| c.0);
for (op, count) in vec {
log::info!("hitting op {op}");
let str_name = map_file
.ins_names
.iter()
.find(|i| i.0 == op as i32)
.map(|v| v.1.value.as_str().to_owned())
.unwrap_or(format!("unk_inst_{op}"));
csv.write_field(str_name).unwrap();
csv.write_field(op.to_string()).unwrap();
csv.write_field(count.to_string()).unwrap();
csv.write_record(None::<&[u8]>).unwrap();
}
csv.flush().unwrap();
}
fn main() {
env_logger::init();
parse_files("utils/th11.eclm", "ecl", "target/ecl_inst.csv", |reader| {
let file = truth::StackEclFile::read_from_stream(reader, Game::Th11).unwrap();
file.subs.values().flat_map(|sub| sub.iter().map(|f| f.opcode)).collect()
});
parse_files("utils/th095.stdm", "std", "target/std_inst.csv", | reader| {
let file = StdFile::read_from_stream(reader, Game::Th11).unwrap();
file.script.into_iter().map(|f|f.opcode).collect()
});
parse_files("utils/v4.anmm", "anm", "target/anm_inst.csv", | reader| {
let file = AnmFile::read_from_stream(reader, Game::Th11, false).unwrap();
file.entries.iter().flat_map(|f|f.scripts.values()).flat_map(|f|f.instrs.iter()).map(|f|f.opcode).collect()
});
}

19
src/engine.rs
View file

@ -1,8 +1,5 @@
use std::{ use std::sync::{Arc, Mutex};
cell::RefCell, rc::Rc, sync::{Arc, Mutex}
};
use crossbeam::atomic::AtomicCell;
use wgpu::{ use wgpu::{
naga::FastHashMap, Backends, CommandEncoder, Device, DeviceDescriptor, Features, Instance, InstanceDescriptor, InstanceFlags, Queue, RequestAdapterOptions, Surface, SurfaceConfiguration, Texture, TextureFormat, TextureUsages naga::FastHashMap, Backends, CommandEncoder, Device, DeviceDescriptor, Features, Instance, InstanceDescriptor, InstanceFlags, Queue, RequestAdapterOptions, Surface, SurfaceConfiguration, Texture, TextureFormat, TextureUsages
}; };
@ -60,7 +57,7 @@ impl Keys {
} }
fn tick_keys(&mut self) { fn tick_keys(&mut self) {
for (key, state) in &mut self.values { for (_, state) in &mut self.values {
if state.is_down() { if state.is_down() {
*state = KeyState::Held; *state = KeyState::Held;
} }
@ -146,7 +143,7 @@ impl<'a> Engine<'a> {
config: &config.clone(), config: &config.clone(),
}); });
let mut engine = Self { Self {
surface, surface,
device, device,
queue, queue,
@ -158,9 +155,7 @@ impl<'a> Engine<'a> {
focused: false, focused: false,
state, state,
}; }
engine
} }
pub fn handle_event(&mut self, window_event: &WindowEvent) { pub fn handle_event(&mut self, window_event: &WindowEvent) {
@ -236,10 +231,10 @@ impl<'a> Engine<'a> {
} }
pub struct UpdateContext<'a> { pub struct UpdateContext<'a> {
pub device: &'a Device, pub device: &'a Arc<Device>,
pub queue: &'a Queue, pub queue: &'a Arc<Queue>,
pub keys: &'a Keys, pub keys: &'a Keys,
pub window: &'a Window, pub window: &'a Arc<Window>,
pub config: &'a Arc<Mutex<SurfaceConfiguration>>, pub config: &'a Arc<Mutex<SurfaceConfiguration>>,
} }

16
src/game.rs
View file

@ -1,10 +1,11 @@
use std::{rc::Rc, sync::Arc}; use std::{path::Path, sync::Arc};
use anm::LoadedFile; use anm::LoadedFile;
use states::GameStateMachine; use states::GameStateMachine;
use wgpu::RenderPass;
use crate::engine::{self, Engine, EngineState, UpdateContext}; use crate::{
engine::{EngineState, UpdateContext}, utils::soon::Soon
};
mod anm; mod anm;
mod snd; mod snd;
@ -23,6 +24,15 @@ struct GameContext<'a> {
} }
impl GameContext<'_> { impl GameContext<'_> {
pub fn start_load_anm(&mut self, file_name: impl AsRef<Path>) -> Soon<Arc<LoadedFile>> {
self.anm_manager.start_load_anm(
self.engine.device.clone(),
self.engine.queue.clone(),
Some(self.engine.window.inner_size()),
file_name,
)
}
pub fn load_anm(&mut self, file_name: &str) -> Arc<LoadedFile> { pub fn load_anm(&mut self, file_name: &str) -> Arc<LoadedFile> {
self.anm_manager.load_anm(&self.engine.device, &self.engine.queue, &self.engine.window, file_name) self.anm_manager.load_anm(&self.engine.device, &self.engine.queue, &self.engine.window, file_name)
} }

28
src/game/anm/loaded_file.rs
View file

@ -7,7 +7,7 @@ use truth::{context::RootEmitter, io::BinReader, AnmFile, Game};
use wgpu::{ use wgpu::{
naga::FastHashMap, util::DeviceExt, BindGroup, BindGroupDescriptor, BindGroupEntry, BindGroupLayoutDescriptor, BindGroupLayoutEntry, Device, Extent3d, Queue, ShaderStages, Texture, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages naga::FastHashMap, util::DeviceExt, BindGroup, BindGroupDescriptor, BindGroupEntry, BindGroupLayoutDescriptor, BindGroupLayoutEntry, Device, Extent3d, Queue, ShaderStages, Texture, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages
}; };
use winit::window::Window; use winit::dpi::PhysicalSize;
use super::{ use super::{
image::{produce_image_from_entry, Image}, vm::opcodes::{Instruction, Op} image::{produce_image_from_entry, Image}, vm::opcodes::{Instruction, Op}
@ -22,11 +22,19 @@ pub struct LoadedEntry {
} }
impl LoadedEntry { impl LoadedEntry {
fn load(device: &Device, queue: &Queue, window: &Window, entry: &truth::anm::Entry) -> Arc<LoadedEntry> { fn load(
device: &Device,
queue: &Queue,
size: Option<PhysicalSize<u32>>,
entry: &truth::anm::Entry,
) -> Arc<LoadedEntry> {
let image = entry.img_data().is_some().then(|| produce_image_from_entry(&entry).expect("failed to parse...")); let image = entry.img_data().is_some().then(|| produce_image_from_entry(&entry).expect("failed to parse..."));
let (width, height, usages) = if *entry.path == "@R" { let (width, height, usages) = if *entry.path == "@R" {
let size = window.inner_size(); let Some(size) = size else {
panic!("loaded window resolution dependent anm without a size passed");
};
( (
size.width, size.width,
size.height, size.height,
@ -159,7 +167,7 @@ impl Add<Vec2> for SpriteUvs {
pub struct LoadedScript { pub struct LoadedScript {
pub instructions: Vec<Instruction>, pub instructions: Vec<Instruction>,
pub interrupts: FastHashMap<i32, usize>, pub interrupts: FastHashMap<u32, (usize, i32)>,
} }
impl LoadedScript { impl LoadedScript {
@ -179,7 +187,7 @@ impl LoadedScript {
.enumerate() .enumerate()
.filter_map(|(index, inst)| { .filter_map(|(index, inst)| {
if let Op::InterruptLabel(label) = inst.op { if let Op::InterruptLabel(label) = inst.op {
Some((label, index)) Some((label, (index, inst.time)))
} else { } else {
None None
} }
@ -199,7 +207,13 @@ pub struct LoadedFile {
} }
impl LoadedFile { impl LoadedFile {
pub fn load(device: &Device, queue: &Queue, window: &Window, file_name: &str, file_data: &[u8]) -> Self { pub fn load(
device: &Device,
queue: &Queue,
size: Option<PhysicalSize<u32>>,
file_name: &str,
file_data: &[u8],
) -> Self {
let file = AnmFile::read_from_stream( let file = AnmFile::read_from_stream(
&mut BinReader::from_reader(&RootEmitter::new_stderr(), file_name, Cursor::new(file_data)), &mut BinReader::from_reader(&RootEmitter::new_stderr(), file_name, Cursor::new(file_data)),
Game::Th11, Game::Th11,
@ -210,7 +224,7 @@ impl LoadedFile {
let scripts = let scripts =
file.entries.iter().flat_map(|entry| &entry.scripts).map(|(_, script)| LoadedScript::load(script)).collect(); file.entries.iter().flat_map(|entry| &entry.scripts).map(|(_, script)| LoadedScript::load(script)).collect();
let entries = file.entries.iter().map(|entry| LoadedEntry::load(device, queue, window, entry)).collect::<Vec<_>>(); let entries = file.entries.iter().map(|entry| LoadedEntry::load(device, queue, size, entry)).collect::<Vec<_>>();
let mut sprite_entries = NonOverlappingIntervalTree::new(); let mut sprite_entries = NonOverlappingIntervalTree::new();

407
src/game/anm/manager.rs
View file

@ -1,407 +0,0 @@
use std::{
cell::RefCell, collections::VecDeque, num::NonZero, path::Path, rc::{Rc, Weak}, sync::Arc
};
use bytemuck::{bytes_of, Pod, Zeroable};
use glam::{Mat4, Vec3, Vec4};
use num_traits::FloatConst;
use wgpu::{
include_wgsl, naga::FastHashMap, util::{BufferInitDescriptor, DeviceExt}, BindGroup, BindGroupDescriptor, BindGroupEntry, BindGroupLayoutDescriptor, BindGroupLayoutEntry, BindingResource, BlendState, Buffer, BufferUsages, ColorTargetState, ColorWrites, DepthStencilState, Device, FragmentState, PipelineLayout, PipelineLayoutDescriptor, PrimitiveState, Queue, RenderPipeline, RenderPipelineDescriptor, ShaderModule, ShaderStages, Texture, TextureFormat, VertexState
};
use winit::window::Window;
use crate::engine::UpdateContext;
use super::{
loaded_file::{LoadedFile, SpriteUvs}, AnmVm
};
mod location;
mod rendering;
pub use location::VmLocation;
pub type Vm = Rc<RefCell<AnmVm>>;
pub type WeakVm = Weak<RefCell<AnmVm>>;
#[derive(Clone, Copy, Pod, Zeroable)]
#[repr(C, packed)]
struct Uniform {
proj_matrix: Mat4,
}
pub struct Manager {
anm_files: FastHashMap<String, Arc<LoadedFile>>,
world_backbuffer_anm: WeakVm,
ui_vms: VecDeque<WeakVm>,
world_vms: VecDeque<WeakVm>,
depth_texture: Texture,
ui_uniform: Uniform,
_world_uniform: Uniform,
uniform_buffer: Buffer,
render_bind_group: BindGroup,
render_pipeline_layout: PipelineLayout,
render_shader: ShaderModule,
clear_pipeline: RenderPipeline,
blit_pipeline: RenderPipeline,
}
impl Manager {
pub fn new(context: &UpdateContext) -> Manager {
let depth_texture = Self::create_depth_texture(context.device, context.window.inner_size());
let texture_bind_group_layout = context.device.create_bind_group_layout(&BindGroupLayoutDescriptor {
entries: &[BindGroupLayoutEntry {
binding: 0,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
visibility: ShaderStages::FRAGMENT,
}],
label: None,
});
let bind_group_layout = context.device.create_bind_group_layout(&BindGroupLayoutDescriptor {
label: None,
entries: &[
BindGroupLayoutEntry {
binding: 0,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
visibility: ShaderStages::FRAGMENT,
},
BindGroupLayoutEntry {
binding: 1,
count: None,
visibility: ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: Some(NonZero::new(std::mem::size_of::<Uniform>() as u64).unwrap()),
},
},
],
});
let sampler = context.device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("sampler"),
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Nearest,
mipmap_filter: wgpu::FilterMode::Nearest,
..Default::default()
});
let ui_uniform = Uniform {
proj_matrix: Mat4::orthographic_lh(0.0, 640.0, 480.0, 0.0, 100.0, -100.0),
};
let uniform_buffer = context.device.create_buffer_init(&BufferInitDescriptor {
contents: bytes_of(&ui_uniform),
label: Some("uniform"),
usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
});
let render_bind_group = context.device.create_bind_group(&BindGroupDescriptor {
label: Some("render bind group"),
layout: &bind_group_layout,
entries: &[
BindGroupEntry {
binding: 0,
resource: BindingResource::Sampler(&sampler),
},
BindGroupEntry {
binding: 1,
resource: BindingResource::Buffer(uniform_buffer.as_entire_buffer_binding()),
},
],
});
let pipeline_layout = context.device.create_pipeline_layout(&PipelineLayoutDescriptor {
label: None,
bind_group_layouts: &[&texture_bind_group_layout, &bind_group_layout],
push_constant_ranges: &[],
});
let render_shader = context.device.create_shader_module(include_wgsl!("./render.wgsl"));
let blit_shader = context.device.create_shader_module(include_wgsl!("./blit_screen.wgsl"));
let clear_shader = context.device.create_shader_module(include_wgsl!("./clear.wgsl"));
let config = context.config.lock().unwrap();
let clear_pipeline = context.device.create_render_pipeline(&RenderPipelineDescriptor {
label: Some("clear"),
layout: Some(&context.device.create_pipeline_layout(&PipelineLayoutDescriptor {
label: None,
bind_group_layouts: &[],
push_constant_ranges: &[],
})),
vertex: VertexState {
buffers: &[],
module: &clear_shader,
compilation_options: Default::default(),
entry_point: "vs_main",
},
primitive: PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleStrip,
..Default::default()
},
depth_stencil: Some(DepthStencilState {
format: TextureFormat::Depth32Float,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
}),
multisample: Default::default(),
fragment: Some(FragmentState {
targets: &[Some(ColorTargetState {
format: config.format,
blend: Some(BlendState::REPLACE),
write_mask: ColorWrites::ALL,
})],
compilation_options: Default::default(),
entry_point: "fs_main",
module: &clear_shader,
}),
multiview: None,
cache: None,
});
let blit_pipeline = context.device.create_render_pipeline(&RenderPipelineDescriptor {
label: Some("blit"),
layout: Some(&pipeline_layout),
vertex: VertexState {
buffers: &[],
module: &blit_shader,
compilation_options: Default::default(),
entry_point: "vs_main",
},
primitive: PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleStrip,
..Default::default()
},
depth_stencil: Some(DepthStencilState {
format: TextureFormat::Depth32Float,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
}),
multisample: Default::default(),
fragment: Some(FragmentState {
targets: &[Some(ColorTargetState {
format: config.format,
blend: Some(BlendState::ALPHA_BLENDING),
write_mask: ColorWrites::ALL,
})],
compilation_options: Default::default(),
entry_point: "fs_main",
module: &blit_shader,
}),
multiview: None,
cache: None,
});
let world_uniform = Uniform {
proj_matrix: Mat4::perspective_lh(
45.0 * (f32::PI() / 180.0),
config.width as f32 / config.height as f32,
0.1,
1000.0,
),
};
Manager {
anm_files: FastHashMap::default(),
world_backbuffer_anm: Weak::new(),
ui_vms: VecDeque::new(),
world_vms: VecDeque::new(),
depth_texture,
ui_uniform,
_world_uniform: world_uniform,
uniform_buffer,
render_bind_group,
render_pipeline_layout: pipeline_layout,
render_shader,
clear_pipeline,
blit_pipeline,
}
}
pub fn load_anm(
&mut self,
device: &Device,
queue: &Queue,
window: &Window,
file_name: impl AsRef<Path>,
) -> Arc<LoadedFile> {
let file_name_str = file_name.as_ref().to_str().unwrap().to_owned();
if let Some(loaded_anm) = self.anm_files.get(&file_name_str) {
return loaded_anm.clone();
}
let file_data = std::fs::read(Path::new("./assets").join(file_name)).expect("failed to load anm file");
let loaded_anm = Arc::new(LoadedFile::load(device, queue, window, &file_name_str, &file_data));
self.anm_files.insert(file_name_str.to_owned(), loaded_anm.clone());
loaded_anm
}
#[allow(unused)]
pub fn set_world_backbuffer_anm(&mut self, file: Arc<LoadedFile>, script: usize) -> Vm {
let vm = Rc::new(RefCell::new(AnmVm::new(file, None, false, false, script, 0)));
self.update_single(&vm);
self.world_backbuffer_anm = Rc::downgrade(&vm);
vm
}
pub fn new_vm(
&mut self,
file: Arc<LoadedFile>,
origin: Option<Vec3>,
ticked_by_parent: bool,
debug: bool,
script: usize,
location: VmLocation,
) -> Vm {
let layer = location.layer();
let vm = Rc::new(RefCell::new(AnmVm::new(
file,
origin,
ticked_by_parent,
debug,
script,
layer,
)));
self.update_single(&vm);
let mut context = ManagerUpdate::new();
vm.borrow_mut().tick(&mut context);
let (vm_list, front) = match location {
VmLocation::Ui { front, .. } => (&mut self.ui_vms, front),
VmLocation::World { front, .. } => (&mut self.world_vms, front),
};
if front {
vm_list.push_front(Rc::downgrade(&vm))
} else {
vm_list.push_back(Rc::downgrade(&vm));
}
vm
}
fn update_single(&mut self, vm: &Vm) {
let mut context = ManagerUpdate::new();
vm.borrow_mut().tick(&mut context);
context.apply_lists(&mut self.ui_vms, &mut self.world_vms);
}
fn update_list(list: &mut VecDeque<WeakVm>, context: &mut ManagerUpdate) {
list.retain(|value| {
if let Some(rc) = value.upgrade() {
!rc.borrow().deleted
} else {
false
}
});
for vm in list {
if let Some(vm) = vm.upgrade() {
if !vm.borrow().ticked_by_parent {
vm.borrow_mut().tick(context);
}
}
}
}
pub fn update(&mut self) {
let mut context = ManagerUpdate::new();
Self::update_list(&mut self.world_vms, &mut context);
Self::update_list(&mut self.ui_vms, &mut context);
context.apply_lists(&mut self.ui_vms, &mut self.world_vms);
}
}
#[derive(Default)]
pub(super) struct ManagerUpdate {
new_ui_vms_front: Vec<WeakVm>,
new_ui_vms_back: Vec<WeakVm>,
new_world_vms_front: Vec<WeakVm>,
new_world_vms_back: Vec<WeakVm>,
}
impl ManagerUpdate {
fn new() -> Self {
Self::default()
}
pub fn new_vm(
&mut self,
file: Arc<LoadedFile>,
origin: Option<Vec3>,
ticked_by_parent: bool,
debug: bool,
script: usize,
location: VmLocation,
) -> Vm {
let layer = location.layer();
let vm = Rc::new(RefCell::new(AnmVm::new(
file,
origin,
ticked_by_parent,
debug,
script,
layer,
)));
vm.borrow_mut().tick(self);
let vm_list = match location {
VmLocation::Ui { front, .. } => {
if front {
&mut self.new_ui_vms_front
} else {
&mut self.new_ui_vms_back
}
}
VmLocation::World { front, .. } => {
if front {
&mut self.new_world_vms_front
} else {
&mut self.new_world_vms_back
}
}
};
vm_list.push(Rc::downgrade(&vm));
vm
}
fn apply_to_list(list: &mut VecDeque<WeakVm>, front: Vec<WeakVm>, back: Vec<WeakVm>) {
for vm in front.into_iter().rev() {
list.push_front(vm.clone());
}
list.extend(back.into_iter());
}
fn apply_lists(self, ui_list: &mut VecDeque<WeakVm>, world_list: &mut VecDeque<WeakVm>) {
Self::apply_to_list(ui_list, self.new_ui_vms_front, self.new_ui_vms_back);
Self::apply_to_list(world_list, self.new_world_vms_front, self.new_world_vms_back);
}
}

57
src/game/anm/manager/loading.rs Normal file
View file

@ -0,0 +1,57 @@
use std::{path::Path, sync::Arc};
use async_std::fs;
use wgpu::{Device, Queue};
use winit::{dpi::PhysicalSize, window::Window};
use crate::{game::anm::LoadedFile, utils::soon::Soon};
use super::Manager;
impl Manager {
pub fn start_load_anm(
&mut self,
device: Arc<Device>,
queue: Arc<Queue>,
size: Option<PhysicalSize<u32>>,
file_name: impl AsRef<Path>,
) -> Soon<Arc<LoadedFile>> {
let file_name_str = file_name.as_ref().to_str().unwrap().to_owned();
if let Some(loaded_anm) = self.anm_files.get(&file_name_str) {
return Soon::Value(loaded_anm.clone());
}
let file_name = file_name.as_ref().to_owned();
Soon::new(async move {
let file_data = fs::read(Path::new("./assets").join(file_name)).await.expect("failed to load anm file");
let file = Arc::new(LoadedFile::load(&device, &queue, size, &file_name_str, &file_data));
file
})
}
pub fn load_anm(
&mut self,
device: &Device,
queue: &Queue,
window: &Window,
file_name: impl AsRef<Path>,
) -> Arc<LoadedFile> {
let file_name_str = file_name.as_ref().to_str().unwrap().to_owned();
if let Some(loaded_anm) = self.anm_files.get(&file_name_str) {
return loaded_anm.clone();
}
let file_data = std::fs::read(Path::new("./assets").join(file_name)).expect("failed to load anm file");
let loaded_anm = Arc::new(LoadedFile::load(
device,
queue,
Some(window.inner_size()),
&file_name_str,
&file_data,
));
self.anm_files.insert(file_name_str.to_owned(), loaded_anm.clone());
loaded_anm
}
}

67
src/game/anm/manager/location.rs
View file

@ -1,41 +1,74 @@
pub enum VmLocation { pub struct VmLocation {
Ui { front: bool, layer: u32 }, pub world: bool,
World { front: bool, layer: u32 }, pub front: bool,
pub child: bool,
pub layer: u32,
} }
#[allow(unused)]
impl VmLocation { impl VmLocation {
pub fn new() -> Self { pub fn new() -> Self {
Self::World { front: false, layer: 0 } Self {
world: true,
front: false,
child: false,
layer: 0,
}
} }
pub fn new_ui() -> Self { pub fn new_ui() -> Self {
Self::Ui { Self {
world: false,
front: false, front: false,
child: false,
layer: 30, layer: 30,
} }
} }
pub fn new_child(layer: u32) -> Self { pub fn new_child(layer: u32) -> Self {
Self::World { front: false, layer } Self {
world: true,
front: false,
child: true,
layer,
}
} }
pub fn new_child_ui(layer: u32) -> Self { pub fn new_child_ui(layer: u32) -> Self {
Self::Ui { front: false, layer } Self {
world: false,
front: false,
child: true,
layer,
}
} }
pub fn new_front() -> Self { pub fn new_front() -> Self {
Self::World { front: true, layer: 0 } Self {
world: true,
front: true,
child: false,
layer: 0,
}
} }
pub fn new_ui_front() -> Self { pub fn new_ui_front() -> Self {
Self::Ui { front: true, layer: 30 } Self {
world: false,
front: true,
child: false,
layer: 30,
}
} }
pub fn new_child_front(layer: u32) -> Self { pub fn new_child_front(layer: u32) -> Self {
Self::World { front: true, layer } Self {
world: true,
front: true,
child: true,
layer,
}
} }
pub fn new_child_ui_front(layer: u32) -> Self { pub fn new_child_ui_front(layer: u32) -> Self {
Self::Ui { front: true, layer } Self {
} world: false,
front: true,
pub fn layer(&self) -> u32 { child: true,
match self { layer,
VmLocation::Ui { layer, .. } => *layer,
VmLocation::World { layer, .. } => *layer,
} }
} }
} }

170
src/game/anm/manager/mod.rs Normal file
View file

@ -0,0 +1,170 @@
use std::{
cell::RefCell, collections::VecDeque, rc::{Rc, Weak}, sync::Arc
};
use bytemuck::{Pod, Zeroable};
use glam::Mat4;
use wgpu::{naga::FastHashMap, BindGroup, Buffer, PipelineLayout, RenderPipeline, ShaderModule, Texture};
use super::{loaded_file::LoadedFile, AnmVm};
mod loading;
mod location;
mod rendering;
pub use location::VmLocation;
pub type Vm = Rc<RefCell<AnmVm>>;
pub type WeakVm = Weak<RefCell<AnmVm>>;
#[derive(Clone, Copy, Pod, Zeroable)]
#[repr(C, packed)]
struct Uniform {
proj_matrix: Mat4,
}
pub struct Manager {
anm_files: FastHashMap<String, Arc<LoadedFile>>,
world_backbuffer_anm: WeakVm,
ui_vms: VecDeque<WeakVm>,
world_vms: VecDeque<WeakVm>,
depth_texture: Texture,
ui_uniform: Uniform,
_world_uniform: Uniform,
uniform_buffer: Buffer,
render_bind_group: BindGroup,
render_pipeline_layout: PipelineLayout,
render_shader: ShaderModule,
clear_pipeline: RenderPipeline,
blit_pipeline: RenderPipeline,
}
impl Manager {
#[allow(unused)]
pub fn set_world_backbuffer_anm(&mut self, file: Arc<LoadedFile>, script: usize) -> Vm {
let vm = Rc::new(RefCell::new(AnmVm::new(file, script, 0)));
self.update_single(&vm);
self.world_backbuffer_anm = Rc::downgrade(&vm);
vm
}
pub fn new_vm(&mut self, file: Arc<LoadedFile>, interrupt: Option<u32>, script: usize, location: VmLocation) -> Vm {
let vm = Rc::new(RefCell::new(AnmVm::new(file, script, location.layer)));
if let Some(interrupt) = interrupt {
vm.borrow_mut().interrupt(interrupt);
}
self.update_single(&vm);
let mut context = ManagerUpdate::new();
vm.borrow_mut().tick(&mut context);
let (vm_list, front) = match location {
VmLocation {
world: false, front, ..
} => (&mut self.ui_vms, front),
VmLocation { world: true, front, .. } => (&mut self.world_vms, front),
};
if front {
vm_list.push_front(Rc::downgrade(&vm))
} else {
vm_list.push_back(Rc::downgrade(&vm));
}
vm
}
fn update_single(&mut self, vm: &Vm) {
let mut context = ManagerUpdate::new();
vm.borrow_mut().tick(&mut context);
context.apply_lists(&mut self.ui_vms, &mut self.world_vms);
}
fn update_list(list: &mut VecDeque<WeakVm>, context: &mut ManagerUpdate) {
list.retain(|value| {
if let Some(rc) = value.upgrade() {
!rc.borrow().deleted()
} else {
false
}
});
for vm in list {
if let Some(vm) = vm.upgrade() {
if !vm.borrow().ticked_by_parent {
vm.borrow_mut().tick(context);
}
}
}
}
pub fn update(&mut self) {
let mut context = ManagerUpdate::new();
Self::update_list(&mut self.world_vms, &mut context);
Self::update_list(&mut self.ui_vms, &mut context);
context.apply_lists(&mut self.ui_vms, &mut self.world_vms);
}
}
#[derive(Default)]
pub(super) struct ManagerUpdate {
new_ui_vms_front: Vec<WeakVm>,
new_ui_vms_back: Vec<WeakVm>,
new_world_vms_front: Vec<WeakVm>,
new_world_vms_back: Vec<WeakVm>,
}
impl ManagerUpdate {
fn new() -> Self {
Self::default()
}
pub fn new_vm(&mut self, file: Arc<LoadedFile>, script: usize, location: VmLocation) -> Vm {
let vm = Rc::new(RefCell::new(AnmVm::new(file, script, location.layer)));
vm.borrow_mut().ticked_by_parent = location.child;
vm.borrow_mut().tick(self);
let vm_list = match location {
VmLocation {
world: false, front, ..
} => {
if front {
&mut self.new_ui_vms_front
} else {
&mut self.new_ui_vms_back
}
}
VmLocation { world: true, front, .. } => {
if front {
&mut self.new_world_vms_front
} else {
&mut self.new_world_vms_back
}
}
};
vm_list.push(Rc::downgrade(&vm));
vm
}
fn apply_to_list(list: &mut VecDeque<WeakVm>, front: Vec<WeakVm>, back: Vec<WeakVm>) {
for vm in front.into_iter().rev() {
list.push_front(vm.clone());
}
list.extend(back.into_iter());
}
fn apply_lists(self, ui_list: &mut VecDeque<WeakVm>, world_list: &mut VecDeque<WeakVm>) {
Self::apply_to_list(ui_list, self.new_ui_vms_front, self.new_ui_vms_back);
Self::apply_to_list(world_list, self.new_world_vms_front, self.new_world_vms_back);
}
}

200
src/game/anm/manager/rendering.rs
View file

@ -1,17 +1,18 @@
use std::collections::VecDeque; use std::{collections::VecDeque, num::NonZero, rc::Weak};
use bytemuck::{bytes_of, Pod, Zeroable}; use bytemuck::{bytes_of, Pod, Zeroable};
use glam::{Mat4, Vec2, Vec3, Vec4}; use glam::{Mat4, Vec2, Vec3, Vec4};
use num_traits::FloatConst;
use wgpu::{ use wgpu::{
BufferDescriptor, BufferUsages, Color, ColorTargetState, ColorWrites, DepthStencilState, Device, Extent3d, FragmentState, LoadOp, Operations, PrimitiveState, RenderPass, RenderPassColorAttachment, RenderPassDepthStencilAttachment, RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor, StoreOp, TextureDescriptor, TextureFormat, TextureUsages, VertexAttribute, VertexBufferLayout, VertexState include_wgsl, naga::FastHashMap, util::{BufferInitDescriptor, DeviceExt}, BindGroupDescriptor, BindGroupEntry, BindGroupLayoutDescriptor, BindGroupLayoutEntry, BindingResource, BlendState, BufferDescriptor, BufferUsages, Color, ColorTargetState, ColorWrites, DepthStencilState, Device, Extent3d, FragmentState, LoadOp, Operations, PipelineLayoutDescriptor, PrimitiveState, RenderPass, RenderPassColorAttachment, RenderPassDepthStencilAttachment, RenderPassDescriptor, RenderPipeline, RenderPipelineDescriptor, ShaderStages, StoreOp, TextureDescriptor, TextureFormat, TextureUsages, VertexAttribute, VertexBufferLayout, VertexState
}; };
use winit::dpi::PhysicalSize; use winit::dpi::PhysicalSize;
use crate::{ use crate::{
engine::Engine, game::anm::{loaded_file::SpriteUvs, vm::RenderingState, AnmVm} engine::{Engine, UpdateContext}, game::anm::{loaded_file::SpriteUvs, vm::RenderingState, AnmVm}
}; };
use super::{Manager, WeakVm}; use super::{Manager, Uniform, WeakVm};
#[derive(Default, Clone, Copy, Pod, Zeroable)] #[derive(Default, Clone, Copy, Pod, Zeroable)]
#[repr(C, packed)] #[repr(C, packed)]
@ -23,6 +24,194 @@ pub(super) struct Instance {
} }
impl Manager { impl Manager {
pub fn new(context: &UpdateContext) -> Manager {
let depth_texture = Self::create_depth_texture(context.device, context.window.inner_size());
let texture_bind_group_layout = context.device.create_bind_group_layout(&BindGroupLayoutDescriptor {
entries: &[BindGroupLayoutEntry {
binding: 0,
ty: wgpu::BindingType::Texture {
sample_type: wgpu::TextureSampleType::Float { filterable: true },
view_dimension: wgpu::TextureViewDimension::D2,
multisampled: false,
},
count: None,
visibility: ShaderStages::FRAGMENT,
}],
label: None,
});
let bind_group_layout = context.device.create_bind_group_layout(&BindGroupLayoutDescriptor {
label: None,
entries: &[
BindGroupLayoutEntry {
binding: 0,
ty: wgpu::BindingType::Sampler(wgpu::SamplerBindingType::Filtering),
count: None,
visibility: ShaderStages::FRAGMENT,
},
BindGroupLayoutEntry {
binding: 1,
count: None,
visibility: ShaderStages::VERTEX,
ty: wgpu::BindingType::Buffer {
ty: wgpu::BufferBindingType::Uniform,
has_dynamic_offset: false,
min_binding_size: Some(NonZero::new(std::mem::size_of::<Uniform>() as u64).unwrap()),
},
},
],
});
let sampler = context.device.create_sampler(&wgpu::SamplerDescriptor {
label: Some("sampler"),
address_mode_u: wgpu::AddressMode::ClampToEdge,
address_mode_v: wgpu::AddressMode::ClampToEdge,
address_mode_w: wgpu::AddressMode::ClampToEdge,
mag_filter: wgpu::FilterMode::Linear,
min_filter: wgpu::FilterMode::Nearest,
mipmap_filter: wgpu::FilterMode::Nearest,
..Default::default()
});
let ui_uniform = Uniform {
proj_matrix: Mat4::orthographic_lh(0.0, 640.0, 480.0, 0.0, 100.0, -100.0),
};
let uniform_buffer = context.device.create_buffer_init(&BufferInitDescriptor {
contents: bytes_of(&ui_uniform),
label: Some("uniform"),
usage: BufferUsages::UNIFORM | BufferUsages::COPY_DST,
});
let render_bind_group = context.device.create_bind_group(&BindGroupDescriptor {
label: Some("render bind group"),
layout: &bind_group_layout,
entries: &[
BindGroupEntry {
binding: 0,
resource: BindingResource::Sampler(&sampler),
},
BindGroupEntry {
binding: 1,
resource: BindingResource::Buffer(uniform_buffer.as_entire_buffer_binding()),
},
],
});
let pipeline_layout = context.device.create_pipeline_layout(&PipelineLayoutDescriptor {
label: None,
bind_group_layouts: &[&texture_bind_group_layout, &bind_group_layout],
push_constant_ranges: &[],
});
let render_shader = context.device.create_shader_module(include_wgsl!("../render.wgsl"));
let blit_shader = context.device.create_shader_module(include_wgsl!("../blit_screen.wgsl"));
let clear_shader = context.device.create_shader_module(include_wgsl!("../clear.wgsl"));
let config = context.config.lock().unwrap();
let clear_pipeline = context.device.create_render_pipeline(&RenderPipelineDescriptor {
label: Some("clear"),
layout: Some(&context.device.create_pipeline_layout(&PipelineLayoutDescriptor {
label: None,
bind_group_layouts: &[],
push_constant_ranges: &[],
})),
vertex: VertexState {
buffers: &[],
module: &clear_shader,
compilation_options: Default::default(),
entry_point: "vs_main",
},
primitive: PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleStrip,
..Default::default()
},
depth_stencil: Some(DepthStencilState {
format: TextureFormat::Depth32Float,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
}),
multisample: Default::default(),
fragment: Some(FragmentState {
targets: &[Some(ColorTargetState {
format: config.format,
blend: Some(BlendState::REPLACE),
write_mask: ColorWrites::ALL,
})],
compilation_options: Default::default(),
entry_point: "fs_main",
module: &clear_shader,
}),
multiview: None,
cache: None,
});
let blit_pipeline = context.device.create_render_pipeline(&RenderPipelineDescriptor {
label: Some("blit"),
layout: Some(&pipeline_layout),
vertex: VertexState {
buffers: &[],
module: &blit_shader,
compilation_options: Default::default(),
entry_point: "vs_main",
},
primitive: PrimitiveState {
topology: wgpu::PrimitiveTopology::TriangleStrip,
..Default::default()
},
depth_stencil: Some(DepthStencilState {
format: TextureFormat::Depth32Float,
depth_write_enabled: true,
depth_compare: wgpu::CompareFunction::Less,
stencil: wgpu::StencilState::default(),
bias: wgpu::DepthBiasState::default(),
}),
multisample: Default::default(),
fragment: Some(FragmentState {
targets: &[Some(ColorTargetState {
format: config.format,
blend: Some(BlendState::ALPHA_BLENDING),
write_mask: ColorWrites::ALL,
})],
compilation_options: Default::default(),
entry_point: "fs_main",
module: &blit_shader,
}),
multiview: None,
cache: None,
});
let world_uniform = Uniform {
proj_matrix: Mat4::perspective_lh(
45.0 * (f32::PI() / 180.0),
config.width as f32 / config.height as f32,
0.1,
1000.0,
),
};
Manager {
anm_files: FastHashMap::default(),
world_backbuffer_anm: Weak::new(),
ui_vms: VecDeque::new(),
world_vms: VecDeque::new(),
depth_texture,
ui_uniform,
_world_uniform: world_uniform,
uniform_buffer,
render_bind_group,
render_pipeline_layout: pipeline_layout,
render_shader,
clear_pipeline,
blit_pipeline,
}
}
fn new_pipeline(&self, engine: &Engine, vm: &AnmVm) -> RenderPipeline { fn new_pipeline(&self, engine: &Engine, vm: &AnmVm) -> RenderPipeline {
let render_pipeline = engine.device.create_render_pipeline(&RenderPipelineDescriptor { let render_pipeline = engine.device.create_render_pipeline(&RenderPipelineDescriptor {
label: Some("anm"), label: Some("anm"),
@ -147,12 +336,9 @@ impl Manager {
rendering_state.pipeline = Some(self.new_pipeline(engine, vm)) rendering_state.pipeline = Some(self.new_pipeline(engine, vm))
} }
// let mut matrix = Mat4::from_translation(layer_origin + vm.position());
let offset = sprite.size.extend(1.0) * vm.anchor_offset.extend(0.0);
let mut matrix = Mat4::IDENTITY; let mut matrix = Mat4::IDENTITY;
matrix *= Mat4::from_translation(layer_origin + vm.position()); matrix *= Mat4::from_translation(layer_origin + vm.position());
matrix *= Mat4::from_rotation_translation(vm.rotation(), Vec3::ZERO); matrix *= Mat4::from_rotation_translation(vm.rotation(), Vec3::ZERO);
// matrix *= Mat4::from_translation(-offset);
matrix *= Mat4::from_scale((sprite.size * vm.scale()).extend(1.0)); matrix *= Mat4::from_scale((sprite.size * vm.scale()).extend(1.0));
engine.queue.write_buffer( engine.queue.write_buffer(

82
src/game/anm/vm/execute.rs
View file

@ -12,7 +12,7 @@ use super::{
impl AnmVm { impl AnmVm {
fn next_instruction(&mut self) -> Option<Instruction> { fn next_instruction(&mut self) -> Option<Instruction> {
if self.waiting_countdown > 0 { if self.time.waiting() {
return None; return None;
} }
@ -21,7 +21,7 @@ impl AnmVm {
return None; return None;
} }
let instruction = instructions[self.pc]; let instruction = instructions[self.pc];
if self.time < instruction.time { if self.time.time() < instruction.time {
return None; return None;
} }
@ -30,11 +30,7 @@ impl AnmVm {
} }
pub(super) fn advance_time(&mut self) { pub(super) fn advance_time(&mut self) {
if self.waiting_countdown == 0 { self.time.tick()
self.time += 1;
}
self.waiting_countdown = self.waiting_countdown.saturating_sub(1);
} }
fn store_int(&mut self, var: i32, value: i32) { fn store_int(&mut self, var: i32, value: i32) {
@ -107,10 +103,35 @@ impl AnmVm {
} }
} }
pub(super) fn execute(&mut self, manager: &mut ManagerUpdate) { pub fn interrupt(&mut self, interrupt_id: u32) {
if let Some(interrupt) = self.pending_interrupt { self.pending_interrupt = Some(interrupt_id);
for ele in self.children.iter() {
ele.borrow_mut().interrupt(interrupt_id);
} }
}
fn handle_interrupt(&mut self) {
if let Some((int_pc, int_time)) =
self.pending_interrupt.take().and_then(|int| self.script.interrupts.get(&int).cloned())
{
self.interrupt_return = Some((self.pc, self.time));
self.pc = int_pc;
self.time = Default::default();
self.time.set_time(int_time)
}
}
fn return_from_interrupt(&mut self) {
if let Some((pc, time)) = self.interrupt_return.take() {
self.pc = pc;
self.time.set_time(time.time());
}
}
pub(super) fn execute(&mut self, manager: &mut ManagerUpdate) {
self.handle_interrupt();
while let Some(inst) = self.next_instruction() { while let Some(inst) = self.next_instruction() {
if self.debug { if self.debug {
log::info!("executing {inst:?}"); log::info!("executing {inst:?}");
@ -124,7 +145,7 @@ impl AnmVm {
Op::Sprite(sprite) => self.sprite = sprite, Op::Sprite(sprite) => self.sprite = sprite,
Op::Jump { index, time } => { Op::Jump { index, time } => {
self.pc = index; self.pc = index;
self.time = time; self.time.set_time(time);
} }
Op::IntOp { op, dest, input } => { Op::IntOp { op, dest, input } => {
let op: fn(i32, i32) -> i32 = match op { let op: fn(i32, i32) -> i32 = match op {
@ -153,10 +174,7 @@ impl AnmVm {
if self.debug { if self.debug {
log::info!( log::info!(
"{dest} {op:?}Assign {input:?} = {}", "{dest} {op:?}Assign {input:?} = {}",
op_func( op_func(self.param_float(Param::Variable(dest)), self.param_float(input))
self.param_float(Param::Variable(dest)),
self.param_float(input)
)
); );
} }
@ -275,7 +293,9 @@ impl AnmVm {
None, None,
None, None,
), ),
Op::Stop => self.waiting_countdown = u32::MAX, Op::Stop => {
self.time.stop();
}
Op::InterruptLabel(_) => {} Op::InterruptLabel(_) => {}
Op::Anchor { horizontal, vertical } => { Op::Anchor { horizontal, vertical } => {
let axis = |value: i16| match value { let axis = |value: i16| match value {
@ -293,36 +313,21 @@ impl AnmVm {
self.sprite_mode = mode; self.sprite_mode = mode;
} }
Op::Layer { layer } => self.layer = layer as u32, Op::Layer { layer } => self.layer = layer as u32,
Op::Wait { time } => self.waiting_countdown = time as u32, Op::Wait { time } => self.time.wait(time as u32),
Op::CaseReturn => {} Op::CaseReturn => {
self.return_from_interrupt();
}
Op::UnknownBitflag { .. } => {} Op::UnknownBitflag { .. } => {}
Op::RandMode { mode } => self.random_mode = mode, Op::RandMode { mode } => self.random_mode = mode,
Op::ScriptNew { script } => { Op::ScriptNew { script } => {
self.children.push(manager.new_vm( self.children.push(manager.new_vm(self.file.clone(), script as usize, VmLocation::new_child(self.layer)));
self.file.clone(),
Some(self.position()),
true,
false,
script as usize,
VmLocation::new_child(self.layer),
));
} }
Op::ScriptNewUI { script } => { Op::ScriptNewUI { script } => {
self.children.push(manager.new_vm( self.children.push(manager.new_vm(self.file.clone(), script as usize, VmLocation::new_child_ui(self.layer)));
self.file.clone(),
Some(self.position()),
true,
false,
script as usize,
VmLocation::new_child_ui(self.layer),
));
} }
Op::ScriptNewFront { script } => { Op::ScriptNewFront { script } => {
self.children.push(manager.new_vm( self.children.push(manager.new_vm(
self.file.clone(), self.file.clone(),
Some(self.position()),
true,
false,
script as usize, script as usize,
VmLocation::new_child_front(self.layer), VmLocation::new_child_front(self.layer),
)); ));
@ -330,9 +335,6 @@ impl AnmVm {
Op::ScriptNewUIFront { script } => { Op::ScriptNewUIFront { script } => {
self.children.push(manager.new_vm( self.children.push(manager.new_vm(
self.file.clone(), self.file.clone(),
Some(self.position()),
true,
false,
script as usize, script as usize,
VmLocation::new_child_ui_front(self.layer), VmLocation::new_child_ui_front(self.layer),
)); ));

50
src/game/anm/vm/mod.rs
View file

@ -1,8 +1,8 @@
use std::{cell::RefCell, rc::Rc, sync::Arc}; use std::{cell::RefCell, sync::Arc};
use glam::{Quat, Vec2, Vec3}; use glam::{Quat, Vec2, Vec3};
use log::warn; use opcodes::SpriteType;
use opcodes::{Instruction, SpriteType}; use timer::Timer;
use wgpu::{BlendComponent, BlendFactor, BlendOperation, BlendState, Buffer, RenderPipeline}; use wgpu::{BlendComponent, BlendFactor, BlendOperation, BlendState, Buffer, RenderPipeline};
use crate::interp::{FloatInterpolator, Vec2Interpolator, Vec3Interpolator}; use crate::interp::{FloatInterpolator, Vec2Interpolator, Vec3Interpolator};
@ -13,6 +13,7 @@ use super::{
pub mod execute; pub mod execute;
pub(super) mod opcodes; pub(super) mod opcodes;
pub mod timer;
pub(super) struct RenderingState { pub(super) struct RenderingState {
pub instance_buffer: Buffer, pub instance_buffer: Buffer,
@ -22,22 +23,21 @@ pub(super) struct RenderingState {
pub struct AnmVm { pub struct AnmVm {
debug: bool, debug: bool,
pub(super) deleted: bool, deleted: bool,
fully_static: bool, fully_static: bool,
frozen: bool, frozen: bool,
pub(super) ticked_by_parent: bool, pub(super) ticked_by_parent: bool,
time: i32, time: Timer,
pc: usize, pc: usize,
pub(super) file: Arc<LoadedFile>, pub(super) file: Arc<LoadedFile>,
script: Arc<LoadedScript>, script: Arc<LoadedScript>,
int_vars: [i32; 6], int_vars: [i32; 6],
float_vars: [f32; 4], float_vars: [f32; 4],
waiting_countdown: u32, pending_interrupt: Option<u32>,
pending_interrupt: Option<usize>, interrupt_return: Option<(usize, Timer)>,
interrupt_return: Option<(usize, i32)>,
origin: Option<Vec3>, pub origin: Vec3,
position_interpolator: Vec3Interpolator, position_interpolator: Vec3Interpolator,
rotation_interpolator: Vec3Interpolator, rotation_interpolator: Vec3Interpolator,
scale_interpolator: Vec2Interpolator, scale_interpolator: Vec2Interpolator,
@ -59,32 +59,24 @@ pub struct AnmVm {
} }
impl AnmVm { impl AnmVm {
pub(super) fn new( pub(super) fn new(file: Arc<LoadedFile>, script: usize, default_layer: u32) -> AnmVm {
file: Arc<LoadedFile>,
origin: Option<Vec3>,
ticked_by_parent: bool,
debug: bool,
script: usize,
default_layer: u32,
) -> AnmVm {
let mut new = AnmVm { let mut new = AnmVm {
deleted: false, deleted: false,
fully_static: false, fully_static: false,
frozen: false, frozen: false,
ticked_by_parent, ticked_by_parent: false,
debug, debug: false,
time: 0, time: Timer::default(),
pc: 0, pc: 0,
script: file.scripts[script].clone(), script: file.scripts[script].clone(),
file, file,
int_vars: [0; 6], int_vars: [0; 6],
float_vars: [0.0; 4], float_vars: [0.0; 4],
waiting_countdown: 0,
pending_interrupt: None, pending_interrupt: None,
interrupt_return: None, interrupt_return: None,
origin, origin: Vec3::ZERO,
position_interpolator: Vec3Interpolator::new(Vec3::ZERO), position_interpolator: Vec3Interpolator::new(Vec3::ZERO),
rotation_interpolator: Vec3Interpolator::new(Vec3::ZERO), rotation_interpolator: Vec3Interpolator::new(Vec3::ZERO),
scale_interpolator: Vec2Interpolator::new(Vec2::ONE), scale_interpolator: Vec2Interpolator::new(Vec2::ONE),
@ -122,10 +114,16 @@ impl AnmVm {
}) })
} }
#[allow(unused)]
pub fn debug_freeze(&mut self) { pub fn debug_freeze(&mut self) {
self.frozen = true; self.frozen = true;
} }
#[allow(unused)]
pub fn debug(&mut self) {
self.debug = true;
}
pub fn scale(&self) -> Vec2 { pub fn scale(&self) -> Vec2 {
self.scale_interpolator.current() self.scale_interpolator.current()
} }
@ -136,8 +134,10 @@ impl AnmVm {
} }
pub fn position(&self) -> Vec3 { pub fn position(&self) -> Vec3 {
self.origin.unwrap_or(Vec3::ZERO) + self.position_interpolator.current() self.origin + self.position_interpolator.current()
} }
#[allow(unused)]
pub fn raw_position(&self) -> Vec3 { pub fn raw_position(&self) -> Vec3 {
self.position_interpolator.current() self.position_interpolator.current()
} }
@ -190,7 +190,7 @@ impl AnmVm {
for child in &self.children { for child in &self.children {
let mut child = child.borrow_mut(); let mut child = child.borrow_mut();
child.origin = Some(self.position()); child.origin = self.position();
child.tick(manager); child.tick(manager);
} }
self.children.retain(|vm| !vm.borrow().deleted); self.children.retain(|vm| !vm.borrow().deleted);
@ -211,7 +211,7 @@ impl AnmVm {
// additive blending // additive blending
color: BlendComponent { color: BlendComponent {
src_factor: BlendFactor::SrcAlpha, src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::One, dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add, operation: BlendOperation::Add,
}, },
alpha: BlendComponent::REPLACE, alpha: BlendComponent::REPLACE,

4
src/game/anm/vm/opcodes.rs
View file

@ -292,7 +292,7 @@ pub enum Op {
FlipX, FlipX,
FlipY, FlipY,
Stop, Stop,
InterruptLabel(i32), InterruptLabel(u32),
Anchor { Anchor {
horizontal: i16, horizontal: i16,
vertical: i16, vertical: i16,
@ -673,7 +673,7 @@ impl Instruction {
Opcode::InterruptLabel => { Opcode::InterruptLabel => {
let label = decode_args!(args, "S"); let label = decode_args!(args, "S");
Op::InterruptLabel(label) Op::InterruptLabel(label as u32)
} }
Opcode::Anchor => { Opcode::Anchor => {
let (horizontal, vertical) = decode_args!(args, "ss"); let (horizontal, vertical) = decode_args!(args, "ss");

41
src/game/anm/vm/timer.rs Normal file
View file

@ -0,0 +1,41 @@
#[derive(Default, Clone, Copy)]
pub struct Timer {
time: i32,
wait_countdown: u32,
stopped: bool,
}
impl Timer {
pub fn time(&self) -> i32 {
self.time
}
pub fn set_time(&mut self, time: i32) {
self.time = time;
}
pub fn waiting(&self) -> bool {
self.wait_countdown > 0 || self.stopped
}
pub fn wait(&mut self, time: u32) {
self.wait_countdown = time;
}
pub fn stop(&mut self) {
self.stopped = true;
}
pub fn tick(&mut self) {
if self.stopped {
return;
}
if self.wait_countdown > 0 {
self.wait_countdown = self.wait_countdown.saturating_sub(1);
return;
}
self.time += 1;
}
}

25
src/game/snd/bgm/format.rs
View file

@ -1,6 +1,5 @@
use std::ffi::CStr; use std::{ffi::CStr, ops::Range};
use rodio::cpal::{BufferSize, SampleFormat, SampleRate, StreamConfig};
use wgpu::naga::FastHashMap; use wgpu::naga::FastHashMap;
use zerocopy::{FromBytes, Immutable, KnownLayout}; use zerocopy::{FromBytes, Immutable, KnownLayout};
@ -8,10 +7,8 @@ pub struct BgmFormat {
pub tracks: FastHashMap<String, BgmTrack>, pub tracks: FastHashMap<String, BgmTrack>,
} }
#[derive(Clone)]
pub struct BgmTrack { pub struct BgmTrack {
pub(super) config: StreamConfig,
pub(super) format: SampleFormat,
pub(super) track_offset: u32, pub(super) track_offset: u32,
pub(super) intro_size: u32, pub(super) intro_size: u32,
pub(super) track_size: u32, pub(super) track_size: u32,
@ -36,6 +33,7 @@ impl BgmFormat {
extra_byte_count: u16, extra_byte_count: u16,
pad: u16, pad: u16,
} }
type TrackName = [u8; 16]; type TrackName = [u8; 16];
const TRACK_NAME_SIZE: usize = size_of::<TrackName>(); const TRACK_NAME_SIZE: usize = size_of::<TrackName>();
@ -54,16 +52,11 @@ impl BgmFormat {
} }
let track_name = track_name.to_str().unwrap().to_owned(); let track_name = track_name.to_str().unwrap().to_owned();
println!("track: {:?}", track_name);
let track = Track::ref_from_bytes(&bytes[(start + TRACK_NAME_SIZE)..(start + TRACK_SIZE)]).unwrap(); let track = Track::ref_from_bytes(&bytes[(start + TRACK_NAME_SIZE)..(start + TRACK_SIZE)]).unwrap();
tracks.insert( tracks.insert(
track_name, track_name,
BgmTrack { BgmTrack {
config: StreamConfig {
channels: track.channels,
sample_rate: SampleRate(track.samples_per_sec),
buffer_size: BufferSize::Fixed(track.intro_size + track.track_size),
},
format: SampleFormat::I16,
track_offset: track.track_offset, track_offset: track.track_offset,
intro_size: track.intro_size, intro_size: track.intro_size,
track_size: track.track_size, track_size: track.track_size,
@ -75,4 +68,14 @@ impl BgmFormat {
Self { tracks } Self { tracks }
} }
pub fn get_track_buffers(&mut self, file_name: &str) -> (Range<usize>, Range<usize>) {
let track = self.tracks.get(file_name).expect("failed to find bgm file");
let intro_start = track.track_offset as usize;
let track_start = intro_start + track.intro_size as usize;
let track_end = intro_start + track.track_size as usize;
(intro_start..track_start, track_start..track_end)
}
} }

43
src/game/snd/bgm/mod.rs
View file

@ -1 +1,44 @@
use async_std::fs::read;
use format::BgmFormat;
use rodio::{static_buffer::StaticSamplesBuffer, Sink, Source};
pub mod format; pub mod format;
pub struct BgmManager {
bgm_format: BgmFormat,
bgm_file: &'static [u8],
music_sink: Sink,
}
impl BgmManager {
pub(super) async fn new(music_sink: Sink) -> BgmManager {
let bgm_format = BgmFormat::new(read("assets/thbgm.fmt").await.unwrap());
let bgm_file = read("./thbgm.dat").await.unwrap();
music_sink.set_volume(0.1);
Self {
bgm_format,
bgm_file: bgm_file.leak(),
music_sink,
}
}
pub fn play_track(&mut self, file_name: &str) {
let (intro_range, track_range) = self.bgm_format.get_track_buffers(file_name);
self.music_sink.clear();
log::info!("intro: {intro_range:?}, {track_range:?}");
self.music_sink.append(StaticSamplesBuffer::<i16>::new(
2,
44100,
bytemuck::cast_slice(&self.bgm_file[intro_range]),
));
self.music_sink.append(
StaticSamplesBuffer::<i16>::new(2, 44100, bytemuck::cast_slice(&self.bgm_file[track_range])).repeat_infinite(),
);
self.music_sink.play();
}
}

41
src/game/snd/mod.rs
View file

@ -1,23 +1,42 @@
use std::{ use std::sync::Arc;
fs::{self, File}, sync::Arc
use bgm::BgmManager;
use rodio::{
dynamic_mixer::{mixer, DynamicMixerController}, OutputStream, Sink
}; };
use bgm::format::BgmFormat; use crate::utils::soon::Soon;
use memmap2::{Mmap, MmapOptions};
pub mod bgm; pub mod bgm;
pub struct Manager { pub struct Manager {
bgm_format: bgm::format::BgmFormat, bgm_manager: Soon<BgmManager>,
bgm_file: Arc<Mmap>, _output_stream: OutputStream,
_sound_sink: Sink,
_sound_controller: Arc<DynamicMixerController<i16>>,
} }
impl Manager { impl Manager {
pub fn new() -> Self { pub fn new() -> Self {
let bgm_format = BgmFormat::new(fs::read("assets/thbgm.fmt").unwrap()); let (output_stream, stream_handle) = OutputStream::try_default().unwrap();
let bgm_file = Arc::new(unsafe { let sound_sink = Sink::try_new(&stream_handle).unwrap();
MmapOptions::new().map(&File::open("./thbgm.dat").unwrap()).expect("failed to open thbgm.dat") let music_sink = Sink::try_new(&stream_handle).unwrap();
}); let (sound_controller, mixer) = mixer::<i16>(2, 44100);
Self { bgm_format, bgm_file } sound_sink.append(mixer);
Self {
bgm_manager: Soon::new(BgmManager::new(music_sink)),
_output_stream: output_stream,
_sound_sink: sound_sink,
_sound_controller: sound_controller,
}
}
pub fn is_bgm_manager_loaded(&mut self) -> bool {
self.bgm_manager.is_done()
}
pub fn get_bgm_manager(&mut self) -> &mut BgmManager {
self.bgm_manager.try_borrow_mut().unwrap()
} }
} }

0
src/game/states/game/enemy/loaded_file.rs Normal file
View file

2
src/game/states/game/enemy/mod.rs Normal file
View file

@ -0,0 +1,2 @@
pub mod loaded_file;
pub mod vm;

5
src/game/states/game/enemy/vm/mod.rs Normal file
View file

@ -0,0 +1,5 @@
mod opcodes;
struct StackEntry {}
pub struct EclVm {}

143
src/game/states/game/enemy/vm/opcodes.rs Normal file
View file

@ -0,0 +1,143 @@
use num_derive::FromPrimitive;
#[derive(FromPrimitive, Clone, Copy)]
enum Opcode {
Nop = 0,
// control flow
Delete = 1,
Ret = 10,
Call = 11,
Jump = 12,
JumpEq = 13,
JumpNeq = 14,
CallAsync = 15,
CallAsyncById = 16,
KillAsync = 17,
KillAllAsync = 21,
// stack math
StackAlloc = 40,
PushInt = 42,
SetInt = 43,
PushFloat = 44,
SetFloat = 45,
AddInt = 50,
AddFloat = 51,
SubInt = 52,
SubFloat = 53,
MulInt = 54,
MulFloat = 55,
DivInt = 56,
DivFloat = 57,
ModInt = 58,
EqualInt = 59,
EqualFloat = 60,
NotEqualInt = 61,
NotEqualFloat = 62,
LessInt = 63,
LessFloat = 64,
LessEqualInt = 65,
LessEqualFloat = 66,
GreaterInt = 67,
GreaterFloat = 68,
GreaterEqualInt = 69,
GreaterEqualFloat = 70,
NotInt = 71,
NotFloat = 72,
LogicalOr = 73,
LogicalAnd = 74,
BitwiseXor = 75,
BitwiseOr = 76,
BitwiseAnd = 77,
DecrementInt = 78,
Sin = 79,
Cos = 80,
CirclePos = 81,
ValidRad = 82,
Wait = 83,
NegateInt = 84,
NegateFloat = 85 ,
SquareSum = 86,
GetAngle = 87,
SquareRoot = 88,
Linear = 89,
PointRotate = 90,
FloatTime = 91,
Math92 = 92,
Math93 = 93,
EnemyCreate = 256,
EnemyCreateAbsolute = 257,
EnemySelectAnm = 258,
EnemySetAnmSprite = 259,
EnemyCreateMirrored = 260,
EnemyCreateMirroredAbsolute = 261,
EnemySetMainAnm = 262,
EnemyPlayAnm = 263,
EnemyPlayAnmAbsolute = 264,
EnemyCreateFiller = 265,
EnemyCreateFillerAbsolute = 266,
EnemyCreateFillerMirrored = 267,
EnemyCreateFillerMirroredAbsolute = 268,
EnemyPlaySelected = 269,
EnemySwitchAnm = 275,
EnemyResetAnm = 276,
EnemyInst277 = 277,
EnemyInst278 = 278,
MovePos = 280,
MovePosTime = 281,
MovePosRel = 282,
MovePosRelTime = 283,
MoveVel = 284,
MoveVelTime = 285,
MoveVelRel = 286,
MoveVelRelTime = 287,
MoveCircle = 288,
MoveCircleTime = 289,
MoveCircleRel = 290,
MoveCircleRelTime = 291,
MoveRand = 292,
MoveRandRel = 293,
MoveAdd = 294,
MoveAddRel = 295,
MoveEllipse = 300,
MoveEllipseRel = 301,
MoveBezier = 305,
MoveReset = 307,
SetHurtbox = 320,
SetHitbox = 321,
FlagSet = 322,
FlagClear = 323,
Movelimit = 324,
MoveLimitReset = 325,
ClearExtraDrops = 326,
AddExtraDrops = 327,
SetDropArea = 328,
DropItems = 329,
SetMainDrop = 330,
SetHealth = 331,
SetBoss = 332,
TimerReset = 333,
SetInterrupt = 334,
SetInvulnerable = 335,
PlaySound = 336,
ShakeScreen = 337,
StartDialogue = 338,
WaitForDialogue = 339,
WaitForDeath = 340,
SetTimeout = 341,
SpellById,
EndSpell,
SetChapter,
KillAllEnemies,
ProtectPlayer,
LifeMarker,
SetByDifficultyInt,
SetByDifficultyFloat,
SpellDifficulty,
SpellDifficultyM1,
}

3
src/game/states/game/mod.rs Normal file
View file

@ -0,0 +1,3 @@
mod enemy;
pub struct Game {}

26
src/game/states/guard.rs
View file

@ -1,26 +0,0 @@
use std::marker::PhantomData;
use sfsm::TransitGuard;
use crate::game::GameContext;
pub enum TimeGuard {
Idle,
Waiting(u32),
}
impl TimeGuard {
pub fn start_wait(&mut self, time: u32) {
*self = Self::Waiting(time);
}
pub fn tick(&mut self) {
if let TimeGuard::Waiting(ref mut counter) = self {
*counter = counter.saturating_sub(1);
}
}
pub fn guard(&self) -> TransitGuard {
matches!(self, TimeGuard::Waiting(0)).into()
}
}

63
src/game/states/loading.rs
View file

@ -1,66 +1,55 @@
use std::{ops::RangeInclusive, rc::Rc, sync::Arc}; use std::{cell::RefCell, ops::RangeInclusive, sync::Arc};
use glam::Vec3; use glam::Vec3;
use sfsm::{State, TransitGuard, Transition}; use sfsm::{State, TransitGuard, Transition};
use winit::keyboard::KeyCode;
use crate::game::{ use crate::{
anm::{Vm, VmLocation}, GameContext game::{
anm::{LoadedFile, Vm, VmLocation}, GameContext
}, utils::soon::Soon
}; };
use super::{guard::TimeGuard, title::TitleScreen, UPDATE_CONTEXT}; use super::{title::TitleScreen, UPDATE_CONTEXT};
pub struct Loading { pub struct Loading {
sig: Vm, _sig: Vm,
ascii_loading: Vm, _ascii_loading: Vm,
test_snowflakes: Vec<Vm>,
time: u32, title_anm: RefCell<Soon<Arc<LoadedFile>>>,
range: RangeInclusive<f32>,
done: TimeGuard,
} }
impl Loading { impl Loading {
pub fn new(context: &mut GameContext) -> Loading { pub fn new(context: &mut GameContext) -> Loading {
let ascii = context.load_anm("ascii.anm"); let ascii = context.load_anm("ascii.anm");
let sig_anm = context.load_anm("sig.anm"); let sig_anm = context.load_anm("sig.anm");
let sig = context.anm_manager.new_vm(sig_anm, None, false, false, 0, VmLocation::new_ui()); let sig = context.anm_manager.new_vm(sig_anm, None, 0, VmLocation::new_ui());
let ascii_loading = context.anm_manager.new_vm( let ascii_loading = context.anm_manager.new_vm(ascii.clone(), None, 16, VmLocation::new_ui());
ascii.clone(), ascii_loading.borrow_mut().origin = Vec3::new(480.0, 392.0, 0.0);
Some(Vec3::new(480.0, 392.0, 0.0)),
// Some(Vec3::new(300.0, 300.0, 0.0)),
false,
false,
16,
VmLocation::new_ui(),
);
// ascii_loading.borrow_mut().debug_freeze();
Loading { Loading {
sig, _sig: sig,
ascii_loading, _ascii_loading: ascii_loading,
test_snowflakes: vec![],
time: 0, title_anm: context.start_load_anm("title.anm").into(),
range: f32::MAX..=f32::MIN,
done: TimeGuard::Idle,
} }
// LoadingState{ascii_loading}
} }
} }
impl State for Loading { impl State for Loading {
fn execute(&mut self) { fn execute(&mut self) {
self.test_snowflakes.retain(|vm| !vm.borrow().deleted()); // if UPDATE_CONTEXT.with(|context| context.sound_manager.get_bgm_manager().is_some()) {
self.time += 1; // log::info!("a");
// }
// if self.title_anm.borrow_mut().is_done() {
// log::info!("b")
// }
} }
} }
impl Transition<TitleScreen> for Loading { impl Transition<TitleScreen> for Loading {
fn guard(&self) -> TransitGuard { fn guard(&self) -> TransitGuard {
// if self.time > 60 { UPDATE_CONTEXT
// TransitGuard::Transit .with(|context| context.sound_manager.is_bgm_manager_loaded() && self.title_anm.borrow_mut().is_done())
// } else { .into()
// TransitGuard::Remain
// }
UPDATE_CONTEXT.with(|context| context.engine.keys.was_key_pressed(KeyCode::Space)).into()
} }
} }

4
src/game/states/mod.rs
View file

@ -1,4 +1,4 @@
mod guard; pub mod game;
mod loading; mod loading;
mod title; mod title;
@ -10,7 +10,7 @@ use title::TitleScreen;
use super::GameContext; use super::GameContext;
pub(super) static UPDATE_CONTEXT: ContextMut<GameContext> = ContextMut::new(); pub(super) static UPDATE_CONTEXT: ContextMut<GameContext, GameStateMachine> = ContextMut::new();
add_state_machine!(Machine, Loading, {Loading, TitleScreen}, { add_state_machine!(Machine, Loading, {Loading, TitleScreen}, {
Loading => TitleScreen, Loading => TitleScreen,

25
src/game/states/title.rs
View file

@ -1,4 +1,4 @@
use sfsm::{State, Transition}; use sfsm::{State, TransitGuard, Transition};
use winit::keyboard::KeyCode; use winit::keyboard::KeyCode;
use crate::game::{ use crate::game::{
@ -17,8 +17,8 @@ impl TitleScreen {
let title = context.load_anm("title.anm"); let title = context.load_anm("title.anm");
// 79, 83 // 79, 83
let splash = context.anm_manager.new_vm(title.clone(), None, false, false, 79, VmLocation::new_ui()); let splash = context.anm_manager.new_vm(title.clone(), Some(8), 79, VmLocation::new_ui());
let logo = context.anm_manager.new_vm(title.clone(), None, false, true, 83, VmLocation::new_ui()); let logo = context.anm_manager.new_vm(title.clone(), Some(8), 83, VmLocation::new_ui());
Self { Self {
_logo: logo, _logo: logo,
@ -28,20 +28,31 @@ impl TitleScreen {
} }
impl State for TitleScreen { impl State for TitleScreen {
fn execute(&mut self) {} fn execute(&mut self) {
UPDATE_CONTEXT.with(|context| {
if context.engine.keys.was_key_pressed(KeyCode::Space) {
self._logo.borrow_mut().interrupt(1);
}
})
}
} }
impl From<Loading> for TitleScreen { impl From<Loading> for TitleScreen {
fn from(_: Loading) -> Self { fn from(_: Loading) -> Self {
UPDATE_CONTEXT.with(|context| TitleScreen::new(context, true)) UPDATE_CONTEXT.with(|context| {
context.sound_manager.get_bgm_manager().play_track("th11_00.wav");
TitleScreen::new(context, true)
})
} }
} }
impl Transition<TitleScreen> for TitleScreen { impl Transition<TitleScreen> for TitleScreen {
fn action(&mut self) { fn action(&mut self) {
*self = UPDATE_CONTEXT.with(|context| TitleScreen::new(context, true)) *self = UPDATE_CONTEXT.with(|context| TitleScreen::new(context, false))
} }
fn guard(&self) -> sfsm::TransitGuard {
fn guard(&self) -> TransitGuard {
UPDATE_CONTEXT.with(|context| context.engine.keys.was_key_pressed(KeyCode::Space)).into() UPDATE_CONTEXT.with(|context| context.engine.keys.was_key_pressed(KeyCode::Space)).into()
// UPDATE_CONTEXT.with(|_| self._logo.borrow().deleted()).into()
} }
} }

12
src/main.rs
View file

@ -1,13 +1,9 @@
pub mod engine; pub mod engine;
pub mod game; pub mod game;
pub mod interp; pub mod interp;
pub mod utils { pub mod utils;
pub mod context;
}
use std::{ use std::{sync::Arc, time::Duration};
sync::Arc, time::{Duration, Instant}
};
use engine::Engine; use engine::Engine;
use wgpu::SurfaceError; use wgpu::SurfaceError;
@ -43,11 +39,11 @@ impl<'a> ApplicationHandler for App<'a> {
std::process::exit(0); std::process::exit(0);
} }
fn about_to_wait(&mut self, event_loop: &winit::event_loop::ActiveEventLoop) { fn about_to_wait(&mut self, _: &winit::event_loop::ActiveEventLoop) {
// self.window.as_ref().unwrap().request_redraw(); // self.window.as_ref().unwrap().request_redraw();
} }
fn new_events(&mut self, event_loop: &winit::event_loop::ActiveEventLoop, cause: winit::event::StartCause) { fn new_events(&mut self, _: &winit::event_loop::ActiveEventLoop, cause: winit::event::StartCause) {
if let StartCause::ResumeTimeReached { .. } = cause { if let StartCause::ResumeTimeReached { .. } = cause {
self.window.as_ref().unwrap().request_redraw(); self.window.as_ref().unwrap().request_redraw();
} }

16
src/utils/context.rs
View file

@ -65,13 +65,13 @@ use std::marker::PhantomData;
#[doc(hidden)] #[doc(hidden)]
#[derive(Default)] #[derive(Default)]
pub struct ContextMut<T>(PhantomData<T>); pub struct ContextMut<T, Key>(PhantomData<(T, Key)>);
unsafe impl<T> Sync for ContextMut<T> {} unsafe impl<T, Key> Sync for ContextMut<T, Key> {}
#[allow(unused)] #[allow(unused)]
impl<T> ContextMut<T> { impl<T, Key> ContextMut<T, Key> {
pub const fn new() -> ContextMut<T> { pub const fn new() -> ContextMut<T, Key> {
ContextMut(PhantomData) ContextMut(PhantomData)
} }
@ -107,13 +107,13 @@ impl<T> ContextMut<T> {
#[doc(hidden)] #[doc(hidden)]
#[derive(Default)] #[derive(Default)]
pub struct Context<T>(PhantomData<T>); pub struct Context<T, Key>(PhantomData<(T, Key)>);
unsafe impl<T> Sync for Context<T> {} unsafe impl<T, Key> Sync for Context<T, Key> {}
#[allow(unused)] #[allow(unused)]
impl<T> Context<T> { impl<T, Key> Context<T, Key> {
pub const fn new() -> Context<T> { pub const fn new() -> Context<T, Key> {
Context(PhantomData) Context(PhantomData)
} }

2
src/utils/mod.rs Normal file
View file

@ -0,0 +1,2 @@
pub mod context;
pub mod soon;

70
src/utils/soon.rs Normal file
View file

@ -0,0 +1,70 @@
use std::future::Future;
use futures::channel::oneshot;
pub enum Soon<T: Send + 'static> {
Waiting(oneshot::Receiver<T>),
Value(T),
}
impl<T: Send + 'static> Soon<T> {
pub fn new(future: impl Future<Output = T> + Send + 'static) -> Self {
let (sender, receiver) = oneshot::channel();
async_std::task::spawn(async move {
let _ = sender.send(future.await);
});
Self::Waiting(receiver)
}
pub fn is_done(&mut self) -> bool {
match self {
Soon::Waiting(receiver) => {
if let Some(value) = receiver.try_recv().unwrap() {
*self = Soon::Value(value);
true
} else {
false
}
}
Soon::Value(_) => true,
}
}
pub fn try_borrow(&mut self) -> Option<&T> {
match self {
Soon::Waiting(receiver) => {
if let Some(value) = receiver.try_recv().unwrap() {
*self = Soon::Value(value);
self.try_borrow()
} else {
None
}
}
Soon::Value(ref value) => Some(value),
}
}
pub fn try_borrow_mut(&mut self) -> Option<&mut T> {
match self {
Soon::Waiting(receiver) => {
if let Some(value) = receiver.try_recv().unwrap() {
*self = Soon::Value(value);
self.try_borrow_mut()
} else {
None
}
}
Soon::Value(ref mut value) => Some(value),
}
}
}
impl<T: Clone + Send + 'static> Soon<T> {
pub fn try_clone(&mut self) -> Option<T> {
self.try_borrow().cloned()
}
}