Vendor dependencies for 0.3.0 release

vendor/encase/tests/assert_uniform_compat_fail.rs

@@ -0,0 +1,71 @@
+use encase::ShaderType;
+
+#[derive(ShaderType)]
+struct S {
+    x: f32,
+}
+
+#[derive(ShaderType)]
+struct WrappedF32 {
+    #[size(16)]
+    elem: f32,
+}
+
+#[test]
+#[should_panic]
+fn test_struct() {
+    #[derive(ShaderType)]
+    struct TestStruct {
+        a: u32,
+        b: S,
+    }
+
+    TestStruct::assert_uniform_compat();
+}
+
+#[test]
+#[should_panic]
+fn test_array() {
+    #[derive(ShaderType)]
+    struct TestArray {
+        a: u32,
+        b: [WrappedF32; 1],
+    }
+
+    TestArray::assert_uniform_compat();
+}
+
+#[test]
+#[should_panic]
+fn test_struct_first() {
+    #[derive(ShaderType)]
+    struct TestStructFirst {
+        a: S,
+        b: f32,
+    }
+
+    TestStructFirst::assert_uniform_compat();
+}
+
+#[test]
+#[should_panic]
+fn test_array_stride() {
+    #[derive(ShaderType)]
+    struct TestArrayStride {
+        a: [u32; 8],
+    }
+
+    TestArrayStride::assert_uniform_compat();
+}
+
+#[test]
+#[should_panic]
+fn test_rts_array() {
+    #[derive(ShaderType)]
+    struct TestRTSArray {
+        #[size(runtime)]
+        a: Vec<f32>,
+    }
+
+    TestRTSArray::assert_uniform_compat();
+}

vendor/encase/tests/assert_uniform_compat_success.rs

@@ -0,0 +1,40 @@
+use encase::ShaderType;
+
+#[derive(ShaderType)]
+struct S {
+    x: f32,
+}
+
+#[derive(ShaderType)]
+struct WrappedF32 {
+    #[size(16)]
+    elem: f32,
+}
+
+#[derive(ShaderType)]
+struct TestStruct {
+    a: u32,
+    #[align(16)]
+    b: S,
+}
+
+#[derive(ShaderType)]
+struct TestArray {
+    a: u32,
+    #[align(16)]
+    b: [WrappedF32; 1],
+}
+
+#[derive(ShaderType)]
+struct TestStructFirst {
+    a: S,
+    #[align(16)]
+    b: f32,
+}
+
+#[test]
+fn assert_uniform_compat_success() {
+    TestStruct::assert_uniform_compat();
+    TestArray::assert_uniform_compat();
+    TestStructFirst::assert_uniform_compat();
+}

vendor/encase/tests/compile_fail/array_length_err.rs

@@ -0,0 +1,9 @@
+use encase::{ArrayLength, ShaderType};
+
+fn main() {}
+
+#[derive(ShaderType)]
+struct Test {
+    a: ArrayLength,
+    b: ArrayLength,
+}

vendor/encase/tests/compile_fail/array_length_err.stderr

@@ -0,0 +1,11 @@
+error: `ArrayLength` type can only be used within a struct containing a runtime-sized array marked as `#[size(runtime)]`!
+ --> tests/compile_fail/array_length_err.rs:7:8
+  |
+7 |     a: ArrayLength,
+  |        ^^^^^^^^^^^
+
+error: only one field can use the `ArrayLength` type!
+ --> tests/compile_fail/array_length_err.rs:8:8
+  |
+8 |     b: ArrayLength,
+  |        ^^^^^^^^^^^

vendor/encase/tests/compile_fail/general_struct_err.rs

@@ -0,0 +1,6 @@
+use encase::ShaderType;
+
+fn main() {}
+
+#[derive(ShaderType)]
+struct Test;

vendor/encase/tests/compile_fail/general_struct_err.stderr

@@ -0,0 +1,7 @@
+error: Only non empty structs with named fields are supported!
+ --> tests/compile_fail/general_struct_err.rs:5:10
+  |
+5 | #[derive(ShaderType)]
+  |          ^^^^^^^^^^
+  |
+  = note: this error originates in the derive macro `ShaderType` (in Nightly builds, run with -Z macro-backtrace for more info)

vendor/encase/tests/compile_fail/invalid_align_attr.rs

@@ -0,0 +1,15 @@
+use encase::ShaderType;
+
+fn main() {}
+
+#[derive(ShaderType)]
+struct Test {
+    #[align]
+    a: u32,
+    #[align()]
+    b: u32,
+    #[align(invalid)]
+    c: u32,
+    #[align(3)]
+    d: u32,
+}

vendor/encase/tests/compile_fail/invalid_align_attr.stderr

@@ -0,0 +1,23 @@
+error: expected attribute arguments in parentheses: `align(...)`
+ --> tests/compile_fail/invalid_align_attr.rs:7:7
+  |
+7 |     #[align]
+  |       ^^^^^
+
+error: expected a power of 2 u32 literal
+ --> tests/compile_fail/invalid_align_attr.rs:9:13
+  |
+9 |     #[align()]
+  |             ^
+
+error: expected a power of 2 u32 literal
+  --> tests/compile_fail/invalid_align_attr.rs:11:13
+   |
+11 |     #[align(invalid)]
+   |             ^^^^^^^
+
+error: expected a power of 2 u32 literal
+  --> tests/compile_fail/invalid_align_attr.rs:13:14
+   |
+13 |     #[align(3)]
+   |              ^

vendor/encase/tests/compile_fail/invalid_size_attr.rs

@@ -0,0 +1,15 @@
+use encase::ShaderType;
+
+fn main() {}
+
+#[derive(ShaderType)]
+struct Test {
+    #[size]
+    a: u32,
+    #[size()]
+    b: u32,
+    #[size(invalid)]
+    c: u32,
+    #[size(-1)]
+    d: u32,
+}

vendor/encase/tests/compile_fail/invalid_size_attr.stderr

@@ -0,0 +1,23 @@
+error: expected attribute arguments in parentheses: `size(...)`
+ --> tests/compile_fail/invalid_size_attr.rs:7:7
+  |
+7 |     #[size]
+  |       ^^^^
+
+error: expected u32 literal
+ --> tests/compile_fail/invalid_size_attr.rs:9:12
+  |
+9 |     #[size()]
+  |            ^
+
+error: expected u32 literal
+  --> tests/compile_fail/invalid_size_attr.rs:11:12
+   |
+11 |     #[size(invalid)]
+   |            ^^^^^^^
+
+error: expected u32 literal or `runtime` identifier
+  --> tests/compile_fail/invalid_size_attr.rs:13:14
+   |
+13 |     #[size(-1)]
+   |              ^

vendor/encase/tests/errors.rs

@@ -0,0 +1,36 @@
+use encase::{internal::Error, ShaderType, StorageBuffer};
+
+#[test]
+fn buffer_too_small() {
+    #[derive(ShaderType)]
+    struct Test {
+        a: u32,
+    }
+
+    let mut v = Test { a: 4 };
+    let mut buffer = StorageBuffer::new([0u8]);
+
+    assert!(matches!(
+        buffer.write(&v),
+        Err(Error::BufferTooSmall {
+            expected: 4,
+            found: 1
+        })
+    ));
+
+    assert!(matches!(
+        buffer.read(&mut v),
+        Err(Error::BufferTooSmall {
+            expected: 4,
+            found: 1
+        })
+    ));
+
+    assert!(matches!(
+        buffer.create::<Test>(),
+        Err(Error::BufferTooSmall {
+            expected: 4,
+            found: 1
+        })
+    ));
+}

vendor/encase/tests/general.rs

@@ -0,0 +1,160 @@
+use encase::{ArrayLength, CalculateSizeFor, ShaderType, StorageBuffer};
+
+macro_rules! gen {
+    ($rng:ident, $ty:ty) => {{
+        let mut buf = [0; 4];
+        use rand::RngCore;
+        $rng.fill_bytes(&mut buf);
+        <$ty>::from_ne_bytes(buf)
+    }};
+}
+
+macro_rules! gen_arr {
+    ($rng:ident, $ty:ty, $n:literal) => {{
+        [(); $n].map(|_| gen!($rng, $ty))
+    }};
+}
+
+macro_rules! gen_2d_arr {
+    ($rng:ident, $ty:ty, $n:literal, $m:literal) => {{
+        [[(); $m]; $n].map(|arr| arr.map(|_| gen!($rng, $ty)))
+    }};
+}
+
+macro_rules! gen_inner {
+    ($n:literal, $($tail:tt)*) => {{
+        [(); $n].map(|_| $($tail)*)
+    }};
+}
+
+#[derive(ShaderType)]
+struct A {
+    f: f32,
+    u: u32,
+    i: i32,
+    nu: Option<core::num::NonZeroU32>,
+    ni: Option<core::num::NonZeroI32>,
+    wu: core::num::Wrapping<u32>,
+    wi: core::num::Wrapping<i32>,
+    au: core::sync::atomic::AtomicU32,
+    ai: core::sync::atomic::AtomicI32,
+    v2: mint::Vector2<f32>,
+    v3: mint::Vector3<u32>,
+    v4: mint::Vector4<i32>,
+    p2: mint::Point2<f32>,
+    p3: mint::Point3<f32>,
+    mat2: mint::ColumnMatrix2<f32>,
+    mat2x3: mint::ColumnMatrix2x3<f32>,
+    mat2x4: mint::ColumnMatrix2x4<f32>,
+    mat3x2: mint::ColumnMatrix3x2<f32>,
+    mat3: mint::ColumnMatrix3<f32>,
+    mat3x4: mint::ColumnMatrix3x4<f32>,
+    mat4x2: mint::ColumnMatrix4x2<f32>,
+    mat4x3: mint::ColumnMatrix4x3<f32>,
+    mat4: mint::ColumnMatrix4<f32>,
+    arrf: [f32; 32],
+    arru: [u32; 32],
+    arri: [i32; 32],
+    arrvf: [mint::Vector2<f32>; 16],
+    arrvu: [mint::Vector3<u32>; 16],
+    arrvi: [mint::Vector4<i32>; 16],
+    arrm2: [mint::ColumnMatrix2<f32>; 8],
+    arrm3: [mint::ColumnMatrix3<f32>; 8],
+    arrm4: [mint::ColumnMatrix4<f32>; 8],
+    rt_arr_len: ArrayLength,
+    #[size(runtime)]
+    rt_arr: Vec<mint::ColumnMatrix2x3<f32>>,
+}
+
+fn gen_a(rng: &mut rand::rngs::StdRng) -> A {
+    A {
+        f: gen!(rng, f32),
+        u: gen!(rng, u32),
+        i: gen!(rng, i32),
+        nu: core::num::NonZeroU32::new(gen!(rng, u32)),
+        ni: core::num::NonZeroI32::new(gen!(rng, i32)),
+        wu: core::num::Wrapping(gen!(rng, u32)),
+        wi: core::num::Wrapping(gen!(rng, i32)),
+        au: core::sync::atomic::AtomicU32::new(gen!(rng, u32)),
+        ai: core::sync::atomic::AtomicI32::new(gen!(rng, i32)),
+        v2: mint::Vector2::from(gen_arr!(rng, f32, 2)),
+        v3: mint::Vector3::from(gen_arr!(rng, u32, 3)),
+        v4: mint::Vector4::from(gen_arr!(rng, i32, 4)),
+        p2: mint::Point2::from(gen_arr!(rng, f32, 2)),
+        p3: mint::Point3::from(gen_arr!(rng, f32, 3)),
+        mat2: mint::ColumnMatrix2::from(gen_2d_arr!(rng, f32, 2, 2)),
+        mat2x3: mint::ColumnMatrix2x3::from(gen_2d_arr!(rng, f32, 3, 2)),
+        mat2x4: mint::ColumnMatrix2x4::from(gen_2d_arr!(rng, f32, 4, 2)),
+        mat3x2: mint::ColumnMatrix3x2::from(gen_2d_arr!(rng, f32, 2, 3)),
+        mat3: mint::ColumnMatrix3::from(gen_2d_arr!(rng, f32, 3, 3)),
+        mat3x4: mint::ColumnMatrix3x4::from(gen_2d_arr!(rng, f32, 4, 3)),
+        mat4x2: mint::ColumnMatrix4x2::from(gen_2d_arr!(rng, f32, 2, 4)),
+        mat4x3: mint::ColumnMatrix4x3::from(gen_2d_arr!(rng, f32, 3, 4)),
+        mat4: mint::ColumnMatrix4::from(gen_2d_arr!(rng, f32, 4, 4)),
+        arrf: gen_arr!(rng, f32, 32),
+        arru: gen_arr!(rng, u32, 32),
+        arri: gen_arr!(rng, i32, 32),
+        arrvf: gen_inner!(16, mint::Vector2::from(gen_arr!(rng, f32, 2))),
+        arrvu: gen_inner!(16, mint::Vector3::from(gen_arr!(rng, u32, 3))),
+        arrvi: gen_inner!(16, mint::Vector4::from(gen_arr!(rng, i32, 4))),
+        arrm2: gen_inner!(8, mint::ColumnMatrix2::from(gen_2d_arr!(rng, f32, 2, 2))),
+        arrm3: gen_inner!(8, mint::ColumnMatrix3::from(gen_2d_arr!(rng, f32, 3, 3))),
+        arrm4: gen_inner!(8, mint::ColumnMatrix4::from(gen_2d_arr!(rng, f32, 4, 4))),
+        rt_arr_len: ArrayLength,
+        rt_arr: vec![mint::ColumnMatrix2x3::from(gen_2d_arr!(rng, f32, 3, 2)); 64],
+    }
+}
+
+#[test]
+fn size() {
+    use rand::SeedableRng;
+    let mut rng = rand::rngs::StdRng::seed_from_u64(1234);
+    let a = gen_a(&mut rng);
+
+    assert_eq!(a.size().get(), 4080);
+}
+
+#[test]
+fn calculate_size_for() {
+    assert_eq!(<&A>::calculate_size_for(12).get(), 2832);
+}
+
+#[test]
+fn all_types() {
+    use rand::SeedableRng;
+    let mut rng = rand::rngs::StdRng::seed_from_u64(1234);
+    let a = gen_a(&mut rng);
+
+    let mut raw_buffer = Vec::new();
+    let mut buffer = StorageBuffer::new(&mut raw_buffer);
+    buffer.write(&a).unwrap();
+
+    let mut a_clone: A = buffer.create().unwrap();
+    let mut raw_buffer_2 = Vec::new();
+    let mut buffer_2 = StorageBuffer::new(&mut raw_buffer_2);
+    buffer_2.write(&a_clone).unwrap();
+
+    assert_eq!(buffer.as_ref(), buffer_2.as_ref());
+
+    a_clone.rt_arr.truncate(10);
+    // a_clone.rt_arr.reserve_exact(0);
+    buffer_2.read(&mut a_clone).unwrap();
+    buffer_2.write(&a_clone).unwrap();
+
+    assert_eq!(raw_buffer, raw_buffer_2);
+}
+
+#[test]
+fn test_opt_writing() {
+    let one = 1_u32;
+    let two = 2_u32;
+    let data = [&one, &two];
+    let data2 = [one, two];
+    let mut in_byte_buffer: Vec<u8> = Vec::new();
+    let mut in_byte_buffer2: Vec<u8> = Vec::new();
+    let mut in_buffer = StorageBuffer::new(&mut in_byte_buffer);
+    let mut in_buffer2 = StorageBuffer::new(&mut in_byte_buffer2);
+    in_buffer.write(&data).unwrap();
+    in_buffer2.write(&data2).unwrap();
+    assert_eq!(in_byte_buffer, in_byte_buffer2);
+}

vendor/encase/tests/hygiene.rs

@@ -0,0 +1,115 @@
+#![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]>,
+}

vendor/encase/tests/metadata.rs

@@ -0,0 +1,12 @@
+use encase::ShaderType;
+
+#[derive(ShaderType)]
+struct WrappedF32 {
+    #[size(16)]
+    value: f32,
+}
+
+#[test]
+fn field_padding() {
+    assert_eq!(WrappedF32::METADATA.padding(0), 12);
+}

vendor/encase/tests/pass/attributes.rs

@@ -0,0 +1,26 @@
+use encase::ShaderType;
+
+fn main() {}
+
+#[derive(ShaderType)]
+struct TestAttributes {
+    #[align(16)]
+    a: u32,
+    #[size(8)]
+    b: u32,
+}
+
+#[derive(ShaderType)]
+struct TestRtArray {
+    #[size(8)]
+    a: u32,
+    #[align(16)]
+    #[size(runtime)]
+    b: Vec<u32>,
+}
+
+#[derive(ShaderType)]
+struct TestDocComment {
+    /// This is an unsigned integer
+    a: u32,
+}

vendor/encase/tests/pass/wrappers.rs

@@ -0,0 +1,16 @@
+use core::cell::Cell;
+use encase::ShaderType;
+use std::{borrow::Cow, rc::Rc, sync::Arc};
+
+fn main() {}
+
+#[derive(ShaderType)]
+struct Test<'a> {
+    a: &'a u32,
+    b: &'a mut u32,
+    c: Box<u32>,
+    d: Cow<'a, u32>,
+    e: Rc<u32>,
+    f: Arc<u32>,
+    g: Cell<u32>,
+}

vendor/encase/tests/shaders/array_length.wgsl

@@ -0,0 +1,23 @@
+struct A {
+    array_length: u32,
+    array_length_call_ret_val: u32,
+    a: vec3<u32>,
+    @align(16)
+    arr: array<u32>,
+}
+
+@group(0) @binding(0)
+var<storage> in: A;
+
+@group(0) @binding(1)
+var<storage, read_write> out: A;
+
+@compute @workgroup_size(1, 1, 1)
+fn main() {
+    out.array_length = in.array_length;
+    out.a = in.a;
+    for (var i = 0u; i < arrayLength(&in.arr); i = i + 1u) {
+        out.arr[i] = in.arr[i];
+    }
+    out.array_length_call_ret_val = arrayLength(&in.arr);
+}

vendor/encase/tests/shaders/general.wgsl

@@ -0,0 +1,45 @@
+struct A {
+    u: u32,
+    v: u32,
+    w: vec2<u32>,
+    @size(16) @align(8)
+    x: u32,
+    xx: u32,
+}
+
+struct B {
+    a: vec2<u32>,
+    b: vec3<u32>,
+    c: u32,
+    d: u32,
+    @align(16)
+    e: A,
+    f: vec3<u32>,
+    g: array<A, 3>,
+    h: i32,
+    @align(32)
+    i: array<A>,
+}
+
+@group(0) @binding(0)
+var<storage> in: B;
+
+@group(0) @binding(1)
+var<storage, read_write> out: B;
+
+@compute @workgroup_size(1, 1, 1)
+fn main() {
+    out.a = in.a;
+    out.b = in.b;
+    out.c = in.c;
+    out.d = in.d;
+    out.e = in.e;
+    out.f = in.f;
+    out.g[0] = in.g[0];
+    out.g[1] = in.g[1];
+    out.g[2] = in.g[2];
+    out.h = in.h;
+    for (var i = 0u; i < arrayLength(&in.i); i = i + 1u) {
+        out.i[i] = in.i[i];
+    }
+}

vendor/encase/tests/trybuild.rs

@@ -0,0 +1,8 @@
+#![cfg(not(miri))] // Can't run (and no point running) trybuild through miri
+
+#[test]
+fn trybuild() {
+    let t = trybuild::TestCases::new();
+    t.pass("tests/pass/*.rs");
+    t.compile_fail("tests/compile_fail/*.rs");
+}

vendor/encase/tests/uniform.rs

@@ -0,0 +1,18 @@
+use encase::{ShaderType, UniformBuffer};
+
+#[derive(Debug, ShaderType, PartialEq, Eq)]
+struct TestUniform {
+    a: u32,
+    b: u32,
+}
+
+#[test]
+fn uniform() {
+    let mut val = TestUniform { a: 4, b: 23 };
+
+    let mut buffer = UniformBuffer::new(Vec::new());
+
+    buffer.write(&val).unwrap();
+    buffer.read(&mut val).unwrap();
+    assert_eq!(val, buffer.create().unwrap());
+}

vendor/encase/tests/wgpu.rs

@@ -0,0 +1,279 @@
+#![cfg(not(miri))] // Can't run wgpu through miri
+
+use encase::{ArrayLength, ShaderType, StorageBuffer};
+use futures::executor::block_on;
+use mint::{Vector2, Vector3};
+use wgpu::{include_wgsl, util::DeviceExt};
+
+#[derive(Debug, ShaderType, PartialEq)]
+struct A {
+    u: u32,
+    v: u32,
+    w: Vector2<u32>,
+    #[size(16)]
+    #[align(8)]
+    x: u32,
+    xx: u32,
+}
+
+#[derive(Debug, ShaderType, PartialEq)]
+struct B {
+    a: Vector2<u32>,
+    b: Vector3<u32>,
+    c: u32,
+    d: u32,
+    #[align(16)]
+    e: A,
+    f: Vector3<u32>,
+    g: [A; 3],
+    h: i32,
+    #[align(32)]
+    #[size(runtime)]
+    i: Vec<A>,
+}
+
+#[test]
+fn test_wgpu() {
+    let b = B {
+        a: Vector2 { x: 45, y: 564 },
+        b: Vector3 {
+            x: 465,
+            y: 56664,
+            z: 5646,
+        },
+        c: 4,
+        d: 3,
+        e: A {
+            u: 5,
+            v: 566,
+            w: Vector2 { x: 4345, y: 43564 },
+            x: 5444,
+            xx: 305444,
+        },
+        f: Vector3 {
+            x: 455465,
+            y: 55665464,
+            z: 5564546,
+        },
+        g: [
+            A {
+                u: 105,
+                v: 10566,
+                w: Vector2 {
+                    x: 14345,
+                    y: 143564,
+                },
+                x: 105444,
+                xx: 305444,
+            },
+            A {
+                u: 205,
+                v: 20566,
+                w: Vector2 {
+                    x: 24345,
+                    y: 243564,
+                },
+                x: 205444,
+                xx: 305444,
+            },
+            A {
+                u: 305,
+                v: 30566,
+                w: Vector2 {
+                    x: 34345,
+                    y: 343564,
+                },
+                x: 305444,
+                xx: 305444,
+            },
+        ],
+        h: 5,
+        i: Vec::from([A {
+            u: 205,
+            v: 20566,
+            w: Vector2 {
+                x: 24345,
+                y: 243564,
+            },
+            x: 205444,
+            xx: 305444,
+        }]),
+    };
+
+    let mut in_byte_buffer = Vec::new();
+    let mut in_buffer = StorageBuffer::new(&mut in_byte_buffer);
+
+    in_buffer.write(&b).unwrap();
+    assert_eq!(in_byte_buffer.len(), b.size().get() as _);
+
+    let shader = include_wgsl!("./shaders/general.wgsl");
+    let out_byte_buffer = in_out::<B, B>(shader, &in_byte_buffer, false);
+
+    assert_eq!(in_byte_buffer, out_byte_buffer);
+
+    let out_buffer = StorageBuffer::new(out_byte_buffer);
+    let out_val: B = out_buffer.create().unwrap();
+    assert_eq!(b, out_val);
+}
+
+#[test]
+fn array_length() {
+    #[derive(Debug, ShaderType, PartialEq)]
+    struct A {
+        array_length: ArrayLength,
+        array_length_call_ret_val: u32,
+        a: Vector3<u32>,
+        #[align(16)]
+        #[size(runtime)]
+        arr: Vec<u32>,
+    }
+
+    let in_value = A {
+        array_length: ArrayLength,
+        array_length_call_ret_val: 4,
+        a: Vector3 { x: 5, y: 4, z: 6 },
+        arr: vec![45],
+    };
+
+    let mut in_byte_buffer = Vec::new();
+    let mut in_buffer = StorageBuffer::new(&mut in_byte_buffer);
+
+    in_buffer.write(&in_value).unwrap();
+    assert_eq!(in_byte_buffer.len(), in_value.size().get() as _);
+
+    let shader = include_wgsl!("./shaders/array_length.wgsl");
+    let out_byte_buffer = in_out::<A, A>(shader, &in_byte_buffer, false);
+
+    assert_eq!(in_byte_buffer, out_byte_buffer);
+
+    let out_buffer = StorageBuffer::new(out_byte_buffer);
+    let out_val: A = out_buffer.create().unwrap();
+
+    assert_eq!(in_value, out_val);
+}
+
+fn in_out<IN: encase::ShaderType, OUT: encase::ShaderType>(
+    shader: wgpu::ShaderModuleDescriptor,
+    data: &[u8],
+    is_uniform: bool,
+) -> Vec<u8> {
+    let instance = wgpu::Instance::new(wgpu::InstanceDescriptor {
+        backends: wgpu::Backends::PRIMARY,
+        dx12_shader_compiler: wgpu::Dx12Compiler::Fxc,
+        ..Default::default()
+    });
+    let adapter = block_on(instance.request_adapter(&wgpu::RequestAdapterOptions {
+        power_preference: wgpu::PowerPreference::default(),
+        ..Default::default()
+    }))
+    .unwrap();
+
+    println!("Adapter info: {:#?}", adapter.get_info());
+
+    let (device, queue) =
+        block_on(adapter.request_device(&wgpu::DeviceDescriptor::default(), None)).unwrap();
+
+    let input_buffer = device.create_buffer_init(&wgpu::util::BufferInitDescriptor {
+        label: Some("Input Buffer"),
+        contents: data,
+        usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::UNIFORM,
+    });
+
+    let output_gpu_buffer = device.create_buffer(&wgpu::BufferDescriptor {
+        label: Some("Output Buffer"),
+        size: data.len() as _,
+        usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
+        mapped_at_creation: false,
+    });
+
+    let mapping_buffer = device.create_buffer(&wgpu::BufferDescriptor {
+        label: Some("Mapping Buffer"),
+        size: data.len() as _,
+        usage: wgpu::BufferUsages::COPY_DST | wgpu::BufferUsages::MAP_READ,
+        mapped_at_creation: false,
+    });
+
+    let bind_group_layout = device.create_bind_group_layout(&wgpu::BindGroupLayoutDescriptor {
+        label: None,
+        entries: &[
+            wgpu::BindGroupLayoutEntry {
+                binding: 0,
+                visibility: wgpu::ShaderStages::COMPUTE,
+                ty: wgpu::BindingType::Buffer {
+                    ty: if is_uniform {
+                        wgpu::BufferBindingType::Uniform
+                    } else {
+                        wgpu::BufferBindingType::Storage { read_only: true }
+                    },
+                    has_dynamic_offset: false,
+                    min_binding_size: Some(IN::min_size()),
+                },
+                count: None,
+            },
+            wgpu::BindGroupLayoutEntry {
+                binding: 1,
+                visibility: wgpu::ShaderStages::COMPUTE,
+                ty: wgpu::BindingType::Buffer {
+                    ty: wgpu::BufferBindingType::Storage { read_only: false },
+                    has_dynamic_offset: false,
+                    min_binding_size: Some(OUT::min_size()),
+                },
+                count: None,
+            },
+        ],
+    });
+
+    let pipeline_layout = device.create_pipeline_layout(&wgpu::PipelineLayoutDescriptor {
+        label: None,
+        bind_group_layouts: &[&bind_group_layout],
+        push_constant_ranges: &[],
+    });
+
+    let shader = device.create_shader_module(shader);
+
+    let compute_pipeline = device.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
+        label: None,
+        layout: Some(&pipeline_layout),
+        module: &shader,
+        entry_point: "main",
+        compilation_options: wgpu::PipelineCompilationOptions::default(),
+        cache: None,
+    });
+
+    let bind_group = device.create_bind_group(&wgpu::BindGroupDescriptor {
+        label: None,
+        layout: &bind_group_layout,
+        entries: &[
+            wgpu::BindGroupEntry {
+                binding: 0,
+                resource: input_buffer.as_entire_binding(),
+            },
+            wgpu::BindGroupEntry {
+                binding: 1,
+                resource: output_gpu_buffer.as_entire_binding(),
+            },
+        ],
+    });
+
+    let mut encoder = device.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
+
+    {
+        let mut cpass = encoder.begin_compute_pass(&wgpu::ComputePassDescriptor::default());
+        cpass.set_pipeline(&compute_pipeline);
+        cpass.set_bind_group(0, &bind_group, &[]);
+        cpass.dispatch_workgroups(1, 1, 1);
+    }
+
+    encoder.copy_buffer_to_buffer(&output_gpu_buffer, 0, &mapping_buffer, 0, data.len() as _);
+
+    queue.submit(core::iter::once(encoder.finish()));
+
+    let output_slice = mapping_buffer.slice(..);
+    output_slice.map_async(wgpu::MapMode::Read, |_| {});
+
+    device.poll(wgpu::Maintain::Wait);
+
+    let output = output_slice.get_mapped_range().to_vec();
+    mapping_buffer.unmap();
+    output
+}