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

work on enemies, stage loading and rendering

Browse source
This commit is contained in:
Aubrey 2025-02-12 10:43:23 -06:00
parent c48627aec9
commit 4a7559e2bb
No known key found for this signature in database
39 changed files with 2197 additions and 537 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

11
Cargo.lock generated
View file

@ -611,6 +611,7 @@ dependencies = [
"glam",
"heapless",
"identconv",
"instructions",
"log",
"macros",
"memmap2",
@ -1594,6 +1595,16 @@ dependencies = [
"hashbrown 0.15.0",
]
[[package]]
name = "instructions"
version = "0.1.0"
dependencies = [
"macros",
"num-derive",
"num-traits",
"truth",
]
[[package]]
name = "is-terminal"
version = "0.4.13"

9
Cargo.toml
View file

@ -1,3 +1,9 @@
[workspace]
resolver = "2"
members = ["instructions", "macros"]
[workspace.dependencies]
truth = { git = "https://github.com/ExpHP/truth" }
[package]
name = "chireiden-thing"
version = "0.1.0"
@ -13,7 +19,7 @@ ndarray = "0.16.1"
num-derive = "0.4.2"
num-traits = "0.2.19"
rand = "0.8.5"
truth = { git = "https://github.com/ExpHP/truth" }
truth = { workspace = true }
anyhow = { version = "1.0", features = ["backtrace"] }
glam = { version = "0.29", features = ["bytemuck"] }
bytemuck = { version = "1.18", features = ["derive"] }
@ -32,6 +38,7 @@ atomic_refcell = "0.1.13"
pin-project = "1.1.7"
heapless = "0.8.0"
bitfield-struct = "0.9.2"
instructions = { version = "0.1.0", path = "instructions" }
[dev-dependencies]
csv = "1.3.0"

6
flake.nix
View file

@ -40,6 +40,12 @@
alsa-lib
(pkgs.callPackage ./thtk.nix {})
(pkgs.callPackage ./truth.nix {})
xorg.libX11
xorg.libXcursor
xorg.libxcb
xorg.libXi
libxkbcommon
];
LD_LIBRARY_PATH = libPath;
};

10
instructions/Cargo.toml Normal file
View file

@ -0,0 +1,10 @@
[package]
name = "instructions"
version = "0.1.0"
edition = "2021"
[dependencies]
macros = { version = "0.1.0", path = "../macros" }
num-derive = "0.4.2"
num-traits = "0.2.19"
truth = { workspace = true }

82
src/game/anm/vm/opcodes.rs → instructions/src/anm.rs
View file

@ -2,9 +2,8 @@ use macros::decode_args;
use num_derive::FromPrimitive;
use num_traits::FromPrimitive;
use truth::llir::RawInstr;
use wgpu::naga::FastHashMap;
use crate::game::param::Param;
use crate::Param;
#[derive(Debug, FromPrimitive)]
enum Opcode {
@ -93,21 +92,21 @@ enum Opcode {
Color2Time = 78,
Alpha2Time = 79,
ColorMode = 80,
CaseReturn = 81,
ReturnFromInterrupt = 81,
RotateAuto = 82,
Ins83CopyPos = 83,
TexCircle = 84,
UnknownBitflag = 85,
SlowdownImmune = 86,
RandMode = 87,
ScriptNew = 88,
NewChildBack = 88,
ResampleMode = 89,
ScriptNewUI = 90,
ScriptNewFront = 91,
ScriptNewUIFront = 92,
NewChildUIBack = 90,
NewChildFront = 91,
NewChildUIFront = 92,
ScrollXTime = 93,
ScrollYTime = 94,
ScriptNewRoot = 95,
NewRootBack = 95,
ScriptNewPos = 96,
ScriptNewRootPos = 97,
MoveBezier = 100,
@ -163,6 +162,8 @@ pub enum SpriteType {
Rotate3D = 2,
RotateZ3D = 3,
RotateBillboard = 4,
Unknown3DA = 6,
Unknown3DB = 8,
}
#[derive(Debug, Clone, Copy)]
@ -312,38 +313,43 @@ pub enum Op {
Visible {
value: i8,
},
ZWriteDisable {
value: i32,
},
ZWriteDisable(bool),
StdRelatedBitflag {
enable: i32,
},
Wait {
time: i32,
},
CaseReturn,
ReturnFromInterrupt,
UnknownBitflag {
enable: i32,
},
RandMode {
mode: i32,
},
ScriptNew {
NewChildBack {
script: i32,
},
ResampleMode {
mode: i32,
},
ScriptNewUI {
NewChildUIBack {
script: i32,
},
ScriptNewFront {
NewChildFront {
script: i32,
},
ScriptNewUIFront {
NewChildUIFront {
script: i32,
},
ScrollXTime,
NewRootBack {
script: i32,
},
SpriteRand {
sprite: i32,
end: Param<i32>,
},
}
#[derive(Debug, Clone, Copy)]
@ -353,7 +359,7 @@ pub struct Instruction {
}
impl Instruction {
pub fn from_raw(inst: RawInstr, instruction_offsets: &FastHashMap<u32, usize>) -> Self {
pub fn from_raw(inst: RawInstr, instruction_offsets: &Vec<(u32, usize)>) -> Self {
let param_int = |value: i32, index: u16| {
if inst.param_mask & (1 << index) == 0 {
Param::Value(value)
@ -385,7 +391,8 @@ impl Instruction {
);
value as i32
};
let offset_to_index = |value: i32| instruction_offsets[&(value as u32)];
let offset_to_index =
|value: i32| instruction_offsets.binary_search_by_key(&(value as u32), |a| a.0).expect("failed to find entry");
let args = &inst.args_blob;
let opcode_raw = inst.opcode;
@ -694,6 +701,18 @@ impl Instruction {
Op::Layer { layer }
}
Opcode::StopHide => Op::StopHide,
Opcode::ScrollX => {
let value = decode_args!(args, "f");
Op::ScrollX { value }
}
Opcode::ScrollY => {
let value = decode_args!(args, "f");
Op::ScrollY { value }
}
Opcode::ZWriteDisable => {
let value = decode_args!(args, "S");
Op::ZWriteDisable(value != 0)
}
Opcode::UnknownBitflag => {
let enable = decode_args!(args, "S");
@ -703,31 +722,40 @@ impl Instruction {
let time = decode_args!(args, "S");
Op::Wait { time }
}
Opcode::CaseReturn => Op::CaseReturn,
Opcode::ReturnFromInterrupt => Op::ReturnFromInterrupt,
Opcode::RandMode => {
let mode = decode_args!(args, "S");
Op::RandMode { mode }
}
Opcode::ScriptNew => {
Opcode::NewChildBack => {
let script = decode_args!(args, "S");
Op::ScriptNew { script }
Op::NewChildBack { script }
}
Opcode::ResampleMode => {
let mode = decode_args!(args, "S");
Op::ResampleMode { mode }
}
Opcode::ScriptNewUI => {
Opcode::NewChildUIBack => {
let script = decode_args!(args, "S");
Op::ScriptNewUI { script }
Op::NewChildUIBack { script }
}
Opcode::ScriptNewFront => {
Opcode::NewChildFront => {
let script = decode_args!(args, "S");
Op::ScriptNewFront { script }
Op::NewChildFront { script }
}
Opcode::ScriptNewUIFront => {
Opcode::NewChildUIFront => {
let script = decode_args!(args, "S");
Op::ScriptNewUIFront { script }
Op::NewChildUIFront { script }
}
Opcode::NewRootBack => {
let script = decode_args!(args, "S");
Op::NewRootBack { script }
}
Opcode::SpriteRand => {
let (sprite, end) = decode_args!(args, "SS");
let end = param_int(end, 1);
Op::SpriteRand { sprite, end }
}
opcode => panic!("unsupported instruction {opcode:?} ({opcode_raw})"),
};

1087
instructions/src/ecl.rs Normal file
View file

File diff suppressed because it is too large Load diff

5
instructions/src/lib.rs Normal file
View file

@ -0,0 +1,5 @@
pub mod anm;
mod param;
pub mod ecl;
pub mod std;
pub use param::*;

0
src/game/param.rs → instructions/src/param.rs
View file

149
instructions/src/std.rs Normal file
View file

@ -0,0 +1,149 @@
use macros::decode_args;
use num_derive::FromPrimitive;
use num_traits::FromPrimitive;
use truth::llir::RawInstr;
#[derive(Debug, FromPrimitive)]
enum Opcode {
Halt = 0,
Jump = 1,
Position = 2,
PositionInterp = 3,
Facing = 4,
FacingInterp = 5,
Rotation = 6,
FieldOfView = 7,
Fog = 8,
FogInterp = 9,
PositionInterpBezier = 10,
FacingInterpBezier = 11,
ShakingMode = 12,
BackgroundFillColor = 13,
BackgroundSprite = 14,
}
#[derive(Debug)]
pub enum Op {
Halt,
Jump {
index: usize,
time: i32,
},
Position {
x: f32,
y: f32,
z: f32,
},
PositionInterp {
time: i32,
mode: i32,
x: f32,
y: f32,
z: f32,
},
Facing {
x: f32,
y: f32,
z: f32,
},
FacingInterp {
time: i32,
mode: i32,
x: f32,
y: f32,
z: f32,
},
Rotation {
x: f32,
y: f32,
z: f32,
},
FieldOfView(f32),
Fog {
color: i32,
start: f32,
end: f32,
},
FogInterp {
time: i32,
mode: i32,
color: i32,
start: f32,
end: f32,
},
ShakingMode {
mode: i32,
},
}
pub struct Instruction {
pub time: i32,
pub op: Op,
}
impl Instruction {
pub fn from_raw(inst: RawInstr, instruction_offsets: &Vec<(u32, usize)>) -> Self {
let offset_to_index =
|value: i32| instruction_offsets.binary_search_by_key(&(value as u32), |a| a.0).expect("failed to find entry");
let args = &inst.args_blob;
let opcode_raw = inst.opcode;
let opcode = Opcode::from_u16(opcode_raw).expect("failed to convert opcode");
let op = match opcode {
Opcode::Halt => Op::Halt,
Opcode::Jump => {
let (offset, time) = decode_args!(args, "ot");
Op::Jump {
index: offset_to_index(offset),
time,
}
}
Opcode::Position => {
let (x, y, z) = decode_args!(args, "fff");
Op::Position { x, y, z }
}
Opcode::PositionInterp => {
let (time, mode, x, y, z) = decode_args!(args, "SUfff");
Op::PositionInterp { time, mode, x, y, z }
}
Opcode::Facing => {
let (x, y, z) = decode_args!(args, "fff");
Op::Facing { x, y, z }
}
Opcode::FacingInterp => {
let (time, mode, x, y, z) = decode_args!(args, "SUfff");
Op::FacingInterp { time, mode, x, y, z }
}
Opcode::Rotation => {
let (x, y, z) = decode_args!(args, "fff");
Op::Rotation { x, y, z }
}
Opcode::FieldOfView => {
let fov = decode_args!(args, "f");
Op::FieldOfView(fov)
}
Opcode::Fog => {
let (color, start, end) = decode_args!(args, "Sff");
Op::Fog { color, start, end }
}
Opcode::FogInterp => {
let (time, mode, color, start, end) = decode_args!(args, "SUSff");
Op::FogInterp {
time,
mode,
color,
start,
end,
}
}
Opcode::PositionInterpBezier => todo!(),
Opcode::FacingInterpBezier => todo!(),
Opcode::ShakingMode => todo!(),
Opcode::BackgroundFillColor => todo!(),
Opcode::BackgroundSprite => todo!(),
};
Instruction { time: inst.time, op }
}
}

139
macros/src/lib.rs
View file

@ -1,20 +1,21 @@
use proc_macro2::TokenStream;
use proc_macro2::{Span, TokenStream};
use quote::quote;
use syn::{
parse::{ParseStream, Parser}, Expr, LitStr, Token
parse::{ParseStream, Parser},
spanned::Spanned,
Expr, ExprLit, Ident, Lit, LitStr, Token, Type, TypeArray,
};
use truth::{
context::RootEmitter, llir::{ArgEncoding, InstrAbi, StringArgSize}, pos::SourceStr
context::RootEmitter,
llir::{ArgEncoding, InstrAbi, StringArgSize},
pos::SourceStr,
};
#[proc_macro]
pub fn decode_args(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
match blob_impl.parse(input.clone()) {
match blob_impl.parse(input) {
Ok(data) => data.into(),
Err(error) => {
// error.span().unwrap().error(error.to_string());
error.into_compile_error().into()
}
Err(error) => error.into_compile_error().into(),
}
}
@ -22,11 +23,14 @@ fn blob_impl(input: ParseStream) -> syn::Result<TokenStream> {
let reader: Expr = input.parse()?;
let _: Token![,] = input.parse()?;
let sig_str: LitStr = input.parse()?;
let sig = InstrAbi::parse(
SourceStr::from_full_source(None, sig_str.value().as_str()),
&RootEmitter::new_stderr(),
)
.unwrap();
let sig_str_span = sig_str.span();
let sig_str = sig_str.value();
let (sig_str, variadic) = if sig_str.ends_with('v') {
(&sig_str.as_str()[..sig_str.len() - 1], true)
} else {
(sig_str.as_str(), false)
};
let sig = InstrAbi::parse(SourceStr::from_full_source(None, sig_str), &RootEmitter::new_stderr()).unwrap();
let encodings: Vec<_> = sig
.arg_encodings()
.map(|enc| {
@ -43,22 +47,127 @@ fn blob_impl(input: ParseStream) -> syn::Result<TokenStream> {
}
ArgEncoding::JumpTime => quote!(cursor.read_i32().unwrap()),
ArgEncoding::JumpOffset => quote!(cursor.read_i32().unwrap()),
ArgEncoding::Color => quote!(cursor.read_u32().unwrap()),
ArgEncoding::String {
size: StringArgSize::Fixed { len, .. },
..
} => quote!(cursor.read_cstring_exact(#len)),
_ => return Err(syn::Error::new(sig_str.span(), "failed...")),
} => quote!(cursor.read_cstring_exact(#len).unwrap().decode(truth::io::DEFAULT_ENCODING).unwrap()),
ArgEncoding::String {
size: StringArgSize::Pascal { block_size },
..
} => quote!(cursor.read_cstring_blockwise(#block_size).unwrap().decode(truth::io::DEFAULT_ENCODING).unwrap()),
_ => return Err(syn::Error::new(sig_str_span, "failed...")),
})
})
.collect::<syn::Result<_>>()?;
let variadic = variadic.then(|| {
quote! {
, {
let file_size = cursor.file_size().unwrap();
let offset = (file_size - cursor.pos().unwrap()) as usize;
cursor.read_byte_vec(offset).unwrap()
}
}
});
Ok(quote! {
{
use truth::io::BinRead;
let mut cursor = ::std::io::Cursor::new(#reader);
(
#(#encodings),*
#variadic
)
}
})
}
//spawner_rank_decode_args!(args, "S", [[f32; 2]; 3])
#[proc_macro]
pub fn spawner_param_decode_args(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
match spawner_param_decode_args_impl.parse(input) {
Ok(data) => data.into(),
Err(error) => error.into_compile_error().into(),
}
}
fn spawner_param_decode_args_impl(input: ParseStream) -> syn::Result<TokenStream> {
let reader: Expr = input.parse()?;
let _: Token![,] = input.parse()?;
let sig_str: LitStr = input.parse()?;
let _: Token![,] = input.parse()?;
let array = input.parse::<TypeArray>()?;
let Expr::Lit(ExprLit { lit: Lit::Int(int), .. }) = array.len else {
return Err(syn::Error::new(array.len.span(), "length must be a constant number"));
};
let rank_count = int.base10_parse::<usize>()?;
let Type::Array(TypeArray {
elem,
len: Expr::Lit(ExprLit { lit: Lit::Int(int), .. }),
..
}) = array.elem.as_ref()
else {
return Err(syn::Error::new(
array.elem.span(),
"element was not an array with constant number ",
));
};
let entry_count = int.base10_parse::<usize>()?;
let Type::Path(path) = elem.as_ref() else {
return Err(syn::Error::new(elem.span(), "expected path as element"));
};
let ident = path.path.get_ident().ok_or(syn::Error::new(path.span(), "path was not a single ident"))?;
let type_id = ident.to_string();
enum ParamType {
Float,
Int,
}
let param_ty = match type_id.as_str() {
"f32" => ParamType::Float,
"i32" => ParamType::Int,
_ => return Err(syn::Error::new(ident.span(), "expected i32 or f32")),
};
let total = entry_count * rank_count;
let mut arguments = sig_str.value();
arguments.extend(std::iter::repeat_n(
match param_ty {
ParamType::Int => 'S',
ParamType::Float => 'f',
},
total,
));
let rank_list: Vec<Vec<Ident>> = (0..rank_count)
.map(|rank| {
(0..entry_count).map(move |entry| Ident::new(&format!("__a_{rank}_{entry}"), Span::call_site())).collect()
})
.collect();
let tuple_pat = rank_list.iter().flatten();
let rank_array = rank_list.iter().enumerate().map(|(rank_index, list)| {
let list = list.iter().enumerate().map(|(entry_index, entry)| {
let param_index = rank_index * entry_count + entry_index + 1;
let param_index = param_index as u16;
let kind = match param_ty {
ParamType::Float => quote!(param_float),
ParamType::Int => quote!(param_int),
};
quote!(#kind(#entry, #param_index))
});
quote! {
[#(#list),*]
}
});
Ok(quote! {
{
let (id, #(#tuple_pat),*) = decode_args!(#reader, #arguments);
(id, [#(#rank_array),*])
}
})
}

31
src/engine.rs
View file

@ -1,5 +1,5 @@
use std::{
sync::{Arc, LazyLock, Mutex}, time::{Duration, Instant}
cell::Cell, ops::ControlFlow, sync::{Arc, LazyLock}, time::{Duration, Instant}
};
use wgpu::{
@ -23,6 +23,7 @@ pub struct Engine<'a> {
last_frame_instant: Instant,
last_second: Instant,
frames: u32,
should_exit: Cell<bool>,
state: GameRunner,
focused: bool,
@ -48,6 +49,7 @@ impl KeyState {
#[derive(Default)]
pub struct Keys {
values: FastHashMap<KeyCode, KeyState>,
down_count: u32,
}
impl Keys {
@ -55,8 +57,10 @@ impl Keys {
let key_state = self.values.entry(key).or_default();
if key_state.is_down() != state.is_pressed() {
*key_state = if state.is_pressed() {
self.down_count += 1;
KeyState::Pressed
} else {
self.down_count -= 1;
KeyState::Released
}
}
@ -85,6 +89,10 @@ impl Keys {
pub fn was_key_pressed(&self, key: KeyCode) -> bool {
matches!(self.values.get(&key), Some(KeyState::Pressed))
}
pub fn is_any_key_down(&self) -> bool {
self.down_count > 0
}
}
impl<'a> Engine<'a> {
@ -127,7 +135,7 @@ impl<'a> Engine<'a> {
let caps = surface.get_capabilities(&adapter);
let format =
caps.formats.iter().find(|f| matches!(f, TextureFormat::Bgra8Unorm)).cloned().unwrap_or(caps.formats[0]);
let config = (SurfaceConfiguration {
let config = SurfaceConfiguration {
usage: TextureUsages::RENDER_ATTACHMENT,
format,
width: size.width,
@ -136,17 +144,19 @@ impl<'a> Engine<'a> {
desired_maximum_frame_latency: 2,
alpha_mode: caps.alpha_modes[0],
view_formats: vec![],
});
};
surface.configure(&device, &config);
let keys = Keys::default();
let should_exit = Cell::new(false);
let state = GameRunner::new(&UpdateContext {
device: &device,
queue: &queue,
window: &window,
keys: &keys,
config: &config,
should_exit: &should_exit,
});
let now = Instant::now();
@ -163,6 +173,7 @@ impl<'a> Engine<'a> {
frames: 0,
keys: Keys::default(),
focused: false,
should_exit,
state,
}
@ -206,19 +217,20 @@ impl<'a> Engine<'a> {
keys: &self.keys,
window: &self.window,
config: &self.config,
should_exit: &self.should_exit
},
new_size,
);
}
}
pub fn update(&mut self) {
// fixed step
pub fn update(&mut self) -> ControlFlow<()> {
// target game at fixed step 60fps always,
const TARGET_FRAMERATE: LazyLock<Duration> = LazyLock::new(|| Duration::from_secs_f64(1. / 60.));
let now = Instant::now();
let since_last_frame = now - self.last_frame_instant;
if since_last_frame < *TARGET_FRAMERATE {
return;
return ControlFlow::Continue(());
}
self.last_frame_instant = now;
self.frames += 1;
@ -229,6 +241,7 @@ impl<'a> Engine<'a> {
keys: &self.keys,
window: &self.window,
config: &self.config,
should_exit: &self.should_exit
});
self.keys.tick_keys();
@ -236,6 +249,11 @@ impl<'a> Engine<'a> {
self.last_second = now;
self.frames = 0;
}
match self.should_exit.get() {
true => ControlFlow::Break(()),
false => ControlFlow::Continue(())
}
}
pub fn render(&self) -> Result<(), wgpu::SurfaceError> {
@ -258,6 +276,7 @@ pub struct UpdateContext<'a> {
pub keys: &'a Keys,
pub window: &'a Arc<Window>,
pub config: &'a SurfaceConfiguration,
pub should_exit: &'a Cell<bool>,
}
pub trait EngineState {

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

@ -1,8 +1,9 @@
use std::{io::Cursor, ops::Add, path::Path, sync::Arc};
use std::{io::Cursor, ops::Add, sync::Arc};
use async_std::fs;
use bytemuck::{Pod, Zeroable};
use glam::Vec2;
use instructions::anm::{Instruction, Op};
use nonoverlapping_interval_tree::NonOverlappingIntervalTree;
use truth::{context::RootEmitter, io::BinReader, AnmFile, Game as TruthGame};
use wgpu::{
@ -14,10 +15,7 @@ use winit::dpi::PhysicalSize;
use crate::utils::game::Game;
use super::{
image::{produce_image_from_entry, Image},
vm::opcodes::{Instruction, Op},
};
use super::image::{produce_image_from_entry, Image};
pub struct LoadedEntry {
_texture: Texture,
@ -169,10 +167,10 @@ pub struct LoadedScript {
impl LoadedScript {
fn load(script: &truth::anm::Script) -> Arc<LoadedScript> {
let mut offset_instructions: FastHashMap<_, _> = Default::default();
let mut offset_instructions: Vec<(_, _)> = Default::default();
let mut current_offset = 0;
for (index, inst) in script.instrs.iter().enumerate() {
offset_instructions.insert(current_offset, index);
offset_instructions.push((current_offset, index));
current_offset += 8 + inst.args_blob.len() as u32
}
@ -204,11 +202,12 @@ pub struct LoadedFile {
}
impl LoadedFile {
pub async fn load(device: &Device, queue: &Queue, size: PhysicalSize<u32>, game: Game, file_name: &str) -> Self {
let file_data = fs::read(game.asset_path(file_name)).await.expect("failed to load anm file");
pub async fn load(device: Arc<Device>, queue: Arc<Queue>, size: PhysicalSize<u32>, game: Game, file_name: impl Into<String> + Send) -> Self {
let file_name = file_name.into();
let file_data = fs::read(game.asset_path(&file_name)).await.expect("failed to load anm file");
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)),
match game {
Game::Mof => TruthGame::Th10,
Game::Sa => TruthGame::Th11,
@ -220,7 +219,7 @@ impl LoadedFile {
let scripts =
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, size, entry)).collect::<Vec<_>>();
let entries = file.entries.iter().map(|entry| LoadedEntry::load(&device, &queue, size, entry)).collect::<Vec<_>>();
let mut sprite_entries = NonOverlappingIntervalTree::new();

15
src/game/anm/manager/loading.rs
View file

@ -13,8 +13,8 @@ use super::Manager;
impl Manager {
pub fn start_load_anm(
&mut self,
device: Arc<Device>,
queue: Arc<Queue>,
device: &Arc<Device>,
queue: &Arc<Queue>,
size: PhysicalSize<u32>,
game: Game,
file_name: impl Into<String>,
@ -25,8 +25,9 @@ impl Manager {
}
let sender = self.anm_sender.clone();
let (device, queue) = (device.clone(), queue.clone());
Soon::new(async move {
let file = Arc::new(LoadedFile::load(&device, &queue, size, game, &file_name).await);
let file = Arc::new(LoadedFile::load(device, queue, size, game, &file_name).await);
sender.send((file_name, file.clone())).unwrap();
@ -42,8 +43,8 @@ impl Manager {
pub fn load_anm(
&mut self,
device: &Device,
queue: &Queue,
device: &Arc<Device>,
queue: &Arc<Queue>,
window: &Window,
game: Game,
file_name: impl Into<String>,
@ -54,8 +55,8 @@ impl Manager {
}
let loaded_anm = Arc::new(async_std::task::block_on(LoadedFile::load(
device,
queue,
device.clone(),
queue.clone(),
window.inner_size(),
game,
&file_name,

14
src/game/anm/manager/mod.rs
View file

@ -3,7 +3,8 @@ use bytemuck::{Pod, Zeroable};
use crossbeam::channel::{Receiver, Sender};
use glam::Mat4;
use std::{
collections::VecDeque, sync::{Arc, Weak}
collections::VecDeque,
sync::{Arc, Weak},
};
use wgpu::{naga::FastHashMap, BindGroup, Buffer, PipelineLayout, RenderPipeline, ShaderModule, Texture};
@ -34,7 +35,7 @@ pub struct Manager {
depth_texture: Texture,
ui_uniform: Uniform,
_world_uniform: Uniform,
world_uniform: Uniform,
uniform_buffer: Buffer,
render_bind_group: BindGroup,
render_pipeline_layout: PipelineLayout,
@ -62,8 +63,6 @@ impl Manager {
vm.borrow_mut().interrupt(interrupt);
}
self.update_single(&vm);
let mut context = ManagerUpdate::new();
vm.borrow_mut().tick(&mut context);
@ -83,12 +82,17 @@ impl Manager {
vm
}
fn update_single(&mut self, vm: &Vm) {
pub 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);
}
pub fn interrupt_immediately(&mut self, vm: &Vm, interrupt: u32) {
vm.borrow_mut().interrupt(interrupt);
self.update_single(vm);
}
fn update_list(list: &mut VecDeque<WeakVm>, context: &mut ManagerUpdate) {
list.retain(|value| {
if let Some(rc) = value.upgrade() {

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

@ -4,12 +4,20 @@ use bytemuck::{bytes_of, Pod, Zeroable};
use glam::{Mat4, Vec2, Vec3, Vec4};
use num_traits::FloatConst;
use wgpu::{
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
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 crate::{
engine::{Engine, UpdateContext}, game::anm::{loaded_file::SpriteUvs, vm::RenderingState, AnmVm}
engine::{Engine, UpdateContext},
game::anm::{loaded_file::SpriteUvs, vm::RenderingState, AnmVm},
};
use super::{Manager, Uniform, WeakVm};
@ -203,7 +211,7 @@ impl Manager {
depth_texture,
ui_uniform,
_world_uniform: world_uniform,
world_uniform,
uniform_buffer,
render_bind_group,
render_pipeline_layout: pipeline_layout,
@ -292,13 +300,6 @@ impl Manager {
render_pipeline
}
pub fn render_vms(&self, engine: &Engine, pass: &mut RenderPass) {
self.render_layer(engine, pass, &self.ui_vms, 21);
self.render_layer(engine, pass, &self.ui_vms, 22);
self.render_layer(engine, pass, &self.ui_vms, 23);
self.render_layer(engine, pass, &self.ui_vms, 29);
}
fn render_layer(&self, engine: &Engine, pass: &mut RenderPass, list: &VecDeque<WeakVm>, layer: u32) {
for vm in list {
if let Some(vm) = vm.upgrade() {
@ -369,7 +370,7 @@ impl Manager {
fn render_ui(&self, engine: &Engine, encoder: &mut wgpu::CommandEncoder, surface: &wgpu::Texture) {
engine.queue.write_buffer(&self.uniform_buffer, 0, bytes_of(&self.ui_uniform));
let mut pass = encoder.begin_render_pass(&RenderPassDescriptor {
label: Some("anm"),
label: Some("ui anms"),
color_attachments: &[Some(RenderPassColorAttachment {
view: &surface.create_view(&Default::default()),
resolve_target: None,
@ -398,7 +399,50 @@ impl Manager {
..Default::default()
});
self.render_vms(engine, &mut pass);
self.render_layer(engine, &mut pass, &self.ui_vms, 21);
self.render_layer(engine, &mut pass, &self.ui_vms, 22);
self.render_layer(engine, &mut pass, &self.ui_vms, 23);
self.render_layer(engine, &mut pass, &self.ui_vms, 29);
}
fn render_world(&self, engine: &Engine, encoder: &mut wgpu::CommandEncoder, surface: &wgpu::Texture) {
engine.queue.write_buffer(&self.uniform_buffer, 0, bytes_of(&self.world_uniform));
let mut pass = encoder.begin_render_pass(&RenderPassDescriptor {
label: Some("world anms"),
color_attachments: &[Some(RenderPassColorAttachment {
view: &surface.create_view(&Default::default()),
resolve_target: None,
ops: Operations {
// load: LoadOp::Clear(Color {
// // r: 100. / 255.,
// // g: 149. / 255.,
// // b: 237. / 255.,
// r: 1.0,
// g: 1.0,
// b: 1.0,
// a: 1.0,
// }),
load: LoadOp::Load,
..Default::default()
},
})],
depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
view: &self.depth_texture.create_view(&Default::default()),
depth_ops: Some(Operations {
load: LoadOp::Clear(1.0),
store: StoreOp::Store,
}),
stencil_ops: None,
}),
..Default::default()
});
self.render_layer(engine, &mut pass, &self.world_vms, 0);
self.render_layer(engine, &mut pass, &self.world_vms, 1);
self.render_layer(engine, &mut pass, &self.world_vms, 2);
self.render_layer(engine, &mut pass, &self.world_vms, 3);
self.render_layer(engine, &mut pass, &self.world_vms, 8);
}
fn clear(&self, encoder: &mut wgpu::CommandEncoder, surface: &wgpu::Texture) {
@ -434,6 +478,7 @@ impl Manager {
pub fn render(&self, engine: &Engine, surface: &wgpu::Texture, encoder: &mut wgpu::CommandEncoder) {
self.clear(encoder, surface);
self.render_world(engine, encoder, surface);
self.render_ui(engine, encoder, surface);
if let Some(backbuffer_anm) = self.world_backbuffer_anm.upgrade() {

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

@ -1,14 +1,17 @@
use glam::{Vec2, Vec3};
use instructions::{
anm::{Instruction, Op, PrimOp, PrimSetOp},
Param,
};
use num_traits::{FloatConst, FromPrimitive};
use rand::Rng;
use crate::{
game::{anm::{manager::ManagerUpdate, VmLocation}, param::Param}, interp::Mode
game::anm::{manager::ManagerUpdate, VmLocation},
interp::Mode,
};
use super::{
opcodes::{Instruction, Op, PrimOp, PrimSetOp}, AnmVm
};
use super::AnmVm;
impl AnmVm {
fn next_instruction(&mut self) -> Option<Instruction> {
@ -104,7 +107,9 @@ impl AnmVm {
}
pub fn interrupt(&mut self, interrupt_id: u32) {
self.pending_interrupt = Some(interrupt_id);
if self.script.interrupts.contains_key(&interrupt_id) {
self.pending_interrupt = Some(interrupt_id);
}
for ele in self.children.iter() {
ele.borrow_mut().interrupt(interrupt_id);
@ -115,7 +120,7 @@ impl AnmVm {
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.interrupt_return.replace((self.pc, self.time));
self.pc = int_pc;
self.time = Default::default();
self.time.set_time(int_time)
@ -124,6 +129,7 @@ impl AnmVm {
fn return_from_interrupt(&mut self) {
if let Some((pc, time)) = self.interrupt_return.take() {
println!("returned");
self.pc = pc;
self.time.set_time(time.time());
}
@ -313,26 +319,27 @@ impl AnmVm {
self.sprite_mode = mode;
}
Op::Layer { layer } => self.layer = layer as u32,
Op::ZWriteDisable(value) => self.zwrite_disable = value,
Op::Wait { time } => self.time.wait(time as u32),
Op::CaseReturn => {
Op::ReturnFromInterrupt => {
self.return_from_interrupt();
}
Op::UnknownBitflag { .. } => {}
Op::RandMode { mode } => self.random_mode = mode,
Op::ScriptNew { script } => {
Op::NewChildBack { script } => {
self.children.push(manager.new_vm(self.file.clone(), script as usize, VmLocation::new_child(self.layer)));
}
Op::ScriptNewUI { script } => {
Op::NewChildUIBack { script } => {
self.children.push(manager.new_vm(self.file.clone(), script as usize, VmLocation::new_child_ui(self.layer)));
}
Op::ScriptNewFront { script } => {
Op::NewChildFront { script } => {
self.children.push(manager.new_vm(
self.file.clone(),
script as usize,
VmLocation::new_child_front(self.layer),
));
}
Op::ScriptNewUIFront { script } => {
Op::NewChildUIFront { script } => {
self.children.push(manager.new_vm(
self.file.clone(),
script as usize,

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

@ -2,17 +2,21 @@ use std::sync::Arc;
use atomic_refcell::AtomicRefCell;
use glam::{Quat, Vec2, Vec3};
use opcodes::SpriteType;
use instructions::anm::SpriteType;
use wgpu::{BlendComponent, BlendFactor, BlendOperation, BlendState, Buffer, RenderPipeline};
use crate::{game::timer::Timer, interp::{FloatInterpolator, Vec2Interpolator, Vec3Interpolator}};
use crate::{
game::timer::Timer,
interp::{FloatInterpolator, Vec2Interpolator, Vec3Interpolator},
};
use super::{
loaded_file::{LoadedEntry, LoadedFile, LoadedScript, LoadedSprite}, manager::ManagerUpdate, Vm
loaded_file::{LoadedEntry, LoadedFile, LoadedScript, LoadedSprite},
manager::ManagerUpdate,
Vm,
};
pub mod execute;
pub(super) mod opcodes;
pub(super) struct RenderingState {
pub instance_buffer: Buffer,
@ -48,6 +52,7 @@ pub struct AnmVm {
pub(super) visible: bool,
pub(super) sprite: Option<u32>,
pub(super) layer: u32,
pub(super) zwrite_disable: bool,
random_mode: i32,
sprite_mode: SpriteType,
pub(super) blend_state: BlendState,
@ -87,6 +92,7 @@ impl AnmVm {
visible: true,
sprite: None,
layer: default_layer,
zwrite_disable: false,
sprite_mode: SpriteType::NoRotate,
blend_state: BlendState::REPLACE,
random_mode: 0,
@ -123,6 +129,14 @@ impl AnmVm {
self.debug = true;
}
pub fn child(&self, index: usize) -> Option<&Vm> {
self.children.get(index)
}
pub fn file(&self) -> &Arc<LoadedFile> {
&self.file
}
pub fn scale(&self) -> Vec2 {
self.scale_interpolator.current()
}
@ -210,7 +224,7 @@ impl AnmVm {
// additive blending
color: BlendComponent {
src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha,
dst_factor: BlendFactor::One,
operation: BlendOperation::Add,
},
alpha: BlendComponent::OVER,

4
src/game/enemy/manager.rs
View file

@ -1,4 +0,0 @@
pub struct Manager {
}

3
src/game/enemy/mod.rs
View file

@ -1,3 +0,0 @@
pub mod loaded_file;
pub mod manager;
pub mod vm;

343
src/game/enemy/vm/opcodes.rs
View file

@ -1,343 +0,0 @@
use macros::decode_args;
use num_derive::FromPrimitive;
use num_traits::FromPrimitive;
use truth::llir::RawInstr;
use wgpu::naga::FastHashMap;
use crate::game::param::Param;
#[derive(Debug, 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 = 342,
EndSpell = 343,
SetChapter = 344,
KillAllEnemies = 345,
ProtectPlayer = 346,
LifeMarker = 347,
SetByDifficultyInt = 355,
SetByDifficultyFloat = 356,
SpellDifficulty = 357,
SpellDifficultyM1 = 358,
SpellDifficultyM2 = 359,
SpawnerReset = 400,
SpawnerEnable = 401,
SpawnerSetSprite = 402,
SpawnerSetOffset = 403,
SpawnerSetAngle = 404,
SpawnerSetSpeed = 405,
SpawnerSetCount = 406,
SpawnerSetAimMode = 407,
SpawnerSetSounds,
SpawnerSet,
SpawnerSetTransformation,
SpawnerSetTransformation2,
SpawnerAddTransformation,
SpawnerAddTransformation2,
ClearAllBullets,
SpawnerCopy,
ShootLaserAimed,
CancelBullets,
}
pub enum PrimOp {
Add,
Sub,
Mul,
Div,
Equal,
NotEqual,
LessThan,
LessEqual,
Greater,
GreaterEqual,
Not,
Negate,
}
pub enum Op {
Nop,
Delete,
Return,
Jump {
index: usize,
time: i32,
},
JumpEqual {
index: usize,
time: i32,
},
JumpNotEqual {
index: usize,
time: i32,
},
CallAsync(String),
CallAsyncId(String, u32),
StackAlloc(usize),
PushInt(Param<i32>),
SetInt(i32),
PushFloat(Param<f32>),
SetFloat(i32),
IntOp(PrimOp),
ModuloInt,
FloatOp(PrimOp),
Or,
And,
BitwiseXor,
BitwiseOr,
BitwiseAnd,
DecrementInt(i32),
Sin,
Cos,
CirclePos {
x: f32,
y: f32,
angle: Param<f32>,
radius: Param<f32>,
},
SetFlag(i32),
ClearFlag(i32),
ClearAllBullets,
CancelBullets(i32),
}
pub struct Instruction {
time: i32,
difficulty: u8,
op: Op,
}
impl Instruction {
pub fn from_raw(inst: RawInstr, instruction_offsets: &FastHashMap<u32, usize>) -> Self {
let param_int = |value: i32, index: u16| {
if inst.param_mask & (1 << index) == 0 {
Param::Value(value)
} else if value < -9932 || value > 10000 {
Param::Value(value)
} else {
Param::Variable(value)
}
};
let param_float = |value: f32, index: u16| {
if inst.param_mask & (1 << index) == 0 {
Param::Value(value)
} else if value != value.trunc() && value < -9932. || value > 10000. {
Param::Value(value)
} else {
Param::Variable(value as i32)
}
};
let var_int = |value: i32, index: u16| {
assert!(inst.param_mask & (1 << index) != 0, "param must be a var");
assert!(value >= -9932 && value <= 10000, "value must be a var");
value
};
let var_float = |value: f32, index: u16| {
assert!(inst.param_mask & (1 << index) != 0, "param must be a var");
assert!(
value.trunc() == value && value >= -9932. && value <= 10000.,
"value must be a var"
);
value as i32
};
let offset_to_index = |value: i32| instruction_offsets[&(value as u32)];
let args = &inst.args_blob;
let opcode_raw = inst.opcode;
let opcode = Opcode::from_u16(opcode_raw).unwrap_or_else(|| todo!("failed to convert opcode {opcode_raw}"));
let op = match opcode {
Opcode::Nop => Op::Nop,
Opcode::Delete => todo!(),
Opcode::Ret => todo!(),
Opcode::Call => todo!(),
Opcode::Jump => {
let (offset, time) = decode_args!(args, "ot");
Op::Jump {
index: offset_to_index(offset),
time,
}
}
Opcode::JumpEq => {
let (offset, time) = decode_args!(args, "ot");
Op::JumpEqual {
index: offset_to_index(offset),
time,
}
}
Opcode::JumpNeq => {
let (offset, time) = decode_args!(args, "ot");
Op::JumpNotEqual {
index: offset_to_index(offset),
time,
}
}
Opcode::CallAsync => todo!(),
Opcode::CallAsyncById => todo!(),
Opcode::KillAsync => todo!(),
Opcode::KillAllAsync => todo!(),
Opcode::StackAlloc => Op::StackAlloc(decode_args!(args, "S") as usize),
Opcode::PushInt => todo!(),
Opcode::SetInt => todo!(),
Opcode::PushFloat => {
let float = decode_args!(args, "f");
Op::PushFloat(param_float(float, 0))
}
Opcode::SetFloat => {
let var = decode_args!(args, "f");
Op::SetFloat(var_float(var, 0))
}
Opcode::FlagSet => {
let flag = decode_args!(args, "S");
Op::SetFlag(flag)
}
Opcode::FlagClear => {
let flag = decode_args!(args, "S");
Op::ClearFlag(flag)
}
Opcode::CancelBullets => {
todo!()
}
_ => {
unimplemented!("opcode {opcode:?} not implemented");
}
};
Self {
time: inst.time,
difficulty: inst.difficulty,
op,
}
}
}

15
src/game/mod.rs
View file

@ -1,4 +1,4 @@
use std::{path::Path, sync::Arc};
use std::sync::Arc;
use anm::LoadedFile;
use states::GameStateMachine;
@ -9,8 +9,7 @@ use crate::{
};
mod anm;
mod enemy;
mod param;
mod stage;
mod snd;
mod states;
mod timer;
@ -30,8 +29,8 @@ struct GameContext<'a> {
impl GameContext<'_> {
pub fn start_load_anm(&mut self, game: Game, file_name: impl Into<String>) -> Soon<Arc<LoadedFile>> {
self.anm_manager.start_load_anm(
self.engine.device.clone(),
self.engine.queue.clone(),
self.engine.device,
self.engine.queue,
self.engine.window.inner_size(),
game,
file_name,
@ -40,9 +39,9 @@ impl GameContext<'_> {
pub fn load_anm(&mut self, game: Game, file_name: impl Into<String>) -> Arc<LoadedFile> {
self.anm_manager.load_anm(
&self.engine.device,
&self.engine.queue,
&self.engine.window,
self.engine.device,
self.engine.queue,
self.engine.window,
game,
file_name,
)

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

@ -52,7 +52,7 @@ impl BgmFormat {
}
let track_name = track_name.to_str().unwrap().to_owned();
println!("track: {:?}", track_name);
println!("track {track_name}");
let track = Track::ref_from_bytes(&bytes[(start + TRACK_NAME_SIZE)..(start + TRACK_SIZE)]).unwrap();
tracks.insert(
track_name,
@ -70,7 +70,9 @@ impl BgmFormat {
}
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 Some(track) = self.tracks.get(file_name) else {
panic!("failed to find bgm file: {file_name:?}")
};
let intro_start = track.track_offset as usize;
let track_start = intro_start + track.intro_size as usize;

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

@ -1,4 +1,4 @@
use std::{rc::Rc, sync::Arc};
use std::sync::Arc;
use async_std::fs::read;
use format::BgmFormat;

6
src/game/stage/enemy/execute.rs Normal file
View file

@ -0,0 +1,6 @@
use super::Vm;
impl Vm {
pub fn execute(&mut self) {
}
}

5
src/game/enemy/vm/flags.rs → src/game/stage/enemy/flags.rs
View file

@ -7,11 +7,12 @@ pub struct Flags {
pub disable_offscreen_horizontal: bool,
pub disable_offscreen_vertical: bool,
pub invincible: bool,
pub intangible: bool,
pub intangible: bool, // override: disable_hurtbox | disable_hitbox | invincible | no_global_delete
pub no_global_delete: bool,
pub always_global_delete: bool,
pub graze: bool,
pub only_delete_on_dialog: bool,
#[bits(22)]
pub only_delete_on_clear: bool,
#[bits(21)]
_a: u32,
}

39
src/game/enemy/loaded_file.rs → src/game/stage/enemy/loaded_file.rs
View file

@ -1,4 +1,4 @@
use std::{io::Cursor, path::Path, sync::Arc};
use std::{io::Cursor, sync::Arc};
use async_std::fs;
use futures::future::{join3, join_all};
@ -8,7 +8,7 @@ use winit::dpi::PhysicalSize;
use crate::{game::anm, utils::game::Game};
use super::vm::opcodes::Instruction;
use instructions::ecl::Instruction;
pub struct LoadedFile {
anm_files: Vec<anm::LoadedFile>,
@ -35,30 +35,41 @@ impl LoadedFile {
)
.unwrap();
let anm_files = join_all(file.anim_list.into_iter().map(|sp| sp.value).map(|anm| {
let (device, queue) = (device.clone(), queue.clone());
async move { anm::LoadedFile::load(&device, &queue, size, game, &anm).await }
}));
let ecl_files = join_all(file.ecli_list.into_iter().map(|sp| sp.value).map(|ecl| {
let (device, queue) = (device.clone(), queue.clone());
async move { LoadedFile::load(device, queue, size, game, ecl).await }
}));
let anm_files = join_all(
file
.anim_list
.into_iter()
.map(|sp| sp.value)
.map(|anm| async_std::task::spawn(anm::LoadedFile::load(device.clone(), queue.clone(), size, game, anm))),
);
let ecl_files = join_all(
file
.ecli_list
.into_iter()
.map(|sp| sp.value)
.map(|ecl| LoadedFile::load(device.clone(), queue.clone(), size, game, ecl)),
);
let subs = file.subs.into_iter().map(|(k, v)| (k.value, v)).collect::<Vec<_>>();
let subs = async_std::task::spawn_blocking(|| {
subs
.into_iter()
.map(|(sub, instructions)| {
let mut offset_instructions: FastHashMap<_, _> = Default::default();
let mut offset_instructions: Vec<(_, _)> = Default::default();
let mut current_offset = 0;
for (index, inst) in instructions.iter().enumerate() {
offset_instructions.insert(current_offset, index);
current_offset += 8 + inst.args_blob.len() as u32
offset_instructions.push((current_offset, index));
current_offset += 16 + inst.args_blob.len() as u32
}
println!("hitting {sub}");
(
sub,
instructions.into_iter().map(|inst| Instruction::from_raw(inst, &offset_instructions)).collect::<Vec<_>>(),
instructions
.into_iter()
.zip(offset_instructions.iter())
.map(|(inst, (offset, _))| Instruction::from_raw(inst, *offset, &offset_instructions))
.collect::<Vec<_>>(),
)
})
.collect::<FastHashMap<_, _>>()

5
src/game/enemy/vm/mod.rs → src/game/stage/enemy/mod.rs
View file

@ -1,7 +1,8 @@
use crate::game::timer::Timer;
pub mod loaded_file;
mod flags;
pub(super) mod opcodes;
mod execute;
struct StackFrame {
pc: usize,
@ -17,4 +18,6 @@ enum Value {
pub struct Vm {
call_stack: heapless::Vec<StackFrame, 8>,
current_frame: StackFrame,
}

71
src/game/stage/mod.rs Normal file
View file

@ -0,0 +1,71 @@
use std::{cell::RefCell, rc::Rc};
use vm::{LoadedFile, StageVm};
use crate::utils::game::Game;
use super::GameContext;
mod enemy;
mod vm;
#[derive(Debug, Clone, Copy)]
pub enum StageNumber {
Stage1 = 1,
Stage2 = 2,
Stage3 = 3,
Stage4 = 4,
Stage5 = 5,
Stage6 = 6,
Extra = 7,
}
impl StageNumber {
pub fn next(&self) -> Option<Self> {
match self {
Self::Stage1 => Some(Self::Stage2),
Self::Stage2 => Some(Self::Stage3),
Self::Stage3 => Some(Self::Stage4),
Self::Stage4 => Some(Self::Stage5),
Self::Stage5 => Some(Self::Stage6),
Self::Stage6 => None,
Self::Extra => None,
}
}
pub fn stage_music(&self, game: Game, boss: bool) -> &'static str {
match (self, game, boss) {
(Self::Stage1, Game::Mof, false) => "th10_00.wav",
(Self::Stage1, Game::Mof, true) => "th10_01.wav",
_ => todo!()
}
}
}
pub struct Stage {
vm: StageVm,
enemies: Vec<Rc<RefCell<enemy::Vm>>>,
game: Game,
stage_number: StageNumber,
}
impl Stage {
pub async fn new(context: &mut GameContext<'_>, game: Game, stage_number: StageNumber) -> Self {
let file = LoadedFile::load(context, game, format!("stage0{}.std", stage_number as u8)).await;
Self {
vm: StageVm::new(file),
enemies: vec![],
game,
stage_number,
}
}
pub fn started(&mut self, context: &mut GameContext) {
context.sound_manager.get_bgm_manager(self.game).play_track(self.stage_number.stage_music(self.game, false));
}
pub fn update(&mut self, context: &mut GameContext) {
self.vm.update(context);
}
}

58
src/game/stage/vm/loaded_file.rs Normal file
View file

@ -0,0 +1,58 @@
use std::io::Cursor;
use async_std::fs;
use instructions::std::Instruction;
use truth::{context::RootEmitter, io::BinReader, std::StdExtra, Game as TruthGame, StdFile};
use wgpu::naga::FastHashMap;
use crate::{
game::{
anm::{self, Vm, VmLocation},
GameContext,
},
utils::game::Game,
};
pub struct LoadedFile {
pub layers: FastHashMap<u16, Vec<Vm>>,
pub instructions: Vec<instructions::std::Instruction>,
}
impl LoadedFile {
pub async fn load(context: &mut GameContext<'_>, game: Game, file_name: impl Into<String> + Send) -> LoadedFile {
let file_name = file_name.into();
let file_data = fs::read(game.asset_path(&file_name)).await.expect("failed to load anm file");
let file = StdFile::read_from_stream(
&mut BinReader::from_reader(&RootEmitter::new_stderr(), &file_name, Cursor::new(file_data)),
match game {
Game::Mof => TruthGame::Th10,
Game::Sa => TruthGame::Th11,
},
)
.unwrap();
let StdExtra::Th10 { anm_path } = file.extra else {
unreachable!()
};
let anm_file = context.start_load_anm(game, anm_path.value).await;
let mut layers: FastHashMap<u16, Vec<Vm>> = FastHashMap::default();
for instance in file.instances {
let object = file.objects.get(&instance.object).expect("failed to get object");
for quad in &object.quads {
let vm = context.anm_manager.new_vm(anm_file.clone(), None, quad.anm_script.into(), VmLocation::new());
layers.entry(object.layer).or_default().push(vm);
}
}
let mut offset_instructions: Vec<(_, _)> = Default::default();
let mut current_offset = 0;
for (index, inst) in file.script.iter().enumerate() {
offset_instructions.push((current_offset, index));
current_offset += 8 + inst.args_blob.len() as u32
}
let instructions =
file.script.into_iter().map(|inst| Instruction::from_raw(inst, &offset_instructions)).collect::<Vec<_>>();
LoadedFile { layers, instructions }
}
}

27
src/game/stage/vm/mod.rs Normal file
View file

@ -0,0 +1,27 @@
pub use loaded_file::LoadedFile;
use crate::game::{timer::Timer, GameContext};
mod loaded_file;
pub struct StageVm {
pub file: LoadedFile,
pc: usize,
timer: Timer,
}
impl StageVm {
pub fn new(file: LoadedFile) -> Self {
Self {
file,
pc: 0,
timer: Timer::default()
}
}
pub fn update(&mut self, context: &mut GameContext) {
self.timer.tick();
}
}

49
src/game/states/gameplay/mod.rs
View file

@ -1,24 +1,47 @@
use async_std::task::{block_on, spawn};
use async_std::task::block_on;
use sfsm::State;
use crate::{
game::{enemy::loaded_file::LoadedFile, GameContext},
game::{
stage::{Stage, StageNumber},
GameContext,
},
utils::game::Game,
};
pub struct Gameplay {}
use super::{loading::Loading, title_mof::TitleScreenMof, UPDATE_CONTEXT};
pub struct Gameplay {
stage: Stage,
}
impl Gameplay {
pub fn new(context: &GameContext) -> Self {
block_on(LoadedFile::load(
context.engine.device.clone(),
context.engine.queue.clone(),
context.engine.window.inner_size(),
Game::Sa,
"default.ecl",
));
Self {}
pub fn new_blocking(context: &mut GameContext<'_>, game: Game, stage_number: StageNumber) -> Self {
block_on(Self::new(context, game, stage_number))
}
pub async fn new(context: &mut GameContext<'_>, game: Game, stage_number: StageNumber) -> Self {
let stage = Stage::new(context, game, stage_number).await;
Self { stage }
}
}
impl State for Gameplay {}
impl State for Gameplay {
fn entry(&mut self) {
UPDATE_CONTEXT.with(|context| self.stage.started(context));
}
fn execute(&mut self) {
UPDATE_CONTEXT.with(|context| self.stage.update(context));
}
}
impl From<Loading> for Gameplay {
fn from(_: Loading) -> Self {
UPDATE_CONTEXT.with(|context| Gameplay::new_blocking(context, Game::Mof, StageNumber::Stage1))
}
}
impl From<TitleScreenMof> for Gameplay {
fn from(_: TitleScreenMof) -> Self {
UPDATE_CONTEXT.with(|context| Gameplay::new_blocking(context, Game::Mof, StageNumber::Stage1))
}
}

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

@ -11,11 +11,12 @@ use crate::{
utils::{game::Game, soon::Soon},
};
use super::{title::TitleScreen, UPDATE_CONTEXT};
use super::{gameplay::Gameplay, title_mof::TitleScreenMof, title_sa::TitleScreenSa, UPDATE_CONTEXT};
pub struct Loading {
_sig: Vm,
_ascii_loading: Vm,
to_gameplay: bool,
title_anm: RefCell<Soon<Arc<LoadedFile>>>,
}
@ -31,27 +32,35 @@ impl Loading {
Loading {
_sig: sig,
_ascii_loading: ascii_loading,
to_gameplay: true,
title_anm: context.start_load_anm(Game::Sa, "title.anm").into(),
title_anm: context.start_load_anm(Game::Mof, "title.anm").into(),
}
}
}
impl State for Loading {
fn execute(&mut self) {
// if UPDATE_CONTEXT.with(|context| context.sound_manager.get_bgm_manager().is_some()) {
// log::info!("a");
// }
// if self.title_anm.borrow_mut().is_done() {
// log::info!("b")
// }
}
}
sfsm::derive_state!(Loading);
impl Transition<TitleScreen> for Loading {
impl Transition<TitleScreenSa> for Loading {
fn guard(&self) -> TransitGuard {
UPDATE_CONTEXT
.with(|context| context.sound_manager.is_bgm_manager_loaded() && self.title_anm.borrow_mut().is_done())
.into()
}
}
impl Transition<TitleScreenMof> for Loading {
fn guard(&self) -> TransitGuard {
UPDATE_CONTEXT
.with(|context|!self.to_gameplay && context.sound_manager.is_bgm_manager_loaded() && self.title_anm.borrow_mut().is_done())
.into()
}
}
impl Transition<Gameplay> for Loading {
fn guard(&self) -> TransitGuard {
UPDATE_CONTEXT
.with(|context| self.to_gameplay && context.sound_manager.is_bgm_manager_loaded() && self.title_anm.borrow_mut().is_done())
.into()
}
}

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

@ -1,21 +1,24 @@
mod gameplay;
mod loading;
mod title;
use gameplay::Gameplay;
use sfsm::*;
mod title_mof;
mod title_sa;
use crate::utils::context::ContextMut;
use gameplay::Gameplay;
use loading::Loading;
use title::TitleScreen;
use sfsm::*;
use title_mof::TitleScreenMof;
use title_sa::TitleScreenSa;
use super::GameContext;
pub(super) static UPDATE_CONTEXT: ContextMut<GameContext, GameStateMachine> = ContextMut::new();
add_state_machine!(Machine, Loading, {Loading, TitleScreen, Gameplay}, {
Loading => TitleScreen,
TitleScreen => TitleScreen
// add_state_machine!(Machine, Gameplay, {Loading, TitleScreen, Gameplay}, {
add_state_machine!(Machine, Loading, {Loading, TitleScreenSa, TitleScreenMof, Gameplay}, {
Loading => TitleScreenMof,
Loading => Gameplay,
TitleScreenMof => Gameplay,
});
pub(super) struct GameStateMachine(Machine);

218
src/game/states/title_mof/main_menu.rs Normal file
View file

@ -0,0 +1,218 @@
use sfsm::*;
use winit::keyboard::KeyCode;
use crate::{
game::{
anm::{Vm, VmLocation},
states::UPDATE_CONTEXT,
},
utils::game::Game,
};
pub struct MainMenu(MainMenuMachine);
impl MainMenu {
pub fn new() -> MainMenu {
UPDATE_CONTEXT.with(|context| {
let title = context.load_anm(Game::Mof, "title.anm");
let title_ver = context.load_anm(Game::Mof, "title_v.anm");
let mut main_menu = MainMenu(MainMenuMachine::new());
main_menu
.0
.start(Boot {
logo: context.anm_manager.new_vm(title, None, 90, VmLocation::new_ui()),
title_ver: context.anm_manager.new_vm(title_ver, None, 0, VmLocation::new_ui()),
})
.unwrap();
main_menu
})
}
pub fn switch_to_gameplay(&self) -> bool {
sfsm::IsState::<StartingGameplay>::is_state(&self.0)
}
}
impl State for MainMenu {
fn execute(&mut self) {
self.0.step().unwrap();
}
}
add_state_machine!(MainMenuMachine, Boot, {Boot, Starting, Selecting, StartingGameplay, Exiting}, {
Boot => Starting,
Starting => Selecting,
Selecting => StartingGameplay,
Selecting => Exiting,
});
struct Boot {
logo: Vm,
title_ver: Vm,
}
impl State for Boot {
fn execute(&mut self) {
self.exit();
UPDATE_CONTEXT.with(|context| {
if context.engine.keys.is_any_key_down() {
self.logo.borrow_mut().interrupt(6);
self.title_ver.borrow_mut().interrupt(1);
}
});
}
}
impl Transition<Starting> for Boot {
fn guard(&self) -> TransitGuard {
self.title_ver.borrow_mut().deleted().into()
}
}
impl From<Boot> for Starting {
fn from(value: Boot) -> Self {
Starting {
logo: value.logo,
time_in_state: 0,
}
}
}
struct Starting {
logo: Vm,
time_in_state: u32,
}
impl State for Starting {
fn execute(&mut self) {
self.time_in_state += 1;
}
}
impl Transition<Selecting> for Starting {
fn guard(&self) -> TransitGuard {
(self.time_in_state >= 30).into()
}
}
impl From<Starting> for Selecting {
fn from(val: Starting) -> Self {
UPDATE_CONTEXT.with(|context| {
let file = val.logo.borrow().file().clone();
Selecting {
logo: val.logo,
main_ui: context.anm_manager.new_vm(file, None, 0, VmLocation::new_child_ui(0)),
selected: 0,
selection_changed: false,
input_locked: false,
}
})
}
}
struct Selecting {
logo: Vm,
main_ui: Vm,
selected: u32,
selection_changed: bool,
input_locked: bool,
}
impl Selecting {
fn selected(&self, desired: u32) -> TransitGuard {
(self.selected == desired && self.input_locked).into()
}
}
impl State for Selecting {
fn execute(&mut self) {
UPDATE_CONTEXT.with(|context| {
if self.input_locked {
return;
}
if context.engine.keys.was_key_pressed(KeyCode::ArrowUp) {
if let Some(prev) = self.selected.checked_sub(1) {
self.selected = prev;
} else {
self.selected = 7;
}
if self.selected == 1 {
self.selected = 0;
}
self.selection_changed = false;
}
if context.engine.keys.was_key_pressed(KeyCode::ArrowDown) {
if self.selected >= 7 {
self.selected = 0;
} else {
self.selected += 1;
}
if self.selected == 1 {
self.selected = 2;
}
self.selection_changed = false;
}
if context.engine.keys.was_key_pressed(KeyCode::KeyZ) {
self.main_ui.borrow_mut().interrupt(3);
self.input_locked = true;
}
if !self.selection_changed {
self.selection_changed = true;
let main_ui = self.main_ui.borrow_mut();
for i in 0..8u32 {
let child = main_ui.child(i as usize).unwrap();
let child_bg = main_ui.child(8 + i as usize).unwrap();
if i == self.selected {
child.borrow_mut().interrupt(i + 7);
child_bg.borrow_mut().interrupt(i + 7);
} else {
context.anm_manager.interrupt_immediately(&child, 3);
context.anm_manager.interrupt_immediately(&child_bg, 3);
}
}
}
});
}
}
#[derive(Default)]
struct StartingGameplay;
derive_state!(StartingGameplay);
derive_transition_into_default!(Selecting, StartingGameplay);
impl Transition<StartingGameplay> for Selecting {
fn guard(&self) -> TransitGuard {
self.selected(0)
}
fn action(&mut self) {
println!("agmlng")
}
}
impl Transition<Exiting> for Selecting {
fn guard(&self) -> TransitGuard {
self.selected(7)
}
}
impl From<Selecting> for Exiting {
fn from(value: Selecting) -> Self {
Exiting {
_logo: value.logo,
_main_ui: value.main_ui,
timer: 0,
}
}
}
struct Exiting {
_logo: Vm,
_main_ui: Vm,
timer: u32,
}
impl State for Exiting {
fn execute(&mut self) {
self.timer += 1;
if self.timer >= 20 {
UPDATE_CONTEXT.with(|context| context.engine.should_exit.set(true));
}
}
}

72
src/game/states/title_mof/mod.rs Normal file
View file

@ -0,0 +1,72 @@
mod main_menu;
use std::sync::Arc;
use main_menu::MainMenu;
use sfsm::*;
use winit::keyboard::KeyCode;
use crate::{
game::{
anm::{LoadedFile, Vm, VmLocation},
GameContext,
},
utils::game::Game,
};
use super::{gameplay::Gameplay, loading::Loading, UPDATE_CONTEXT};
pub struct TitleScreenMof {
_splash: Vm,
_title_anm: Arc<LoadedFile>,
machine: TitleScreenMachine,
}
add_state_machine!(TitleScreenMachine, MainMenu, { MainMenu }, {});
impl TitleScreenMof {
fn new(context: &mut GameContext, _: bool) -> Self {
let title = context.load_anm(Game::Mof, "title.anm");
// 79, 83
let splash = context.anm_manager.new_vm(title.clone(), None, 88, VmLocation::new_ui());
Self {
_splash: splash,
_title_anm: title,
machine: TitleScreenMachine::new(),
}
}
}
impl State for TitleScreenMof {
fn entry(&mut self) {
self.machine.start(MainMenu::new()).unwrap();
}
fn execute(&mut self) {
self.machine.step().unwrap();
}
}
impl From<Loading> for TitleScreenMof {
fn from(_: Loading) -> Self {
UPDATE_CONTEXT.with(|context| {
context.sound_manager.get_bgm_manager(Game::Mof).play_track("th10_02.wav");
// context.sound_manager.get_bgm_manager(Game::Mof).play_track("th11_00.wav");
TitleScreenMof::new(context, true)
})
}
}
impl Transition<Gameplay> for TitleScreenMof {
fn guard(&self) -> TransitGuard {
match &self.machine.states {
TitleScreenMachineStates::MainMenuState(Some(main_menu)) => main_menu.switch_to_gameplay().into(),
_ => TransitGuard::Remain
}
}
fn action(&mut self) {
println!("hsttkasdgn")
}
}

26
src/game/states/title.rs → src/game/states/title_sa.rs
View file

@ -11,20 +11,18 @@ use crate::{
use super::{loading::Loading, UPDATE_CONTEXT};
pub struct TitleScreen {
pub struct TitleScreenSa {
_logo: Vm,
_splash: Vm,
}
impl TitleScreen {
impl TitleScreenSa {
fn new(context: &mut GameContext, _: bool) -> Self {
let title = context.load_anm(Game::Mof, "title.anm");
let title = context.load_anm(Game::Sa, "title.anm");
// 79, 83
// let splash = context.anm_manager.new_vm(title.clone(), Some(8), 79, VmLocation::new_ui());
// let logo = context.anm_manager.new_vm(title.clone(), Some(8), 83, VmLocation::new_ui());
let splash = context.anm_manager.new_vm(title.clone(), Some(8), 88, VmLocation::new_ui());
let logo = context.anm_manager.new_vm(title.clone(), Some(8), 90, 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(), Some(8), 83, VmLocation::new_ui());
Self {
_logo: logo,
@ -33,7 +31,7 @@ impl TitleScreen {
}
}
impl State for TitleScreen {
impl State for TitleScreenSa {
fn execute(&mut self) {
UPDATE_CONTEXT.with(|context| {
if context.engine.keys.was_key_pressed(KeyCode::Space) {
@ -43,19 +41,19 @@ impl State for TitleScreen {
}
}
impl From<Loading> for TitleScreen {
impl From<Loading> for TitleScreenSa {
fn from(_: Loading) -> Self {
UPDATE_CONTEXT.with(|context| {
context.sound_manager.get_bgm_manager(Game::Mof).play_track("th10_02.wav");
// context.sound_manager.get_bgm_manager_sa().play_track("th11_00.wav");
TitleScreen::new(context, true)
// context.sound_manager.get_bgm_manager(Game::Mof).play_track("th10_02.wav");
context.sound_manager.get_bgm_manager(Game::Sa).play_track("th11_00.wav");
TitleScreenSa::new(context, true)
})
}
}
impl Transition<TitleScreen> for TitleScreen {
impl Transition<TitleScreenSa> for TitleScreenSa {
fn action(&mut self) {
*self = UPDATE_CONTEXT.with(|context| TitleScreen::new(context, false))
*self = UPDATE_CONTEXT.with(|context| TitleScreenSa::new(context, false))
}
fn guard(&self) -> TransitGuard {

16
src/main.rs
View file

@ -4,13 +4,19 @@ pub mod interp;
pub mod utils;
use std::{
sync::{Arc, Mutex}, time::Duration
ops::ControlFlow,
sync::Arc,
};
use engine::Engine;
use wgpu::SurfaceError;
use winit::{
application::ApplicationHandler, dpi::PhysicalSize, event::{ElementState, KeyEvent, StartCause, WindowEvent}, event_loop::EventLoop, keyboard::{KeyCode, PhysicalKey}, platform::pump_events::EventLoopExtPumpEvents, window::Window
application::ApplicationHandler,
dpi::PhysicalSize,
event::{ElementState, KeyEvent, StartCause, WindowEvent},
event_loop::EventLoop,
keyboard::{KeyCode, PhysicalKey},
window::Window,
};
#[derive(Default)]
@ -73,8 +79,10 @@ impl<'a> ApplicationHandler for App<'a> {
self.engine.as_mut().unwrap().resize(new_size);
}
WindowEvent::RedrawRequested => {
let mut engine = self.engine.as_mut().unwrap();
engine.update();
let engine = self.engine.as_mut().unwrap();
if let ControlFlow::Break(()) = engine.update() {
return event_loop.exit();
}
match engine.render() {
Ok(_) => {}
Err(SurfaceError::Lost) => {

10
src/utils/context.rs
View file

@ -1,4 +1,4 @@
use std::marker::PhantomData;
use std::{cell::RefCell, ffi::c_void, marker::PhantomData, thread::LocalKey};
#[doc(hidden)]
#[derive(Default)]
@ -12,9 +12,9 @@ impl<T, Key> ContextMut<T, Key> {
ContextMut(PhantomData)
}
fn thread_local() -> &'static std::thread::LocalKey<std::cell::RefCell<Option<*mut std::ffi::c_void>>> {
fn thread_local() -> &'static LocalKey<RefCell<Option<*mut c_void>>> {
std::thread_local! {
static CTX: std::cell::RefCell<Option<*mut std::ffi::c_void>> = Default::default();
static CTX: RefCell<Option<*mut c_void>> = Default::default();
}
&CTX
@ -54,9 +54,9 @@ impl<T, Key> Context<T, Key> {
Context(PhantomData)
}
fn thread_local() -> &'static std::thread::LocalKey<std::cell::RefCell<Option<*const std::ffi::c_void>>> {
fn thread_local() -> &'static LocalKey<RefCell<Option<*const c_void>>> {
std::thread_local! {
static CTX: std::cell::RefCell<Option<*const std::ffi::c_void>> = Default::default();
static CTX: RefCell<Option<*const c_void>> = Default::default();
}
&CTX

2
utils/th10.eclm
View file

@ -649,7 +649,7 @@
!ins_intrinsics
#10 RetStack() ## Internally calls FrameLeave()
#11 CallStack()
12 Jmp()
#12 Jmp()
#13 StackJmp(op="==")
#14 StackJmp(op="!=")
#15 CallStackAsync()