mirror of
https://github.com/storytold/wgpu.git
synced 2026-11-20 14:31:08 +01:00
Add per-vertex attribute support to vulkan, spir-v and wgsl. (#8821)
Co-authored-by: Connor Fitzgerald <connorwadefitzgerald@gmail.com>
This commit is contained in:
1 parent
fc9060f510
commit
4a3526a745
26 files changed
+476
-15
No files matched your search
@@ -44,6 +44,7 @@ Bottom level categories:
|
||||
### New Features
|
||||
|
||||
- Added support for cooperative load/store operations in shaders. Currently only WGSL on the input and SPIR-V, METAL, and WGSL on the output are supported. By @kvark in [#8251](https://github.com/gfx-rs/wgpu/issues/8251).
|
||||
- Added support for per-vertex attributes in fragment shaders. Currently only WGSL input is supported, and only SPIR-V or WGSL output is supported. By @atlv24 in [#8821](https://github.com/gfx-rs/wgpu/issues/8821).
|
||||
- Added support for no-perspective barycentric coordinates. By @atlv24 in [#8852](https://github.com/gfx-rs/wgpu/issues/8852).
|
||||
- Added support for obtaining `AdapterInfo` from `Device`. By @sagudev in [#8807](https://github.com/gfx-rs/wgpu/pull/8807).
|
||||
- Added `Limits::or_worse_values_from`. By @atlv24 in [#8870](https://github.com/gfx-rs/wgpu/pull/8870).
|
||||
|
||||
@@ -160,6 +160,7 @@ pub(in crate::back::glsl) const fn glsl_interpolation(
|
||||
I::Perspective => "smooth",
|
||||
I::Linear => "noperspective",
|
||||
I::Flat => "flat",
|
||||
I::PerVertex => unreachable!(),
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -205,6 +205,7 @@ impl crate::Interpolation {
|
||||
Self::Perspective => None,
|
||||
Self::Linear => Some("noperspective"),
|
||||
Self::Flat => Some("nointerpolation"),
|
||||
Self::PerVertex => unreachable!(),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -2987,6 +2987,14 @@ impl Writer {
|
||||
Some(crate::Interpolation::Linear) => {
|
||||
others.push(Decoration::NoPerspective);
|
||||
}
|
||||
Some(crate::Interpolation::PerVertex) => {
|
||||
others.push(Decoration::PerVertexKHR);
|
||||
self.require_any(
|
||||
"`per_vertex` interpolation",
|
||||
&[spirv::Capability::FragmentBarycentricKHR],
|
||||
)?;
|
||||
self.use_extension("SPV_KHR_fragment_shader_barycentric");
|
||||
}
|
||||
}
|
||||
match sampling {
|
||||
// Center sampling is the default in SPIR-V.
|
||||
|
||||
@@ -211,6 +211,7 @@ impl ToWgsl for crate::Interpolation {
|
||||
crate::Interpolation::Perspective => "perspective",
|
||||
crate::Interpolation::Linear => "linear",
|
||||
crate::Interpolation::Flat => "flat",
|
||||
crate::Interpolation::PerVertex => "per_vertex",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -96,6 +96,7 @@ pub const SUPPORTED_EXTENSIONS: &[&str] = &[
|
||||
"SPV_EXT_descriptor_indexing",
|
||||
"SPV_EXT_shader_atomic_float_add",
|
||||
"SPV_KHR_16bit_storage",
|
||||
"SPV_KHR_fragment_shader_barycentric",
|
||||
];
|
||||
pub const SUPPORTED_EXT_SETS: &[&str] = &["GLSL.std.450"];
|
||||
|
||||
@@ -778,6 +779,9 @@ impl<I: Iterator<Item = u32>> Frontend<I> {
|
||||
spirv::Decoration::Flat => {
|
||||
dec.interpolation = Some(crate::Interpolation::Flat);
|
||||
}
|
||||
spirv::Decoration::PerVertexKHR => {
|
||||
dec.interpolation = Some(crate::Interpolation::PerVertex);
|
||||
}
|
||||
spirv::Decoration::Centroid => {
|
||||
dec.sampling = Some(crate::Sampling::Centroid);
|
||||
}
|
||||
|
||||
@@ -112,6 +112,7 @@ pub fn map_interpolation(word: &str, span: Span) -> Result<'_, crate::Interpolat
|
||||
"linear" => Ok(crate::Interpolation::Linear),
|
||||
"flat" => Ok(crate::Interpolation::Flat),
|
||||
"perspective" => Ok(crate::Interpolation::Perspective),
|
||||
"per_vertex" => Ok(crate::Interpolation::PerVertex),
|
||||
_ => Err(Box::new(Error::UnknownAttribute(span))),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -588,6 +588,9 @@ pub enum Interpolation {
|
||||
Linear,
|
||||
/// Indicates that no interpolation will be performed.
|
||||
Flat,
|
||||
/// Indicates the fragment input binding holds an array of per-vertex values.
|
||||
/// This is typically used with barycentrics.
|
||||
PerVertex,
|
||||
}
|
||||
|
||||
/// The sampling qualifiers of a binding or struct field.
|
||||
|
||||
+44
-10
@@ -58,6 +58,8 @@ pub enum VaryingError {
|
||||
NotIOShareableType(Handle<crate::Type>),
|
||||
#[error("Interpolation is not valid")]
|
||||
InvalidInterpolation,
|
||||
#[error("Interpolation {0:?} is only valid for stage {1:?}")]
|
||||
InvalidInterpolationInStage(crate::Interpolation, crate::ShaderStage),
|
||||
#[error("Cannot combine {interpolation:?} interpolation with the {sampling:?} sample type")]
|
||||
InvalidInterpolationSamplingCombination {
|
||||
interpolation: crate::Interpolation,
|
||||
@@ -100,6 +102,8 @@ pub enum VaryingError {
|
||||
InvalidPerPrimitive,
|
||||
#[error("Non-builtin members of a mesh primitive output struct must be decorated with `@per_primitive`")]
|
||||
MissingPerPrimitive,
|
||||
#[error("Per vertex fragment inputs must be an array of length 3.")]
|
||||
PerVertexNotArrayOfThree,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, thiserror::Error)]
|
||||
@@ -447,6 +451,33 @@ impl VaryingContext<'_> {
|
||||
Capabilities::MESH_SHADER,
|
||||
));
|
||||
}
|
||||
if interpolation == Some(crate::Interpolation::PerVertex) {
|
||||
if self.stage != crate::ShaderStage::Fragment {
|
||||
return Err(VaryingError::InvalidInterpolationInStage(
|
||||
crate::Interpolation::PerVertex,
|
||||
crate::ShaderStage::Fragment,
|
||||
));
|
||||
}
|
||||
if !self.capabilities.contains(Capabilities::PER_VERTEX) {
|
||||
return Err(VaryingError::UnsupportedCapability(
|
||||
Capabilities::PER_VERTEX,
|
||||
));
|
||||
}
|
||||
}
|
||||
// If this is per-vertex, we change the type we validate to the inner type, otherwise we leave it be.
|
||||
// This lets all validation be done on the inner type once we've ensured the per-vertex is array<T, 3>
|
||||
let (ty, ty_inner) = if interpolation == Some(crate::Interpolation::PerVertex) {
|
||||
let three = crate::ArraySize::Constant(core::num::NonZeroU32::new(3).unwrap());
|
||||
match ty_inner {
|
||||
&Ti::Array { base, size, .. } if size == three => {
|
||||
(base, &self.types[base].inner)
|
||||
}
|
||||
_ => return Err(VaryingError::PerVertexNotArrayOfThree),
|
||||
}
|
||||
} else {
|
||||
(ty, ty_inner)
|
||||
};
|
||||
|
||||
// Only IO-shareable types may be stored in locations.
|
||||
if !self.type_info[ty.index()]
|
||||
.flags
|
||||
@@ -554,19 +585,22 @@ impl VaryingContext<'_> {
|
||||
return Err(VaryingError::UnsupportedCapability(required));
|
||||
}
|
||||
|
||||
match ty_inner.scalar_kind() {
|
||||
Some(crate::ScalarKind::Float) => {
|
||||
if needs_interpolation && interpolation.is_none() {
|
||||
return Err(VaryingError::MissingInterpolation);
|
||||
if interpolation != Some(crate::Interpolation::PerVertex) {
|
||||
match ty_inner.scalar_kind() {
|
||||
Some(crate::ScalarKind::Float) => {
|
||||
if needs_interpolation && interpolation.is_none() {
|
||||
return Err(VaryingError::MissingInterpolation);
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(_) => {
|
||||
if needs_interpolation && interpolation != Some(crate::Interpolation::Flat)
|
||||
{
|
||||
return Err(VaryingError::InvalidInterpolation);
|
||||
Some(_) => {
|
||||
if needs_interpolation
|
||||
&& interpolation != Some(crate::Interpolation::Flat)
|
||||
{
|
||||
return Err(VaryingError::InvalidInterpolation);
|
||||
}
|
||||
}
|
||||
None => return Err(VaryingError::InvalidType(ty)),
|
||||
}
|
||||
None => return Err(VaryingError::InvalidType(ty)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -203,6 +203,8 @@ bitflags::bitflags! {
|
||||
const STORAGE_BUFFER_BINDING_ARRAY_NON_UNIFORM_INDEXING = 1 << 35;
|
||||
/// Support for cooperative matrix types and operations
|
||||
const COOPERATIVE_MATRIX = 1 << 36;
|
||||
/// Support for per-vertex fragment input.
|
||||
const PER_VERTEX = 1 << 37;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@@ -0,0 +1,39 @@
|
||||
; SPIR-V
|
||||
; Version: 1.1
|
||||
; Generator: rspirv
|
||||
; Bound: 22
|
||||
OpCapability Shader
|
||||
OpCapability FragmentBarycentricKHR
|
||||
OpExtension "SPV_KHR_fragment_shader_barycentric"
|
||||
%1 = OpExtInstImport "GLSL.std.450"
|
||||
OpMemoryModel Logical GLSL450
|
||||
OpEntryPoint Fragment %14 "fs_main" %9 %12
|
||||
OpExecutionMode %14 OriginUpperLeft
|
||||
OpDecorate %4 ArrayStride 4
|
||||
OpDecorate %9 Location 0
|
||||
OpDecorate %9 PerVertexKHR
|
||||
OpDecorate %12 Location 0
|
||||
%2 = OpTypeVoid
|
||||
%3 = OpTypeFloat 32
|
||||
%6 = OpTypeInt 32 0
|
||||
%5 = OpConstant %6 3
|
||||
%4 = OpTypeArray %3 %5
|
||||
%7 = OpTypeVector %3 4
|
||||
%10 = OpTypePointer Input %4
|
||||
%9 = OpVariable %10 Input
|
||||
%13 = OpTypePointer Output %7
|
||||
%12 = OpVariable %13 Output
|
||||
%15 = OpTypeFunction %2
|
||||
%16 = OpConstant %3 1
|
||||
%14 = OpFunction %2 None %15
|
||||
%8 = OpLabel
|
||||
%11 = OpLoad %4 %9
|
||||
OpBranch %17
|
||||
%17 = OpLabel
|
||||
%18 = OpCompositeExtract %3 %11 0
|
||||
%19 = OpCompositeExtract %3 %11 1
|
||||
%20 = OpCompositeExtract %3 %11 2
|
||||
%21 = OpCompositeConstruct %7 %18 %19 %20 %16
|
||||
OpStore %12 %21
|
||||
OpReturn
|
||||
OpFunctionEnd
|
||||
@@ -0,0 +1,2 @@
|
||||
capabilities = "PER_VERTEX"
|
||||
targets = "SPIRV | WGSL"
|
||||
@@ -0,0 +1,2 @@
|
||||
capabilities = "PER_VERTEX"
|
||||
targets = "WGSL | SPIRV"
|
||||
@@ -0,0 +1,4 @@
|
||||
@fragment
|
||||
fn fs_main(@location(0) @interpolate(per_vertex) v: array<f32, 3>) -> @location(0) vec4<f32> {
|
||||
return vec4(v[0], v[1], v[2], 1.0);
|
||||
}
|
||||
@@ -409,6 +409,7 @@ fn incompatible_interpolation_and_sampling_types() {
|
||||
naga::Interpolation::Flat,
|
||||
naga::Interpolation::Linear,
|
||||
naga::Interpolation::Perspective,
|
||||
naga::Interpolation::PerVertex,
|
||||
]
|
||||
.into_iter()
|
||||
.cartesian_product(
|
||||
@@ -498,6 +499,7 @@ mod dummy_interpolation_shader {
|
||||
naga::Interpolation::Flat => "flat",
|
||||
naga::Interpolation::Linear => "linear",
|
||||
naga::Interpolation::Perspective => "perspective",
|
||||
naga::Interpolation::PerVertex => "per_vertex",
|
||||
};
|
||||
let sampling_str = match sampling {
|
||||
None => String::new(),
|
||||
@@ -515,6 +517,7 @@ mod dummy_interpolation_shader {
|
||||
let member_type = match interpolation {
|
||||
naga::Interpolation::Perspective | naga::Interpolation::Linear => "f32",
|
||||
naga::Interpolation::Flat => "u32",
|
||||
naga::Interpolation::PerVertex => "array<u32, 3>",
|
||||
};
|
||||
|
||||
let interpolate_attr = format!("@interpolate({interpolation_str}{sampling_str})");
|
||||
|
||||
@@ -1209,6 +1209,31 @@ fn int64_capability() {
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn per_vertex_capability() {
|
||||
check_validation! {
|
||||
r#"
|
||||
@fragment
|
||||
fn fs_main(@location(0) @interpolate(per_vertex) v: array<f32, 3>) -> @location(0) vec4<f32> {
|
||||
return vec4(v[0], v[1], v[2], 1.0);
|
||||
}
|
||||
"#:
|
||||
Err(
|
||||
naga::valid::ValidationError::EntryPoint {
|
||||
stage: naga::ShaderStage::Fragment,
|
||||
source: valid::EntryPointError::Argument(
|
||||
0,
|
||||
valid::VaryingError::UnsupportedCapability(
|
||||
Capabilities::PER_VERTEX,
|
||||
|
||||
),
|
||||
),
|
||||
..
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn multiple_enables_valid() {
|
||||
check_success(
|
||||
|
||||
@@ -0,0 +1,56 @@
|
||||
; SPIR-V
|
||||
; Version: 1.1
|
||||
; Generator: rspirv
|
||||
; Bound: 34
|
||||
OpCapability Shader
|
||||
OpCapability FragmentBarycentricKHR
|
||||
OpExtension "SPV_KHR_fragment_shader_barycentric"
|
||||
%1 = OpExtInstImport "GLSL.std.450"
|
||||
OpMemoryModel Logical GLSL450
|
||||
OpEntryPoint Fragment %30 "fs_main" %25 %28
|
||||
OpExecutionMode %30 OriginUpperLeft
|
||||
OpDecorate %4 ArrayStride 4
|
||||
OpDecorate %25 Location 0
|
||||
OpDecorate %25 PerVertexKHR
|
||||
OpDecorate %28 Location 0
|
||||
%2 = OpTypeVoid
|
||||
%3 = OpTypeFloat 32
|
||||
%6 = OpTypeInt 32 0
|
||||
%5 = OpConstant %6 3
|
||||
%4 = OpTypeArray %3 %5
|
||||
%7 = OpTypeVector %3 4
|
||||
%8 = OpConstant %3 1
|
||||
%10 = OpTypePointer Private %4
|
||||
%11 = OpConstantNull %4
|
||||
%9 = OpVariable %10 Private %11
|
||||
%13 = OpTypePointer Private %7
|
||||
%14 = OpConstantNull %7
|
||||
%12 = OpVariable %13 Private %14
|
||||
%17 = OpTypeFunction %2
|
||||
%26 = OpTypePointer Input %4
|
||||
%25 = OpVariable %26 Input
|
||||
%29 = OpTypePointer Output %7
|
||||
%28 = OpVariable %29 Output
|
||||
%16 = OpFunction %2 None %17
|
||||
%15 = OpLabel
|
||||
OpBranch %18
|
||||
%18 = OpLabel
|
||||
%19 = OpLoad %4 %9
|
||||
%20 = OpCompositeExtract %3 %19 0
|
||||
%21 = OpCompositeExtract %3 %19 1
|
||||
%22 = OpCompositeExtract %3 %19 2
|
||||
%23 = OpCompositeConstruct %7 %20 %21 %22 %8
|
||||
OpStore %12 %23
|
||||
OpReturn
|
||||
OpFunctionEnd
|
||||
%30 = OpFunction %2 None %17
|
||||
%24 = OpLabel
|
||||
%27 = OpLoad %4 %25
|
||||
OpBranch %31
|
||||
%31 = OpLabel
|
||||
OpStore %9 %27
|
||||
%32 = OpFunctionCall %2 %16
|
||||
%33 = OpLoad %7 %12
|
||||
OpStore %28 %33
|
||||
OpReturn
|
||||
OpFunctionEnd
|
||||
@@ -0,0 +1,39 @@
|
||||
; SPIR-V
|
||||
; Version: 1.1
|
||||
; Generator: rspirv
|
||||
; Bound: 22
|
||||
OpCapability Shader
|
||||
OpCapability FragmentBarycentricKHR
|
||||
OpExtension "SPV_KHR_fragment_shader_barycentric"
|
||||
%1 = OpExtInstImport "GLSL.std.450"
|
||||
OpMemoryModel Logical GLSL450
|
||||
OpEntryPoint Fragment %14 "fs_main" %9 %12
|
||||
OpExecutionMode %14 OriginUpperLeft
|
||||
OpDecorate %4 ArrayStride 4
|
||||
OpDecorate %9 Location 0
|
||||
OpDecorate %9 PerVertexKHR
|
||||
OpDecorate %12 Location 0
|
||||
%2 = OpTypeVoid
|
||||
%3 = OpTypeFloat 32
|
||||
%6 = OpTypeInt 32 0
|
||||
%5 = OpConstant %6 3
|
||||
%4 = OpTypeArray %3 %5
|
||||
%7 = OpTypeVector %3 4
|
||||
%10 = OpTypePointer Input %4
|
||||
%9 = OpVariable %10 Input
|
||||
%13 = OpTypePointer Output %7
|
||||
%12 = OpVariable %13 Output
|
||||
%15 = OpTypeFunction %2
|
||||
%16 = OpConstant %3 1
|
||||
%14 = OpFunction %2 None %15
|
||||
%8 = OpLabel
|
||||
%11 = OpLoad %4 %9
|
||||
OpBranch %17
|
||||
%17 = OpLabel
|
||||
%18 = OpCompositeExtract %3 %11 0
|
||||
%19 = OpCompositeExtract %3 %11 1
|
||||
%20 = OpCompositeExtract %3 %11 2
|
||||
%21 = OpCompositeConstruct %7 %18 %19 %20 %16
|
||||
OpStore %12 %21
|
||||
OpReturn
|
||||
OpFunctionEnd
|
||||
@@ -0,0 +1,16 @@
|
||||
var<private> global: array<f32, 3>;
|
||||
var<private> global_1: vec4<f32>;
|
||||
|
||||
fn function() {
|
||||
let _e3 = global;
|
||||
global_1 = vec4<f32>(_e3[0], _e3[1], _e3[2], 1f);
|
||||
return;
|
||||
}
|
||||
|
||||
@fragment
|
||||
fn fs_main(@location(0) @interpolate(per_vertex) param: array<f32, 3>) -> @location(0) vec4<f32> {
|
||||
global = param;
|
||||
function();
|
||||
let _e3 = global_1;
|
||||
return _e3;
|
||||
}
|
||||
@@ -0,0 +1,4 @@
|
||||
@fragment
|
||||
fn fs_main(@location(0) @interpolate(per_vertex) v: array<f32, 3>) -> @location(0) vec4<f32> {
|
||||
return vec4<f32>(v[0], v[1], v[2], 1f);
|
||||
}
|
||||
@@ -42,6 +42,7 @@ mod occlusion_query;
|
||||
mod oob_indexing;
|
||||
mod oom;
|
||||
mod pass_ops;
|
||||
mod per_vertex;
|
||||
mod pipeline;
|
||||
mod pipeline_cache;
|
||||
mod planar_texture;
|
||||
@@ -106,6 +107,7 @@ fn all_tests() -> Vec<wgpu_test::GpuTestInitializer> {
|
||||
oob_indexing::all_tests(&mut tests);
|
||||
oom::all_tests(&mut tests);
|
||||
pass_ops::all_tests(&mut tests);
|
||||
per_vertex::all_tests(&mut tests);
|
||||
pipeline_cache::all_tests(&mut tests);
|
||||
pipeline::all_tests(&mut tests);
|
||||
planar_texture::all_tests(&mut tests);
|
||||
|
||||
@@ -0,0 +1,179 @@
|
||||
use wgpu::util::DeviceExt;
|
||||
use wgpu_test::{gpu_test, GpuTestConfiguration, TestParameters, TestingContext};
|
||||
|
||||
pub fn all_tests(vec: &mut Vec<wgpu_test::GpuTestInitializer>) {
|
||||
vec.push(PER_VERTEX);
|
||||
}
|
||||
|
||||
//
|
||||
// These tests render a triangle strip to a 2x2 render target. The first triangle
|
||||
// in the vertex buffer covers the top-left pixel, the second triangle
|
||||
// covers the bottom two pixels, and the last triangle covers the top-right pixel.
|
||||
// XY layout of the render target, with the three triangles, pixel centers marked with '
|
||||
//
|
||||
// (-1,1) (0,1) (1,1)
|
||||
// +---------+---------+
|
||||
// | o-------o-------o |
|
||||
// | | /|\ | |
|
||||
// | | ' / | \ ' | |
|
||||
// | | / | \ | |
|
||||
// (-1,0) +-|---/---+---\---|-+ (1,0)
|
||||
// | | / | \ | |
|
||||
// | | / | \ | |
|
||||
// | |/ ' | ' \| |
|
||||
// | o---------------o |
|
||||
// +---------+---------+
|
||||
// (-1,-1) (0,-1) (1,-1)
|
||||
//
|
||||
// The fragment shader outputs color based on per-vertex position:
|
||||
//
|
||||
// return vec4(z[0], z[1], z[2], 1.0);
|
||||
//
|
||||
|
||||
#[gpu_test]
|
||||
static PER_VERTEX: GpuTestConfiguration = GpuTestConfiguration::new()
|
||||
.parameters(
|
||||
TestParameters::default()
|
||||
.test_features_limits()
|
||||
.features(wgpu::Features::SHADER_PER_VERTEX),
|
||||
)
|
||||
.run_async(per_vertex);
|
||||
|
||||
async fn per_vertex(ctx: TestingContext) {
|
||||
let shader = ctx
|
||||
.device
|
||||
.create_shader_module(wgpu::include_wgsl!("per_vertex.wgsl"));
|
||||
|
||||
let trianglestrip_xyz: [f32; 15] = [
|
||||
-0.9, 0.9, 0.0, // top left
|
||||
-0.9, -0.9, 0.25, // bottom left
|
||||
0.0, 0.9, 0.5, // top center
|
||||
0.9, -0.9, 0.75, // bottom right
|
||||
0.9, 0.9, 1.0, // top right
|
||||
];
|
||||
let vertex_buffer = ctx
|
||||
.device
|
||||
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||
label: None,
|
||||
contents: bytemuck::cast_slice(&trianglestrip_xyz),
|
||||
usage: wgpu::BufferUsages::VERTEX | wgpu::BufferUsages::COPY_DST,
|
||||
});
|
||||
|
||||
let indices = [0u32, 1, 2, 3, 4];
|
||||
let index_buffer = ctx
|
||||
.device
|
||||
.create_buffer_init(&wgpu::util::BufferInitDescriptor {
|
||||
label: None,
|
||||
contents: bytemuck::cast_slice(&indices),
|
||||
usage: wgpu::BufferUsages::INDEX | wgpu::BufferUsages::COPY_DST,
|
||||
});
|
||||
|
||||
let pipeline = ctx
|
||||
.device
|
||||
.create_render_pipeline(&wgpu::RenderPipelineDescriptor {
|
||||
label: None,
|
||||
layout: None,
|
||||
vertex: wgpu::VertexState {
|
||||
module: &shader,
|
||||
entry_point: Some("vs_main"),
|
||||
compilation_options: Default::default(),
|
||||
buffers: &[wgpu::VertexBufferLayout {
|
||||
array_stride: 12,
|
||||
step_mode: wgpu::VertexStepMode::Vertex,
|
||||
attributes: &[wgpu::VertexAttribute {
|
||||
format: wgpu::VertexFormat::Float32x3,
|
||||
offset: 0,
|
||||
shader_location: 0,
|
||||
}],
|
||||
}],
|
||||
},
|
||||
primitive: wgpu::PrimitiveState {
|
||||
topology: wgpu::PrimitiveTopology::TriangleStrip,
|
||||
strip_index_format: Some(wgpu::IndexFormat::Uint32),
|
||||
..wgpu::PrimitiveState::default()
|
||||
},
|
||||
depth_stencil: None,
|
||||
multisample: wgpu::MultisampleState::default(),
|
||||
fragment: Some(wgpu::FragmentState {
|
||||
module: &shader,
|
||||
entry_point: Some("fs_main"),
|
||||
compilation_options: Default::default(),
|
||||
targets: &[Some(wgpu::ColorTargetState {
|
||||
format: wgpu::TextureFormat::Rgba8Unorm,
|
||||
blend: None,
|
||||
write_mask: wgpu::ColorWrites::ALL,
|
||||
})],
|
||||
}),
|
||||
multiview_mask: None,
|
||||
cache: None,
|
||||
});
|
||||
|
||||
let width = 2;
|
||||
let height = 2;
|
||||
let texture_size = wgpu::Extent3d {
|
||||
width,
|
||||
height,
|
||||
depth_or_array_layers: 1,
|
||||
};
|
||||
let color_texture = ctx.device.create_texture(&wgpu::TextureDescriptor {
|
||||
label: None,
|
||||
size: texture_size,
|
||||
mip_level_count: 1,
|
||||
sample_count: 1,
|
||||
dimension: wgpu::TextureDimension::D2,
|
||||
format: wgpu::TextureFormat::Rgba8Unorm,
|
||||
usage: wgpu::TextureUsages::RENDER_ATTACHMENT | wgpu::TextureUsages::COPY_SRC,
|
||||
view_formats: &[],
|
||||
});
|
||||
let color_view = color_texture.create_view(&wgpu::TextureViewDescriptor::default());
|
||||
|
||||
let readback_buffer = wgpu_test::image::ReadbackBuffers::new(&ctx.device, &color_texture);
|
||||
|
||||
let mut encoder = ctx
|
||||
.device
|
||||
.create_command_encoder(&wgpu::CommandEncoderDescriptor::default());
|
||||
{
|
||||
let mut rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
|
||||
label: None,
|
||||
color_attachments: &[Some(wgpu::RenderPassColorAttachment {
|
||||
ops: wgpu::Operations {
|
||||
load: wgpu::LoadOp::Clear(wgpu::Color::WHITE),
|
||||
store: wgpu::StoreOp::Store,
|
||||
},
|
||||
resolve_target: None,
|
||||
view: &color_view,
|
||||
depth_slice: None,
|
||||
})],
|
||||
depth_stencil_attachment: None,
|
||||
timestamp_writes: None,
|
||||
occlusion_query_set: None,
|
||||
multiview_mask: None,
|
||||
});
|
||||
|
||||
rpass.set_pipeline(&pipeline);
|
||||
rpass.set_index_buffer(index_buffer.slice(..), wgpu::IndexFormat::Uint32);
|
||||
rpass.set_vertex_buffer(0, vertex_buffer.slice(..));
|
||||
rpass.draw(0..5, 0..1);
|
||||
}
|
||||
readback_buffer.copy_from(&ctx.device, &mut encoder, &color_texture);
|
||||
ctx.queue.submit(Some(encoder.finish()));
|
||||
|
||||
// 0 127 255
|
||||
// o-----o-----o
|
||||
// | /|\ |
|
||||
// | '/ | \' |
|
||||
// +--/--+--\--+
|
||||
// | / | \ |
|
||||
// |/ ' | ' \|
|
||||
// o-----+-----o
|
||||
// 64 191
|
||||
let expected = [
|
||||
0, 64, 127, 255, // top left
|
||||
127, 191, 255, 255, // top right
|
||||
64, 191, 127, 255, // bottom left
|
||||
64, 191, 127, 255, // bottom right
|
||||
];
|
||||
readback_buffer
|
||||
.assert_buffer_contents(&ctx, &expected)
|
||||
.await;
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
struct VertexOutput {
|
||||
@builtin(position) clip: vec4<f32>,
|
||||
@interpolate(flat) @location(0) z: f32,
|
||||
}
|
||||
|
||||
@vertex
|
||||
fn vs_main(@location(0) xyz: vec3<f32>) -> VertexOutput {
|
||||
return VertexOutput(vec4<f32>(xyz.xy, 0.0, 1.0), xyz.z);
|
||||
}
|
||||
|
||||
@fragment
|
||||
fn fs_main(@interpolate(per_vertex) @location(0) z: array<f32, 3>) -> @location(0) vec4<f32> {
|
||||
return vec4(z[0], z[1], z[2], 1.0);
|
||||
}
|
||||
@@ -543,6 +543,10 @@ pub fn create_validator(
|
||||
Caps::COOPERATIVE_MATRIX,
|
||||
features.intersects(wgt::Features::EXPERIMENTAL_COOPERATIVE_MATRIX),
|
||||
);
|
||||
caps.set(
|
||||
Caps::PER_VERTEX,
|
||||
features.intersects(wgt::Features::SHADER_PER_VERTEX),
|
||||
);
|
||||
|
||||
naga::valid::Validator::new(flags, caps)
|
||||
}
|
||||
@@ -563,7 +563,9 @@ impl PhysicalDeviceFeatures {
|
||||
shader_barycentrics: if enabled_extensions
|
||||
.contains(&khr::fragment_shader_barycentric::NAME)
|
||||
{
|
||||
let needed = requested_features.intersects(wgt::Features::SHADER_BARYCENTRICS);
|
||||
let needed = requested_features.intersects(
|
||||
wgt::Features::SHADER_BARYCENTRICS | wgt::Features::SHADER_PER_VERTEX,
|
||||
);
|
||||
Some(
|
||||
vk::PhysicalDeviceFragmentShaderBarycentricFeaturesKHR::default()
|
||||
.fragment_shader_barycentric(needed),
|
||||
@@ -745,7 +747,7 @@ impl PhysicalDeviceFeatures {
|
||||
|
||||
if let Some(ref shader_barycentrics) = self.shader_barycentrics {
|
||||
features.set(
|
||||
F::SHADER_BARYCENTRICS,
|
||||
F::SHADER_BARYCENTRICS | F::SHADER_PER_VERTEX,
|
||||
shader_barycentrics.fragment_shader_barycentric != 0,
|
||||
);
|
||||
}
|
||||
@@ -1292,8 +1294,11 @@ impl PhysicalDeviceProperties {
|
||||
extensions.push(ext::mesh_shader::NAME);
|
||||
}
|
||||
|
||||
// Require `VK_KHR_fragment_shader_barycentric` if the associated feature was requested
|
||||
if requested_features.intersects(wgt::Features::SHADER_BARYCENTRICS) {
|
||||
// Require `VK_KHR_fragment_shader_barycentric` if an associated feature was requested
|
||||
// Vulkan bundles both barycentrics and per-vertex attributes under the same feature.
|
||||
if requested_features
|
||||
.intersects(wgt::Features::SHADER_BARYCENTRICS | wgt::Features::SHADER_PER_VERTEX)
|
||||
{
|
||||
extensions.push(khr::fragment_shader_barycentric::NAME);
|
||||
}
|
||||
|
||||
@@ -2341,7 +2346,10 @@ impl super::Adapter {
|
||||
capabilities.push(spv::Capability::ClipDistance);
|
||||
}
|
||||
|
||||
if features.intersects(wgt::Features::SHADER_BARYCENTRICS) {
|
||||
// Vulkan bundles both barycentrics and per-vertex attributes under the same feature.
|
||||
if features
|
||||
.intersects(wgt::Features::SHADER_BARYCENTRICS | wgt::Features::SHADER_PER_VERTEX)
|
||||
{
|
||||
capabilities.push(spv::Capability::FragmentBarycentricKHR);
|
||||
}
|
||||
|
||||
|
||||
@@ -1274,6 +1274,14 @@ bitflags_array! {
|
||||
///
|
||||
/// This is a native only feature.
|
||||
const EXPERIMENTAL_COOPERATIVE_MATRIX = 1 << 57;
|
||||
|
||||
/// Enables shader per-vertex attributes.
|
||||
///
|
||||
/// Supported platforms:
|
||||
/// - Vulkan (with VK_KHR_fragment_shader_barycentric)
|
||||
///
|
||||
/// This is a native only feature.
|
||||
const SHADER_PER_VERTEX = 1 << 58;
|
||||
}
|
||||
|
||||
/// Features that are not guaranteed to be supported.
|
||||
|
||||
Reference in new issue
Block a user