Mirrors/bevy
2
0
Fork 0
mirror of https://github.com/bevyengine/bevy synced 2024-11-22 04:33:37 +00:00
Code Issues Projects Releases Packages Wiki Activity

Update vendored Crevice to 0.8.0 + PR for arrays (#3059)

Browse source 
# Objective

- Update vendor crevice to have the latest update from crevice 0.8.0
- Using https://github.com/ElectronicRU/crevice/tree/arrays which has the changes to make arrays work

## Solution

- Also updated glam and hexasphere to only have one version of glam
- From the original PR, using crevice to write GLSL code containing arrays would probably not work but it's not something used by Bevy
This commit is contained in:
François 2021-11-12 01:39:25 +00:00
parent e375addec6
commit 290b7dd9ab
39 changed files with 1846 additions and 668 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
Cargo.toml
View file

@ -108,7 +108,7 @@ ron = "0.6.2"
serde = { version = "1", features = ["derive"] } serde = { version = "1", features = ["derive"] }
# Needed to poll Task examples # Needed to poll Task examples
futures-lite = "1.11.3" futures-lite = "1.11.3"
crevice = {path = "crates/crevice"} crevice = { path = "crates/crevice", version = "0.8.0", features = ["glam"] }
[[example]] [[example]]
name = "hello_world" name = "hello_world"

2
crates/bevy_math/Cargo.toml
View file

@ -13,5 +13,5 @@ license = "MIT OR Apache-2.0"
keywords = ["bevy"] keywords = ["bevy"]
[dependencies] [dependencies]
glam = { version = "0.15.1", features = ["serde", "bytemuck"] } glam = { version = "0.20.0", features = ["serde", "bytemuck"] }
bevy_reflect = { path = "../bevy_reflect", version = "0.5.0", features = ["bevy"] } bevy_reflect = { path = "../bevy_reflect", version = "0.5.0", features = ["bevy"] }

2
crates/bevy_reflect/Cargo.toml
View file

@ -28,7 +28,7 @@ parking_lot = "0.11.0"
thiserror = "1.0" thiserror = "1.0"
serde = "1" serde = "1"
smallvec = { version = "1.6", features = ["serde", "union", "const_generics"], optional = true } smallvec = { version = "1.6", features = ["serde", "union", "const_generics"], optional = true }
glam = { version = "0.15.1", features = ["serde"], optional = true } glam = { version = "0.20.0", features = ["serde"], optional = true }
[dev-dependencies] [dev-dependencies]
ron = "0.6.2" ron = "0.6.2"

2
crates/bevy_render/Cargo.toml
View file

@ -32,7 +32,7 @@ downcast-rs = "1.2.0"
thiserror = "1.0" thiserror = "1.0"
anyhow = "1.0.4" anyhow = "1.0.4"
hex = "0.4.2" hex = "0.4.2"
hexasphere = "4.0.0" hexasphere = "6.0.0"
parking_lot = "0.11.0" parking_lot = "0.11.0"
[target.'cfg(not(target_arch = "wasm32"))'.dependencies] [target.'cfg(not(target_arch = "wasm32"))'.dependencies]

20
crates/crevice/Cargo.toml
View file

@ -1,8 +1,8 @@
[package] [package]
name = "crevice" name = "crevice"
description = "Create GLSL-compatible versions of structs with explicitly-initialized padding" description = "Create GLSL-compatible versions of structs with explicitly-initialized padding"
version = "0.6.0" version = "0.8.0"
edition = "2018" edition = "2021"
authors = ["Lucien Greathouse <me@lpghatguy.com>"] authors = ["Lucien Greathouse <me@lpghatguy.com>"]
documentation = "https://docs.rs/crevice" documentation = "https://docs.rs/crevice"
homepage = "https://github.com/LPGhatguy/crevice" homepage = "https://github.com/LPGhatguy/crevice"
@ -10,6 +10,7 @@ repository = "https://github.com/LPGhatguy/crevice"
readme = "README.md" readme = "README.md"
keywords = ["glsl", "std140", "std430"] keywords = ["glsl", "std140", "std430"]
license = "MIT OR Apache-2.0" license = "MIT OR Apache-2.0"
# resolver = "2"
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
@ -17,12 +18,19 @@ license = "MIT OR Apache-2.0"
default = ["std"] default = ["std"]
std = [] std = []
# [workspace]
# members = ["crevice-derive", "crevice-tests"]
# default-members = ["crevice-derive", "crevice-tests"]
[dependencies] [dependencies]
crevice-derive = { version = "0.6.0", path = "crevice-derive" } crevice-derive = { version = "0.8.0", path = "crevice-derive" }
bytemuck = "1.4.1" bytemuck = "1.4.1"
mint = "0.5.5" mint = "0.5.8"
glam = "0.15.1"
cgmath = { version = "0.18.0", optional = true }
glam = { version = "0.20.0", features = ["mint"], optional = true }
nalgebra = { version = "0.29.0", features = ["mint"], optional = true }
[dev-dependencies] [dev-dependencies]
crevice-derive = { version = "0.6.0", path = "crevice-derive" } insta = "0.16.1"

76
crates/crevice/README.md
View file

@ -11,19 +11,34 @@ method to allow safely packing data into buffers for uploading.
Generated structs also implement [`bytemuck::Zeroable`] and Generated structs also implement [`bytemuck::Zeroable`] and
[`bytemuck::Pod`] for use with other libraries. [`bytemuck::Pod`] for use with other libraries.
Crevice is similar to [`glsl-layout`][glsl-layout], but supports `mint` types Crevice is similar to [`glsl-layout`][glsl-layout], but supports types from many
and explicitly initializes padding to remove one source of undefined behavior. math crates, can generate GLSL source from structs, and explicitly initializes
padding to remove one source of undefined behavior.
Examples in this crate use cgmath, but any math crate that works with the mint Crevice has support for many Rust math libraries via feature flags, and most
crate will also work. Some other crates include nalgebra, ultraviolet, glam, and other math libraries by use of the mint crate. Crevice currently supports:
vek.
* mint 0.5, enabled by default
* cgmath 0.18, using the `cgmath` feature
* nalgebra 0.29, using the `nalgebra` feature
* glam 0.19, using the `glam` feature
PRs are welcome to add or update math libraries to Crevice.
If your math library is not supported, it's possible to define structs using the
types from mint and convert your math library's types into mint types. This is
supported by most Rust math libraries.
Your math library may require you to turn on a feature flag to get mint support.
For example, cgmath requires the "mint" feature to be enabled to allow
conversions to and from mint types.
## Examples ## Examples
### Single Value ### Single Value
Uploading many types can be done by deriving `AsStd140` and using Uploading many types can be done by deriving [`AsStd140`][std140::AsStd140] and
[`as_std140`][std140::AsStd140::as_std140] and using [`as_std140`][std140::AsStd140::as_std140] and
[`as_bytes`][std140::Std140::as_bytes] to turn the result into bytes. [`as_bytes`][std140::Std140::as_bytes] to turn the result into bytes.
```glsl ```glsl
@ -36,8 +51,6 @@ uniform MAIN {
```rust ```rust
use crevice::std140::{AsStd140, Std140}; use crevice::std140::{AsStd140, Std140};
use cgmath::prelude::*;
use cgmath::{Matrix3, Vector3};
#[derive(AsStd140)] #[derive(AsStd140)]
struct MainUniform { struct MainUniform {
@ -47,8 +60,12 @@ struct MainUniform {
} }
let value = MainUniform { let value = MainUniform {
orientation: Matrix3::identity().into(), orientation: [
position: Vector3::new(1.0, 2.0, 3.0).into(), [1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0],
].into(),
position: [1.0, 2.0, 3.0].into(),
scale: 4.0, scale: 4.0,
}; };
@ -57,9 +74,10 @@ let value_std140 = value.as_std140();
upload_data_to_gpu(value_std140.as_bytes()); upload_data_to_gpu(value_std140.as_bytes());
``` ```
#### Sequential Types ### Sequential Types
More complicated data can be uploaded using the std140 `Writer` type. More complicated data can be uploaded using the std140
[`Writer`][std140::Writer] type.
```glsl ```glsl
struct PointLight { struct PointLight {
@ -113,24 +131,40 @@ unmap_gpu_buffer();
``` ```
### Minimum Supported Rust Version (MSRV) ## Features
Crevice supports Rust 1.46.0 and newer due to use of new `const fn` features. * `std` (default): Enables [`std::io::Write`]-based structs.
* `cgmath`: Enables support for types from cgmath.
* `nalgebra`: Enables support for types from nalgebra.
* `glam`: Enables support for types from glam.
## Minimum Supported Rust Version (MSRV)
Crevice supports Rust 1.52.1 and newer due to use of new `const fn` features.
[glsl-layout]: https://github.com/rustgd/glsl-layout [glsl-layout]: https://github.com/rustgd/glsl-layout
[Zeroable]: https://docs.rs/bytemuck/latest/bytemuck/trait.Zeroable.html
[Pod]: https://docs.rs/bytemuck/latest/bytemuck/trait.Pod.html [std140::AsStd140]: https://docs.rs/crevice/latest/crevice/std140/trait.AsStd140.html
[TypeLayout]: https://docs.rs/type-layout/latest/type_layout/trait.TypeLayout.html [std140::AsStd140::as_std140]: https://docs.rs/crevice/latest/crevice/std140/trait.AsStd140.html#method.as_std140
[std140::Std140::as_bytes]: https://docs.rs/crevice/latest/crevice/std140/trait.Std140.html#method.as_bytes
[std140::Writer]: https://docs.rs/crevice/latest/crevice/std140/struct.Writer.html
[`std::io::Write`]: https://doc.rust-lang.org/stable/std/io/trait.Write.html
[`bytemuck::Pod`]: https://docs.rs/bytemuck/latest/bytemuck/trait.Pod.html
[`bytemuck::Zeroable`]: https://docs.rs/bytemuck/latest/bytemuck/trait.Zeroable.html
## License ## License
Licensed under either of Licensed under either of
* Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or [http://www.apache.org/licenses/LICENSE-2.0](http://www.apache.org/licenses/LICENSE-2.0)) * Apache License, Version 2.0, ([LICENSE-APACHE](http://www.apache.org/licenses/LICENSE-2.0))
* MIT license ([LICENSE-MIT](LICENSE-MIT) or [http://opensource.org/licenses/MIT](http://opensource.org/licenses/MIT)) * MIT license ([LICENSE-MIT](http://opensource.org/licenses/MIT))
at your option. at your option.
### Contribution ### Contribution
Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions. Unless you explicitly state otherwise, any contribution intentionally submitted
for inclusion in the work by you, as defined in the Apache-2.0 license, shall
be dual licensed as above, without any additional terms or conditions.

10
crates/crevice/README.tpl
View file

@ -2,6 +2,16 @@
{{readme}} {{readme}}
[std140::AsStd140]: https://docs.rs/crevice/latest/crevice/std140/trait.AsStd140.html
[std140::AsStd140::as_std140]: https://docs.rs/crevice/latest/crevice/std140/trait.AsStd140.html#method.as_std140
[std140::Std140::as_bytes]: https://docs.rs/crevice/latest/crevice/std140/trait.Std140.html#method.as_bytes
[std140::Writer]: https://docs.rs/crevice/latest/crevice/std140/struct.Writer.html
[`std::io::Write`]: https://doc.rust-lang.org/stable/std/io/trait.Write.html
[`bytemuck::Pod`]: https://docs.rs/bytemuck/latest/bytemuck/trait.Pod.html
[`bytemuck::Zeroable`]: https://docs.rs/bytemuck/latest/bytemuck/trait.Zeroable.html
## License ## License
Licensed under either of Licensed under either of

8
crates/crevice/crevice-derive/Cargo.toml
View file

@ -1,7 +1,7 @@
[package] [package]
name = "crevice-derive" name = "crevice-derive"
description = "Derive crate for the 'crevice' crate" description = "Derive crate for the 'crevice' crate"
version = "0.6.0" version = "0.8.0"
edition = "2018" edition = "2018"
authors = ["Lucien Greathouse <me@lpghatguy.com>"] authors = ["Lucien Greathouse <me@lpghatguy.com>"]
documentation = "https://docs.rs/crevice-derive" documentation = "https://docs.rs/crevice-derive"
@ -9,6 +9,12 @@ homepage = "https://github.com/LPGhatguy/crevice"
repository = "https://github.com/LPGhatguy/crevice" repository = "https://github.com/LPGhatguy/crevice"
license = "MIT OR Apache-2.0" license = "MIT OR Apache-2.0"
[features]
default = []
# Enable methods that let you introspect into the generated structs.
debug-methods = []
[lib] [lib]
proc-macro = true proc-macro = true

49
crates/crevice/crevice-derive/src/glsl.rs Normal file
View file

@ -0,0 +1,49 @@
use proc_macro2::{Literal, TokenStream};
use quote::quote;
use syn::{parse_quote, Data, DeriveInput, Fields, Path};
pub fn emit(input: DeriveInput) -> TokenStream {
let fields = match &input.data {
Data::Struct(data) => match &data.fields {
Fields::Named(fields) => fields,
Fields::Unnamed(_) => panic!("Tuple structs are not supported"),
Fields::Unit => panic!("Unit structs are not supported"),
},
Data::Enum(_) | Data::Union(_) => panic!("Only structs are supported"),
};
let base_trait_path: Path = parse_quote!(::crevice::glsl::Glsl);
let struct_trait_path: Path = parse_quote!(::crevice::glsl::GlslStruct);
let name = input.ident;
let name_str = Literal::string(&name.to_string());
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
let glsl_fields = fields.named.iter().map(|field| {
let field_ty = &field.ty;
let field_name_str = Literal::string(&field.ident.as_ref().unwrap().to_string());
let field_as = quote! {<#field_ty as ::crevice::glsl::GlslArray>};
quote! {
s.push_str("\t");
s.push_str(#field_as::NAME);
s.push_str(" ");
s.push_str(#field_name_str);
<#field_as::ArraySize as ::crevice::glsl::DimensionList>::push_to_string(s);
s.push_str(";\n");
}
});
quote! {
unsafe impl #impl_generics #base_trait_path for #name #ty_generics #where_clause {
const NAME: &'static str = #name_str;
}
unsafe impl #impl_generics #struct_trait_path for #name #ty_generics #where_clause {
fn enumerate_fields(s: &mut String) {
#( #glsl_fields )*
}
}
}
}

288
crates/crevice/crevice-derive/src/layout.rs Normal file
View file

@ -0,0 +1,288 @@
use proc_macro2::{Span, TokenStream};
use quote::{format_ident, quote};
use syn::{parse_quote, Data, DeriveInput, Fields, Ident, Path, Type};
pub fn emit(
input: DeriveInput,
trait_name: &'static str,
mod_name: &'static str,
min_struct_alignment: usize,
) -> TokenStream {
let mod_name = Ident::new(mod_name, Span::call_site());
let trait_name = Ident::new(trait_name, Span::call_site());
let mod_path: Path = parse_quote!(::crevice::#mod_name);
let trait_path: Path = parse_quote!(#mod_path::#trait_name);
let as_trait_name = format_ident!("As{}", trait_name);
let as_trait_path: Path = parse_quote!(#mod_path::#as_trait_name);
let as_trait_method = format_ident!("as_{}", mod_name);
let from_trait_method = format_ident!("from_{}", mod_name);
let padded_name = format_ident!("{}Padded", trait_name);
let padded_path: Path = parse_quote!(#mod_path::#padded_name);
let visibility = input.vis;
let input_name = input.ident;
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
let generated_name = format_ident!("{}{}", trait_name, input_name);
// Crevice's derive only works on regular structs. We could potentially
// support transparent tuple structs in the future.
let fields: Vec<_> = match &input.data {
Data::Struct(data) => match &data.fields {
Fields::Named(fields) => fields.named.iter().collect(),
Fields::Unnamed(_) => panic!("Tuple structs are not supported"),
Fields::Unit => panic!("Unit structs are not supported"),
},
Data::Enum(_) | Data::Union(_) => panic!("Only structs are supported"),
};
// Gives the layout-specific version of the given type.
let layout_version_of_ty = |ty: &Type| {
quote! {
<#ty as #as_trait_path>::Output
}
};
// Gives an expression returning the layout-specific alignment for the type.
let layout_alignment_of_ty = |ty: &Type| {
quote! {
<<#ty as #as_trait_path>::Output as #trait_path>::ALIGNMENT
}
};
// Gives an expression telling whether the type should have trailing padding
// at least equal to its alignment.
let layout_pad_at_end_of_ty = |ty: &Type| {
quote! {
<<#ty as #as_trait_path>::Output as #trait_path>::PAD_AT_END
}
};
let field_alignments = fields.iter().map(|field| layout_alignment_of_ty(&field.ty));
let struct_alignment = quote! {
::crevice::internal::max_arr([
#min_struct_alignment,
#(#field_alignments,)*
])
};
// Generate names for each padding calculation function.
let pad_fns: Vec<_> = (0..fields.len())
.map(|index| format_ident!("_{}__{}Pad{}", input_name, trait_name, index))
.collect();
// Computes the offset immediately AFTER the field with the given index.
//
// This function depends on the generated padding calculation functions to
// do correct alignment. Be careful not to cause recursion!
let offset_after_field = |target: usize| {
let mut output = vec![quote!(0usize)];
for index in 0..=target {
let field_ty = &fields[index].ty;
let layout_ty = layout_version_of_ty(field_ty);
output.push(quote! {
+ ::core::mem::size_of::<#layout_ty>()
});
// For every field except our target field, also add the generated
// padding. Padding occurs after each field, so it isn't included in
// this value.
if index < target {
let pad_fn = &pad_fns[index];
output.push(quote! {
+ #pad_fn()
});
}
}
output.into_iter().collect::<TokenStream>()
};
let pad_fn_impls: TokenStream = fields
.iter()
.enumerate()
.map(|(index, prev_field)| {
let pad_fn = &pad_fns[index];
let starting_offset = offset_after_field(index);
let prev_field_has_end_padding = layout_pad_at_end_of_ty(&prev_field.ty);
let prev_field_alignment = layout_alignment_of_ty(&prev_field.ty);
let next_field_or_self_alignment = fields
.get(index + 1)
.map(|next_field| layout_alignment_of_ty(&next_field.ty))
.unwrap_or(quote!(#struct_alignment));
quote! {
/// Tells how many bytes of padding have to be inserted after
/// the field with index #index.
#[allow(non_snake_case)]
const fn #pad_fn() -> usize {
// First up, calculate our offset into the struct so far.
// We'll use this value to figure out how far out of
// alignment we are.
let starting_offset = #starting_offset;
// If the previous field is a struct or array, we must align
// the next field to at least THAT field's alignment.
let min_alignment = if #prev_field_has_end_padding {
#prev_field_alignment
} else {
0
};
// We set our target alignment to the larger of the
// alignment due to the previous field and the alignment
// requirement of the next field.
let alignment = ::crevice::internal::max(
#next_field_or_self_alignment,
min_alignment,
);
// Using everything we've got, compute our padding amount.
::crevice::internal::align_offset(starting_offset, alignment)
}
}
})
.collect();
let generated_struct_fields: TokenStream = fields
.iter()
.enumerate()
.map(|(index, field)| {
let field_name = field.ident.as_ref().unwrap();
let field_ty = layout_version_of_ty(&field.ty);
let pad_field_name = format_ident!("_pad{}", index);
let pad_fn = &pad_fns[index];
quote! {
#field_name: #field_ty,
#pad_field_name: [u8; #pad_fn()],
}
})
.collect();
let generated_struct_field_init: TokenStream = fields
.iter()
.map(|field| {
let field_name = field.ident.as_ref().unwrap();
quote! {
#field_name: self.#field_name.#as_trait_method(),
}
})
.collect();
let input_struct_field_init: TokenStream = fields
.iter()
.map(|field| {
let field_name = field.ident.as_ref().unwrap();
quote! {
#field_name: #as_trait_path::#from_trait_method(input.#field_name),
}
})
.collect();
let struct_definition = quote! {
#[derive(Debug, Clone, Copy)]
#[repr(C)]
#[allow(non_snake_case)]
#visibility struct #generated_name #ty_generics #where_clause {
#generated_struct_fields
}
};
let debug_methods = if cfg!(feature = "debug-methods") {
let debug_fields: TokenStream = fields
.iter()
.map(|field| {
let field_name = field.ident.as_ref().unwrap();
let field_ty = &field.ty;
quote! {
fields.push(Field {
name: stringify!(#field_name),
size: ::core::mem::size_of::<#field_ty>(),
offset: (&zeroed.#field_name as *const _ as usize)
- (&zeroed as *const _ as usize),
});
}
})
.collect();
quote! {
impl #impl_generics #generated_name #ty_generics #where_clause {
fn debug_metrics() -> String {
let size = ::core::mem::size_of::<Self>();
let align = <Self as #trait_path>::ALIGNMENT;
let zeroed: Self = ::crevice::internal::bytemuck::Zeroable::zeroed();
#[derive(Debug)]
struct Field {
name: &'static str,
offset: usize,
size: usize,
}
let mut fields = Vec::new();
#debug_fields
format!("Size {}, Align {}, fields: {:#?}", size, align, fields)
}
fn debug_definitions() -> &'static str {
stringify!(
#struct_definition
#pad_fn_impls
)
}
}
}
} else {
quote!()
};
quote! {
#pad_fn_impls
#struct_definition
unsafe impl #impl_generics ::crevice::internal::bytemuck::Zeroable for #generated_name #ty_generics #where_clause {}
unsafe impl #impl_generics ::crevice::internal::bytemuck::Pod for #generated_name #ty_generics #where_clause {}
unsafe impl #impl_generics #mod_path::#trait_name for #generated_name #ty_generics #where_clause {
const ALIGNMENT: usize = #struct_alignment;
const PAD_AT_END: bool = true;
type Padded = #padded_path<Self, {::crevice::internal::align_offset(
::core::mem::size_of::<#generated_name>(),
#struct_alignment
)}>;
}
impl #impl_generics #as_trait_path for #input_name #ty_generics #where_clause {
type Output = #generated_name;
fn #as_trait_method(&self) -> Self::Output {
Self::Output {
#generated_struct_field_init
..::crevice::internal::bytemuck::Zeroable::zeroed()
}
}
fn #from_trait_method(input: Self::Output) -> Self {
Self {
#input_struct_field_init
}
}
}
#debug_methods
}
}

284
crates/crevice/crevice-derive/src/lib.rs
View file

@ -1,13 +1,14 @@
mod glsl;
mod layout;
use proc_macro::TokenStream as CompilerTokenStream; use proc_macro::TokenStream as CompilerTokenStream;
use proc_macro2::{Span, TokenStream}; use syn::{parse_macro_input, DeriveInput};
use quote::{format_ident, quote};
use syn::{parse_macro_input, parse_quote, Data, DeriveInput, Fields, Ident, Path};
#[proc_macro_derive(AsStd140)] #[proc_macro_derive(AsStd140)]
pub fn derive_as_std140(input: CompilerTokenStream) -> CompilerTokenStream { pub fn derive_as_std140(input: CompilerTokenStream) -> CompilerTokenStream {
let input = parse_macro_input!(input as DeriveInput); let input = parse_macro_input!(input as DeriveInput);
let expanded = EmitOptions::new("Std140", "std140", 16).emit(input); let expanded = layout::emit(input, "Std140", "std140", 16);
CompilerTokenStream::from(expanded) CompilerTokenStream::from(expanded)
} }
@ -15,278 +16,15 @@ pub fn derive_as_std140(input: CompilerTokenStream) -> CompilerTokenStream {
#[proc_macro_derive(AsStd430)] #[proc_macro_derive(AsStd430)]
pub fn derive_as_std430(input: CompilerTokenStream) -> CompilerTokenStream { pub fn derive_as_std430(input: CompilerTokenStream) -> CompilerTokenStream {
let input = parse_macro_input!(input as DeriveInput); let input = parse_macro_input!(input as DeriveInput);
let expanded = EmitOptions::new("Std430", "std430", 0).emit(input); let expanded = layout::emit(input, "Std430", "std430", 0);
CompilerTokenStream::from(expanded) CompilerTokenStream::from(expanded)
} }
struct EmitOptions { #[proc_macro_derive(GlslStruct)]
/// The Rust-friendly name of the layout, like Std140. pub fn derive_glsl_struct(input: CompilerTokenStream) -> CompilerTokenStream {
layout_name: Ident, let input = parse_macro_input!(input as DeriveInput);
let expanded = glsl::emit(input);
/// The minimum alignment for a struct in this layout. CompilerTokenStream::from(expanded)
min_struct_alignment: usize,
/// The fully-qualified path to the Crevice module containing everything for
/// this layout.
mod_path: Path,
/// The fully-qualified path to the trait defining a type in this layout.
trait_path: Path,
/// The fully-qualified path to the trait implemented for types that can be
/// converted into this layout, like AsStd140.
as_trait_path: Path,
/// The name of the associated type contained in AsTrait.
as_trait_assoc: Ident,
/// The name of the method used to convert from AsTrait to Trait.
as_trait_method: Ident,
// The name of the method used to convert from Trait to AsTrait.
from_trait_method: Ident,
/// The name of the struct used for Padded type.
padded_name: Ident,
}
impl EmitOptions {
fn new(layout_name: &'static str, mod_name: &'static str, min_struct_alignment: usize) -> Self {
let mod_name = Ident::new(mod_name, Span::call_site());
let layout_name = Ident::new(layout_name, Span::call_site());
let mod_path = parse_quote!(::crevice::#mod_name);
let trait_path = parse_quote!(#mod_path::#layout_name);
let as_trait_name = format_ident!("As{}", layout_name);
let as_trait_path = parse_quote!(#mod_path::#as_trait_name);
let as_trait_assoc = format_ident!("{}Type", layout_name);
let as_trait_method = format_ident!("as_{}", mod_name);
let from_trait_method = format_ident!("from_{}", mod_name);
let padded_name = format_ident!("{}Padded", layout_name);
Self {
layout_name,
min_struct_alignment,
mod_path,
trait_path,
as_trait_path,
as_trait_assoc,
as_trait_method,
from_trait_method,
padded_name,
}
}
fn emit(&self, input: DeriveInput) -> TokenStream {
let min_struct_alignment = self.min_struct_alignment;
let layout_name = &self.layout_name;
let mod_path = &self.mod_path;
let trait_path = &self.trait_path;
let as_trait_path = &self.as_trait_path;
let as_trait_assoc = &self.as_trait_assoc;
let as_trait_method = &self.as_trait_method;
let from_trait_method = &self.from_trait_method;
let padded_name = &self.padded_name;
let visibility = input.vis;
let name = input.ident;
let generated_name = format_ident!("{}{}", layout_name, name);
let alignment_mod_name = format_ident!("{}{}Alignment", layout_name, name);
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
let fields = match &input.data {
Data::Struct(data) => match &data.fields {
Fields::Named(fields) => fields,
Fields::Unnamed(_) => panic!("Tuple structs are not supported"),
Fields::Unit => panic!("Unit structs are not supported"),
},
Data::Enum(_) | Data::Union(_) => panic!("Only structs are supported"),
};
// Generate the names we'll use for calculating alignment of each field.
// Each name will turn into a const fn that's invoked to compute the
// size of a padding array before each field.
let align_names: Vec<_> = fields
.named
.iter()
.map(|field| format_ident!("_{}_align", field.ident.as_ref().unwrap()))
.collect();
// Generate one function per field that is used to apply alignment
// padding. Each function invokes all previous functions to calculate
// the total offset into the struct for the current field, then aligns
// up to the nearest multiple of alignment.
let alignment_calculators: Vec<_> = fields
.named
.iter()
.enumerate()
.map(|(index, field)| {
let align_name = &align_names[index];
let offset_accumulation =
fields
.named
.iter()
.zip(&align_names)
.take(index)
.map(|(field, align_name)| {
let field_ty = &field.ty;
quote! {
offset += #align_name();
offset += ::core::mem::size_of::<<#field_ty as #as_trait_path>::#as_trait_assoc>();
}
});
let pad_at_end = index
.checked_sub(1)
.map_or(quote!{0usize}, |prev_index|{
let field = &fields.named[prev_index];
let field_ty = &field.ty;
quote! {
if <<#field_ty as #as_trait_path>::#as_trait_assoc as #mod_path::#layout_name>::PAD_AT_END {
<<#field_ty as #as_trait_path>::#as_trait_assoc as #mod_path::#layout_name>::ALIGNMENT
}
else {
0usize
}
}
});
let field_ty = &field.ty;
quote! {
pub const fn #align_name() -> usize {
let mut offset = 0;
#( #offset_accumulation )*
::crevice::internal::align_offset(
offset,
::crevice::internal::max(
<<#field_ty as #as_trait_path>::#as_trait_assoc as #mod_path::#layout_name>::ALIGNMENT,
#pad_at_end
)
)
}
}
})
.collect();
// Generate the struct fields that will be present in the generated
// struct. Each field in the original struct turns into two fields in
// the generated struct:
//
// * Alignment, a byte array whose size is computed from #align_name().
// * Data, the layout-specific version of the original field.
let generated_fields: Vec<_> = fields
.named
.iter()
.zip(&align_names)
.map(|(field, align_name)| {
let field_ty = &field.ty;
let field_name = field.ident.as_ref().unwrap();
quote! {
#align_name: [u8; #alignment_mod_name::#align_name()],
#field_name: <#field_ty as #as_trait_path>::#as_trait_assoc,
}
})
.collect();
// Generate an initializer for each field in the original struct.
// Alignment fields are filled in with zeroes using struct update
// syntax.
let field_initializers: Vec<_> = fields
.named
.iter()
.map(|field| {
let field_name = field.ident.as_ref().unwrap();
quote!(#field_name: self.#field_name.#as_trait_method())
})
.collect();
let field_unwrappers: Vec<_> = fields
.named
.iter()
.map(|field|{
let field_name = field.ident.as_ref().unwrap();
let field_ty = &field.ty;
quote!(#field_name: <#field_ty as #as_trait_path>::#from_trait_method(value.#field_name))
})
.collect();
// This fold builds up an expression that finds the maximum alignment out of
// all of the fields in the struct. For this struct:
//
// struct Foo { a: ty1, b: ty2 }
//
// ...we should generate an expression like this:
//
// max(ty2_align, max(ty1_align, min_align))
let struct_alignment = fields.named.iter().fold(
quote!(#min_struct_alignment),
|last, field| {
let field_ty = &field.ty;
quote! {
::crevice::internal::max(
<<#field_ty as #as_trait_path>::#as_trait_assoc as #trait_path>::ALIGNMENT,
#last,
)
}
},
);
quote! {
#[allow(non_snake_case)]
mod #alignment_mod_name {
use super::*;
#( #alignment_calculators )*
}
#[derive(Debug, Clone, Copy)]
#[repr(C)]
#visibility struct #generated_name #ty_generics #where_clause {
#( #generated_fields )*
}
unsafe impl #impl_generics ::crevice::internal::bytemuck::Zeroable for #generated_name #ty_generics #where_clause {}
unsafe impl #impl_generics ::crevice::internal::bytemuck::Pod for #generated_name #ty_generics #where_clause {}
unsafe impl #impl_generics #mod_path::#layout_name for #generated_name #ty_generics #where_clause {
const ALIGNMENT: usize = #struct_alignment;
const PAD_AT_END: bool = true;
type Padded = #mod_path::#padded_name<Self, {::crevice::internal::align_offset(
::core::mem::size_of::<#generated_name>(),
#struct_alignment
)}>;
}
impl #impl_generics #as_trait_path for #name #ty_generics #where_clause {
type #as_trait_assoc = #generated_name;
fn #as_trait_method(&self) -> Self::#as_trait_assoc {
Self::#as_trait_assoc {
#( #field_initializers, )*
..::crevice::internal::bytemuck::Zeroable::zeroed()
}
}
fn #from_trait_method(value: Self::#as_trait_assoc) -> Self {
Self {
#( #field_unwrappers, )*
}
}
}
}
}
} }

20
crates/crevice/crevice-tests/Cargo.toml Normal file
View file

@ -0,0 +1,20 @@
[package]
name = "crevice-tests"
version = "0.1.0"
edition = "2018"
[features]
wgpu-validation = ["wgpu", "naga", "futures"]
[dependencies]
crevice = { path = ".." }
crevice-derive = { path = "../crevice-derive", features = ["debug-methods"] }
anyhow = "1.0.44"
bytemuck = "1.7.2"
memoffset = "0.6.4"
mint = "0.5.5"
futures = { version = "0.3.17", features = ["executor"], optional = true }
naga = { version = "0.7.0", features = ["glsl-in", "wgsl-out"], optional = true }
wgpu = { version = "0.11.0", optional = true }

268
crates/crevice/crevice-tests/src/gpu.rs Normal file
View file

@ -0,0 +1,268 @@
use std::borrow::Cow;
use std::fmt::Debug;
use std::marker::PhantomData;
use crevice::glsl::{Glsl, GlslStruct};
use crevice::std140::{AsStd140, Std140};
use crevice::std430::{AsStd430, Std430};
use futures::executor::block_on;
use wgpu::util::DeviceExt;
const BASE_SHADER: &str = "#version 450
{struct_definition}
layout({layout}, set = 0, binding = 0) readonly buffer INPUT {
{struct_name} in_data;
};
layout({layout}, set = 0, binding = 1) buffer OUTPUT {
{struct_name} out_data;
};
void main() {
out_data = in_data;
}";
pub fn test_round_trip_struct<T: Debug + PartialEq + AsStd140 + AsStd430 + GlslStruct>(value: T) {
let shader_std140 = glsl_shader_for_struct::<T>("std140");
let shader_std430 = glsl_shader_for_struct::<T>("std430");
let context = Context::new();
context.test_round_trip_std140(&shader_std140, &value);
context.test_round_trip_std430(&shader_std430, &value);
}
pub fn test_round_trip_primitive<T: Debug + PartialEq + AsStd140 + AsStd430 + Glsl>(value: T) {
let shader_std140 = glsl_shader_for_primitive::<T>("std140");
let shader_std430 = glsl_shader_for_primitive::<T>("std430");
let context = Context::new();
context.test_round_trip_std140(&shader_std140, &value);
context.test_round_trip_std430(&shader_std430, &value);
}
fn glsl_shader_for_struct<T: GlslStruct>(layout: &str) -> String {
BASE_SHADER
.replace("{struct_name}", T::NAME)
.replace("{struct_definition}", &T::glsl_definition())
.replace("{layout}", layout)
}
fn glsl_shader_for_primitive<T: Glsl>(layout: &str) -> String {
BASE_SHADER
.replace("{struct_name}", T::NAME)
.replace("{struct_definition}", "")
.replace("{layout}", layout)
}
fn compile_glsl(glsl: &str) -> String {
match compile(glsl) {
Ok(shader) => shader,
Err(err) => {
eprintln!("Bad shader: {}", glsl);
panic!("{}", err);
}
}
}
struct Context<T> {
device: wgpu::Device,
queue: wgpu::Queue,
_phantom: PhantomData<*const T>,
}
impl<T> Context<T>
where
T: Debug + PartialEq + AsStd140 + AsStd430 + Glsl,
{
fn new() -> Self {
let (device, queue) = setup();
Self {
device,
queue,
_phantom: PhantomData,
}
}
fn test_round_trip_std140(&self, glsl_shader: &str, value: &T) {
let mut data = Vec::new();
data.extend_from_slice(value.as_std140().as_bytes());
let wgsl_shader = compile_glsl(glsl_shader);
let bytes = self.round_trip(&wgsl_shader, &data);
let std140 = bytemuck::from_bytes::<<T as AsStd140>::Output>(&bytes);
let output = T::from_std140(*std140);
if value != &output {
println!(
"std140 value did not round-trip through wgpu successfully.\n\
Input: {:?}\n\
Output: {:?}\n\n\
GLSL shader:\n{}\n\n\
WGSL shader:\n{}",
value, output, glsl_shader, wgsl_shader,
);
panic!("wgpu round-trip failure for {}", T::NAME);
}
}
fn test_round_trip_std430(&self, glsl_shader: &str, value: &T) {
let mut data = Vec::new();
data.extend_from_slice(value.as_std430().as_bytes());
let wgsl_shader = compile_glsl(glsl_shader);
let bytes = self.round_trip(&wgsl_shader, &data);
let std430 = bytemuck::from_bytes::<<T as AsStd430>::Output>(&bytes);
let output = T::from_std430(*std430);
if value != &output {
println!(
"std430 value did not round-trip through wgpu successfully.\n\
Input: {:?}\n\
Output: {:?}\n\n\
GLSL shader:\n{}\n\n\
WGSL shader:\n{}",
value, output, glsl_shader, wgsl_shader,
);
panic!("wgpu round-trip failure for {}", T::NAME);
}
}
fn round_trip(&self, shader: &str, data: &[u8]) -> Vec<u8> {
let input_buffer = self
.device
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
label: Some("Input Buffer"),
contents: &data,
usage: wgpu::BufferUsages::STORAGE
| wgpu::BufferUsages::COPY_DST
| wgpu::BufferUsages::COPY_SRC,
});
let output_gpu_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Output Buffer"),
size: data.len() as wgpu::BufferAddress,
usage: wgpu::BufferUsages::STORAGE | wgpu::BufferUsages::COPY_SRC,
mapped_at_creation: false,
});
let output_cpu_buffer = self.device.create_buffer(&wgpu::BufferDescriptor {
label: Some("Output Buffer"),
size: data.len() as wgpu::BufferAddress,
usage: wgpu::BufferUsages::MAP_READ | wgpu::BufferUsages::COPY_DST,
mapped_at_creation: false,
});
let cs_module = self
.device
.create_shader_module(&wgpu::ShaderModuleDescriptor {
label: None,
source: wgpu::ShaderSource::Wgsl(Cow::Borrowed(shader)),
});
let compute_pipeline =
self.device
.create_compute_pipeline(&wgpu::ComputePipelineDescriptor {
label: None,
layout: None,
module: &cs_module,
entry_point: "main",
});
let bind_group_layout = compute_pipeline.get_bind_group_layout(0);
let bind_group = self.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 = self
.device
.create_command_encoder(&wgpu::CommandEncoderDescriptor { label: None });
{
let mut cpass =
encoder.begin_compute_pass(&wgpu::ComputePassDescriptor { label: None });
cpass.set_pipeline(&compute_pipeline);
cpass.set_bind_group(0, &bind_group, &[]);
cpass.dispatch(1, 1, 1);
}
encoder.copy_buffer_to_buffer(
&output_gpu_buffer,
0,
&output_cpu_buffer,
0,
data.len() as wgpu::BufferAddress,
);
self.queue.submit(std::iter::once(encoder.finish()));
let output_slice = output_cpu_buffer.slice(..);
let output_future = output_slice.map_async(wgpu::MapMode::Read);
self.device.poll(wgpu::Maintain::Wait);
block_on(output_future).unwrap();
let output = output_slice.get_mapped_range().to_vec();
output_cpu_buffer.unmap();
output
}
}
fn setup() -> (wgpu::Device, wgpu::Queue) {
let instance = wgpu::Instance::new(wgpu::Backends::all());
let adapter =
block_on(instance.request_adapter(&wgpu::RequestAdapterOptions::default())).unwrap();
println!("Adapter info: {:#?}", adapter.get_info());
block_on(adapter.request_device(
&wgpu::DeviceDescriptor {
label: None,
features: wgpu::Features::empty(),
limits: wgpu::Limits::downlevel_defaults(),
},
None,
))
.unwrap()
}
fn compile(glsl_source: &str) -> anyhow::Result<String> {
let mut parser = naga::front::glsl::Parser::default();
let module = parser
.parse(
&naga::front::glsl::Options {
stage: naga::ShaderStage::Compute,
defines: Default::default(),
},
glsl_source,
)
.map_err(|err| anyhow::format_err!("{:?}", err))?;
let info = naga::valid::Validator::new(
naga::valid::ValidationFlags::default(),
naga::valid::Capabilities::all(),
)
.validate(&module)?;
let wgsl = naga::back::wgsl::write_string(&module, &info)?;
Ok(wgsl)
}

366
crates/crevice/crevice-tests/src/lib.rs Normal file
View file

@ -0,0 +1,366 @@
#![cfg(test)]
#[cfg(feature = "wgpu-validation")]
mod gpu;
#[cfg(feature = "wgpu-validation")]
use gpu::{test_round_trip_primitive, test_round_trip_struct};
#[cfg(not(feature = "wgpu-validation"))]
fn test_round_trip_struct<T>(_value: T) {}
#[cfg(not(feature = "wgpu-validation"))]
fn test_round_trip_primitive<T>(_value: T) {}
#[macro_use]
mod util;
use crevice::glsl::GlslStruct;
use crevice::std140::AsStd140;
use crevice::std430::AsStd430;
use mint::{ColumnMatrix2, ColumnMatrix3, ColumnMatrix4, Vector2, Vector3, Vector4};
#[test]
fn two_f32() {
#[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
struct TwoF32 {
x: f32,
y: f32,
}
assert_std140!((size = 16, align = 16) TwoF32 {
x: 0,
y: 4,
});
assert_std430!((size = 8, align = 4) TwoF32 {
x: 0,
y: 4,
});
test_round_trip_struct(TwoF32 { x: 5.0, y: 7.0 });
}
#[test]
fn vec2() {
#[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
struct UseVec2 {
one: Vector2<f32>,
}
assert_std140!((size = 16, align = 16) UseVec2 {
one: 0,
});
test_round_trip_struct(UseVec2 {
one: [1.0, 2.0].into(),
});
}
#[test]
fn mat2_bare() {
type Mat2 = ColumnMatrix2<f32>;
assert_std140!((size = 32, align = 16) Mat2 {
x: 0,
y: 16,
});
assert_std430!((size = 16, align = 8) Mat2 {
x: 0,
y: 8,
});
// Naga doesn't work with std140 mat2 values.
// https://github.com/gfx-rs/naga/issues/1400
// test_round_trip_primitive(Mat2 {
// x: [1.0, 2.0].into(),
// y: [3.0, 4.0].into(),
// });
}
#[test]
fn mat3_bare() {
type Mat3 = ColumnMatrix3<f32>;
assert_std140!((size = 48, align = 16) Mat3 {
x: 0,
y: 16,
z: 32,
});
// Naga produces invalid HLSL for mat3 value.
// https://github.com/gfx-rs/naga/issues/1466
// test_round_trip_primitive(Mat3 {
// x: [1.0, 2.0, 3.0].into(),
// y: [4.0, 5.0, 6.0].into(),
// z: [7.0, 8.0, 9.0].into(),
// });
}
#[test]
fn mat4_bare() {
type Mat4 = ColumnMatrix4<f32>;
assert_std140!((size = 64, align = 16) Mat4 {
x: 0,
y: 16,
z: 32,
w: 48,
});
test_round_trip_primitive(Mat4 {
x: [1.0, 2.0, 3.0, 4.0].into(),
y: [5.0, 6.0, 7.0, 8.0].into(),
z: [9.0, 10.0, 11.0, 12.0].into(),
w: [13.0, 14.0, 15.0, 16.0].into(),
});
}
#[test]
fn mat3() {
#[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
struct TestData {
one: ColumnMatrix3<f32>,
}
// Naga produces invalid HLSL for mat3 value.
// https://github.com/gfx-rs/naga/issues/1466
// test_round_trip_struct(TestData {
// one: [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]].into(),
// });
}
#[test]
fn dvec4() {
#[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
struct UsingDVec4 {
doubles: Vector4<f64>,
}
assert_std140!((size = 32, align = 32) UsingDVec4 {
doubles: 0,
});
// Naga does not appear to support doubles.
// https://github.com/gfx-rs/naga/issues/1272
// test_round_trip_struct(UsingDVec4 {
// doubles: [1.0, 2.0, 3.0, 4.0].into(),
// });
}
#[test]
fn four_f64() {
#[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
struct FourF64 {
x: f64,
y: f64,
z: f64,
w: f64,
}
assert_std140!((size = 32, align = 16) FourF64 {
x: 0,
y: 8,
z: 16,
w: 24,
});
// Naga does not appear to support doubles.
// https://github.com/gfx-rs/naga/issues/1272
// test_round_trip_struct(FourF64 {
// x: 5.0,
// y: 7.0,
// z: 9.0,
// w: 11.0,
// });
}
#[test]
fn two_vec3() {
#[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
struct TwoVec3 {
one: Vector3<f32>,
two: Vector3<f32>,
}
print_std140!(TwoVec3);
print_std430!(TwoVec3);
assert_std140!((size = 32, align = 16) TwoVec3 {
one: 0,
two: 16,
});
assert_std430!((size = 32, align = 16) TwoVec3 {
one: 0,
two: 16,
});
test_round_trip_struct(TwoVec3 {
one: [1.0, 2.0, 3.0].into(),
two: [4.0, 5.0, 6.0].into(),
});
}
#[test]
fn two_vec4() {
#[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
struct TwoVec4 {
one: Vector4<f32>,
two: Vector4<f32>,
}
assert_std140!((size = 32, align = 16) TwoVec4 {
one: 0,
two: 16,
});
test_round_trip_struct(TwoVec4 {
one: [1.0, 2.0, 3.0, 4.0].into(),
two: [5.0, 6.0, 7.0, 8.0].into(),
});
}
#[test]
fn vec3_then_f32() {
#[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
struct Vec3ThenF32 {
one: Vector3<f32>,
two: f32,
}
assert_std140!((size = 16, align = 16) Vec3ThenF32 {
one: 0,
two: 12,
});
test_round_trip_struct(Vec3ThenF32 {
one: [1.0, 2.0, 3.0].into(),
two: 4.0,
});
}
#[test]
fn mat3_padding() {
#[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
struct Mat3Padding {
// Three rows of 16 bytes (3x f32 + 4 bytes padding)
one: mint::ColumnMatrix3<f32>,
two: f32,
}
assert_std140!((size = 64, align = 16) Mat3Padding {
one: 0,
two: 48,
});
// Naga produces invalid HLSL for mat3 value.
// https://github.com/gfx-rs/naga/issues/1466
// test_round_trip_struct(Mat3Padding {
// one: [[1.0, 2.0, 3.0], [4.0, 5.0, 6.0], [7.0, 8.0, 9.0]].into(),
// two: 10.0,
// });
}
#[test]
fn padding_after_struct() {
#[derive(AsStd140)]
struct TwoF32 {
x: f32,
}
#[derive(AsStd140)]
struct PaddingAfterStruct {
base_value: TwoF32,
// There should be 8 bytes of padding inserted here.
small_field: f32,
}
assert_std140!((size = 32, align = 16) PaddingAfterStruct {
base_value: 0,
small_field: 16,
});
}
#[test]
fn proper_offset_calculations_for_differing_member_sizes() {
#[derive(AsStd140)]
struct Foo {
x: f32,
}
#[derive(AsStd140)]
struct Bar {
first: Foo,
second: Foo,
}
#[derive(AsStd140)]
struct Outer {
leading: Bar,
trailing: Foo,
}
// Offset Size Contents
// 0 4 Bar.leading.first.x
// 4 12 [padding]
// 16 4 Bar.leading.second.x
// 20 12 [padding]
// 32 4 Bar.trailing.x
// 36 12 [padding]
//
// Total size is 48.
assert_std140!((size = 48, align = 16) Outer {
leading: 0,
trailing: 32,
});
}
#[test]
fn array_strides_small_value() {
#[derive(Debug, PartialEq, AsStd140, AsStd430)]
struct ArrayOfSmallValues {
inner: [f32; 4],
}
assert_std140!((size = 64, align = 16) ArrayOfSmallValues {
inner: 0,
});
assert_std430!((size = 16, align = 4) ArrayOfSmallValues {
inner: 0,
});
}
#[test]
fn array_strides_vec3() {
#[derive(Debug, PartialEq, AsStd140, AsStd430, GlslStruct)]
struct ArrayOfVector3 {
inner: [Vector3<f32>; 4],
}
assert_std140!((size = 64, align = 16) ArrayOfVector3 {
inner: 0,
});
assert_std430!((size = 64, align = 16) ArrayOfVector3 {
inner: 0,
});
test_round_trip_struct(ArrayOfVector3 {
inner: [
[0.0, 1.0, 2.0].into(),
[3.0, 4.0, 5.0].into(),
[6.0, 7.0, 8.0].into(),
[9.0, 10.0, 11.0].into(),
],
})
}

143
crates/crevice/crevice-tests/src/util.rs Normal file
View file

@ -0,0 +1,143 @@
#[macro_export]
macro_rules! print_std140 {
($type:ty) => {
println!(
"{}",
<$type as crevice::std140::AsStd140>::Output::debug_metrics()
);
println!();
println!();
println!(
"{}",
<$type as crevice::std140::AsStd140>::Output::debug_definitions()
);
};
}
#[macro_export]
macro_rules! print_std430 {
($type:ty) => {
println!(
"{}",
<$type as crevice::std430::AsStd430>::Output::debug_metrics()
);
println!();
println!();
println!(
"{}",
<$type as crevice::std430::AsStd430>::Output::debug_definitions()
);
};
}
#[macro_export]
macro_rules! assert_std140 {
((size = $size:literal, align = $align:literal) $struct:ident {
$( $field:ident: $offset:literal, )*
}) => {{
type Target = <$struct as crevice::std140::AsStd140>::Output;
let mut fail = false;
let actual_size = std::mem::size_of::<Target>();
if actual_size != $size {
fail = true;
println!(
"Invalid size for std140 struct {}\n\
Expected: {}\n\
Actual: {}\n",
stringify!($struct),
$size,
actual_size,
);
}
let actual_alignment = <Target as crevice::std140::Std140>::ALIGNMENT;
if actual_alignment != $align {
fail = true;
println!(
"Invalid alignment for std140 struct {}\n\
Expected: {}\n\
Actual: {}\n",
stringify!($struct),
$align,
actual_alignment,
);
}
$({
let actual_offset = memoffset::offset_of!(Target, $field);
if actual_offset != $offset {
fail = true;
println!(
"Invalid offset for field {}\n\
Expected: {}\n\
Actual: {}\n",
stringify!($field),
$offset,
actual_offset,
);
}
})*
if fail {
panic!("Invalid std140 result for {}", stringify!($struct));
}
}};
}
#[macro_export]
macro_rules! assert_std430 {
((size = $size:literal, align = $align:literal) $struct:ident {
$( $field:ident: $offset:literal, )*
}) => {{
type Target = <$struct as crevice::std430::AsStd430>::Output;
let mut fail = false;
let actual_size = std::mem::size_of::<Target>();
if actual_size != $size {
fail = true;
println!(
"Invalid size for std430 struct {}\n\
Expected: {}\n\
Actual: {}\n",
stringify!($struct),
$size,
actual_size,
);
}
let actual_alignment = <Target as crevice::std430::Std430>::ALIGNMENT;
if actual_alignment != $align {
fail = true;
println!(
"Invalid alignment for std430 struct {}\n\
Expected: {}\n\
Actual: {}\n",
stringify!($struct),
$align,
actual_alignment,
);
}
$({
let actual_offset = memoffset::offset_of!(Target, $field);
if actual_offset != $offset {
fail = true;
println!(
"Invalid offset for std430 field {}\n\
Expected: {}\n\
Actual: {}\n",
stringify!($field),
$offset,
actual_offset,
);
}
})*
if fail {
panic!("Invalid std430 result for {}", stringify!($struct));
}
}};
}

103
crates/crevice/src/glam.rs
View file

@ -1,103 +0,0 @@
use bytemuck::Zeroable;
use crate::std140::{self, AsStd140};
use crate::std430::{self, AsStd430};
macro_rules! glam_vectors {
( $( $glam_ty:ty, $std_name:ident, ( $($field:ident),* ), )* ) => {
$(
impl AsStd140 for $glam_ty {
type Std140Type = std140::$std_name;
fn as_std140(&self) -> Self::Std140Type {
std140::$std_name {
$(
$field: self.$field,
)*
}
}
fn from_std140(value: Self::Std140Type) -> Self {
Self::new($(value.$field,)*)
}
}
impl AsStd430 for $glam_ty {
type Std430Type = std430::$std_name;
fn as_std430(&self) -> Self::Std430Type {
std430::$std_name {
$(
$field: self.$field,
)*
}
}
fn from_std430(value: Self::Std430Type) -> Self {
Self::new($(value.$field,)*)
}
}
)*
};
}
glam_vectors! {
glam::UVec4, UVec4, (x, y, z, w),
glam::Vec2, Vec2, (x, y),
glam::Vec3, Vec3, (x, y, z),
glam::Vec4, Vec4, (x, y, z, w),
}
macro_rules! glam_matrices {
( $( $glam_ty:ty, $std_name:ident, ( $($glam_field:ident),* ), ( $($field:ident),* ))* ) => {
$(
impl AsStd140 for $glam_ty {
type Std140Type = std140::$std_name;
fn as_std140(&self) -> Self::Std140Type {
std140::$std_name {
$(
$field: self.$glam_field.as_std140(),
)*
..Zeroable::zeroed()
}
}
fn from_std140(value: Self::Std140Type) -> Self {
Self::from_cols(
$(
<_ as AsStd140>::from_std140(value.$field),
)*
)
}
}
impl AsStd430 for $glam_ty {
type Std430Type = std430::$std_name;
fn as_std430(&self) -> Self::Std430Type {
std430::$std_name {
$(
$field: self.$glam_field.as_std430(),
)*
..Zeroable::zeroed()
}
}
fn from_std430(value: Self::Std430Type) -> Self {
Self::from_cols(
$(
<_ as AsStd430>::from_std430(value.$field),
)*
)
}
}
)*
};
}
glam_matrices! {
glam::Mat2, Mat2, (x_axis, y_axis), (x, y)
glam::Mat3, Mat3, (x_axis, y_axis, z_axis), (x, y, z)
glam::Mat4, Mat4, (x_axis, y_axis, z_axis, w_axis), (x, y, z, w)
}

93
crates/crevice/src/glsl.rs Normal file
View file

@ -0,0 +1,93 @@
//! Defines traits and types for generating GLSL code from Rust definitions.
pub use crevice_derive::GlslStruct;
use std::marker::PhantomData;
/// Type-level linked list of array dimensions
pub struct Dimension<A, const N: usize> {
_marker: PhantomData<A>,
}
/// Type-level linked list terminator for array dimensions.
pub struct DimensionNil;
/// Trait for type-level array dimensions. Probably shouldn't be implemented outside this crate.
pub unsafe trait DimensionList {
/// Write dimensions in square brackets to a string, list tail to list head.
fn push_to_string(s: &mut String);
}
unsafe impl DimensionList for DimensionNil {
fn push_to_string(_: &mut String) {}
}
unsafe impl<A: DimensionList, const N: usize> DimensionList for Dimension<A, N> {
fn push_to_string(s: &mut String) {
use std::fmt::Write;
A::push_to_string(s);
write!(s, "[{}]", N).unwrap();
}
}
/// Trait for types that have a GLSL equivalent. Useful for generating GLSL code
/// from Rust structs.
pub unsafe trait Glsl {
/// The name of this type in GLSL, like `vec2` or `mat4`.
const NAME: &'static str;
}
/// Trait for types that can be represented as a struct in GLSL.
///
/// This trait should not generally be implemented by hand, but can be derived.
pub unsafe trait GlslStruct: Glsl {
/// The fields contained in this struct.
fn enumerate_fields(s: &mut String);
/// Generates GLSL code that represents this struct and its fields.
fn glsl_definition() -> String {
let mut output = String::new();
output.push_str("struct ");
output.push_str(Self::NAME);
output.push_str(" {\n");
Self::enumerate_fields(&mut output);
output.push_str("};");
output
}
}
/// Trait for types that are expressible as a GLSL type with (possibly zero) array dimensions.
pub unsafe trait GlslArray {
/// Base type name.
const NAME: &'static str;
/// Type-level linked list of array dimensions, ordered outer to inner.
type ArraySize: DimensionList;
}
unsafe impl<T: Glsl> GlslArray for T {
const NAME: &'static str = <T as Glsl>::NAME;
type ArraySize = DimensionNil;
}
unsafe impl Glsl for f32 {
const NAME: &'static str = "float";
}
unsafe impl Glsl for f64 {
const NAME: &'static str = "double";
}
unsafe impl Glsl for i32 {
const NAME: &'static str = "int";
}
unsafe impl Glsl for u32 {
const NAME: &'static str = "uint";
}
unsafe impl<T: GlslArray, const N: usize> GlslArray for [T; N] {
const NAME: &'static str = T::NAME;
type ArraySize = Dimension<T::ArraySize, N>;
}

10
crates/crevice/src/imp.rs Normal file
View file

@ -0,0 +1,10 @@
mod imp_mint;
#[cfg(feature = "cgmath")]
mod imp_cgmath;
#[cfg(feature = "glam")]
mod imp_glam;
#[cfg(feature = "nalgebra")]
mod imp_nalgebra;

30
crates/crevice/src/imp/imp_cgmath.rs Normal file
View file

@ -0,0 +1,30 @@
easy_impl! {
Vec2 cgmath::Vector2<f32> { x, y },
Vec3 cgmath::Vector3<f32> { x, y, z },
Vec4 cgmath::Vector4<f32> { x, y, z, w },
IVec2 cgmath::Vector2<i32> { x, y },
IVec3 cgmath::Vector3<i32> { x, y, z },
IVec4 cgmath::Vector4<i32> { x, y, z, w },
UVec2 cgmath::Vector2<u32> { x, y },
UVec3 cgmath::Vector3<u32> { x, y, z },
UVec4 cgmath::Vector4<u32> { x, y, z, w },
// bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
// BVec2 cgmath::Vector2<bool> { x, y },
// BVec3 cgmath::Vector3<bool> { x, y, z },
// BVec4 cgmath::Vector4<bool> { x, y, z, w },
DVec2 cgmath::Vector2<f64> { x, y },
DVec3 cgmath::Vector3<f64> { x, y, z },
DVec4 cgmath::Vector4<f64> { x, y, z, w },
Mat2 cgmath::Matrix2<f32> { x, y },
Mat3 cgmath::Matrix3<f32> { x, y, z },
Mat4 cgmath::Matrix4<f32> { x, y, z, w },
DMat2 cgmath::Matrix2<f64> { x, y },
DMat3 cgmath::Matrix3<f64> { x, y, z },
DMat4 cgmath::Matrix4<f64> { x, y, z, w },
}

24
crates/crevice/src/imp/imp_glam.rs Normal file
View file

@ -0,0 +1,24 @@
minty_impl! {
mint::Vector2<f32> => glam::Vec2,
mint::Vector3<f32> => glam::Vec3,
mint::Vector4<f32> => glam::Vec4,
mint::Vector2<i32> => glam::IVec2,
mint::Vector3<i32> => glam::IVec3,
mint::Vector4<i32> => glam::IVec4,
mint::Vector2<u32> => glam::UVec2,
mint::Vector3<u32> => glam::UVec3,
mint::Vector4<u32> => glam::UVec4,
// bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
// mint::Vector2<bool> => glam::BVec2,
// mint::Vector3<bool> => glam::BVec3,
// mint::Vector4<bool> => glam::BVec4,
mint::Vector2<f64> => glam::DVec2,
mint::Vector3<f64> => glam::DVec3,
mint::Vector4<f64> => glam::DVec4,
mint::ColumnMatrix2<f32> => glam::Mat2,
mint::ColumnMatrix3<f32> => glam::Mat3,
mint::ColumnMatrix4<f32> => glam::Mat4,
mint::ColumnMatrix2<f64> => glam::DMat2,
mint::ColumnMatrix3<f64> => glam::DMat3,
mint::ColumnMatrix4<f64> => glam::DMat4,
}

30
crates/crevice/src/imp/imp_mint.rs Normal file
View file

@ -0,0 +1,30 @@
easy_impl! {
Vec2 mint::Vector2<f32> { x, y },
Vec3 mint::Vector3<f32> { x, y, z },
Vec4 mint::Vector4<f32> { x, y, z, w },
IVec2 mint::Vector2<i32> { x, y },
IVec3 mint::Vector3<i32> { x, y, z },
IVec4 mint::Vector4<i32> { x, y, z, w },
UVec2 mint::Vector2<u32> { x, y },
UVec3 mint::Vector3<u32> { x, y, z },
UVec4 mint::Vector4<u32> { x, y, z, w },
// bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
// BVec2 mint::Vector2<bool> { x, y },
// BVec3 mint::Vector3<bool> { x, y, z },
// BVec4 mint::Vector4<bool> { x, y, z, w },
DVec2 mint::Vector2<f64> { x, y },
DVec3 mint::Vector3<f64> { x, y, z },
DVec4 mint::Vector4<f64> { x, y, z, w },
Mat2 mint::ColumnMatrix2<f32> { x, y },
Mat3 mint::ColumnMatrix3<f32> { x, y, z },
Mat4 mint::ColumnMatrix4<f32> { x, y, z, w },
DMat2 mint::ColumnMatrix2<f64> { x, y },
DMat3 mint::ColumnMatrix3<f64> { x, y, z },
DMat4 mint::ColumnMatrix4<f64> { x, y, z, w },
}

24
crates/crevice/src/imp/imp_nalgebra.rs Normal file
View file

@ -0,0 +1,24 @@
minty_impl! {
mint::Vector2<f32> => nalgebra::Vector2<f32>,
mint::Vector3<f32> => nalgebra::Vector3<f32>,
mint::Vector4<f32> => nalgebra::Vector4<f32>,
mint::Vector2<i32> => nalgebra::Vector2<i32>,
mint::Vector3<i32> => nalgebra::Vector3<i32>,
mint::Vector4<i32> => nalgebra::Vector4<i32>,
mint::Vector2<u32> => nalgebra::Vector2<u32>,
mint::Vector3<u32> => nalgebra::Vector3<u32>,
mint::Vector4<u32> => nalgebra::Vector4<u32>,
// bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
// mint::Vector2<bool> => nalgebra::Vector2<bool>,
// mint::Vector3<bool> => nalgebra::Vector3<bool>,
// mint::Vector4<bool> => nalgebra::Vector4<bool>,
mint::Vector2<f64> => nalgebra::Vector2<f64>,
mint::Vector3<f64> => nalgebra::Vector3<f64>,
mint::Vector4<f64> => nalgebra::Vector4<f64>,
mint::ColumnMatrix2<f32> => nalgebra::Matrix2<f32>,
mint::ColumnMatrix3<f32> => nalgebra::Matrix3<f32>,
mint::ColumnMatrix4<f32> => nalgebra::Matrix4<f32>,
mint::ColumnMatrix2<f64> => nalgebra::Matrix2<f64>,
mint::ColumnMatrix3<f64> => nalgebra::Matrix3<f64>,
mint::ColumnMatrix4<f64> => nalgebra::Matrix4<f64>,
}

21
crates/crevice/src/internal.rs
View file

@ -3,9 +3,9 @@
pub use bytemuck; pub use bytemuck;
/// Align the given struct offset up to the given alignment. /// Gives the number of bytes needed to make `offset` be aligned to `alignment`.
pub const fn align_offset(offset: usize, alignment: usize) -> usize { pub const fn align_offset(offset: usize, alignment: usize) -> usize {
if offset % alignment == 0 { if alignment == 0 || offset % alignment == 0 {
0 0
} else { } else {
alignment - offset % alignment alignment - offset % alignment
@ -21,3 +21,20 @@ pub const fn max(a: usize, b: usize) -> usize {
b b
} }
} }
/// Max of an array of `usize`. This function's implementation is funky because
/// we have no for loops!
pub const fn max_arr<const N: usize>(input: [usize; N]) -> usize {
let mut max = 0;
let mut i = 0;
while i < N {
if input[i] > max {
max = input[i];
}
i += 1;
}
max
}

74
crates/crevice/src/lib.rs
View file

@ -1,5 +1,9 @@
#![allow(clippy::all)] #![allow(
clippy::new_without_default,
clippy::needless_update,
clippy::len_without_is_empty,
clippy::needless_range_loop
)]
/*! /*!
[![GitHub CI Status](https://github.com/LPGhatguy/crevice/workflows/CI/badge.svg)](https://github.com/LPGhatguy/crevice/actions) [![GitHub CI Status](https://github.com/LPGhatguy/crevice/workflows/CI/badge.svg)](https://github.com/LPGhatguy/crevice/actions)
[![crevice on crates.io](https://img.shields.io/crates/v/crevice.svg)](https://crates.io/crates/crevice) [![crevice on crates.io](https://img.shields.io/crates/v/crevice.svg)](https://crates.io/crates/crevice)
@ -12,19 +16,34 @@ method to allow safely packing data into buffers for uploading.
Generated structs also implement [`bytemuck::Zeroable`] and Generated structs also implement [`bytemuck::Zeroable`] and
[`bytemuck::Pod`] for use with other libraries. [`bytemuck::Pod`] for use with other libraries.
Crevice is similar to [`glsl-layout`][glsl-layout], but supports `mint` types Crevice is similar to [`glsl-layout`][glsl-layout], but supports types from many
and explicitly initializes padding to remove one source of undefined behavior. math crates, can generate GLSL source from structs, and explicitly initializes
padding to remove one source of undefined behavior.
Examples in this crate use cgmath, but any math crate that works with the mint Crevice has support for many Rust math libraries via feature flags, and most
crate will also work. Some other crates include nalgebra, ultraviolet, glam, and other math libraries by use of the mint crate. Crevice currently supports:
vek.
* mint 0.5, enabled by default
* cgmath 0.18, using the `cgmath` feature
* nalgebra 0.29, using the `nalgebra` feature
* glam 0.19, using the `glam` feature
PRs are welcome to add or update math libraries to Crevice.
If your math library is not supported, it's possible to define structs using the
types from mint and convert your math library's types into mint types. This is
supported by most Rust math libraries.
Your math library may require you to turn on a feature flag to get mint support.
For example, cgmath requires the "mint" feature to be enabled to allow
conversions to and from mint types.
## Examples ## Examples
### Single Value ### Single Value
Uploading many types can be done by deriving `AsStd140` and using Uploading many types can be done by deriving [`AsStd140`][std140::AsStd140] and
[`as_std140`][std140::AsStd140::as_std140] and using [`as_std140`][std140::AsStd140::as_std140] and
[`as_bytes`][std140::Std140::as_bytes] to turn the result into bytes. [`as_bytes`][std140::Std140::as_bytes] to turn the result into bytes.
```glsl ```glsl
@ -35,10 +54,8 @@ uniform MAIN {
} main; } main;
``` ```
```skip ```rust
use crevice::std140::{AsStd140, Std140}; use crevice::std140::{AsStd140, Std140};
use cgmath::prelude::*;
use cgmath::{Matrix3, Vector3};
#[derive(AsStd140)] #[derive(AsStd140)]
struct MainUniform { struct MainUniform {
@ -48,8 +65,12 @@ struct MainUniform {
} }
let value = MainUniform { let value = MainUniform {
orientation: Matrix3::identity().into(), orientation: [
position: Vector3::new(1.0, 2.0, 3.0).into(), [1.0, 0.0, 0.0],
[0.0, 1.0, 0.0],
[0.0, 0.0, 1.0],
].into(),
position: [1.0, 2.0, 3.0].into(),
scale: 4.0, scale: 4.0,
}; };
@ -61,7 +82,8 @@ upload_data_to_gpu(value_std140.as_bytes());
### Sequential Types ### Sequential Types
More complicated data can be uploaded using the std140 `Writer` type. More complicated data can be uploaded using the std140
[`Writer`][std140::Writer] type.
```glsl ```glsl
struct PointLight { struct PointLight {
@ -76,7 +98,7 @@ buffer POINT_LIGHTS {
} point_lights; } point_lights;
``` ```
```skip ```rust
use crevice::std140::{self, AsStd140}; use crevice::std140::{self, AsStd140};
#[derive(AsStd140)] #[derive(AsStd140)]
@ -120,25 +142,31 @@ unmap_gpu_buffer();
# Ok::<(), std::io::Error>(()) # Ok::<(), std::io::Error>(())
``` ```
## Features
* `std` (default): Enables [`std::io::Write`]-based structs.
* `cgmath`: Enables support for types from cgmath.
* `nalgebra`: Enables support for types from nalgebra.
* `glam`: Enables support for types from glam.
## Minimum Supported Rust Version (MSRV) ## Minimum Supported Rust Version (MSRV)
Crevice supports Rust 1.46.0 and newer due to use of new `const fn` features. Crevice supports Rust 1.52.1 and newer due to use of new `const fn` features.
[glsl-layout]: https://github.com/rustgd/glsl-layout [glsl-layout]: https://github.com/rustgd/glsl-layout
[Zeroable]: https://docs.rs/bytemuck/latest/bytemuck/trait.Zeroable.html
[Pod]: https://docs.rs/bytemuck/latest/bytemuck/trait.Pod.html
[TypeLayout]: https://docs.rs/type-layout/latest/type_layout/trait.TypeLayout.html
*/ */
#![deny(missing_docs)] #![deny(missing_docs)]
#![cfg_attr(not(feature = "std"), no_std)] #![cfg_attr(not(feature = "std"), no_std)]
#[macro_use]
mod util;
pub mod glsl;
pub mod std140; pub mod std140;
pub mod std430; pub mod std430;
#[doc(hidden)] #[doc(hidden)]
pub mod internal; pub mod internal;
mod mint; mod imp;
mod glam;

130
crates/crevice/src/mint.rs
View file

@ -1,130 +0,0 @@
use bytemuck::Zeroable;
use crate::std140::{self, AsStd140};
use crate::std430::{self, AsStd430};
macro_rules! mint_vectors {
( $( $mint_ty:ty, $std_name:ident, ( $($field:ident),* ), )* ) => {
$(
impl AsStd140 for $mint_ty {
type Std140Type = std140::$std_name;
fn as_std140(&self) -> Self::Std140Type {
std140::$std_name {
$(
$field: self.$field,
)*
}
}
fn from_std140(value: Self::Std140Type) -> Self {
Self {
$(
$field: value.$field,
)*
}
}
}
impl AsStd430 for $mint_ty {
type Std430Type = std430::$std_name;
fn as_std430(&self) -> Self::Std430Type {
std430::$std_name {
$(
$field: self.$field,
)*
}
}
fn from_std430(value: Self::Std430Type) -> Self {
Self {
$(
$field: value.$field,
)*
}
}
}
)*
};
}
mint_vectors! {
mint::Vector2<f32>, Vec2, (x, y),
mint::Vector3<f32>, Vec3, (x, y, z),
mint::Vector4<f32>, Vec4, (x, y, z, w),
mint::Vector2<i32>, IVec2, (x, y),
mint::Vector3<i32>, IVec3, (x, y, z),
mint::Vector4<i32>, IVec4, (x, y, z, w),
mint::Vector2<u32>, UVec2, (x, y),
mint::Vector3<u32>, UVec3, (x, y, z),
mint::Vector4<u32>, UVec4, (x, y, z, w),
mint::Vector2<bool>, BVec2, (x, y),
mint::Vector3<bool>, BVec3, (x, y, z),
mint::Vector4<bool>, BVec4, (x, y, z, w),
mint::Vector2<f64>, DVec2, (x, y),
mint::Vector3<f64>, DVec3, (x, y, z),
mint::Vector4<f64>, DVec4, (x, y, z, w),
}
macro_rules! mint_matrices {
( $( $mint_ty:ty, $std_name:ident, ( $($field:ident),* ), )* ) => {
$(
impl AsStd140 for $mint_ty {
type Std140Type = std140::$std_name;
fn as_std140(&self) -> Self::Std140Type {
std140::$std_name {
$(
$field: self.$field.as_std140(),
)*
..Zeroable::zeroed()
}
}
fn from_std140(value: Self::Std140Type) -> Self {
Self {
$(
$field: <_ as AsStd140>::from_std140(value.$field),
)*
}
}
}
impl AsStd430 for $mint_ty {
type Std430Type = std430::$std_name;
fn as_std430(&self) -> Self::Std430Type {
std430::$std_name {
$(
$field: self.$field.as_std430(),
)*
..Zeroable::zeroed()
}
}
fn from_std430(value: Self::Std430Type) -> Self {
Self {
$(
$field: <_ as AsStd430>::from_std430(value.$field),
)*
}
}
}
)*
};
}
mint_matrices! {
mint::ColumnMatrix2<f32>, Mat2, (x, y),
mint::ColumnMatrix3<f32>, Mat3, (x, y, z),
mint::ColumnMatrix4<f32>, Mat4, (x, y, z, w),
mint::ColumnMatrix2<f64>, DMat2, (x, y),
mint::ColumnMatrix3<f64>, DMat3, (x, y, z),
mint::ColumnMatrix4<f64>, DMat4, (x, y, z, w),
}

6
crates/crevice/src/std140/dynamic_uniform.rs
View file

@ -11,13 +11,13 @@ use crate::std140::{AsStd140, Std140};
pub struct DynamicUniform<T>(pub T); pub struct DynamicUniform<T>(pub T);
impl<T: AsStd140> AsStd140 for DynamicUniform<T> { impl<T: AsStd140> AsStd140 for DynamicUniform<T> {
type Std140Type = DynamicUniformStd140<<T as AsStd140>::Std140Type>; type Output = DynamicUniformStd140<<T as AsStd140>::Output>;
fn as_std140(&self) -> Self::Std140Type { fn as_std140(&self) -> Self::Output {
DynamicUniformStd140(self.0.as_std140()) DynamicUniformStd140(self.0.as_std140())
} }
fn from_std140(value: Self::Std140Type) -> Self { fn from_std140(value: Self::Output) -> Self {
DynamicUniform(<T as AsStd140>::from_std140(value.0)) DynamicUniform(<T as AsStd140>::from_std140(value.0))
} }
} }

61
crates/crevice/src/std140/primitives.rs
View file

@ -1,5 +1,6 @@
use bytemuck::{Pod, Zeroable}; use bytemuck::{Pod, Zeroable};
use crate::glsl::Glsl;
use crate::std140::{Std140, Std140Padded}; use crate::std140::{Std140, Std140Padded};
use crate::internal::{align_offset, max}; use crate::internal::{align_offset, max};
@ -28,13 +29,14 @@ unsafe impl Std140 for u32 {
macro_rules! vectors { macro_rules! vectors {
( (
$( $(
#[$doc:meta] align($align:literal) $name:ident <$prim:ident> ($($field:ident),+) #[$doc:meta] align($align:literal) $glsl_name:ident $name:ident <$prim:ident> ($($field:ident),+)
)+ )+
) => { ) => {
$( $(
#[$doc] #[$doc]
#[allow(missing_docs)] #[allow(missing_docs)]
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy, PartialEq)]
#[repr(C)]
pub struct $name { pub struct $name {
$(pub $field: $prim,)+ $(pub $field: $prim,)+
} }
@ -46,30 +48,36 @@ macro_rules! vectors {
const ALIGNMENT: usize = $align; const ALIGNMENT: usize = $align;
type Padded = Std140Padded<Self, {align_offset(size_of::<$name>(), max(16, $align))}>; type Padded = Std140Padded<Self, {align_offset(size_of::<$name>(), max(16, $align))}>;
} }
unsafe impl Glsl for $name {
const NAME: &'static str = stringify!($glsl_name);
}
)+ )+
}; };
} }
vectors! { vectors! {
#[doc = "Corresponds to a GLSL `vec2` in std140 layout."] align(8) Vec2<f32>(x, y) #[doc = "Corresponds to a GLSL `vec2` in std140 layout."] align(8) vec2 Vec2<f32>(x, y)
#[doc = "Corresponds to a GLSL `vec3` in std140 layout."] align(16) Vec3<f32>(x, y, z) #[doc = "Corresponds to a GLSL `vec3` in std140 layout."] align(16) vec3 Vec3<f32>(x, y, z)
#[doc = "Corresponds to a GLSL `vec4` in std140 layout."] align(16) Vec4<f32>(x, y, z, w) #[doc = "Corresponds to a GLSL `vec4` in std140 layout."] align(16) vec4 Vec4<f32>(x, y, z, w)
#[doc = "Corresponds to a GLSL `ivec2` in std140 layout."] align(8) IVec2<i32>(x, y) #[doc = "Corresponds to a GLSL `ivec2` in std140 layout."] align(8) ivec2 IVec2<i32>(x, y)
#[doc = "Corresponds to a GLSL `ivec3` in std140 layout."] align(16) IVec3<i32>(x, y, z) #[doc = "Corresponds to a GLSL `ivec3` in std140 layout."] align(16) ivec3 IVec3<i32>(x, y, z)
#[doc = "Corresponds to a GLSL `ivec4` in std140 layout."] align(16) IVec4<i32>(x, y, z, w) #[doc = "Corresponds to a GLSL `ivec4` in std140 layout."] align(16) ivec4 IVec4<i32>(x, y, z, w)
#[doc = "Corresponds to a GLSL `uvec2` in std140 layout."] align(8) UVec2<u32>(x, y) #[doc = "Corresponds to a GLSL `uvec2` in std140 layout."] align(8) uvec2 UVec2<u32>(x, y)
#[doc = "Corresponds to a GLSL `uvec3` in std140 layout."] align(16) UVec3<u32>(x, y, z) #[doc = "Corresponds to a GLSL `uvec3` in std140 layout."] align(16) uvec3 UVec3<u32>(x, y, z)
#[doc = "Corresponds to a GLSL `uvec4` in std140 layout."] align(16) UVec4<u32>(x, y, z, w) #[doc = "Corresponds to a GLSL `uvec4` in std140 layout."] align(16) uvec4 UVec4<u32>(x, y, z, w)
#[doc = "Corresponds to a GLSL `bvec2` in std140 layout."] align(8) BVec2<bool>(x, y) // bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
#[doc = "Corresponds to a GLSL `bvec3` in std140 layout."] align(16) BVec3<bool>(x, y, z)
#[doc = "Corresponds to a GLSL `bvec4` in std140 layout."] align(16) BVec4<bool>(x, y, z, w)
#[doc = "Corresponds to a GLSL `dvec2` in std140 layout."] align(16) DVec2<f64>(x, y) // #[doc = "Corresponds to a GLSL `bvec2` in std140 layout."] align(8) bvec2 BVec2<bool>(x, y)
#[doc = "Corresponds to a GLSL `dvec3` in std140 layout."] align(32) DVec3<f64>(x, y, z) // #[doc = "Corresponds to a GLSL `bvec3` in std140 layout."] align(16) bvec3 BVec3<bool>(x, y, z)
#[doc = "Corresponds to a GLSL `dvec4` in std140 layout."] align(32) DVec4<f64>(x, y, z, w) // #[doc = "Corresponds to a GLSL `bvec4` in std140 layout."] align(16) bvec4 BVec4<bool>(x, y, z, w)
#[doc = "Corresponds to a GLSL `dvec2` in std140 layout."] align(16) dvec2 DVec2<f64>(x, y)
#[doc = "Corresponds to a GLSL `dvec3` in std140 layout."] align(32) dvec3 DVec3<f64>(x, y, z)
#[doc = "Corresponds to a GLSL `dvec4` in std140 layout."] align(32) dvec4 DVec4<f64>(x, y, z, w)
} }
macro_rules! matrices { macro_rules! matrices {
@ -77,7 +85,7 @@ macro_rules! matrices {
$( $(
#[$doc:meta] #[$doc:meta]
align($align:literal) align($align:literal)
$name:ident { $glsl_name:ident $name:ident {
$($field:ident: $field_ty:ty,)+ $($field:ident: $field_ty:ty,)+
} }
)+ )+
@ -86,6 +94,7 @@ macro_rules! matrices {
#[$doc] #[$doc]
#[allow(missing_docs)] #[allow(missing_docs)]
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct $name { pub struct $name {
$(pub $field: $field_ty,)+ $(pub $field: $field_ty,)+
} }
@ -99,6 +108,10 @@ macro_rules! matrices {
const PAD_AT_END: bool = true; const PAD_AT_END: bool = true;
type Padded = Std140Padded<Self, {align_offset(size_of::<$name>(), max(16, $align))}>; type Padded = Std140Padded<Self, {align_offset(size_of::<$name>(), max(16, $align))}>;
} }
unsafe impl Glsl for $name {
const NAME: &'static str = stringify!($glsl_name);
}
)+ )+
}; };
} }
@ -106,7 +119,7 @@ macro_rules! matrices {
matrices! { matrices! {
#[doc = "Corresponds to a GLSL `mat2` in std140 layout."] #[doc = "Corresponds to a GLSL `mat2` in std140 layout."]
align(16) align(16)
Mat2 { mat2 Mat2 {
x: Vec2, x: Vec2,
_pad_x: [f32; 2], _pad_x: [f32; 2],
y: Vec2, y: Vec2,
@ -115,7 +128,7 @@ matrices! {
#[doc = "Corresponds to a GLSL `mat3` in std140 layout."] #[doc = "Corresponds to a GLSL `mat3` in std140 layout."]
align(16) align(16)
Mat3 { mat3 Mat3 {
x: Vec3, x: Vec3,
_pad_x: f32, _pad_x: f32,
y: Vec3, y: Vec3,
@ -126,7 +139,7 @@ matrices! {
#[doc = "Corresponds to a GLSL `mat4` in std140 layout."] #[doc = "Corresponds to a GLSL `mat4` in std140 layout."]
align(16) align(16)
Mat4 { mat4 Mat4 {
x: Vec4, x: Vec4,
y: Vec4, y: Vec4,
z: Vec4, z: Vec4,
@ -135,14 +148,14 @@ matrices! {
#[doc = "Corresponds to a GLSL `dmat2` in std140 layout."] #[doc = "Corresponds to a GLSL `dmat2` in std140 layout."]
align(16) align(16)
DMat2 { dmat2 DMat2 {
x: DVec2, x: DVec2,
y: DVec2, y: DVec2,
} }
#[doc = "Corresponds to a GLSL `dmat3` in std140 layout."] #[doc = "Corresponds to a GLSL `dmat3` in std140 layout."]
align(32) align(32)
DMat3 { dmat3 DMat3 {
x: DVec3, x: DVec3,
_pad_x: f64, _pad_x: f64,
y: DVec3, y: DVec3,
@ -153,7 +166,7 @@ matrices! {
#[doc = "Corresponds to a GLSL `dmat3` in std140 layout."] #[doc = "Corresponds to a GLSL `dmat3` in std140 layout."]
align(32) align(32)
DMat4 { dmat4 DMat4 {
x: DVec4, x: DVec4,
y: DVec4, y: DVec4,
z: DVec4, z: DVec4,

4
crates/crevice/src/std140/sizer.rs
View file

@ -61,8 +61,8 @@ impl Sizer {
where where
T: AsStd140, T: AsStd140,
{ {
let size = size_of::<<T as AsStd140>::Std140Type>(); let size = size_of::<<T as AsStd140>::Output>();
let alignment = <T as AsStd140>::Std140Type::ALIGNMENT; let alignment = <T as AsStd140>::Output::ALIGNMENT;
let padding = align_offset(self.offset, alignment); let padding = align_offset(self.offset, alignment);
self.offset += padding; self.offset += padding;

55
crates/crevice/src/std140/traits.rs
View file

@ -17,9 +17,10 @@ pub unsafe trait Std140: Copy + Zeroable + Pod {
/// control and zero their padding bytes, making converting them to and from /// control and zero their padding bytes, making converting them to and from
/// slices safe. /// slices safe.
const ALIGNMENT: usize; const ALIGNMENT: usize;
/// Whether this type requires a padding at the end (ie, is a struct or an array /// Whether this type requires a padding at the end (ie, is a struct or an array
/// of primitives). /// of primitives).
/// See https://www.khronos.org/registry/OpenGL/specs/gl/glspec45.core.pdf#page=159 /// See <https://www.khronos.org/registry/OpenGL/specs/gl/glspec45.core.pdf#page=159>
/// (rule 4 and 9) /// (rule 4 and 9)
const PAD_AT_END: bool = false; const PAD_AT_END: bool = false;
/// Padded type (Std140Padded specialization) /// Padded type (Std140Padded specialization)
@ -75,7 +76,7 @@ struct which contains only fields that also implement `AsStd140` can derive
`AsStd140`. `AsStd140`.
Types from the mint crate implement `AsStd140`, making them convenient for use Types from the mint crate implement `AsStd140`, making them convenient for use
in uniform types. Most Rust geometry crates, like cgmath, nalgebra, and in uniform types. Most Rust math crates, like cgmath, nalgebra, and
ultraviolet support mint. ultraviolet support mint.
## Example ## Example
@ -87,9 +88,7 @@ uniform CAMERA {
} camera; } camera;
``` ```
```skip ```no_run
use cgmath::prelude::*;
use cgmath::{Matrix4, Deg, perspective};
use crevice::std140::{AsStd140, Std140}; use crevice::std140::{AsStd140, Std140};
#[derive(AsStd140)] #[derive(AsStd140)]
@ -98,9 +97,12 @@ struct CameraUniform {
projection: mint::ColumnMatrix4<f32>, projection: mint::ColumnMatrix4<f32>,
} }
let view: mint::ColumnMatrix4<f32> = todo!("your math code here");
let projection: mint::ColumnMatrix4<f32> = todo!("your math code here");
let camera = CameraUniform { let camera = CameraUniform {
view: Matrix4::identity().into(), view,
projection: perspective(Deg(60.0), 16.0/9.0, 0.01, 100.0).into(), projection,
}; };
# fn write_to_gpu_buffer(bytes: &[u8]) {} # fn write_to_gpu_buffer(bytes: &[u8]) {}
@ -110,26 +112,26 @@ write_to_gpu_buffer(camera_std140.as_bytes());
*/ */
pub trait AsStd140 { pub trait AsStd140 {
/// The `std140` version of this value. /// The `std140` version of this value.
type Std140Type: Std140; type Output: Std140;
/// Convert this value into the `std140` version of itself. /// Convert this value into the `std140` version of itself.
fn as_std140(&self) -> Self::Std140Type; fn as_std140(&self) -> Self::Output;
/// Returns the size of the `std140` version of this type. Useful for /// Returns the size of the `std140` version of this type. Useful for
/// pre-sizing buffers. /// pre-sizing buffers.
fn std140_size_static() -> usize { fn std140_size_static() -> usize {
size_of::<Self::Std140Type>() size_of::<Self::Output>()
} }
/// Converts from `std140` version of self to self. /// Converts from `std140` version of self to self.
fn from_std140(val: Self::Std140Type) -> Self; fn from_std140(val: Self::Output) -> Self;
} }
impl<T> AsStd140 for T impl<T> AsStd140 for T
where where
T: Std140, T: Std140,
{ {
type Std140Type = Self; type Output = Self;
fn as_std140(&self) -> Self { fn as_std140(&self) -> Self {
*self *self
@ -178,29 +180,36 @@ where
type Padded = Self; type Padded = Self;
} }
impl<T: Std140, const N: usize> Std140Array<T, N> {
fn uninit_array() -> [MaybeUninit<T::Padded>; N] {
unsafe { MaybeUninit::uninit().assume_init() }
}
fn from_uninit_array(a: [MaybeUninit<T::Padded>; N]) -> Self {
unsafe { core::mem::transmute_copy(&a) }
}
}
impl<T: AsStd140, const N: usize> AsStd140 for [T; N] impl<T: AsStd140, const N: usize> AsStd140 for [T; N]
where where
<T::Std140Type as Std140>::Padded: Pod, <T::Output as Std140>::Padded: Pod,
{ {
type Std140Type = Std140Array<T::Std140Type, N>; type Output = Std140Array<T::Output, N>;
fn as_std140(&self) -> Self::Std140Type { fn as_std140(&self) -> Self::Output {
let mut res: [MaybeUninit<<T::Std140Type as Std140>::Padded>; N] = let mut res = Self::Output::uninit_array();
unsafe { MaybeUninit::uninit().assume_init() };
for i in 0..N { for i in 0..N {
res[i] = MaybeUninit::new(Std140Convertible::from_std140(self[i].as_std140())); res[i] = MaybeUninit::new(Std140Convertible::from_std140(self[i].as_std140()));
} }
unsafe { core::mem::transmute_copy(&res) } Self::Output::from_uninit_array(res)
} }
fn from_std140(val: Self::Std140Type) -> Self { fn from_std140(val: Self::Output) -> Self {
let mut res: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() }; let mut res: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
for i in 0..N { for i in 0..N {
res[i] = MaybeUninit::new(AsStd140::from_std140(val.0[i].into_std140())); res[i] = MaybeUninit::new(T::from_std140(Std140Convertible::into_std140(val.0[i])));
} }
unsafe { core::mem::transmute_copy(&res) } unsafe { core::mem::transmute_copy(&res) }
} }
} }
@ -241,7 +250,7 @@ where
} }
fn std140_size(&self) -> usize { fn std140_size(&self) -> usize {
size_of::<<Self as AsStd140>::Std140Type>() size_of::<<Self as AsStd140>::Output>()
} }
} }

67
crates/crevice/src/std430/primitives.rs
View file

@ -1,5 +1,6 @@
use bytemuck::{Pod, Zeroable}; use bytemuck::{Pod, Zeroable};
use crate::glsl::Glsl;
use crate::std430::{Std430, Std430Padded}; use crate::std430::{Std430, Std430Padded};
use crate::internal::align_offset; use crate::internal::align_offset;
@ -28,13 +29,14 @@ unsafe impl Std430 for u32 {
macro_rules! vectors { macro_rules! vectors {
( (
$( $(
#[$doc:meta] align($align:literal) $name:ident <$prim:ident> ($($field:ident),+) #[$doc:meta] align($align:literal) $glsl_name:ident $name:ident <$prim:ident> ($($field:ident),+)
)+ )+
) => { ) => {
$( $(
#[$doc] #[$doc]
#[allow(missing_docs)] #[allow(missing_docs)]
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct $name { pub struct $name {
$(pub $field: $prim,)+ $(pub $field: $prim,)+
} }
@ -46,30 +48,36 @@ macro_rules! vectors {
const ALIGNMENT: usize = $align; const ALIGNMENT: usize = $align;
type Padded = Std430Padded<Self, {align_offset(size_of::<$name>(), $align)}>; type Padded = Std430Padded<Self, {align_offset(size_of::<$name>(), $align)}>;
} }
unsafe impl Glsl for $name {
const NAME: &'static str = stringify!($glsl_name);
}
)+ )+
}; };
} }
vectors! { vectors! {
#[doc = "Corresponds to a GLSL `vec2` in std430 layout."] align(8) Vec2<f32>(x, y) #[doc = "Corresponds to a GLSL `vec2` in std430 layout."] align(8) vec2 Vec2<f32>(x, y)
#[doc = "Corresponds to a GLSL `vec3` in std430 layout."] align(16) Vec3<f32>(x, y, z) #[doc = "Corresponds to a GLSL `vec3` in std430 layout."] align(16) vec3 Vec3<f32>(x, y, z)
#[doc = "Corresponds to a GLSL `vec4` in std430 layout."] align(16) Vec4<f32>(x, y, z, w) #[doc = "Corresponds to a GLSL `vec4` in std430 layout."] align(16) vec4 Vec4<f32>(x, y, z, w)
#[doc = "Corresponds to a GLSL `ivec2` in std140 layout."] align(8) IVec2<i32>(x, y) #[doc = "Corresponds to a GLSL `ivec2` in std430 layout."] align(8) ivec2 IVec2<i32>(x, y)
#[doc = "Corresponds to a GLSL `ivec3` in std140 layout."] align(16) IVec3<i32>(x, y, z) #[doc = "Corresponds to a GLSL `ivec3` in std430 layout."] align(16) ivec3 IVec3<i32>(x, y, z)
#[doc = "Corresponds to a GLSL `ivec4` in std140 layout."] align(16) IVec4<i32>(x, y, z, w) #[doc = "Corresponds to a GLSL `ivec4` in std430 layout."] align(16) ivec4 IVec4<i32>(x, y, z, w)
#[doc = "Corresponds to a GLSL `uvec2` in std140 layout."] align(8) UVec2<u32>(x, y) #[doc = "Corresponds to a GLSL `uvec2` in std430 layout."] align(8) uvec2 UVec2<u32>(x, y)
#[doc = "Corresponds to a GLSL `uvec3` in std140 layout."] align(16) UVec3<u32>(x, y, z) #[doc = "Corresponds to a GLSL `uvec3` in std430 layout."] align(16) uvec3 UVec3<u32>(x, y, z)
#[doc = "Corresponds to a GLSL `uvec4` in std140 layout."] align(16) UVec4<u32>(x, y, z, w) #[doc = "Corresponds to a GLSL `uvec4` in std430 layout."] align(16) uvec4 UVec4<u32>(x, y, z, w)
#[doc = "Corresponds to a GLSL `bvec2` in std140 layout."] align(8) BVec2<bool>(x, y) // bool vectors are disabled due to https://github.com/LPGhatguy/crevice/issues/36
#[doc = "Corresponds to a GLSL `bvec3` in std140 layout."] align(16) BVec3<bool>(x, y, z)
#[doc = "Corresponds to a GLSL `bvec4` in std140 layout."] align(16) BVec4<bool>(x, y, z, w)
#[doc = "Corresponds to a GLSL `dvec2` in std430 layout."] align(16) DVec2<f64>(x, y) // #[doc = "Corresponds to a GLSL `bvec2` in std430 layout."] align(8) bvec2 BVec2<bool>(x, y)
#[doc = "Corresponds to a GLSL `dvec3` in std430 layout."] align(32) DVec3<f64>(x, y, z) // #[doc = "Corresponds to a GLSL `bvec3` in std430 layout."] align(16) bvec3 BVec3<bool>(x, y, z)
#[doc = "Corresponds to a GLSL `dvec4` in std430 layout."] align(32) DVec4<f64>(x, y, z, w) // #[doc = "Corresponds to a GLSL `bvec4` in std430 layout."] align(16) bvec4 BVec4<bool>(x, y, z, w)
#[doc = "Corresponds to a GLSL `dvec2` in std430 layout."] align(16) dvec2 DVec2<f64>(x, y)
#[doc = "Corresponds to a GLSL `dvec3` in std430 layout."] align(32) dvec3 DVec3<f64>(x, y, z)
#[doc = "Corresponds to a GLSL `dvec4` in std430 layout."] align(32) dvec4 DVec4<f64>(x, y, z, w)
} }
macro_rules! matrices { macro_rules! matrices {
@ -77,7 +85,7 @@ macro_rules! matrices {
$( $(
#[$doc:meta] #[$doc:meta]
align($align:literal) align($align:literal)
$name:ident { $glsl_name:ident $name:ident {
$($field:ident: $field_ty:ty,)+ $($field:ident: $field_ty:ty,)+
} }
)+ )+
@ -86,6 +94,7 @@ macro_rules! matrices {
#[$doc] #[$doc]
#[allow(missing_docs)] #[allow(missing_docs)]
#[derive(Debug, Clone, Copy)] #[derive(Debug, Clone, Copy)]
#[repr(C)]
pub struct $name { pub struct $name {
$(pub $field: $field_ty,)+ $(pub $field: $field_ty,)+
} }
@ -99,29 +108,36 @@ macro_rules! matrices {
const PAD_AT_END: bool = true; const PAD_AT_END: bool = true;
type Padded = Std430Padded<Self, {align_offset(size_of::<$name>(), $align)}>; type Padded = Std430Padded<Self, {align_offset(size_of::<$name>(), $align)}>;
} }
unsafe impl Glsl for $name {
const NAME: &'static str = stringify!($glsl_name);
}
)+ )+
}; };
} }
matrices! { matrices! {
#[doc = "Corresponds to a GLSL `mat2` in std430 layout."] #[doc = "Corresponds to a GLSL `mat2` in std430 layout."]
align(16) align(8)
Mat2 { mat2 Mat2 {
x: Vec2, x: Vec2,
y: Vec2, y: Vec2,
} }
#[doc = "Corresponds to a GLSL `mat3` in std430 layout."] #[doc = "Corresponds to a GLSL `mat3` in std430 layout."]
align(16) align(16)
Mat3 { mat3 Mat3 {
x: Vec3, x: Vec3,
_pad_x: f32,
y: Vec3, y: Vec3,
_pad_y: f32,
z: Vec3, z: Vec3,
_pad_z: f32,
} }
#[doc = "Corresponds to a GLSL `mat4` in std430 layout."] #[doc = "Corresponds to a GLSL `mat4` in std430 layout."]
align(16) align(16)
Mat4 { mat4 Mat4 {
x: Vec4, x: Vec4,
y: Vec4, y: Vec4,
z: Vec4, z: Vec4,
@ -130,22 +146,25 @@ matrices! {
#[doc = "Corresponds to a GLSL `dmat2` in std430 layout."] #[doc = "Corresponds to a GLSL `dmat2` in std430 layout."]
align(16) align(16)
DMat2 { dmat2 DMat2 {
x: DVec2, x: DVec2,
y: DVec2, y: DVec2,
} }
#[doc = "Corresponds to a GLSL `dmat3` in std430 layout."] #[doc = "Corresponds to a GLSL `dmat3` in std430 layout."]
align(32) align(32)
DMat3 { dmat3 DMat3 {
x: DVec3, x: DVec3,
_pad_x: f64,
y: DVec3, y: DVec3,
_pad_y: f64,
z: DVec3, z: DVec3,
_pad_z: f64,
} }
#[doc = "Corresponds to a GLSL `dmat3` in std430 layout."] #[doc = "Corresponds to a GLSL `dmat3` in std430 layout."]
align(32) align(32)
DMat4 { dmat4 DMat4 {
x: DVec4, x: DVec4,
y: DVec4, y: DVec4,
z: DVec4, z: DVec4,

4
crates/crevice/src/std430/sizer.rs
View file

@ -61,8 +61,8 @@ impl Sizer {
where where
T: AsStd430, T: AsStd430,
{ {
let size = size_of::<<T as AsStd430>::Std430Type>(); let size = size_of::<<T as AsStd430>::Output>();
let alignment = <T as AsStd430>::Std430Type::ALIGNMENT; let alignment = <T as AsStd430>::Output::ALIGNMENT;
let padding = align_offset(self.offset, alignment); let padding = align_offset(self.offset, alignment);
self.offset += padding; self.offset += padding;

53
crates/crevice/src/std430/traits.rs
View file

@ -17,9 +17,10 @@ pub unsafe trait Std430: Copy + Zeroable + Pod {
/// control and zero their padding bytes, making converting them to and from /// control and zero their padding bytes, making converting them to and from
/// slices safe. /// slices safe.
const ALIGNMENT: usize; const ALIGNMENT: usize;
/// Whether this type requires a padding at the end (ie, is a struct or an array /// Whether this type requires a padding at the end (ie, is a struct or an array
/// of primitives). /// of primitives).
/// See https://www.khronos.org/registry/OpenGL/specs/gl/glspec45.core.pdf#page=159 /// See <https://www.khronos.org/registry/OpenGL/specs/gl/glspec45.core.pdf#page=159>
/// (rule 4 and 9) /// (rule 4 and 9)
const PAD_AT_END: bool = false; const PAD_AT_END: bool = false;
/// Padded type (Std430Padded specialization) /// Padded type (Std430Padded specialization)
@ -87,9 +88,7 @@ uniform CAMERA {
} camera; } camera;
``` ```
```skip ```no_run
use cgmath::prelude::*;
use cgmath::{Matrix4, Deg, perspective};
use crevice::std430::{AsStd430, Std430}; use crevice::std430::{AsStd430, Std430};
#[derive(AsStd430)] #[derive(AsStd430)]
@ -98,9 +97,12 @@ struct CameraUniform {
projection: mint::ColumnMatrix4<f32>, projection: mint::ColumnMatrix4<f32>,
} }
let view: mint::ColumnMatrix4<f32> = todo!("your math code here");
let projection: mint::ColumnMatrix4<f32> = todo!("your math code here");
let camera = CameraUniform { let camera = CameraUniform {
view: Matrix4::identity().into(), view,
projection: perspective(Deg(60.0), 16.0/9.0, 0.01, 100.0).into(), projection,
}; };
# fn write_to_gpu_buffer(bytes: &[u8]) {} # fn write_to_gpu_buffer(bytes: &[u8]) {}
@ -110,26 +112,26 @@ write_to_gpu_buffer(camera_std430.as_bytes());
*/ */
pub trait AsStd430 { pub trait AsStd430 {
/// The `std430` version of this value. /// The `std430` version of this value.
type Std430Type: Std430; type Output: Std430;
/// Convert this value into the `std430` version of itself. /// Convert this value into the `std430` version of itself.
fn as_std430(&self) -> Self::Std430Type; fn as_std430(&self) -> Self::Output;
/// Returns the size of the `std430` version of this type. Useful for /// Returns the size of the `std430` version of this type. Useful for
/// pre-sizing buffers. /// pre-sizing buffers.
fn std430_size_static() -> usize { fn std430_size_static() -> usize {
size_of::<Self::Std430Type>() size_of::<Self::Output>()
} }
/// Converts from `std430` version of self to self. /// Converts from `std430` version of self to self.
fn from_std430(value: Self::Std430Type) -> Self; fn from_std430(value: Self::Output) -> Self;
} }
impl<T> AsStd430 for T impl<T> AsStd430 for T
where where
T: Std430, T: Std430,
{ {
type Std430Type = Self; type Output = Self;
fn as_std430(&self) -> Self { fn as_std430(&self) -> Self {
*self *self
@ -178,29 +180,36 @@ where
type Padded = Self; type Padded = Self;
} }
impl<T: Std430, const N: usize> Std430Array<T, N> {
fn uninit_array() -> [MaybeUninit<T::Padded>; N] {
unsafe { MaybeUninit::uninit().assume_init() }
}
fn from_uninit_array(a: [MaybeUninit<T::Padded>; N]) -> Self {
unsafe { core::mem::transmute_copy(&a) }
}
}
impl<T: AsStd430, const N: usize> AsStd430 for [T; N] impl<T: AsStd430, const N: usize> AsStd430 for [T; N]
where where
<T::Std430Type as Std430>::Padded: Pod, <T::Output as Std430>::Padded: Pod,
{ {
type Std430Type = Std430Array<T::Std430Type, N>; type Output = Std430Array<T::Output, N>;
fn as_std430(&self) -> Self::Std430Type { fn as_std430(&self) -> Self::Output {
let mut res: [MaybeUninit<<T::Std430Type as Std430>::Padded>; N] = let mut res = Self::Output::uninit_array();
unsafe { MaybeUninit::uninit().assume_init() };
for i in 0..N { for i in 0..N {
res[i] = MaybeUninit::new(Std430Convertible::from_std430(self[i].as_std430())); res[i] = MaybeUninit::new(Std430Convertible::from_std430(self[i].as_std430()));
} }
unsafe { core::mem::transmute_copy(&res) } Self::Output::from_uninit_array(res)
} }
fn from_std430(val: Self::Std430Type) -> Self { fn from_std430(val: Self::Output) -> Self {
let mut res: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() }; let mut res: [MaybeUninit<T>; N] = unsafe { MaybeUninit::uninit().assume_init() };
for i in 0..N { for i in 0..N {
res[i] = MaybeUninit::new(AsStd430::from_std430(val.0[i].into_std430())); res[i] = MaybeUninit::new(T::from_std430(val.0[i].into_std430()));
} }
unsafe { core::mem::transmute_copy(&res) } unsafe { core::mem::transmute_copy(&res) }
} }
} }
@ -241,7 +250,7 @@ where
} }
fn std430_size(&self) -> usize { fn std430_size(&self) -> usize {
size_of::<<Self as AsStd430>::Std430Type>() size_of::<<Self as AsStd430>::Output>()
} }
} }

97
crates/crevice/src/util.rs Normal file
View file

@ -0,0 +1,97 @@
#![allow(unused_macros)]
macro_rules! easy_impl {
( $( $std_name:ident $imp_ty:ty { $($field:ident),* }, )* ) => {
$(
impl crate::std140::AsStd140 for $imp_ty {
type Output = crate::std140::$std_name;
#[inline]
fn as_std140(&self) -> Self::Output {
crate::std140::$std_name {
$(
$field: self.$field.as_std140(),
)*
..bytemuck::Zeroable::zeroed()
}
}
#[inline]
fn from_std140(value: Self::Output) -> Self {
Self {
$(
$field: <_ as crate::std140::AsStd140>::from_std140(value.$field),
)*
}
}
}
impl crate::std430::AsStd430 for $imp_ty {
type Output = crate::std430::$std_name;
#[inline]
fn as_std430(&self) -> Self::Output {
crate::std430::$std_name {
$(
$field: self.$field.as_std430(),
)*
..bytemuck::Zeroable::zeroed()
}
}
#[inline]
fn from_std430(value: Self::Output) -> Self {
Self {
$(
$field: <_ as crate::std430::AsStd430>::from_std430(value.$field),
)*
}
}
}
unsafe impl crate::glsl::Glsl for $imp_ty {
const NAME: &'static str = crate::std140::$std_name::NAME;
}
)*
};
}
macro_rules! minty_impl {
( $( $mint_ty:ty => $imp_ty:ty, )* ) => {
$(
impl crate::std140::AsStd140 for $imp_ty {
type Output = <$mint_ty as crate::std140::AsStd140>::Output;
#[inline]
fn as_std140(&self) -> Self::Output {
let mint: $mint_ty = (*self).into();
mint.as_std140()
}
#[inline]
fn from_std140(value: Self::Output) -> Self {
<$mint_ty>::from_std140(value).into()
}
}
impl crate::std430::AsStd430 for $imp_ty {
type Output = <$mint_ty as crate::std430::AsStd430>::Output;
#[inline]
fn as_std430(&self) -> Self::Output {
let mint: $mint_ty = (*self).into();
mint.as_std430()
}
#[inline]
fn from_std430(value: Self::Output) -> Self {
<$mint_ty>::from_std430(value).into()
}
}
unsafe impl crate::glsl::Glsl for $imp_ty {
const NAME: &'static str = <$mint_ty>::NAME;
}
)*
};
}

8
crates/crevice/tests/snapshots/test__generate_struct_array_glsl.snap Normal file
View file

@ -0,0 +1,8 @@
---
source: tests/test.rs
expression: "TestGlsl::glsl_definition()"
---
struct TestGlsl {
vec3 foo[8][4];
};

9
crates/crevice/tests/snapshots/test__generate_struct_glsl.snap Normal file
View file

@ -0,0 +1,9 @@
---
source: tests/test.rs
expression: "TestGlsl::glsl_definition()"
---
struct TestGlsl {
vec3 foo;
mat2 bar;
};

61
crates/crevice/tests/test.rs Normal file
View file

@ -0,0 +1,61 @@
use crevice::glsl::GlslStruct;
use crevice::std140::AsStd140;
#[test]
fn there_and_back_again() {
#[derive(AsStd140, Debug, PartialEq)]
struct ThereAndBackAgain {
view: mint::ColumnMatrix3<f32>,
origin: mint::Vector3<f32>,
}
let x = ThereAndBackAgain {
view: mint::ColumnMatrix3 {
x: mint::Vector3 {
x: 1.0,
y: 0.0,
z: 0.0,
},
y: mint::Vector3 {
x: 0.0,
y: 1.0,
z: 0.0,
},
z: mint::Vector3 {
x: 0.0,
y: 0.0,
z: 1.0,
},
},
origin: mint::Vector3 {
x: 0.0,
y: 1.0,
z: 2.0,
},
};
let x_as = x.as_std140();
assert_eq!(<ThereAndBackAgain as AsStd140>::from_std140(x_as), x);
}
#[test]
fn generate_struct_glsl() {
#[allow(dead_code)]
#[derive(GlslStruct)]
struct TestGlsl {
foo: mint::Vector3<f32>,
bar: mint::ColumnMatrix2<f32>,
}
insta::assert_display_snapshot!(TestGlsl::glsl_definition());
}
#[test]
fn generate_struct_array_glsl() {
#[allow(dead_code)]
#[derive(GlslStruct)]
struct TestGlsl {
foo: [[mint::Vector3<f32>; 8]; 4],
}
insta::assert_display_snapshot!(TestGlsl::glsl_definition());
}

2
pipelined/bevy_pbr2/Cargo.toml
View file

@ -29,5 +29,5 @@ bevy_utils = { path = "../../crates/bevy_utils", version = "0.5.0" }
bitflags = "1.2" bitflags = "1.2"
# direct dependency required for derive macro # direct dependency required for derive macro
bytemuck = { version = "1", features = ["derive"] } bytemuck = { version = "1", features = ["derive"] }
crevice = { path = "../../crates/crevice", version = "0.6.0" } crevice = { path = "../../crates/crevice", version = "0.8.0", features = ["glam"] }
wgpu = { version = "0.11.0", features = ["spirv"] } wgpu = { version = "0.11.0", features = ["spirv"] }

4
pipelined/bevy_render2/Cargo.toml
View file

@ -40,10 +40,10 @@ thiserror = "1.0"
futures-lite = "1.4.0" futures-lite = "1.4.0"
anyhow = "1.0" anyhow = "1.0"
hex = "0.4.2" hex = "0.4.2"
hexasphere = "4.0" hexasphere = "6.0.0"
parking_lot = "0.11.0" parking_lot = "0.11.0"
regex = "1.5" regex = "1.5"
crevice = { path = "../../crates/crevice", version = "0.6.0" } crevice = { path = "../../crates/crevice", version = "0.8.0", features = ["glam"] }
[target.'cfg(target_arch = "wasm32")'.dependencies] [target.'cfg(target_arch = "wasm32")'.dependencies]
wgpu = { version = "0.11.0", features = ["spirv", "webgl"] } wgpu = { version = "0.11.0", features = ["spirv", "webgl"] }

4
pipelined/bevy_render2/src/render_resource/uniform_vec.rs
View file

@ -21,8 +21,8 @@ impl<T: AsStd140> Default for UniformVec<T> {
scratch: Vec::new(), scratch: Vec::new(),
uniform_buffer: None, uniform_buffer: None,
capacity: 0, capacity: 0,
item_size: (T::std140_size_static() + <T as AsStd140>::Std140Type::ALIGNMENT - 1) item_size: (T::std140_size_static() + <T as AsStd140>::Output::ALIGNMENT - 1)
& !(<T as AsStd140>::Std140Type::ALIGNMENT - 1), & !(<T as AsStd140>::Output::ALIGNMENT - 1),
} }
} }
} }