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

update for wgpu 0.8 (#1959)

Browse source 
Changes to get Bevy to compile with wgpu master.

With this, on a Mac:
* 2d examples look fine
* ~~3d examples crash with an error specific to metal about a compilation error~~
* 3d examples work fine after enabling feature `wgpu/cross`


Feature `wgpu/cross` seems to be needed only on some platforms, not sure how to know which. It was introduced in https://github.com/gfx-rs/wgpu-rs/pull/826
This commit is contained in:
François 2021-05-02 20:45:25 +00:00
parent b399a374cb
commit afaf4ad3da
25 changed files with 556 additions and 521 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
Cargo.toml
View file

@ -82,9 +82,6 @@ bevy_ci_testing = ["bevy_internal/bevy_ci_testing"]
bevy_dylib = {path = "crates/bevy_dylib", version = "0.5.0", default-features = false, optional = true} bevy_dylib = {path = "crates/bevy_dylib", version = "0.5.0", default-features = false, optional = true}
bevy_internal = {path = "crates/bevy_internal", version = "0.5.0", default-features = false} bevy_internal = {path = "crates/bevy_internal", version = "0.5.0", default-features = false}
[target.'cfg(target_arch = "wasm32")'.dependencies]
syn = "=1.0.65"
[dev-dependencies] [dev-dependencies]
anyhow = "1.0" anyhow = "1.0"
rand = "0.8.0" rand = "0.8.0"

10
crates/bevy_gltf/src/loader.rs
View file

@ -116,35 +116,35 @@ async fn load_gltf<'a, 'b>(
if let Some(vertex_attribute) = reader if let Some(vertex_attribute) = reader
.read_positions() .read_positions()
.map(|v| VertexAttributeValues::Float3(v.collect())) .map(|v| VertexAttributeValues::Float32x3(v.collect()))
{ {
mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, vertex_attribute); mesh.set_attribute(Mesh::ATTRIBUTE_POSITION, vertex_attribute);
} }
if let Some(vertex_attribute) = reader if let Some(vertex_attribute) = reader
.read_normals() .read_normals()
.map(|v| VertexAttributeValues::Float3(v.collect())) .map(|v| VertexAttributeValues::Float32x3(v.collect()))
{ {
mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, vertex_attribute); mesh.set_attribute(Mesh::ATTRIBUTE_NORMAL, vertex_attribute);
} }
if let Some(vertex_attribute) = reader if let Some(vertex_attribute) = reader
.read_tangents() .read_tangents()
.map(|v| VertexAttributeValues::Float4(v.collect())) .map(|v| VertexAttributeValues::Float32x4(v.collect()))
{ {
mesh.set_attribute(Mesh::ATTRIBUTE_TANGENT, vertex_attribute); mesh.set_attribute(Mesh::ATTRIBUTE_TANGENT, vertex_attribute);
} }
if let Some(vertex_attribute) = reader if let Some(vertex_attribute) = reader
.read_tex_coords(0) .read_tex_coords(0)
.map(|v| VertexAttributeValues::Float2(v.into_f32().collect())) .map(|v| VertexAttributeValues::Float32x2(v.into_f32().collect()))
{ {
mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, vertex_attribute); mesh.set_attribute(Mesh::ATTRIBUTE_UV_0, vertex_attribute);
} }
if let Some(vertex_attribute) = reader if let Some(vertex_attribute) = reader
.read_colors(0) .read_colors(0)
.map(|v| VertexAttributeValues::Float4(v.into_rgba_f32().collect())) .map(|v| VertexAttributeValues::Float32x4(v.into_rgba_f32().collect()))
{ {
mesh.set_attribute(Mesh::ATTRIBUTE_COLOR, vertex_attribute); mesh.set_attribute(Mesh::ATTRIBUTE_COLOR, vertex_attribute);
} }

12
crates/bevy_pbr/src/render_graph/pbr_pipeline/mod.rs
View file

@ -2,8 +2,9 @@ use bevy_asset::{Assets, HandleUntyped};
use bevy_reflect::TypeUuid; use bevy_reflect::TypeUuid;
use bevy_render::{ use bevy_render::{
pipeline::{ pipeline::{
BlendFactor, BlendOperation, BlendState, ColorTargetState, ColorWrite, CompareFunction, BlendComponent, BlendFactor, BlendOperation, BlendState, ColorTargetState, ColorWrite,
DepthBiasState, DepthStencilState, PipelineDescriptor, StencilFaceState, StencilState, CompareFunction, DepthBiasState, DepthStencilState, PipelineDescriptor, StencilFaceState,
StencilState,
}, },
shader::{Shader, ShaderStage, ShaderStages}, shader::{Shader, ShaderStage, ShaderStages},
texture::TextureFormat, texture::TextureFormat,
@ -29,20 +30,21 @@ pub(crate) fn build_pbr_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescri
slope_scale: 0.0, slope_scale: 0.0,
clamp: 0.0, clamp: 0.0,
}, },
clamp_depth: false,
}), }),
color_target_states: vec![ColorTargetState { color_target_states: vec![ColorTargetState {
format: TextureFormat::default(), format: TextureFormat::default(),
color_blend: BlendState { blend: Some(BlendState {
color: BlendComponent {
src_factor: BlendFactor::SrcAlpha, src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha, dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add, operation: BlendOperation::Add,
}, },
alpha_blend: BlendState { alpha: BlendComponent {
src_factor: BlendFactor::One, src_factor: BlendFactor::One,
dst_factor: BlendFactor::One, dst_factor: BlendFactor::One,
operation: BlendOperation::Add, operation: BlendOperation::Add,
}, },
}),
write_mask: ColorWrite::ALL, write_mask: ColorWrite::ALL,
}], }],
..PipelineDescriptor::new(ShaderStages { ..PipelineDescriptor::new(ShaderStages {

282
crates/bevy_render/src/mesh/mesh.rs
View file

@ -27,34 +27,34 @@ pub const VERTEX_ATTRIBUTE_BUFFER_ID: u64 = 10;
/// An array where each entry describes a property of a single vertex. /// An array where each entry describes a property of a single vertex.
#[derive(Clone, Debug, EnumVariantMeta)] #[derive(Clone, Debug, EnumVariantMeta)]
pub enum VertexAttributeValues { pub enum VertexAttributeValues {
Float(Vec<f32>), Float32(Vec<f32>),
Int(Vec<i32>), Sint32(Vec<i32>),
Uint(Vec<u32>), Uint32(Vec<u32>),
Float2(Vec<[f32; 2]>), Float32x2(Vec<[f32; 2]>),
Int2(Vec<[i32; 2]>), Sint32x2(Vec<[i32; 2]>),
Uint2(Vec<[u32; 2]>), Uint32x2(Vec<[u32; 2]>),
Float3(Vec<[f32; 3]>), Float32x3(Vec<[f32; 3]>),
Int3(Vec<[i32; 3]>), Sint32x3(Vec<[i32; 3]>),
Uint3(Vec<[u32; 3]>), Uint32x3(Vec<[u32; 3]>),
Float4(Vec<[f32; 4]>), Float32x4(Vec<[f32; 4]>),
Int4(Vec<[i32; 4]>), Sint32x4(Vec<[i32; 4]>),
Uint4(Vec<[u32; 4]>), Uint32x4(Vec<[u32; 4]>),
Short2(Vec<[i16; 2]>), Sint16x2(Vec<[i16; 2]>),
Short2Norm(Vec<[i16; 2]>), Snorm16x2(Vec<[i16; 2]>),
Ushort2(Vec<[u16; 2]>), Uint16x2(Vec<[u16; 2]>),
Ushort2Norm(Vec<[u16; 2]>), Unorm16x2(Vec<[u16; 2]>),
Short4(Vec<[i16; 4]>), Sint16x4(Vec<[i16; 4]>),
Short4Norm(Vec<[i16; 4]>), Snorm16x4(Vec<[i16; 4]>),
Ushort4(Vec<[u16; 4]>), Uint16x4(Vec<[u16; 4]>),
Ushort4Norm(Vec<[u16; 4]>), Unorm16x4(Vec<[u16; 4]>),
Char2(Vec<[i8; 2]>), Sint8x2(Vec<[i8; 2]>),
Char2Norm(Vec<[i8; 2]>), Snorm8x2(Vec<[i8; 2]>),
Uchar2(Vec<[u8; 2]>), Uint8x2(Vec<[u8; 2]>),
Uchar2Norm(Vec<[u8; 2]>), Unorm8x2(Vec<[u8; 2]>),
Char4(Vec<[i8; 4]>), Sint8x4(Vec<[i8; 4]>),
Char4Norm(Vec<[i8; 4]>), Snorm8x4(Vec<[i8; 4]>),
Uchar4(Vec<[u8; 4]>), Uint8x4(Vec<[u8; 4]>),
Uchar4Norm(Vec<[u8; 4]>), Unorm8x4(Vec<[u8; 4]>),
} }
impl VertexAttributeValues { impl VertexAttributeValues {
@ -62,34 +62,34 @@ impl VertexAttributeValues {
/// mesh, all of the VertexAttributeValues must have the same length. /// mesh, all of the VertexAttributeValues must have the same length.
pub fn len(&self) -> usize { pub fn len(&self) -> usize {
match *self { match *self {
VertexAttributeValues::Float(ref values) => values.len(), VertexAttributeValues::Float32(ref values) => values.len(),
VertexAttributeValues::Int(ref values) => values.len(), VertexAttributeValues::Sint32(ref values) => values.len(),
VertexAttributeValues::Uint(ref values) => values.len(), VertexAttributeValues::Uint32(ref values) => values.len(),
VertexAttributeValues::Float2(ref values) => values.len(), VertexAttributeValues::Float32x2(ref values) => values.len(),
VertexAttributeValues::Int2(ref values) => values.len(), VertexAttributeValues::Sint32x2(ref values) => values.len(),
VertexAttributeValues::Uint2(ref values) => values.len(), VertexAttributeValues::Uint32x2(ref values) => values.len(),
VertexAttributeValues::Float3(ref values) => values.len(), VertexAttributeValues::Float32x3(ref values) => values.len(),
VertexAttributeValues::Int3(ref values) => values.len(), VertexAttributeValues::Sint32x3(ref values) => values.len(),
VertexAttributeValues::Uint3(ref values) => values.len(), VertexAttributeValues::Uint32x3(ref values) => values.len(),
VertexAttributeValues::Float4(ref values) => values.len(), VertexAttributeValues::Float32x4(ref values) => values.len(),
VertexAttributeValues::Int4(ref values) => values.len(), VertexAttributeValues::Sint32x4(ref values) => values.len(),
VertexAttributeValues::Uint4(ref values) => values.len(), VertexAttributeValues::Uint32x4(ref values) => values.len(),
VertexAttributeValues::Short2(ref values) => values.len(), VertexAttributeValues::Sint16x2(ref values) => values.len(),
VertexAttributeValues::Short2Norm(ref values) => values.len(), VertexAttributeValues::Snorm16x2(ref values) => values.len(),
VertexAttributeValues::Ushort2(ref values) => values.len(), VertexAttributeValues::Uint16x2(ref values) => values.len(),
VertexAttributeValues::Ushort2Norm(ref values) => values.len(), VertexAttributeValues::Unorm16x2(ref values) => values.len(),
VertexAttributeValues::Short4(ref values) => values.len(), VertexAttributeValues::Sint16x4(ref values) => values.len(),
VertexAttributeValues::Short4Norm(ref values) => values.len(), VertexAttributeValues::Snorm16x4(ref values) => values.len(),
VertexAttributeValues::Ushort4(ref values) => values.len(), VertexAttributeValues::Uint16x4(ref values) => values.len(),
VertexAttributeValues::Ushort4Norm(ref values) => values.len(), VertexAttributeValues::Unorm16x4(ref values) => values.len(),
VertexAttributeValues::Char2(ref values) => values.len(), VertexAttributeValues::Sint8x2(ref values) => values.len(),
VertexAttributeValues::Char2Norm(ref values) => values.len(), VertexAttributeValues::Snorm8x2(ref values) => values.len(),
VertexAttributeValues::Uchar2(ref values) => values.len(), VertexAttributeValues::Uint8x2(ref values) => values.len(),
VertexAttributeValues::Uchar2Norm(ref values) => values.len(), VertexAttributeValues::Unorm8x2(ref values) => values.len(),
VertexAttributeValues::Char4(ref values) => values.len(), VertexAttributeValues::Sint8x4(ref values) => values.len(),
VertexAttributeValues::Char4Norm(ref values) => values.len(), VertexAttributeValues::Snorm8x4(ref values) => values.len(),
VertexAttributeValues::Uchar4(ref values) => values.len(), VertexAttributeValues::Uint8x4(ref values) => values.len(),
VertexAttributeValues::Uchar4Norm(ref values) => values.len(), VertexAttributeValues::Unorm8x4(ref values) => values.len(),
} }
} }
@ -100,7 +100,7 @@ impl VertexAttributeValues {
fn as_float3(&self) -> Option<&[[f32; 3]]> { fn as_float3(&self) -> Option<&[[f32; 3]]> {
match self { match self {
VertexAttributeValues::Float3(values) => Some(values), VertexAttributeValues::Float32x3(values) => Some(values),
_ => None, _ => None,
} }
} }
@ -110,34 +110,34 @@ impl VertexAttributeValues {
/// useful for serialization and sending to the GPU. /// useful for serialization and sending to the GPU.
pub fn get_bytes(&self) -> &[u8] { pub fn get_bytes(&self) -> &[u8] {
match self { match self {
VertexAttributeValues::Float(values) => values.as_slice().as_bytes(), VertexAttributeValues::Float32(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Int(values) => values.as_slice().as_bytes(), VertexAttributeValues::Sint32(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Uint(values) => values.as_slice().as_bytes(), VertexAttributeValues::Uint32(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Float2(values) => values.as_slice().as_bytes(), VertexAttributeValues::Float32x2(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Int2(values) => values.as_slice().as_bytes(), VertexAttributeValues::Sint32x2(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Uint2(values) => values.as_slice().as_bytes(), VertexAttributeValues::Uint32x2(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Float3(values) => values.as_slice().as_bytes(), VertexAttributeValues::Float32x3(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Int3(values) => values.as_slice().as_bytes(), VertexAttributeValues::Sint32x3(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Uint3(values) => values.as_slice().as_bytes(), VertexAttributeValues::Uint32x3(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Float4(values) => values.as_slice().as_bytes(), VertexAttributeValues::Float32x4(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Int4(values) => values.as_slice().as_bytes(), VertexAttributeValues::Sint32x4(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Uint4(values) => values.as_slice().as_bytes(), VertexAttributeValues::Uint32x4(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Short2(values) => values.as_slice().as_bytes(), VertexAttributeValues::Sint16x2(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Short2Norm(values) => values.as_slice().as_bytes(), VertexAttributeValues::Snorm16x2(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Ushort2(values) => values.as_slice().as_bytes(), VertexAttributeValues::Uint16x2(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Ushort2Norm(values) => values.as_slice().as_bytes(), VertexAttributeValues::Unorm16x2(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Short4(values) => values.as_slice().as_bytes(), VertexAttributeValues::Sint16x4(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Short4Norm(values) => values.as_slice().as_bytes(), VertexAttributeValues::Snorm16x4(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Ushort4(values) => values.as_slice().as_bytes(), VertexAttributeValues::Uint16x4(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Ushort4Norm(values) => values.as_slice().as_bytes(), VertexAttributeValues::Unorm16x4(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Char2(values) => values.as_slice().as_bytes(), VertexAttributeValues::Sint8x2(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Char2Norm(values) => values.as_slice().as_bytes(), VertexAttributeValues::Snorm8x2(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Uchar2(values) => values.as_slice().as_bytes(), VertexAttributeValues::Uint8x2(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Uchar2Norm(values) => values.as_slice().as_bytes(), VertexAttributeValues::Unorm8x2(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Char4(values) => values.as_slice().as_bytes(), VertexAttributeValues::Sint8x4(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Char4Norm(values) => values.as_slice().as_bytes(), VertexAttributeValues::Snorm8x4(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Uchar4(values) => values.as_slice().as_bytes(), VertexAttributeValues::Uint8x4(values) => values.as_slice().as_bytes(),
VertexAttributeValues::Uchar4Norm(values) => values.as_slice().as_bytes(), VertexAttributeValues::Unorm8x4(values) => values.as_slice().as_bytes(),
} }
} }
} }
@ -145,34 +145,34 @@ impl VertexAttributeValues {
impl From<&VertexAttributeValues> for VertexFormat { impl From<&VertexAttributeValues> for VertexFormat {
fn from(values: &VertexAttributeValues) -> Self { fn from(values: &VertexAttributeValues) -> Self {
match values { match values {
VertexAttributeValues::Float(_) => VertexFormat::Float, VertexAttributeValues::Float32(_) => VertexFormat::Float32,
VertexAttributeValues::Int(_) => VertexFormat::Int, VertexAttributeValues::Sint32(_) => VertexFormat::Sint32,
VertexAttributeValues::Uint(_) => VertexFormat::Uint, VertexAttributeValues::Uint32(_) => VertexFormat::Uint32,
VertexAttributeValues::Float2(_) => VertexFormat::Float2, VertexAttributeValues::Float32x2(_) => VertexFormat::Float32x2,
VertexAttributeValues::Int2(_) => VertexFormat::Int2, VertexAttributeValues::Sint32x2(_) => VertexFormat::Sint32x2,
VertexAttributeValues::Uint2(_) => VertexFormat::Uint2, VertexAttributeValues::Uint32x2(_) => VertexFormat::Uint32x2,
VertexAttributeValues::Float3(_) => VertexFormat::Float3, VertexAttributeValues::Float32x3(_) => VertexFormat::Float32x3,
VertexAttributeValues::Int3(_) => VertexFormat::Int3, VertexAttributeValues::Sint32x3(_) => VertexFormat::Sint32x3,
VertexAttributeValues::Uint3(_) => VertexFormat::Uint3, VertexAttributeValues::Uint32x3(_) => VertexFormat::Uint32x3,
VertexAttributeValues::Float4(_) => VertexFormat::Float4, VertexAttributeValues::Float32x4(_) => VertexFormat::Float32x4,
VertexAttributeValues::Int4(_) => VertexFormat::Int4, VertexAttributeValues::Sint32x4(_) => VertexFormat::Sint32x4,
VertexAttributeValues::Uint4(_) => VertexFormat::Uint4, VertexAttributeValues::Uint32x4(_) => VertexFormat::Uint32x4,
VertexAttributeValues::Short2(_) => VertexFormat::Short2, VertexAttributeValues::Sint16x2(_) => VertexFormat::Sint16x2,
VertexAttributeValues::Short2Norm(_) => VertexFormat::Short2Norm, VertexAttributeValues::Snorm16x2(_) => VertexFormat::Snorm16x2,
VertexAttributeValues::Ushort2(_) => VertexFormat::Ushort2, VertexAttributeValues::Uint16x2(_) => VertexFormat::Uint16x2,
VertexAttributeValues::Ushort2Norm(_) => VertexFormat::Ushort2Norm, VertexAttributeValues::Unorm16x2(_) => VertexFormat::Unorm16x2,
VertexAttributeValues::Short4(_) => VertexFormat::Short4, VertexAttributeValues::Sint16x4(_) => VertexFormat::Sint16x4,
VertexAttributeValues::Short4Norm(_) => VertexFormat::Short4Norm, VertexAttributeValues::Snorm16x4(_) => VertexFormat::Snorm16x4,
VertexAttributeValues::Ushort4(_) => VertexFormat::Ushort4, VertexAttributeValues::Uint16x4(_) => VertexFormat::Uint16x4,
VertexAttributeValues::Ushort4Norm(_) => VertexFormat::Ushort4Norm, VertexAttributeValues::Unorm16x4(_) => VertexFormat::Unorm16x4,
VertexAttributeValues::Char2(_) => VertexFormat::Char2, VertexAttributeValues::Sint8x2(_) => VertexFormat::Sint8x2,
VertexAttributeValues::Char2Norm(_) => VertexFormat::Char2Norm, VertexAttributeValues::Snorm8x2(_) => VertexFormat::Snorm8x2,
VertexAttributeValues::Uchar2(_) => VertexFormat::Uchar2, VertexAttributeValues::Uint8x2(_) => VertexFormat::Uint8x2,
VertexAttributeValues::Uchar2Norm(_) => VertexFormat::Uchar2Norm, VertexAttributeValues::Unorm8x2(_) => VertexFormat::Unorm8x2,
VertexAttributeValues::Char4(_) => VertexFormat::Char4, VertexAttributeValues::Sint8x4(_) => VertexFormat::Sint8x4,
VertexAttributeValues::Char4Norm(_) => VertexFormat::Char4Norm, VertexAttributeValues::Snorm8x4(_) => VertexFormat::Snorm8x4,
VertexAttributeValues::Uchar4(_) => VertexFormat::Uchar4, VertexAttributeValues::Uint8x4(_) => VertexFormat::Uint8x4,
VertexAttributeValues::Uchar4Norm(_) => VertexFormat::Uchar4Norm, VertexAttributeValues::Unorm8x4(_) => VertexFormat::Unorm8x4,
} }
} }
} }
@ -408,34 +408,34 @@ impl Mesh {
for (_, attributes) in self.attributes.iter_mut() { for (_, attributes) in self.attributes.iter_mut() {
let indices = indices.iter(); let indices = indices.iter();
match attributes { match attributes {
VertexAttributeValues::Float(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Float32(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Int(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Sint32(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Uint(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Uint32(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Float2(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Float32x2(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Int2(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Sint32x2(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Uint2(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Uint32x2(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Float3(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Float32x3(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Int3(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Sint32x3(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Uint3(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Uint32x3(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Int4(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Sint32x4(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Uint4(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Uint32x4(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Float4(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Float32x4(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Short2(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Sint16x2(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Short2Norm(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Snorm16x2(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Ushort2(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Uint16x2(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Ushort2Norm(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Unorm16x2(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Short4(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Sint16x4(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Short4Norm(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Snorm16x4(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Ushort4(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Uint16x4(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Ushort4Norm(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Unorm16x4(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Char2(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Sint8x2(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Char2Norm(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Snorm8x2(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Uchar2(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Uint8x2(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Uchar2Norm(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Unorm8x2(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Char4(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Sint8x4(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Char4Norm(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Snorm8x4(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Uchar4(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Uint8x4(vec) => *vec = duplicate(&vec, indices),
VertexAttributeValues::Uchar4Norm(vec) => *vec = duplicate(&vec, indices), VertexAttributeValues::Unorm8x4(vec) => *vec = duplicate(&vec, indices),
} }
} }
} }

86
crates/bevy_render/src/mesh/mesh/conversions.rs
View file

@ -50,79 +50,79 @@ impl FromVertexAttributeError {
impl From<Vec<f32>> for VertexAttributeValues { impl From<Vec<f32>> for VertexAttributeValues {
fn from(vec: Vec<f32>) -> Self { fn from(vec: Vec<f32>) -> Self {
VertexAttributeValues::Float(vec) VertexAttributeValues::Float32(vec)
} }
} }
impl From<Vec<i32>> for VertexAttributeValues { impl From<Vec<i32>> for VertexAttributeValues {
fn from(vec: Vec<i32>) -> Self { fn from(vec: Vec<i32>) -> Self {
VertexAttributeValues::Int(vec) VertexAttributeValues::Sint32(vec)
} }
} }
impl From<Vec<u32>> for VertexAttributeValues { impl From<Vec<u32>> for VertexAttributeValues {
fn from(vec: Vec<u32>) -> Self { fn from(vec: Vec<u32>) -> Self {
VertexAttributeValues::Uint(vec) VertexAttributeValues::Uint32(vec)
} }
} }
impl From<Vec<[f32; 2]>> for VertexAttributeValues { impl From<Vec<[f32; 2]>> for VertexAttributeValues {
fn from(vec: Vec<[f32; 2]>) -> Self { fn from(vec: Vec<[f32; 2]>) -> Self {
VertexAttributeValues::Float2(vec) VertexAttributeValues::Float32x2(vec)
} }
} }
impl From<Vec<[i32; 2]>> for VertexAttributeValues { impl From<Vec<[i32; 2]>> for VertexAttributeValues {
fn from(vec: Vec<[i32; 2]>) -> Self { fn from(vec: Vec<[i32; 2]>) -> Self {
VertexAttributeValues::Int2(vec) VertexAttributeValues::Sint32x2(vec)
} }
} }
impl From<Vec<[u32; 2]>> for VertexAttributeValues { impl From<Vec<[u32; 2]>> for VertexAttributeValues {
fn from(vec: Vec<[u32; 2]>) -> Self { fn from(vec: Vec<[u32; 2]>) -> Self {
VertexAttributeValues::Uint2(vec) VertexAttributeValues::Uint32x2(vec)
} }
} }
impl From<Vec<[f32; 3]>> for VertexAttributeValues { impl From<Vec<[f32; 3]>> for VertexAttributeValues {
fn from(vec: Vec<[f32; 3]>) -> Self { fn from(vec: Vec<[f32; 3]>) -> Self {
VertexAttributeValues::Float3(vec) VertexAttributeValues::Float32x3(vec)
} }
} }
impl From<Vec<[i32; 3]>> for VertexAttributeValues { impl From<Vec<[i32; 3]>> for VertexAttributeValues {
fn from(vec: Vec<[i32; 3]>) -> Self { fn from(vec: Vec<[i32; 3]>) -> Self {
VertexAttributeValues::Int3(vec) VertexAttributeValues::Sint32x3(vec)
} }
} }
impl From<Vec<[u32; 3]>> for VertexAttributeValues { impl From<Vec<[u32; 3]>> for VertexAttributeValues {
fn from(vec: Vec<[u32; 3]>) -> Self { fn from(vec: Vec<[u32; 3]>) -> Self {
VertexAttributeValues::Uint3(vec) VertexAttributeValues::Uint32x3(vec)
} }
} }
impl From<Vec<[f32; 4]>> for VertexAttributeValues { impl From<Vec<[f32; 4]>> for VertexAttributeValues {
fn from(vec: Vec<[f32; 4]>) -> Self { fn from(vec: Vec<[f32; 4]>) -> Self {
VertexAttributeValues::Float4(vec) VertexAttributeValues::Float32x4(vec)
} }
} }
impl From<Vec<[i32; 4]>> for VertexAttributeValues { impl From<Vec<[i32; 4]>> for VertexAttributeValues {
fn from(vec: Vec<[i32; 4]>) -> Self { fn from(vec: Vec<[i32; 4]>) -> Self {
VertexAttributeValues::Int4(vec) VertexAttributeValues::Sint32x4(vec)
} }
} }
impl From<Vec<[u32; 4]>> for VertexAttributeValues { impl From<Vec<[u32; 4]>> for VertexAttributeValues {
fn from(vec: Vec<[u32; 4]>) -> Self { fn from(vec: Vec<[u32; 4]>) -> Self {
VertexAttributeValues::Uint4(vec) VertexAttributeValues::Uint32x4(vec)
} }
} }
impl From<Vec<[u8; 4]>> for VertexAttributeValues { impl From<Vec<[u8; 4]>> for VertexAttributeValues {
fn from(vec: Vec<[u8; 4]>) -> Self { fn from(vec: Vec<[u8; 4]>) -> Self {
VertexAttributeValues::Uchar4Norm(vec) VertexAttributeValues::Unorm8x4(vec)
} }
} }
@ -131,8 +131,8 @@ impl TryFrom<VertexAttributeValues> for Vec<[u8; 4]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Uchar4(value) => Ok(value), VertexAttributeValues::Uint8x4(value) => Ok(value),
VertexAttributeValues::Uchar4Norm(value) => Ok(value), VertexAttributeValues::Unorm8x4(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -143,8 +143,8 @@ impl TryFrom<VertexAttributeValues> for Vec<[i8; 4]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Char4(value) => Ok(value), VertexAttributeValues::Sint8x4(value) => Ok(value),
VertexAttributeValues::Char4Norm(value) => Ok(value), VertexAttributeValues::Snorm8x4(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -155,8 +155,8 @@ impl TryFrom<VertexAttributeValues> for Vec<[u8; 2]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Uchar2(value) => Ok(value), VertexAttributeValues::Uint8x2(value) => Ok(value),
VertexAttributeValues::Uchar2Norm(value) => Ok(value), VertexAttributeValues::Unorm8x2(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -167,8 +167,8 @@ impl TryFrom<VertexAttributeValues> for Vec<[i8; 2]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Char2(value) => Ok(value), VertexAttributeValues::Sint8x2(value) => Ok(value),
VertexAttributeValues::Char2Norm(value) => Ok(value), VertexAttributeValues::Snorm8x2(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -179,8 +179,8 @@ impl TryFrom<VertexAttributeValues> for Vec<[i16; 4]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Short4(value) => Ok(value), VertexAttributeValues::Sint16x4(value) => Ok(value),
VertexAttributeValues::Short4Norm(value) => Ok(value), VertexAttributeValues::Snorm16x4(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -191,8 +191,8 @@ impl TryFrom<VertexAttributeValues> for Vec<[u16; 4]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Ushort4(value) => Ok(value), VertexAttributeValues::Uint16x4(value) => Ok(value),
VertexAttributeValues::Ushort4Norm(value) => Ok(value), VertexAttributeValues::Unorm16x4(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -203,8 +203,8 @@ impl TryFrom<VertexAttributeValues> for Vec<[u16; 2]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Ushort2(value) => Ok(value), VertexAttributeValues::Uint16x2(value) => Ok(value),
VertexAttributeValues::Ushort2Norm(value) => Ok(value), VertexAttributeValues::Unorm16x2(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -215,8 +215,8 @@ impl TryFrom<VertexAttributeValues> for Vec<[i16; 2]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Short2(value) => Ok(value), VertexAttributeValues::Sint16x2(value) => Ok(value),
VertexAttributeValues::Short2Norm(value) => Ok(value), VertexAttributeValues::Snorm16x2(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -227,7 +227,7 @@ impl TryFrom<VertexAttributeValues> for Vec<[u32; 4]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Uint4(value) => Ok(value), VertexAttributeValues::Uint32x4(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -238,7 +238,7 @@ impl TryFrom<VertexAttributeValues> for Vec<[i32; 4]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Int4(value) => Ok(value), VertexAttributeValues::Sint32x4(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -249,7 +249,7 @@ impl TryFrom<VertexAttributeValues> for Vec<[f32; 4]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Float4(value) => Ok(value), VertexAttributeValues::Float32x4(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -260,7 +260,7 @@ impl TryFrom<VertexAttributeValues> for Vec<[u32; 3]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Uint3(value) => Ok(value), VertexAttributeValues::Uint32x3(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -271,7 +271,7 @@ impl TryFrom<VertexAttributeValues> for Vec<[i32; 3]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Int3(value) => Ok(value), VertexAttributeValues::Sint32x3(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -282,7 +282,7 @@ impl TryFrom<VertexAttributeValues> for Vec<[f32; 3]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Float3(value) => Ok(value), VertexAttributeValues::Float32x3(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -293,7 +293,7 @@ impl TryFrom<VertexAttributeValues> for Vec<[u32; 2]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Uint2(value) => Ok(value), VertexAttributeValues::Uint32x2(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -304,7 +304,7 @@ impl TryFrom<VertexAttributeValues> for Vec<[i32; 2]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Int2(value) => Ok(value), VertexAttributeValues::Sint32x2(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -315,7 +315,7 @@ impl TryFrom<VertexAttributeValues> for Vec<[f32; 2]> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Float2(value) => Ok(value), VertexAttributeValues::Float32x2(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -326,7 +326,7 @@ impl TryFrom<VertexAttributeValues> for Vec<u32> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Uint(value) => Ok(value), VertexAttributeValues::Uint32(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -337,7 +337,7 @@ impl TryFrom<VertexAttributeValues> for Vec<i32> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Int(value) => Ok(value), VertexAttributeValues::Sint32(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -348,7 +348,7 @@ impl TryFrom<VertexAttributeValues> for Vec<f32> {
fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> { fn try_from(value: VertexAttributeValues) -> Result<Self, Self::Error> {
match value { match value {
VertexAttributeValues::Float(value) => Ok(value), VertexAttributeValues::Float32(value) => Ok(value),
_ => Err(FromVertexAttributeError::new::<Self>(value)), _ => Err(FromVertexAttributeError::new::<Self>(value)),
} }
} }
@ -513,9 +513,9 @@ mod tests {
}; };
assert_eq!( assert_eq!(
format!("{}", error), format!("{}", error),
"cannot convert VertexAttributeValues::Uint4 to alloc::vec::Vec<u32>" "cannot convert VertexAttributeValues::Uint32x4 to alloc::vec::Vec<u32>"
); );
assert_eq!(format!("{:?}", error), assert_eq!(format!("{:?}", error),
"FromVertexAttributeError { from: Uint4([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]), variant: \"Uint4\", into: \"alloc::vec::Vec<u32>\" }"); "FromVertexAttributeError { from: Uint32x4([[0, 0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0]]), variant: \"Uint32x4\", into: \"alloc::vec::Vec<u32>\" }");
} }
} }

8
crates/bevy_render/src/pass/pass.rs
View file

@ -28,7 +28,7 @@ impl Default for ClearColor {
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct RenderPassColorAttachmentDescriptor { pub struct RenderPassColorAttachment {
/// The actual color attachment. /// The actual color attachment.
pub attachment: TextureAttachment, pub attachment: TextureAttachment,
@ -40,7 +40,7 @@ pub struct RenderPassColorAttachmentDescriptor {
} }
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct RenderPassDepthStencilAttachmentDescriptor { pub struct RenderPassDepthStencilAttachment {
pub attachment: TextureAttachment, pub attachment: TextureAttachment,
/// What operations will be performed on the depth part of the attachment. /// What operations will be performed on the depth part of the attachment.
pub depth_ops: Option<Operations<f32>>, pub depth_ops: Option<Operations<f32>>,
@ -51,7 +51,7 @@ pub struct RenderPassDepthStencilAttachmentDescriptor {
// A set of pipeline bindings and draw calls with color and depth outputs // A set of pipeline bindings and draw calls with color and depth outputs
#[derive(Debug, Clone)] #[derive(Debug, Clone)]
pub struct PassDescriptor { pub struct PassDescriptor {
pub color_attachments: Vec<RenderPassColorAttachmentDescriptor>, pub color_attachments: Vec<RenderPassColorAttachment>,
pub depth_stencil_attachment: Option<RenderPassDepthStencilAttachmentDescriptor>, pub depth_stencil_attachment: Option<RenderPassDepthStencilAttachment>,
pub sample_count: u32, pub sample_count: u32,
} }

21
crates/bevy_render/src/pipeline/pipeline.rs
View file

@ -1,14 +1,14 @@
use super::{ use super::{
state_descriptors::{ state_descriptors::{
BlendFactor, BlendOperation, ColorWrite, CompareFunction, CullMode, FrontFace, BlendFactor, BlendOperation, ColorWrite, CompareFunction, Face, FrontFace,
PrimitiveTopology, PrimitiveTopology,
}, },
PipelineLayout, PipelineLayout,
}; };
use crate::{ use crate::{
pipeline::{ pipeline::{
BlendState, ColorTargetState, DepthBiasState, DepthStencilState, MultisampleState, BlendComponent, BlendState, ColorTargetState, DepthBiasState, DepthStencilState,
PolygonMode, PrimitiveState, StencilFaceState, StencilState, MultisampleState, PolygonMode, PrimitiveState, StencilFaceState, StencilState,
}, },
shader::ShaderStages, shader::ShaderStages,
texture::TextureFormat, texture::TextureFormat,
@ -41,8 +41,10 @@ impl PipelineDescriptor {
topology: PrimitiveTopology::TriangleList, topology: PrimitiveTopology::TriangleList,
strip_index_format: None, strip_index_format: None,
front_face: FrontFace::Ccw, front_face: FrontFace::Ccw,
cull_mode: CullMode::Back, cull_mode: Some(Face::Back),
polygon_mode: PolygonMode::Fill, polygon_mode: PolygonMode::Fill,
clamp_depth: false,
conservative: false,
}, },
multisample: MultisampleState { multisample: MultisampleState {
count: 1, count: 1,
@ -59,8 +61,10 @@ impl PipelineDescriptor {
topology: PrimitiveTopology::TriangleList, topology: PrimitiveTopology::TriangleList,
strip_index_format: None, strip_index_format: None,
front_face: FrontFace::Ccw, front_face: FrontFace::Ccw,
cull_mode: CullMode::Back, cull_mode: Some(Face::Back),
polygon_mode: PolygonMode::Fill, polygon_mode: PolygonMode::Fill,
clamp_depth: false,
conservative: false,
}, },
layout: None, layout: None,
depth_stencil: Some(DepthStencilState { depth_stencil: Some(DepthStencilState {
@ -78,20 +82,21 @@ impl PipelineDescriptor {
slope_scale: 0.0, slope_scale: 0.0,
clamp: 0.0, clamp: 0.0,
}, },
clamp_depth: false,
}), }),
color_target_states: vec![ColorTargetState { color_target_states: vec![ColorTargetState {
format: TextureFormat::default(), format: TextureFormat::default(),
color_blend: BlendState { blend: Some(BlendState {
color: BlendComponent {
src_factor: BlendFactor::SrcAlpha, src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha, dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add, operation: BlendOperation::Add,
}, },
alpha_blend: BlendState { alpha: BlendComponent {
src_factor: BlendFactor::One, src_factor: BlendFactor::One,
dst_factor: BlendFactor::One, dst_factor: BlendFactor::One,
operation: BlendOperation::Add, operation: BlendOperation::Add,
}, },
}),
write_mask: ColorWrite::ALL, write_mask: ColorWrite::ALL,
}], }],
multisample: MultisampleState { multisample: MultisampleState {

47
crates/bevy_render/src/pipeline/state_descriptors.rs
View file

@ -9,7 +9,6 @@ pub struct DepthStencilState {
pub depth_compare: CompareFunction, pub depth_compare: CompareFunction,
pub stencil: StencilState, pub stencil: StencilState,
pub bias: DepthBiasState, pub bias: DepthBiasState,
pub clamp_depth: bool,
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
@ -117,16 +116,9 @@ impl Default for FrontFace {
} }
#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)] #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
pub enum CullMode { pub enum Face {
None = 0, Front = 0,
Front = 1, Back = 1,
Back = 2,
}
impl Default for CullMode {
fn default() -> Self {
CullMode::None
}
} }
#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)] #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]
@ -150,31 +142,30 @@ pub struct PrimitiveState {
pub topology: PrimitiveTopology, pub topology: PrimitiveTopology,
pub strip_index_format: Option<IndexFormat>, pub strip_index_format: Option<IndexFormat>,
pub front_face: FrontFace, pub front_face: FrontFace,
pub cull_mode: CullMode, pub cull_mode: Option<Face>,
pub polygon_mode: PolygonMode, pub polygon_mode: PolygonMode,
pub clamp_depth: bool,
pub conservative: bool,
} }
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
pub struct ColorTargetState { pub struct ColorTargetState {
pub format: TextureFormat, pub format: TextureFormat,
pub alpha_blend: BlendState, pub blend: Option<BlendState>,
pub color_blend: BlendState,
pub write_mask: ColorWrite, pub write_mask: ColorWrite,
} }
#[derive(Clone, Debug, PartialEq)] #[derive(Clone, Copy, Debug, PartialEq)]
pub struct BlendState { pub struct BlendComponent {
pub src_factor: BlendFactor, pub src_factor: BlendFactor,
pub dst_factor: BlendFactor, pub dst_factor: BlendFactor,
pub operation: BlendOperation, pub operation: BlendOperation,
} }
impl BlendState { #[derive(Clone, Copy, Debug, PartialEq)]
pub const REPLACE: Self = BlendState { pub struct BlendState {
src_factor: BlendFactor::One, pub alpha: BlendComponent,
dst_factor: BlendFactor::Zero, pub color: BlendComponent,
operation: BlendOperation::Add,
};
} }
bitflags::bitflags! { bitflags::bitflags! {
@ -199,17 +190,17 @@ impl Default for ColorWrite {
pub enum BlendFactor { pub enum BlendFactor {
Zero = 0, Zero = 0,
One = 1, One = 1,
SrcColor = 2, Src = 2,
OneMinusSrcColor = 3, OneMinusSrc = 3,
SrcAlpha = 4, SrcAlpha = 4,
OneMinusSrcAlpha = 5, OneMinusSrcAlpha = 5,
DstColor = 6, Dst = 6,
OneMinusDstColor = 7, OneMinusDst = 7,
DstAlpha = 8, DstAlpha = 8,
OneMinusDstAlpha = 9, OneMinusDstAlpha = 9,
SrcAlphaSaturated = 10, SrcAlphaSaturated = 10,
BlendColor = 11, Constant = 11,
OneMinusBlendColor = 12, OneMinusConstant = 12,
} }
#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)] #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq)]

144
crates/bevy_render/src/pipeline/vertex_format.rs
View file

@ -3,71 +3,71 @@ use bevy_math::{Mat4, Vec2, Vec3, Vec4};
use serde::{Deserialize, Serialize}; use serde::{Deserialize, Serialize};
#[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)] #[derive(Copy, Clone, Debug, Hash, Eq, PartialEq, Serialize, Deserialize)]
pub enum VertexFormat { pub enum VertexFormat {
Uchar2 = 1, Uint8x2 = 1,
Uchar4 = 3, Uint8x4 = 3,
Char2 = 5, Sint8x2 = 5,
Char4 = 7, Sint8x4 = 7,
Uchar2Norm = 9, Unorm8x2 = 9,
Uchar4Norm = 11, Unorm8x4 = 11,
Char2Norm = 14, Snorm8x2 = 14,
Char4Norm = 16, Snorm8x4 = 16,
Ushort2 = 18, Uint16x2 = 18,
Ushort4 = 20, Uint16x4 = 20,
Short2 = 22, Sint16x2 = 22,
Short4 = 24, Sint16x4 = 24,
Ushort2Norm = 26, Unorm16x2 = 26,
Ushort4Norm = 28, Unorm16x4 = 28,
Short2Norm = 30, Snorm16x2 = 30,
Short4Norm = 32, Snorm16x4 = 32,
Half2 = 34, Float16x2 = 34,
Half4 = 36, Float16x4 = 36,
Float = 37, Float32 = 37,
Float2 = 38, Float32x2 = 38,
Float3 = 39, Float32x3 = 39,
Float4 = 40, Float32x4 = 40,
Uint = 41, Uint32 = 41,
Uint2 = 42, Uint32x2 = 42,
Uint3 = 43, Uint32x3 = 43,
Uint4 = 44, Uint32x4 = 44,
Int = 45, Sint32 = 45,
Int2 = 46, Sint32x2 = 46,
Int3 = 47, Sint32x3 = 47,
Int4 = 48, Sint32x4 = 48,
} }
impl VertexFormat { impl VertexFormat {
pub fn get_size(&self) -> u64 { pub fn get_size(&self) -> u64 {
match *self { match *self {
VertexFormat::Uchar2 => 2, VertexFormat::Uint8x2 => 2,
VertexFormat::Uchar4 => 4, VertexFormat::Uint8x4 => 4,
VertexFormat::Char2 => 2, VertexFormat::Sint8x2 => 2,
VertexFormat::Char4 => 4, VertexFormat::Sint8x4 => 4,
VertexFormat::Uchar2Norm => 2, VertexFormat::Unorm8x2 => 2,
VertexFormat::Uchar4Norm => 4, VertexFormat::Unorm8x4 => 4,
VertexFormat::Char2Norm => 2, VertexFormat::Snorm8x2 => 2,
VertexFormat::Char4Norm => 4, VertexFormat::Snorm8x4 => 4,
VertexFormat::Ushort2 => 2 * 2, VertexFormat::Uint16x2 => 2 * 2,
VertexFormat::Ushort4 => 2 * 4, VertexFormat::Uint16x4 => 2 * 4,
VertexFormat::Short2 => 2 * 2, VertexFormat::Sint16x2 => 2 * 2,
VertexFormat::Short4 => 2 * 4, VertexFormat::Sint16x4 => 2 * 4,
VertexFormat::Ushort2Norm => 2 * 2, VertexFormat::Unorm16x2 => 2 * 2,
VertexFormat::Ushort4Norm => 2 * 4, VertexFormat::Unorm16x4 => 2 * 4,
VertexFormat::Short2Norm => 2 * 2, VertexFormat::Snorm16x2 => 2 * 2,
VertexFormat::Short4Norm => 2 * 4, VertexFormat::Snorm16x4 => 2 * 4,
VertexFormat::Half2 => 2 * 2, VertexFormat::Float16x2 => 2 * 2,
VertexFormat::Half4 => 2 * 4, VertexFormat::Float16x4 => 2 * 4,
VertexFormat::Float => 4, VertexFormat::Float32 => 4,
VertexFormat::Float2 => 4 * 2, VertexFormat::Float32x2 => 4 * 2,
VertexFormat::Float3 => 4 * 3, VertexFormat::Float32x3 => 4 * 3,
VertexFormat::Float4 => 4 * 4, VertexFormat::Float32x4 => 4 * 4,
VertexFormat::Uint => 4, VertexFormat::Uint32 => 4,
VertexFormat::Uint2 => 4 * 2, VertexFormat::Uint32x2 => 4 * 2,
VertexFormat::Uint3 => 4 * 3, VertexFormat::Uint32x3 => 4 * 3,
VertexFormat::Uint4 => 4 * 4, VertexFormat::Uint32x4 => 4 * 4,
VertexFormat::Int => 4, VertexFormat::Sint32 => 4,
VertexFormat::Int2 => 4 * 2, VertexFormat::Sint32x2 => 4 * 2,
VertexFormat::Int3 => 4 * 3, VertexFormat::Sint32x3 => 4 * 3,
VertexFormat::Int4 => 4 * 4, VertexFormat::Sint32x4 => 4 * 4,
} }
} }
} }
@ -78,59 +78,59 @@ pub trait AsVertexFormats {
impl AsVertexFormats for f32 { impl AsVertexFormats for f32 {
fn as_vertex_formats() -> &'static [VertexFormat] { fn as_vertex_formats() -> &'static [VertexFormat] {
&[VertexFormat::Float] &[VertexFormat::Float32]
} }
} }
impl AsVertexFormats for Vec2 { impl AsVertexFormats for Vec2 {
fn as_vertex_formats() -> &'static [VertexFormat] { fn as_vertex_formats() -> &'static [VertexFormat] {
&[VertexFormat::Float2] &[VertexFormat::Float32x2]
} }
} }
impl AsVertexFormats for Vec3 { impl AsVertexFormats for Vec3 {
fn as_vertex_formats() -> &'static [VertexFormat] { fn as_vertex_formats() -> &'static [VertexFormat] {
&[VertexFormat::Float3] &[VertexFormat::Float32x3]
} }
} }
impl AsVertexFormats for Vec4 { impl AsVertexFormats for Vec4 {
fn as_vertex_formats() -> &'static [VertexFormat] { fn as_vertex_formats() -> &'static [VertexFormat] {
&[VertexFormat::Float4] &[VertexFormat::Float32x4]
} }
} }
impl AsVertexFormats for Mat4 { impl AsVertexFormats for Mat4 {
fn as_vertex_formats() -> &'static [VertexFormat] { fn as_vertex_formats() -> &'static [VertexFormat] {
&[ &[
VertexFormat::Float4, VertexFormat::Float32x4,
VertexFormat::Float4, VertexFormat::Float32x4,
VertexFormat::Float4, VertexFormat::Float32x4,
VertexFormat::Float4, VertexFormat::Float32x4,
] ]
} }
} }
impl AsVertexFormats for Color { impl AsVertexFormats for Color {
fn as_vertex_formats() -> &'static [VertexFormat] { fn as_vertex_formats() -> &'static [VertexFormat] {
&[VertexFormat::Float4] &[VertexFormat::Float32x4]
} }
} }
impl AsVertexFormats for [f32; 2] { impl AsVertexFormats for [f32; 2] {
fn as_vertex_formats() -> &'static [VertexFormat] { fn as_vertex_formats() -> &'static [VertexFormat] {
&[VertexFormat::Float2] &[VertexFormat::Float32x2]
} }
} }
impl AsVertexFormats for [f32; 3] { impl AsVertexFormats for [f32; 3] {
fn as_vertex_formats() -> &'static [VertexFormat] { fn as_vertex_formats() -> &'static [VertexFormat] {
&[VertexFormat::Float3] &[VertexFormat::Float32x3]
} }
} }
impl AsVertexFormats for [f32; 4] { impl AsVertexFormats for [f32; 4] {
fn as_vertex_formats() -> &'static [VertexFormat] { fn as_vertex_formats() -> &'static [VertexFormat] {
&[VertexFormat::Float4] &[VertexFormat::Float32x4]
} }
} }

20
crates/bevy_render/src/render_graph/base.rs
View file

@ -4,8 +4,8 @@ use super::{
}; };
use crate::{ use crate::{
pass::{ pass::{
LoadOp, Operations, PassDescriptor, RenderPassColorAttachmentDescriptor, LoadOp, Operations, PassDescriptor, RenderPassColorAttachment,
RenderPassDepthStencilAttachmentDescriptor, TextureAttachment, RenderPassDepthStencilAttachment, TextureAttachment,
}, },
texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsage}, texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsage},
Color, Color,
@ -31,20 +31,20 @@ impl Default for Msaa {
} }
impl Msaa { impl Msaa {
pub fn color_attachment_descriptor( pub fn color_attachment(
&self, &self,
attachment: TextureAttachment, attachment: TextureAttachment,
resolve_target: TextureAttachment, resolve_target: TextureAttachment,
ops: Operations<Color>, ops: Operations<Color>,
) -> RenderPassColorAttachmentDescriptor { ) -> RenderPassColorAttachment {
if self.samples > 1 { if self.samples > 1 {
RenderPassColorAttachmentDescriptor { RenderPassColorAttachment {
attachment, attachment,
resolve_target: Some(resolve_target), resolve_target: Some(resolve_target),
ops, ops,
} }
} else { } else {
RenderPassColorAttachmentDescriptor { RenderPassColorAttachment {
attachment, attachment,
resolve_target: None, resolve_target: None,
ops, ops,
@ -117,7 +117,7 @@ pub(crate) fn add_base_graph(config: &BaseRenderGraphConfig, world: &mut World)
WindowId::primary(), WindowId::primary(),
TextureDescriptor { TextureDescriptor {
size: Extent3d { size: Extent3d {
depth: 1, depth_or_array_layers: 1,
width: 1, width: 1,
height: 1, height: 1,
}, },
@ -134,7 +134,7 @@ pub(crate) fn add_base_graph(config: &BaseRenderGraphConfig, world: &mut World)
if config.add_main_pass { if config.add_main_pass {
let mut main_pass_node = PassNode::<&MainPass>::new(PassDescriptor { let mut main_pass_node = PassNode::<&MainPass>::new(PassDescriptor {
color_attachments: vec![msaa.color_attachment_descriptor( color_attachments: vec![msaa.color_attachment(
TextureAttachment::Input("color_attachment".to_string()), TextureAttachment::Input("color_attachment".to_string()),
TextureAttachment::Input("color_resolve_target".to_string()), TextureAttachment::Input("color_resolve_target".to_string()),
Operations { Operations {
@ -142,7 +142,7 @@ pub(crate) fn add_base_graph(config: &BaseRenderGraphConfig, world: &mut World)
store: true, store: true,
}, },
)], )],
depth_stencil_attachment: Some(RenderPassDepthStencilAttachmentDescriptor { depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
attachment: TextureAttachment::Input("depth".to_string()), attachment: TextureAttachment::Input("depth".to_string()),
depth_ops: Some(Operations { depth_ops: Some(Operations {
load: LoadOp::Clear(1.0), load: LoadOp::Clear(1.0),
@ -212,7 +212,7 @@ pub(crate) fn add_base_graph(config: &BaseRenderGraphConfig, world: &mut World)
WindowId::primary(), WindowId::primary(),
TextureDescriptor { TextureDescriptor {
size: Extent3d { size: Extent3d {
depth: 1, depth_or_array_layers: 1,
width: 1, width: 1,
height: 1, height: 1,
}, },

3
crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
View file

@ -42,7 +42,8 @@ impl Node for TextureCopyNode {
format_size format_size
* aligned_width * aligned_width
* texture.size.height as usize * texture.size.height as usize
* texture.size.depth as usize * texture.size.depth_or_array_layers
as usize
]; ];
texture texture
.data .data

52
crates/bevy_render/src/shader/shader_reflect.rs
View file

@ -148,7 +148,7 @@ fn reflect_binding(
&binding.name, &binding.name,
BindType::Sampler { BindType::Sampler {
comparison: false, comparison: false,
filtering: false, filtering: true,
}, },
), ),
_ => panic!("Unsupported bind type {:?}.", binding.descriptor_type), _ => panic!("Unsupported bind type {:?}.", binding.descriptor_type),
@ -269,28 +269,28 @@ fn reflect_vertex_format(type_description: &ReflectTypeDescription) -> VertexFor
let width = traits.numeric.scalar.width; let width = traits.numeric.scalar.width;
match (number_type, traits.numeric.vector.component_count, width) { match (number_type, traits.numeric.vector.component_count, width) {
(NumberType::UInt, 2, 8) => VertexFormat::Uchar2, (NumberType::UInt, 2, 8) => VertexFormat::Uint8x2,
(NumberType::UInt, 4, 8) => VertexFormat::Uchar4, (NumberType::UInt, 4, 8) => VertexFormat::Uint8x4,
(NumberType::Int, 2, 8) => VertexFormat::Char2, (NumberType::Int, 2, 8) => VertexFormat::Sint8x2,
(NumberType::Int, 4, 8) => VertexFormat::Char4, (NumberType::Int, 4, 8) => VertexFormat::Sint8x4,
(NumberType::UInt, 2, 16) => VertexFormat::Ushort2, (NumberType::UInt, 2, 16) => VertexFormat::Uint16x2,
(NumberType::UInt, 4, 16) => VertexFormat::Ushort4, (NumberType::UInt, 4, 16) => VertexFormat::Uint16x4,
(NumberType::Int, 2, 16) => VertexFormat::Short2, (NumberType::Int, 2, 16) => VertexFormat::Sint16x2,
(NumberType::Int, 8, 16) => VertexFormat::Short4, (NumberType::Int, 8, 16) => VertexFormat::Sint16x4,
(NumberType::Float, 2, 16) => VertexFormat::Half2, (NumberType::Float, 2, 16) => VertexFormat::Float16x2,
(NumberType::Float, 4, 16) => VertexFormat::Half4, (NumberType::Float, 4, 16) => VertexFormat::Float16x4,
(NumberType::Float, 0, 32) => VertexFormat::Float, (NumberType::Float, 0, 32) => VertexFormat::Float32,
(NumberType::Float, 2, 32) => VertexFormat::Float2, (NumberType::Float, 2, 32) => VertexFormat::Float32x2,
(NumberType::Float, 3, 32) => VertexFormat::Float3, (NumberType::Float, 3, 32) => VertexFormat::Float32x3,
(NumberType::Float, 4, 32) => VertexFormat::Float4, (NumberType::Float, 4, 32) => VertexFormat::Float32x4,
(NumberType::UInt, 0, 32) => VertexFormat::Uint, (NumberType::UInt, 0, 32) => VertexFormat::Uint32,
(NumberType::UInt, 2, 32) => VertexFormat::Uint2, (NumberType::UInt, 2, 32) => VertexFormat::Uint32x2,
(NumberType::UInt, 3, 32) => VertexFormat::Uint3, (NumberType::UInt, 3, 32) => VertexFormat::Uint32x3,
(NumberType::UInt, 4, 32) => VertexFormat::Uint4, (NumberType::UInt, 4, 32) => VertexFormat::Uint32x4,
(NumberType::Int, 0, 32) => VertexFormat::Int, (NumberType::Int, 0, 32) => VertexFormat::Sint32,
(NumberType::Int, 2, 32) => VertexFormat::Int2, (NumberType::Int, 2, 32) => VertexFormat::Sint32x2,
(NumberType::Int, 3, 32) => VertexFormat::Int3, (NumberType::Int, 3, 32) => VertexFormat::Sint32x3,
(NumberType::Int, 4, 32) => VertexFormat::Int4, (NumberType::Int, 4, 32) => VertexFormat::Sint32x4,
(number_type, component_count, width) => panic!( (number_type, component_count, width) => panic!(
"unexpected uniform property format {:?} {} {}", "unexpected uniform property format {:?} {} {}",
number_type, component_count, width number_type, component_count, width
@ -343,7 +343,7 @@ mod tests {
VertexBufferLayout::new_from_attribute( VertexBufferLayout::new_from_attribute(
VertexAttribute { VertexAttribute {
name: "Vertex_Position".into(), name: "Vertex_Position".into(),
format: VertexFormat::Float4, format: VertexFormat::Float32x4,
offset: 0, offset: 0,
shader_location: 0, shader_location: 0,
}, },
@ -353,7 +353,7 @@ mod tests {
VertexBufferLayout::new_from_attribute( VertexBufferLayout::new_from_attribute(
VertexAttribute { VertexAttribute {
name: "Vertex_Normal".into(), name: "Vertex_Normal".into(),
format: VertexFormat::Uint4, format: VertexFormat::Uint32x4,
offset: 0, offset: 0,
shader_location: 1, shader_location: 1,
}, },
@ -363,7 +363,7 @@ mod tests {
VertexBufferLayout::new_from_attribute( VertexBufferLayout::new_from_attribute(
VertexAttribute { VertexAttribute {
name: "I_TestInstancing_Property".into(), name: "I_TestInstancing_Property".into(),
format: VertexFormat::Uint4, format: VertexFormat::Uint32x4,
offset: 0, offset: 0,
shader_location: 2, shader_location: 2,
}, },

6
crates/bevy_render/src/texture/texture.rs
View file

@ -31,7 +31,7 @@ impl Default for Texture {
size: Extent3d { size: Extent3d {
width: 1, width: 1,
height: 1, height: 1,
depth: 1, depth_or_array_layers: 1,
}, },
format: TextureFormat::Rgba8UnormSrgb, format: TextureFormat::Rgba8UnormSrgb,
dimension: TextureDimension::D2, dimension: TextureDimension::D2,
@ -119,13 +119,13 @@ impl Texture {
pub fn reinterpret_stacked_2d_as_array(&mut self, layers: u32) { pub fn reinterpret_stacked_2d_as_array(&mut self, layers: u32) {
// Must be a stacked image, and the height must be divisible by layers. // Must be a stacked image, and the height must be divisible by layers.
assert!(self.dimension == TextureDimension::D2); assert!(self.dimension == TextureDimension::D2);
assert!(self.size.depth == 1); assert!(self.size.depth_or_array_layers == 1);
assert_eq!(self.size.height % layers, 0); assert_eq!(self.size.height % layers, 0);
self.reinterpret_size(Extent3d { self.reinterpret_size(Extent3d {
width: self.size.width, width: self.size.width,
height: self.size.height / layers, height: self.size.height / layers,
depth: layers, depth_or_array_layers: layers,
}); });
} }

2
crates/bevy_render/src/texture/texture_descriptor.rs
View file

@ -30,7 +30,7 @@ impl Default for TextureDescriptor {
size: Extent3d { size: Extent3d {
width: 1, width: 1,
height: 1, height: 1,
depth: 1, depth_or_array_layers: 1,
}, },
mip_level_count: 1, mip_level_count: 1,
sample_count: 1, sample_count: 1,

14
crates/bevy_render/src/texture/texture_dimension.rs
View file

@ -26,24 +26,28 @@ pub enum TextureDimension {
pub struct Extent3d { pub struct Extent3d {
pub width: u32, pub width: u32,
pub height: u32, pub height: u32,
pub depth: u32, pub depth_or_array_layers: u32,
} }
impl Extent3d { impl Extent3d {
pub fn new(width: u32, height: u32, depth: u32) -> Self { pub fn new(width: u32, height: u32, depth_or_array_layers: u32) -> Self {
Self { Self {
width, width,
height, height,
depth, depth_or_array_layers,
} }
} }
pub fn volume(&self) -> usize { pub fn volume(&self) -> usize {
(self.width * self.height * self.depth) as usize (self.width * self.height * self.depth_or_array_layers) as usize
} }
pub fn as_vec3(&self) -> Vec3 { pub fn as_vec3(&self) -> Vec3 {
Vec3::new(self.width as f32, self.height as f32, self.depth as f32) Vec3::new(
self.width as f32,
self.height as f32,
self.depth_or_array_layers as f32,
)
} }
} }

8
crates/bevy_render/src/wireframe/pipeline.rs
View file

@ -1,7 +1,5 @@
use crate::{ use crate::{
pipeline::{ pipeline::{FrontFace, PipelineDescriptor, PolygonMode, PrimitiveState, PrimitiveTopology},
CullMode, FrontFace, PipelineDescriptor, PolygonMode, PrimitiveState, PrimitiveTopology,
},
shader::{Shader, ShaderStage, ShaderStages}, shader::{Shader, ShaderStage, ShaderStages},
}; };
use bevy_asset::Assets; use bevy_asset::Assets;
@ -13,8 +11,10 @@ pub(crate) fn build_wireframe_pipeline(shaders: &mut Assets<Shader>) -> Pipeline
topology: PrimitiveTopology::TriangleList, topology: PrimitiveTopology::TriangleList,
strip_index_format: None, strip_index_format: None,
front_face: FrontFace::Ccw, front_face: FrontFace::Ccw,
cull_mode: CullMode::None, cull_mode: None,
polygon_mode: PolygonMode::Line, polygon_mode: PolygonMode::Line,
clamp_depth: false,
conservative: false,
}, },
..PipelineDescriptor::default_config(ShaderStages { ..PipelineDescriptor::default_config(ShaderStages {
vertex: shaders.add(Shader::from_glsl( vertex: shaders.add(Shader::from_glsl(

28
crates/bevy_sprite/src/render/mod.rs
View file

@ -3,9 +3,9 @@ use bevy_asset::{Assets, HandleUntyped};
use bevy_reflect::TypeUuid; use bevy_reflect::TypeUuid;
use bevy_render::{ use bevy_render::{
pipeline::{ pipeline::{
BlendFactor, BlendOperation, BlendState, ColorTargetState, ColorWrite, CompareFunction, BlendComponent, BlendFactor, BlendOperation, BlendState, ColorTargetState, ColorWrite,
CullMode, DepthBiasState, DepthStencilState, FrontFace, PipelineDescriptor, PolygonMode, CompareFunction, DepthBiasState, DepthStencilState, FrontFace, PipelineDescriptor,
PrimitiveState, PrimitiveTopology, StencilFaceState, StencilState, PolygonMode, PrimitiveState, PrimitiveTopology, StencilFaceState, StencilState,
}, },
render_graph::{base, AssetRenderResourcesNode, RenderGraph, RenderResourcesNode}, render_graph::{base, AssetRenderResourcesNode, RenderGraph, RenderResourcesNode},
shader::{Shader, ShaderStage, ShaderStages}, shader::{Shader, ShaderStage, ShaderStages},
@ -35,28 +35,31 @@ pub fn build_sprite_sheet_pipeline(shaders: &mut Assets<Shader>) -> PipelineDesc
slope_scale: 0.0, slope_scale: 0.0,
clamp: 0.0, clamp: 0.0,
}, },
clamp_depth: false,
}), }),
color_target_states: vec![ColorTargetState { color_target_states: vec![ColorTargetState {
format: TextureFormat::default(), format: TextureFormat::default(),
color_blend: BlendState { blend: Some(BlendState {
color: BlendComponent {
src_factor: BlendFactor::SrcAlpha, src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha, dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add, operation: BlendOperation::Add,
}, },
alpha_blend: BlendState { alpha: BlendComponent {
src_factor: BlendFactor::One, src_factor: BlendFactor::One,
dst_factor: BlendFactor::One, dst_factor: BlendFactor::One,
operation: BlendOperation::Add, operation: BlendOperation::Add,
}, },
}),
write_mask: ColorWrite::ALL, write_mask: ColorWrite::ALL,
}], }],
primitive: PrimitiveState { primitive: PrimitiveState {
topology: PrimitiveTopology::TriangleList, topology: PrimitiveTopology::TriangleList,
strip_index_format: None, strip_index_format: None,
front_face: FrontFace::Ccw, front_face: FrontFace::Ccw,
cull_mode: CullMode::None, cull_mode: None,
polygon_mode: PolygonMode::Fill, polygon_mode: PolygonMode::Fill,
clamp_depth: false,
conservative: false,
}, },
..PipelineDescriptor::new(ShaderStages { ..PipelineDescriptor::new(ShaderStages {
vertex: shaders.add(Shader::from_glsl( vertex: shaders.add(Shader::from_glsl(
@ -88,28 +91,31 @@ pub fn build_sprite_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor
slope_scale: 0.0, slope_scale: 0.0,
clamp: 0.0, clamp: 0.0,
}, },
clamp_depth: false,
}), }),
color_target_states: vec![ColorTargetState { color_target_states: vec![ColorTargetState {
format: TextureFormat::default(), format: TextureFormat::default(),
color_blend: BlendState { blend: Some(BlendState {
color: BlendComponent {
src_factor: BlendFactor::SrcAlpha, src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha, dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add, operation: BlendOperation::Add,
}, },
alpha_blend: BlendState { alpha: BlendComponent {
src_factor: BlendFactor::One, src_factor: BlendFactor::One,
dst_factor: BlendFactor::One, dst_factor: BlendFactor::One,
operation: BlendOperation::Add, operation: BlendOperation::Add,
}, },
}),
write_mask: ColorWrite::ALL, write_mask: ColorWrite::ALL,
}], }],
primitive: PrimitiveState { primitive: PrimitiveState {
topology: PrimitiveTopology::TriangleList, topology: PrimitiveTopology::TriangleList,
strip_index_format: None, strip_index_format: None,
front_face: FrontFace::Ccw, front_face: FrontFace::Ccw,
cull_mode: CullMode::None, cull_mode: None,
polygon_mode: PolygonMode::Fill, polygon_mode: PolygonMode::Fill,
clamp_depth: false,
conservative: false,
}, },
..PipelineDescriptor::new(ShaderStages { ..PipelineDescriptor::new(ShaderStages {
vertex: shaders.add(Shader::from_glsl( vertex: shaders.add(Shader::from_glsl(

14
crates/bevy_ui/src/render/mod.rs
View file

@ -5,8 +5,7 @@ use bevy_reflect::TypeUuid;
use bevy_render::{ use bevy_render::{
camera::ActiveCameras, camera::ActiveCameras,
pass::{ pass::{
LoadOp, Operations, PassDescriptor, RenderPassDepthStencilAttachmentDescriptor, LoadOp, Operations, PassDescriptor, RenderPassDepthStencilAttachment, TextureAttachment,
TextureAttachment,
}, },
pipeline::*, pipeline::*,
prelude::Msaa, prelude::Msaa,
@ -38,20 +37,21 @@ pub fn build_ui_pipeline(shaders: &mut Assets<Shader>) -> PipelineDescriptor {
slope_scale: 0.0, slope_scale: 0.0,
clamp: 0.0, clamp: 0.0,
}, },
clamp_depth: false,
}), }),
color_target_states: vec![ColorTargetState { color_target_states: vec![ColorTargetState {
format: TextureFormat::default(), format: TextureFormat::default(),
color_blend: BlendState { blend: Some(BlendState {
color: BlendComponent {
src_factor: BlendFactor::SrcAlpha, src_factor: BlendFactor::SrcAlpha,
dst_factor: BlendFactor::OneMinusSrcAlpha, dst_factor: BlendFactor::OneMinusSrcAlpha,
operation: BlendOperation::Add, operation: BlendOperation::Add,
}, },
alpha_blend: BlendState { alpha: BlendComponent {
src_factor: BlendFactor::One, src_factor: BlendFactor::One,
dst_factor: BlendFactor::One, dst_factor: BlendFactor::One,
operation: BlendOperation::Add, operation: BlendOperation::Add,
}, },
}),
write_mask: ColorWrite::ALL, write_mask: ColorWrite::ALL,
}], }],
..PipelineDescriptor::new(ShaderStages { ..PipelineDescriptor::new(ShaderStages {
@ -90,7 +90,7 @@ pub(crate) fn add_ui_graph(world: &mut World) {
pipelines.set_untracked(UI_PIPELINE_HANDLE, build_ui_pipeline(&mut shaders)); pipelines.set_untracked(UI_PIPELINE_HANDLE, build_ui_pipeline(&mut shaders));
let mut ui_pass_node = PassNode::<&Node>::new(PassDescriptor { let mut ui_pass_node = PassNode::<&Node>::new(PassDescriptor {
color_attachments: vec![msaa.color_attachment_descriptor( color_attachments: vec![msaa.color_attachment(
TextureAttachment::Input("color_attachment".to_string()), TextureAttachment::Input("color_attachment".to_string()),
TextureAttachment::Input("color_resolve_target".to_string()), TextureAttachment::Input("color_resolve_target".to_string()),
Operations { Operations {
@ -98,7 +98,7 @@ pub(crate) fn add_ui_graph(world: &mut World) {
store: true, store: true,
}, },
)], )],
depth_stencil_attachment: Some(RenderPassDepthStencilAttachmentDescriptor { depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
attachment: TextureAttachment::Input("depth".to_string()), attachment: TextureAttachment::Input("depth".to_string()),
depth_ops: Some(Operations { depth_ops: Some(Operations {
load: LoadOp::Clear(1.0), load: LoadOp::Clear(1.0),

2
crates/bevy_wgpu/Cargo.toml
View file

@ -29,7 +29,7 @@ bevy_winit = { path = "../bevy_winit", optional = true, version = "0.5.0" }
bevy_utils = { path = "../bevy_utils", version = "0.5.0" } bevy_utils = { path = "../bevy_utils", version = "0.5.0" }
# other # other
wgpu = "0.7" wgpu = "0.8"
futures-lite = "1.4.0" futures-lite = "1.4.0"
crossbeam-channel = "0.5.0" crossbeam-channel = "0.5.0"
crossbeam-utils = "0.8.1" crossbeam-utils = "0.8.1"

16
crates/bevy_wgpu/src/lib.rs
View file

@ -62,6 +62,14 @@ pub struct WgpuLimits {
pub max_uniform_buffers_per_shader_stage: u32, pub max_uniform_buffers_per_shader_stage: u32,
pub max_uniform_buffer_binding_size: u32, pub max_uniform_buffer_binding_size: u32,
pub max_push_constant_size: u32, pub max_push_constant_size: u32,
pub max_texture_dimension_1d: u32,
pub max_texture_dimension_2d: u32,
pub max_texture_dimension_3d: u32,
pub max_texture_array_layers: u32,
pub max_storage_buffer_binding_size: u32,
pub max_vertex_buffers: u32,
pub max_vertex_attributes: u32,
pub max_vertex_buffer_array_stride: u32,
} }
impl Default for WgpuLimits { impl Default for WgpuLimits {
@ -80,6 +88,14 @@ impl Default for WgpuLimits {
max_uniform_buffers_per_shader_stage: default.max_uniform_buffers_per_shader_stage, max_uniform_buffers_per_shader_stage: default.max_uniform_buffers_per_shader_stage,
max_uniform_buffer_binding_size: default.max_uniform_buffer_binding_size, max_uniform_buffer_binding_size: default.max_uniform_buffer_binding_size,
max_push_constant_size: default.max_push_constant_size, max_push_constant_size: default.max_push_constant_size,
max_texture_dimension_1d: default.max_texture_dimension_1d,
max_texture_dimension_2d: default.max_texture_dimension_2d,
max_texture_dimension_3d: default.max_texture_dimension_3d,
max_texture_array_layers: default.max_texture_array_layers,
max_storage_buffer_binding_size: default.max_storage_buffer_binding_size,
max_vertex_buffers: default.max_vertex_buffers,
max_vertex_attributes: default.max_vertex_attributes,
max_vertex_buffer_array_stride: default.max_vertex_buffer_array_stride,
} }
} }
} }

52
crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
View file

@ -3,8 +3,8 @@ use crate::{wgpu_type_converter::WgpuInto, WgpuRenderPass, WgpuResourceRefs};
use bevy_render::{ use bevy_render::{
pass::{ pass::{
PassDescriptor, RenderPass, RenderPassColorAttachmentDescriptor, PassDescriptor, RenderPass, RenderPassColorAttachment, RenderPassDepthStencilAttachment,
RenderPassDepthStencilAttachmentDescriptor, TextureAttachment, TextureAttachment,
}, },
renderer::{ renderer::{
BufferId, RenderContext, RenderResourceBinding, RenderResourceBindings, BufferId, RenderContext, RenderResourceBinding, RenderResourceBindings,
@ -211,16 +211,10 @@ pub fn create_render_pass<'a, 'b>(
color_attachments: &pass_descriptor color_attachments: &pass_descriptor
.color_attachments .color_attachments
.iter() .iter()
.map(|c| { .map(|c| create_wgpu_color_attachment(global_render_resource_bindings, refs, c))
create_wgpu_color_attachment_descriptor(global_render_resource_bindings, refs, c) .collect::<Vec<wgpu::RenderPassColorAttachment>>(),
})
.collect::<Vec<wgpu::RenderPassColorAttachmentDescriptor>>(),
depth_stencil_attachment: pass_descriptor.depth_stencil_attachment.as_ref().map(|d| { depth_stencil_attachment: pass_descriptor.depth_stencil_attachment.as_ref().map(|d| {
create_wgpu_depth_stencil_attachment_descriptor( create_wgpu_depth_stencil_attachment(global_render_resource_bindings, refs, d)
global_render_resource_bindings,
refs,
d,
)
}), }),
}) })
} }
@ -242,47 +236,47 @@ fn get_texture_view<'a>(
} }
} }
fn create_wgpu_color_attachment_descriptor<'a>( fn create_wgpu_color_attachment<'a>(
global_render_resource_bindings: &RenderResourceBindings, global_render_resource_bindings: &RenderResourceBindings,
refs: &WgpuResourceRefs<'a>, refs: &WgpuResourceRefs<'a>,
color_attachment_descriptor: &RenderPassColorAttachmentDescriptor, color_attachment: &RenderPassColorAttachment,
) -> wgpu::RenderPassColorAttachmentDescriptor<'a> { ) -> wgpu::RenderPassColorAttachment<'a> {
let attachment = get_texture_view( let view = get_texture_view(
global_render_resource_bindings, global_render_resource_bindings,
refs, refs,
&color_attachment_descriptor.attachment, &color_attachment.attachment,
); );
let resolve_target = color_attachment_descriptor let resolve_target = color_attachment
.resolve_target .resolve_target
.as_ref() .as_ref()
.map(|target| get_texture_view(global_render_resource_bindings, refs, &target)); .map(|target| get_texture_view(global_render_resource_bindings, refs, &target));
wgpu::RenderPassColorAttachmentDescriptor { wgpu::RenderPassColorAttachment {
ops: (&color_attachment_descriptor.ops).wgpu_into(), ops: (&color_attachment.ops).wgpu_into(),
attachment, view,
resolve_target, resolve_target,
} }
} }
fn create_wgpu_depth_stencil_attachment_descriptor<'a>( fn create_wgpu_depth_stencil_attachment<'a>(
global_render_resource_bindings: &RenderResourceBindings, global_render_resource_bindings: &RenderResourceBindings,
refs: &WgpuResourceRefs<'a>, refs: &WgpuResourceRefs<'a>,
depth_stencil_attachment_descriptor: &RenderPassDepthStencilAttachmentDescriptor, depth_stencil_attachment: &RenderPassDepthStencilAttachment,
) -> wgpu::RenderPassDepthStencilAttachmentDescriptor<'a> { ) -> wgpu::RenderPassDepthStencilAttachment<'a> {
let attachment = get_texture_view( let view = get_texture_view(
global_render_resource_bindings, global_render_resource_bindings,
refs, refs,
&depth_stencil_attachment_descriptor.attachment, &depth_stencil_attachment.attachment,
); );
wgpu::RenderPassDepthStencilAttachmentDescriptor { wgpu::RenderPassDepthStencilAttachment {
attachment, view,
depth_ops: depth_stencil_attachment_descriptor depth_ops: depth_stencil_attachment
.depth_ops .depth_ops
.as_ref() .as_ref()
.map(|ops| ops.wgpu_into()), .map(|ops| ops.wgpu_into()),
stencil_ops: depth_stencil_attachment_descriptor stencil_ops: depth_stencil_attachment
.stencil_ops .stencil_ops
.as_ref() .as_ref()
.map(|ops| ops.wgpu_into()), .map(|ops| ops.wgpu_into()),

35
crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs
View file

@ -16,7 +16,12 @@ use bevy_render::{
use bevy_utils::tracing::trace; use bevy_utils::tracing::trace;
use bevy_window::{Window, WindowId}; use bevy_window::{Window, WindowId};
use futures_lite::future; use futures_lite::future;
use std::{borrow::Cow, num::NonZeroU64, ops::Range, sync::Arc}; use std::{
borrow::Cow,
num::{NonZeroU32, NonZeroU64},
ops::Range,
sync::Arc,
};
use wgpu::util::DeviceExt; use wgpu::util::DeviceExt;
#[derive(Clone, Debug)] #[derive(Clone, Debug)]
@ -81,7 +86,7 @@ impl WgpuRenderResourceContext {
let source = textures.get(&source_texture).unwrap(); let source = textures.get(&source_texture).unwrap();
let destination = textures.get(&destination_texture).unwrap(); let destination = textures.get(&destination_texture).unwrap();
command_encoder.copy_texture_to_texture( command_encoder.copy_texture_to_texture(
wgpu::TextureCopyView { wgpu::ImageCopyTexture {
texture: source, texture: source,
mip_level: source_mip_level, mip_level: source_mip_level,
origin: wgpu::Origin3d { origin: wgpu::Origin3d {
@ -90,7 +95,7 @@ impl WgpuRenderResourceContext {
z: source_origin[2], z: source_origin[2],
}, },
}, },
wgpu::TextureCopyView { wgpu::ImageCopyTexture {
texture: destination, texture: destination,
mip_level: destination_mip_level, mip_level: destination_mip_level,
origin: wgpu::Origin3d { origin: wgpu::Origin3d {
@ -121,7 +126,7 @@ impl WgpuRenderResourceContext {
let source = textures.get(&source_texture).unwrap(); let source = textures.get(&source_texture).unwrap();
let destination = buffers.get(&destination_buffer).unwrap(); let destination = buffers.get(&destination_buffer).unwrap();
command_encoder.copy_texture_to_buffer( command_encoder.copy_texture_to_buffer(
wgpu::TextureCopyView { wgpu::ImageCopyTexture {
texture: source, texture: source,
mip_level: source_mip_level, mip_level: source_mip_level,
origin: wgpu::Origin3d { origin: wgpu::Origin3d {
@ -130,12 +135,12 @@ impl WgpuRenderResourceContext {
z: source_origin[2], z: source_origin[2],
}, },
}, },
wgpu::BufferCopyView { wgpu::ImageCopyBuffer {
buffer: destination, buffer: destination,
layout: wgpu::TextureDataLayout { layout: wgpu::ImageDataLayout {
offset: destination_offset, offset: destination_offset,
bytes_per_row: destination_bytes_per_row, bytes_per_row: NonZeroU32::new(destination_bytes_per_row),
rows_per_image: size.height, rows_per_image: NonZeroU32::new(size.height),
}, },
}, },
size.wgpu_into(), size.wgpu_into(),
@ -160,15 +165,15 @@ impl WgpuRenderResourceContext {
let source = buffers.get(&source_buffer).unwrap(); let source = buffers.get(&source_buffer).unwrap();
let destination = textures.get(&destination_texture).unwrap(); let destination = textures.get(&destination_texture).unwrap();
command_encoder.copy_buffer_to_texture( command_encoder.copy_buffer_to_texture(
wgpu::BufferCopyView { wgpu::ImageCopyBuffer {
buffer: source, buffer: source,
layout: wgpu::TextureDataLayout { layout: wgpu::ImageDataLayout {
offset: source_offset, offset: source_offset,
bytes_per_row: source_bytes_per_row, bytes_per_row: NonZeroU32::new(source_bytes_per_row),
rows_per_image: size.height, rows_per_image: NonZeroU32::new(size.height),
}, },
}, },
wgpu::TextureCopyView { wgpu::ImageCopyTexture {
texture: destination, texture: destination,
mip_level: destination_mip_level, mip_level: destination_mip_level,
origin: wgpu::Origin3d { origin: wgpu::Origin3d {
@ -562,11 +567,11 @@ impl RenderResourceContext for WgpuRenderResourceContext {
let wgpu_buffer = buffers.get(&buffer).unwrap(); let wgpu_buffer = buffers.get(&buffer).unwrap();
let size = NonZeroU64::new(range.end - range.start) let size = NonZeroU64::new(range.end - range.start)
.expect("Size of the buffer needs to be greater than 0!"); .expect("Size of the buffer needs to be greater than 0!");
wgpu::BindingResource::Buffer { wgpu::BindingResource::Buffer(wgpu::BufferBinding {
buffer: wgpu_buffer, buffer: wgpu_buffer,
offset: range.start, offset: range.start,
size: Some(size), size: Some(size),
} })
} }
}; };
wgpu::BindGroupEntry { wgpu::BindGroupEntry {

118
crates/bevy_wgpu/src/wgpu_type_converter.rs
View file

@ -4,7 +4,7 @@ use bevy_render::{
pass::{LoadOp, Operations}, pass::{LoadOp, Operations},
pipeline::{ pipeline::{
BindType, BlendFactor, BlendOperation, BlendState, ColorTargetState, ColorWrite, BindType, BlendFactor, BlendOperation, BlendState, ColorTargetState, ColorWrite,
CompareFunction, CullMode, DepthBiasState, DepthStencilState, FrontFace, IndexFormat, CompareFunction, DepthBiasState, DepthStencilState, Face, FrontFace, IndexFormat,
InputStepMode, MultisampleState, PolygonMode, PrimitiveState, PrimitiveTopology, InputStepMode, MultisampleState, PolygonMode, PrimitiveState, PrimitiveTopology,
StencilFaceState, StencilOperation, StencilState, VertexAttribute, VertexBufferLayout, StencilFaceState, StencilOperation, StencilState, VertexAttribute, VertexBufferLayout,
VertexFormat, VertexFormat,
@ -39,36 +39,36 @@ where
impl WgpuFrom<VertexFormat> for wgpu::VertexFormat { impl WgpuFrom<VertexFormat> for wgpu::VertexFormat {
fn from(val: VertexFormat) -> Self { fn from(val: VertexFormat) -> Self {
match val { match val {
VertexFormat::Uchar2 => wgpu::VertexFormat::Uchar2, VertexFormat::Uint8x2 => wgpu::VertexFormat::Uint8x2,
VertexFormat::Uchar4 => wgpu::VertexFormat::Uchar4, VertexFormat::Uint8x4 => wgpu::VertexFormat::Uint8x4,
VertexFormat::Char2 => wgpu::VertexFormat::Char2, VertexFormat::Sint8x2 => wgpu::VertexFormat::Sint8x2,
VertexFormat::Char4 => wgpu::VertexFormat::Char4, VertexFormat::Sint8x4 => wgpu::VertexFormat::Sint8x4,
VertexFormat::Uchar2Norm => wgpu::VertexFormat::Uchar2Norm, VertexFormat::Unorm8x2 => wgpu::VertexFormat::Unorm8x2,
VertexFormat::Uchar4Norm => wgpu::VertexFormat::Uchar4Norm, VertexFormat::Unorm8x4 => wgpu::VertexFormat::Unorm8x4,
VertexFormat::Char2Norm => wgpu::VertexFormat::Char2Norm, VertexFormat::Snorm8x2 => wgpu::VertexFormat::Snorm8x2,
VertexFormat::Char4Norm => wgpu::VertexFormat::Char4Norm, VertexFormat::Snorm8x4 => wgpu::VertexFormat::Snorm8x4,
VertexFormat::Ushort2 => wgpu::VertexFormat::Ushort2, VertexFormat::Uint16x2 => wgpu::VertexFormat::Uint16x2,
VertexFormat::Ushort4 => wgpu::VertexFormat::Ushort4, VertexFormat::Uint16x4 => wgpu::VertexFormat::Uint16x4,
VertexFormat::Short2 => wgpu::VertexFormat::Short2, VertexFormat::Sint16x2 => wgpu::VertexFormat::Sint16x2,
VertexFormat::Short4 => wgpu::VertexFormat::Short4, VertexFormat::Sint16x4 => wgpu::VertexFormat::Sint16x4,
VertexFormat::Ushort2Norm => wgpu::VertexFormat::Ushort2Norm, VertexFormat::Unorm16x2 => wgpu::VertexFormat::Unorm16x2,
VertexFormat::Ushort4Norm => wgpu::VertexFormat::Ushort4Norm, VertexFormat::Unorm16x4 => wgpu::VertexFormat::Unorm16x4,
VertexFormat::Short2Norm => wgpu::VertexFormat::Short2Norm, VertexFormat::Snorm16x2 => wgpu::VertexFormat::Snorm16x2,
VertexFormat::Short4Norm => wgpu::VertexFormat::Short4Norm, VertexFormat::Snorm16x4 => wgpu::VertexFormat::Snorm16x4,
VertexFormat::Half2 => wgpu::VertexFormat::Half2, VertexFormat::Float16x2 => wgpu::VertexFormat::Float16x2,
VertexFormat::Half4 => wgpu::VertexFormat::Half4, VertexFormat::Float16x4 => wgpu::VertexFormat::Float16x4,
VertexFormat::Float => wgpu::VertexFormat::Float, VertexFormat::Float32 => wgpu::VertexFormat::Float32,
VertexFormat::Float2 => wgpu::VertexFormat::Float2, VertexFormat::Float32x2 => wgpu::VertexFormat::Float32x2,
VertexFormat::Float3 => wgpu::VertexFormat::Float3, VertexFormat::Float32x3 => wgpu::VertexFormat::Float32x3,
VertexFormat::Float4 => wgpu::VertexFormat::Float4, VertexFormat::Float32x4 => wgpu::VertexFormat::Float32x4,
VertexFormat::Uint => wgpu::VertexFormat::Uint, VertexFormat::Uint32 => wgpu::VertexFormat::Uint32,
VertexFormat::Uint2 => wgpu::VertexFormat::Uint2, VertexFormat::Uint32x2 => wgpu::VertexFormat::Uint32x2,
VertexFormat::Uint3 => wgpu::VertexFormat::Uint3, VertexFormat::Uint32x3 => wgpu::VertexFormat::Uint32x3,
VertexFormat::Uint4 => wgpu::VertexFormat::Uint4, VertexFormat::Uint32x4 => wgpu::VertexFormat::Uint32x4,
VertexFormat::Int => wgpu::VertexFormat::Int, VertexFormat::Sint32 => wgpu::VertexFormat::Sint32,
VertexFormat::Int2 => wgpu::VertexFormat::Int2, VertexFormat::Sint32x2 => wgpu::VertexFormat::Sint32x2,
VertexFormat::Int3 => wgpu::VertexFormat::Int3, VertexFormat::Sint32x3 => wgpu::VertexFormat::Sint32x3,
VertexFormat::Int4 => wgpu::VertexFormat::Int4, VertexFormat::Sint32x4 => wgpu::VertexFormat::Sint32x4,
} }
} }
} }
@ -257,9 +257,9 @@ impl WgpuFrom<StorageTextureAccess> for wgpu::StorageTextureAccess {
impl WgpuFrom<Extent3d> for wgpu::Extent3d { impl WgpuFrom<Extent3d> for wgpu::Extent3d {
fn from(val: Extent3d) -> Self { fn from(val: Extent3d) -> Self {
wgpu::Extent3d { wgpu::Extent3d {
depth: val.depth,
height: val.height, height: val.height,
width: val.width, width: val.width,
depth_or_array_layers: val.depth_or_array_layers,
} }
} }
} }
@ -371,7 +371,6 @@ impl WgpuFrom<DepthStencilState> for wgpu::DepthStencilState {
format: val.format.wgpu_into(), format: val.format.wgpu_into(),
stencil: (&val.stencil).wgpu_into(), stencil: (&val.stencil).wgpu_into(),
bias: val.bias.wgpu_into(), bias: val.bias.wgpu_into(),
clamp_depth: val.clamp_depth,
} }
} }
} }
@ -472,12 +471,11 @@ impl WgpuFrom<FrontFace> for wgpu::FrontFace {
} }
} }
impl WgpuFrom<CullMode> for wgpu::CullMode { impl WgpuFrom<Face> for wgpu::Face {
fn from(val: CullMode) -> Self { fn from(val: Face) -> Self {
match val { match val {
CullMode::None => wgpu::CullMode::None, Face::Front => wgpu::Face::Front,
CullMode::Front => wgpu::CullMode::Front, Face::Back => wgpu::Face::Back,
CullMode::Back => wgpu::CullMode::Back,
} }
} }
} }
@ -506,9 +504,8 @@ impl WgpuFrom<&ColorTargetState> for wgpu::ColorTargetState {
fn from(val: &ColorTargetState) -> Self { fn from(val: &ColorTargetState) -> Self {
wgpu::ColorTargetState { wgpu::ColorTargetState {
format: val.format.wgpu_into(), format: val.format.wgpu_into(),
alpha_blend: (&val.alpha_blend).wgpu_into(),
color_blend: (&val.color_blend).wgpu_into(),
write_mask: val.write_mask.wgpu_into(), write_mask: val.write_mask.wgpu_into(),
blend: val.blend.map(|blend| blend.wgpu_into()),
} }
} }
} }
@ -521,8 +518,10 @@ impl WgpuFrom<PrimitiveState> for wgpu::PrimitiveState {
.strip_index_format .strip_index_format
.map(|index_format| index_format.wgpu_into()), .map(|index_format| index_format.wgpu_into()),
front_face: val.front_face.wgpu_into(), front_face: val.front_face.wgpu_into(),
cull_mode: val.cull_mode.wgpu_into(), cull_mode: val.cull_mode.map(|face| face.wgpu_into()),
polygon_mode: val.polygon_mode.wgpu_into(), polygon_mode: val.polygon_mode.wgpu_into(),
clamp_depth: val.clamp_depth,
conservative: val.conservative,
} }
} }
} }
@ -533,12 +532,19 @@ impl WgpuFrom<ColorWrite> for wgpu::ColorWrite {
} }
} }
impl WgpuFrom<&BlendState> for wgpu::BlendState { impl WgpuFrom<BlendState> for wgpu::BlendState {
fn from(val: &BlendState) -> Self { fn from(val: BlendState) -> Self {
wgpu::BlendState { wgpu::BlendState {
src_factor: val.src_factor.wgpu_into(), color: wgpu::BlendComponent {
dst_factor: val.dst_factor.wgpu_into(), src_factor: val.color.src_factor.wgpu_into(),
operation: val.operation.wgpu_into(), dst_factor: val.color.dst_factor.wgpu_into(),
operation: val.color.operation.wgpu_into(),
},
alpha: wgpu::BlendComponent {
src_factor: val.alpha.src_factor.wgpu_into(),
dst_factor: val.alpha.dst_factor.wgpu_into(),
operation: val.alpha.operation.wgpu_into(),
},
} }
} }
} }
@ -548,17 +554,17 @@ impl WgpuFrom<BlendFactor> for wgpu::BlendFactor {
match val { match val {
BlendFactor::Zero => wgpu::BlendFactor::Zero, BlendFactor::Zero => wgpu::BlendFactor::Zero,
BlendFactor::One => wgpu::BlendFactor::One, BlendFactor::One => wgpu::BlendFactor::One,
BlendFactor::SrcColor => wgpu::BlendFactor::SrcColor, BlendFactor::Src => wgpu::BlendFactor::Src,
BlendFactor::OneMinusSrcColor => wgpu::BlendFactor::OneMinusSrcColor, BlendFactor::OneMinusSrc => wgpu::BlendFactor::OneMinusSrc,
BlendFactor::SrcAlpha => wgpu::BlendFactor::SrcAlpha, BlendFactor::SrcAlpha => wgpu::BlendFactor::SrcAlpha,
BlendFactor::OneMinusSrcAlpha => wgpu::BlendFactor::OneMinusSrcAlpha, BlendFactor::OneMinusSrcAlpha => wgpu::BlendFactor::OneMinusSrcAlpha,
BlendFactor::DstColor => wgpu::BlendFactor::DstColor, BlendFactor::Dst => wgpu::BlendFactor::Dst,
BlendFactor::OneMinusDstColor => wgpu::BlendFactor::OneMinusDstColor, BlendFactor::OneMinusDst => wgpu::BlendFactor::OneMinusDst,
BlendFactor::DstAlpha => wgpu::BlendFactor::DstAlpha, BlendFactor::DstAlpha => wgpu::BlendFactor::DstAlpha,
BlendFactor::OneMinusDstAlpha => wgpu::BlendFactor::OneMinusDstAlpha, BlendFactor::OneMinusDstAlpha => wgpu::BlendFactor::OneMinusDstAlpha,
BlendFactor::SrcAlphaSaturated => wgpu::BlendFactor::SrcAlphaSaturated, BlendFactor::SrcAlphaSaturated => wgpu::BlendFactor::SrcAlphaSaturated,
BlendFactor::BlendColor => wgpu::BlendFactor::BlendColor, BlendFactor::Constant => wgpu::BlendFactor::Constant,
BlendFactor::OneMinusBlendColor => wgpu::BlendFactor::OneMinusBlendColor, BlendFactor::OneMinusConstant => wgpu::BlendFactor::OneMinusConstant,
} }
} }
} }
@ -710,6 +716,14 @@ impl WgpuFrom<WgpuLimits> for wgpu::Limits {
max_uniform_buffers_per_shader_stage: val.max_uniform_buffers_per_shader_stage, max_uniform_buffers_per_shader_stage: val.max_uniform_buffers_per_shader_stage,
max_uniform_buffer_binding_size: val.max_uniform_buffer_binding_size, max_uniform_buffer_binding_size: val.max_uniform_buffer_binding_size,
max_push_constant_size: val.max_push_constant_size, max_push_constant_size: val.max_push_constant_size,
max_texture_dimension_1d: val.max_texture_dimension_1d,
max_texture_dimension_2d: val.max_texture_dimension_2d,
max_texture_dimension_3d: val.max_texture_dimension_3d,
max_texture_array_layers: val.max_texture_array_layers,
max_storage_buffer_binding_size: val.max_storage_buffer_binding_size,
max_vertex_buffers: val.max_vertex_buffers,
max_vertex_attributes: val.max_vertex_attributes,
max_vertex_buffer_array_stride: val.max_vertex_buffer_array_stride,
} }
} }
} }

8
examples/3d/render_to_texture.rs
View file

@ -4,8 +4,8 @@ use bevy::{
render::{ render::{
camera::{ActiveCameras, Camera, CameraProjection}, camera::{ActiveCameras, Camera, CameraProjection},
pass::{ pass::{
LoadOp, Operations, PassDescriptor, RenderPassColorAttachmentDescriptor, LoadOp, Operations, PassDescriptor, RenderPassColorAttachment,
RenderPassDepthStencilAttachmentDescriptor, TextureAttachment, RenderPassDepthStencilAttachment, TextureAttachment,
}, },
render_graph::{ render_graph::{
base::{node::MAIN_PASS, MainPass}, base::{node::MAIN_PASS, MainPass},
@ -31,7 +31,7 @@ pub const FIRST_PASS_CAMERA: &str = "first_pass_camera";
fn add_render_to_texture_graph(graph: &mut RenderGraph, size: Extent3d) { fn add_render_to_texture_graph(graph: &mut RenderGraph, size: Extent3d) {
let mut pass_node = PassNode::<&FirstPass>::new(PassDescriptor { let mut pass_node = PassNode::<&FirstPass>::new(PassDescriptor {
color_attachments: vec![RenderPassColorAttachmentDescriptor { color_attachments: vec![RenderPassColorAttachment {
attachment: TextureAttachment::Input("color_attachment".to_string()), attachment: TextureAttachment::Input("color_attachment".to_string()),
resolve_target: None, resolve_target: None,
ops: Operations { ops: Operations {
@ -39,7 +39,7 @@ fn add_render_to_texture_graph(graph: &mut RenderGraph, size: Extent3d) {
store: true, store: true,
}, },
}], }],
depth_stencil_attachment: Some(RenderPassDepthStencilAttachmentDescriptor { depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
attachment: TextureAttachment::Input("depth".to_string()), attachment: TextureAttachment::Input("depth".to_string()),
depth_ops: Some(Operations { depth_ops: Some(Operations {
load: LoadOp::Clear(1.0), load: LoadOp::Clear(1.0),

6
examples/window/multiple_windows.rs
View file

@ -102,7 +102,7 @@ fn setup_pipeline(
// add a new render pass for our new window / camera // add a new render pass for our new window / camera
let mut second_window_pass = PassNode::<&MainPass>::new(PassDescriptor { let mut second_window_pass = PassNode::<&MainPass>::new(PassDescriptor {
color_attachments: vec![msaa.color_attachment_descriptor( color_attachments: vec![msaa.color_attachment(
TextureAttachment::Input("color_attachment".to_string()), TextureAttachment::Input("color_attachment".to_string()),
TextureAttachment::Input("color_resolve_target".to_string()), TextureAttachment::Input("color_resolve_target".to_string()),
Operations { Operations {
@ -110,7 +110,7 @@ fn setup_pipeline(
store: true, store: true,
}, },
)], )],
depth_stencil_attachment: Some(RenderPassDepthStencilAttachmentDescriptor { depth_stencil_attachment: Some(RenderPassDepthStencilAttachment {
attachment: TextureAttachment::Input("depth".to_string()), attachment: TextureAttachment::Input("depth".to_string()),
depth_ops: Some(Operations { depth_ops: Some(Operations {
load: LoadOp::Clear(1.0), load: LoadOp::Clear(1.0),
@ -159,7 +159,7 @@ fn setup_pipeline(
window_id, window_id,
TextureDescriptor { TextureDescriptor {
size: Extent3d { size: Extent3d {
depth: 1, depth_or_array_layers: 1,
width: 1, width: 1,
height: 1, height: 1,
}, },