reo/raidillon
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Physics Support #8

Merged
reo merged 6 commits from 2025-10-19-physics into master 2025-11-16 15:38:20 +00:00
Conversation 0 Commits 6 Files changed 19 +80 -36
1 changed files with 80 additions and 36 deletions
Download patch file Download diff file Expand all files Collapse all files
Showing only changes of commit 73dbcdbd6c - Show all commits

116
core/src/utils/typemap.rs
View file

@ -101,7 +101,7 @@ macro_rules! define_typemap {
{ {
type Output<'a> = (&'a mut A,); type Output<'a> = (&'a mut A,);
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> { fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?; let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
unsafe { unsafe {
let a = (&mut *ptr_a).downcast_mut::<A>()?; let a = (&mut *ptr_a).downcast_mut::<A>()?;
Some((a,)) Some((a,))
@ -133,8 +133,8 @@ macro_rules! define_typemap {
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> { fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
let ids = [TypeId::of::<A>(), TypeId::of::<B>()]; let ids = [TypeId::of::<A>(), TypeId::of::<B>()];
if ids[0] == ids[1] { return None; } if ids[0] == ids[1] { return None; }
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?; let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?; let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
unsafe { unsafe {
let a = (&mut *ptr_a).downcast_mut::<A>()?; let a = (&mut *ptr_a).downcast_mut::<A>()?;
let b = (&mut *ptr_b).downcast_mut::<B>()?; let b = (&mut *ptr_b).downcast_mut::<B>()?;
@ -170,9 +170,9 @@ macro_rules! define_typemap {
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> { fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>()]; let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>()];
if ids[0] == ids[1] || ids[0] == ids[2] || ids[1] == ids[2] { return None; } if ids[0] == ids[1] || ids[0] == ids[2] || ids[1] == ids[2] { return None; }
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?; let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?; let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?; let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
unsafe { unsafe {
let a = (&mut *ptr_a).downcast_mut::<A>()?; let a = (&mut *ptr_a).downcast_mut::<A>()?;
let b = (&mut *ptr_b).downcast_mut::<B>()?; let b = (&mut *ptr_b).downcast_mut::<B>()?;
@ -212,10 +212,10 @@ macro_rules! define_typemap {
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> { fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>()]; let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>()];
for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } } for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?; let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?; let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?; let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?; let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
unsafe { unsafe {
let a = (&mut *ptr_a).downcast_mut::<A>()?; let a = (&mut *ptr_a).downcast_mut::<A>()?;
let b = (&mut *ptr_b).downcast_mut::<B>()?; let b = (&mut *ptr_b).downcast_mut::<B>()?;
@ -259,11 +259,11 @@ macro_rules! define_typemap {
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> { fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>()]; let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>()];
for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } } for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?; let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?; let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?; let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?; let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?; let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
unsafe { unsafe {
let a = (&mut *ptr_a).downcast_mut::<A>()?; let a = (&mut *ptr_a).downcast_mut::<A>()?;
let b = (&mut *ptr_b).downcast_mut::<B>()?; let b = (&mut *ptr_b).downcast_mut::<B>()?;
@ -311,12 +311,12 @@ macro_rules! define_typemap {
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> { fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>()]; let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>()];
for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } } for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?; let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?; let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?; let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?; let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?; let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v as *mut dyn Any) }?; let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v.as_mut() as *mut dyn Any) }?;
unsafe { unsafe {
let a = (&mut *ptr_a).downcast_mut::<A>()?; let a = (&mut *ptr_a).downcast_mut::<A>()?;
let b = (&mut *ptr_b).downcast_mut::<B>()?; let b = (&mut *ptr_b).downcast_mut::<B>()?;
@ -368,13 +368,13 @@ macro_rules! define_typemap {
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> { fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>(), TypeId::of::<G>()]; let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>(), TypeId::of::<G>()];
for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } } for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?; let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?; let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?; let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?; let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?; let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v as *mut dyn Any) }?; let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v as *mut dyn Any) }?; let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v.as_mut() as *mut dyn Any) }?;
unsafe { unsafe {
let a = (&mut *ptr_a).downcast_mut::<A>()?; let a = (&mut *ptr_a).downcast_mut::<A>()?;
let b = (&mut *ptr_b).downcast_mut::<B>()?; let b = (&mut *ptr_b).downcast_mut::<B>()?;
@ -430,14 +430,14 @@ macro_rules! define_typemap {
fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> { fn get_from_mut<'a>(map: &'a mut HashMap<TypeId, Box<dyn Any>>) -> Option<Self::Output<'a>> {
let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>(), TypeId::of::<G>(), TypeId::of::<H>()]; let ids = [TypeId::of::<A>(), TypeId::of::<B>(), TypeId::of::<C>(), TypeId::of::<D>(), TypeId::of::<E>(), TypeId::of::<F>(), TypeId::of::<G>(), TypeId::of::<H>()];
for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } } for i in 0..ids.len() { for j in (i+1)..ids.len() { if ids[i] == ids[j] { return None; } } }
let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v as *mut dyn Any) }?; let ptr_a = { map.get_mut(&TypeId::of::<A>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v as *mut dyn Any) }?; let ptr_b = { map.get_mut(&TypeId::of::<B>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v as *mut dyn Any) }?; let ptr_c = { map.get_mut(&TypeId::of::<C>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v as *mut dyn Any) }?; let ptr_d = { map.get_mut(&TypeId::of::<D>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v as *mut dyn Any) }?; let ptr_e = { map.get_mut(&TypeId::of::<E>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v as *mut dyn Any) }?; let ptr_f = { map.get_mut(&TypeId::of::<F>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v as *mut dyn Any) }?; let ptr_g = { map.get_mut(&TypeId::of::<G>()).map(|v| v.as_mut() as *mut dyn Any) }?;
let ptr_h = { map.get_mut(&TypeId::of::<H>()).map(|v| v as *mut dyn Any) }?; let ptr_h = { map.get_mut(&TypeId::of::<H>()).map(|v| v.as_mut() as *mut dyn Any) }?;
unsafe { unsafe {
let a = (&mut *ptr_a).downcast_mut::<A>()?; let a = (&mut *ptr_a).downcast_mut::<A>()?;
let b = (&mut *ptr_b).downcast_mut::<B>()?; let b = (&mut *ptr_b).downcast_mut::<B>()?;
@ -498,3 +498,47 @@ macro_rules! define_typemap {
// Self::new() // Self::new()
// } // }
// } // }
#[cfg(test)]
mod tests {
use crate::define_typemap;
define_typemap!(TestMap,);
#[test]
fn get_test() {
let mut tm = TestMap::new();
tm.insert::<u32>(42);
let v = tm.get::<u32>().expect("value should be present");
assert_eq!(*v, 42);
}
#[test]
fn get_many_test() {
let mut tm = TestMap::new();
tm.insert::<u32>(1);
tm.insert::<i32>(-2);
tm.insert::<f32>(3.5);
let (a, b, c) = tm
.get_many::<(u32, i32, f32)>()
.expect("all values should be present");
assert_eq!((*a, *b, *c), (1, -2, 3.5));
}
#[test]
fn get_many_mut_test() {
let mut tm = TestMap::new();
tm.insert::<i32>(-2);
tm.insert::<u32>(1);
tm.insert::<f32>(3.5);
let (a, b, c) = tm
.get_many_mut::<(i32, u32, f32)>()
.expect("all values should be present");
*a = 4;
*b = 5;
*c = 6.5;
}
}