116 lines
2.8 KiB
Rust
116 lines
2.8 KiB
Rust
#![no_implicit_prelude]
|
|
#![allow(non_camel_case_types)]
|
|
|
|
macro_rules! decl_primitives_as_traits {
|
|
($($primitive:ident),*) => {$(#[allow(dead_code)] trait $primitive {})*};
|
|
}
|
|
|
|
// from core::primitive
|
|
decl_primitives_as_traits!(
|
|
bool, char, f32, f64, i128, i16, i32, i64, i8, isize, str, u128, u16, u32, u64, u8, usize
|
|
);
|
|
|
|
mod impl_vector {
|
|
use ::core::{
|
|
convert::{AsMut, AsRef, From},
|
|
marker::PhantomData,
|
|
unimplemented,
|
|
};
|
|
|
|
pub struct Test<'a, T> {
|
|
data: PhantomData<&'a T>,
|
|
}
|
|
|
|
impl<'a, T, const N: usize> AsRef<[T; N]> for Test<'a, T> {
|
|
fn as_ref(&self) -> &[T; N] {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
impl<'a, T, const N: usize> AsMut<[T; N]> for Test<'a, T> {
|
|
fn as_mut(&mut self) -> &mut [T; N] {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
impl<'a, T, const N: usize> From<[T; N]> for Test<'a, T> {
|
|
fn from(_: [T; N]) -> Self {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
}
|
|
|
|
::encase::impl_vector!(2, impl_vector::Test<'a, T>; ('a, T: 'a); using AsRef AsMut From);
|
|
|
|
mod impl_matrix {
|
|
use ::core::{
|
|
convert::{AsMut, AsRef, From},
|
|
marker::PhantomData,
|
|
unimplemented,
|
|
};
|
|
|
|
pub struct Test<'a, T> {
|
|
data: PhantomData<&'a T>,
|
|
}
|
|
|
|
impl<'a, T, const N: usize, const M: usize> AsRef<[[T; M]; N]> for Test<'a, T> {
|
|
fn as_ref(&self) -> &[[T; M]; N] {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
impl<'a, T, const N: usize, const M: usize> AsMut<[[T; M]; N]> for Test<'a, T> {
|
|
fn as_mut(&mut self) -> &mut [[T; M]; N] {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
impl<'a, T, const N: usize, const M: usize> From<[[T; M]; N]> for Test<'a, T> {
|
|
fn from(_: [[T; M]; N]) -> Self {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
}
|
|
|
|
::encase::impl_matrix!(2, 2, impl_matrix::Test<'a, T>; ('a, T: 'a); using AsRef AsMut From);
|
|
|
|
mod impl_rts_array {
|
|
use ::core::{marker::PhantomData, unimplemented};
|
|
|
|
pub trait Array {
|
|
type Item;
|
|
}
|
|
|
|
pub struct Test<A: Array> {
|
|
data: PhantomData<A>,
|
|
}
|
|
|
|
impl<A: Array> Test<A> {
|
|
pub fn len(&self) -> usize {
|
|
unimplemented!()
|
|
}
|
|
|
|
pub fn truncate(&mut self, _len: usize) {
|
|
unimplemented!()
|
|
}
|
|
}
|
|
}
|
|
|
|
::encase::impl_rts_array!(impl_rts_array::Test<A>; (T, A: impl_rts_array::Array<Item = T>); using len truncate);
|
|
|
|
#[derive(::encase::ShaderType)]
|
|
struct Test {
|
|
a: [::mint::Vector3<::core::primitive::f32>; 2],
|
|
b: ::core::primitive::u32,
|
|
}
|
|
|
|
#[derive(::encase::ShaderType)]
|
|
struct TestGeneric<
|
|
'a,
|
|
T: 'a + ::encase::ShaderType + ::encase::ShaderSize,
|
|
const N: ::core::primitive::usize,
|
|
> {
|
|
#[size(90)]
|
|
a: &'a mut Test,
|
|
b: &'a mut [T; N],
|
|
#[align(16)]
|
|
#[size(runtime)]
|
|
c: &'a mut ::std::vec::Vec<[::mint::Vector3<::core::primitive::f32>; 2]>,
|
|
}
|