encounter
/
dawn-cmake
mirror of https://github.com/encounter/dawn-cmake.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Remove utility to create shader modules from GLSL 

And rename CreateShaderModuleFromWGSL to CreateShaderModule.

Bug: dawn:572
Change-Id: I80dab401078b2001d738b87d6e24437f93b690d1
Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/45764
Reviewed-by: Ryan Harrison <rharrison@chromium.org>
Reviewed-by: Austin Eng <enga@chromium.org>
Commit-Queue: Austin Eng <enga@chromium.org>
Auto-Submit: Corentin Wallez <cwallez@chromium.org>
This commit is contained in:
Corentin Wallez 2021-03-24 15:55:32 +00:00 committed by Commit Bot service account
parent 1452cf60e5
commit 7aec4ae7c5
81 changed files with 338 additions and 432 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
examples/Animometer.cpp
View File

@ -55,8 +55,7 @@ void init() {
swapchain.Configure(GetPreferredSwapChainTextureFormat(), wgpu::TextureUsage::RenderAttachment, swapchain.Configure(GetPreferredSwapChainTextureFormat(), wgpu::TextureUsage::RenderAttachment,
640, 480); 640, 480);
wgpu::ShaderModule vsModule = wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
utils::CreateShaderModuleFromWGSL(device, R"(
[[block]] struct Constants { [[block]] struct Constants {
scale : f32; scale : f32;
time : f32; time : f32;
@ -108,7 +107,7 @@ void init() {
Position = vec4<f32>(xpos, ypos, 0.0, 1.0); Position = vec4<f32>(xpos, ypos, 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> FragColor : vec4<f32>; [[location(0)]] var<out> FragColor : vec4<f32>;
[[location(0)]] var<in> v_color : vec4<f32>; [[location(0)]] var<in> v_color : vec4<f32>;

4
examples/CHelloTriangle.cpp
View File

@ -48,7 +48,7 @@ void init() {
" Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);\n" " Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);\n"
" return;\n" " return;\n"
"}\n"; "}\n";
WGPUShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, vs).Release(); WGPUShaderModule vsModule = utils::CreateShaderModule(device, vs).Release();
const char* fs = const char* fs =
"[[location(0)]] var<out> fragColor : vec4<f32>;\n" "[[location(0)]] var<out> fragColor : vec4<f32>;\n"
@ -56,7 +56,7 @@ void init() {
" fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);\n" " fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);\n"
" return;\n" " return;\n"
"}\n"; "}\n";
WGPUShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, fs).Release(); WGPUShaderModule fsModule = utils::CreateShaderModule(device, fs).Release();
{ {
WGPURenderPipelineDescriptor2 descriptor = {}; WGPURenderPipelineDescriptor2 descriptor = {};

6
examples/ComputeBoids.cpp
View File

@ -95,7 +95,7 @@ void initBuffers() {
} }
void initRender() { void initRender() {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> a_particlePos : vec2<f32>; [[location(0)]] var<in> a_particlePos : vec2<f32>;
[[location(1)]] var<in> a_particleVel : vec2<f32>; [[location(1)]] var<in> a_particleVel : vec2<f32>;
[[location(2)]] var<in> a_pos : vec2<f32>; [[location(2)]] var<in> a_pos : vec2<f32>;
@ -112,7 +112,7 @@ void initRender() {
} }
)"); )");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> FragColor : vec4<f32>; [[location(0)]] var<out> FragColor : vec4<f32>;
[[stage(fragment)]] [[stage(fragment)]]
fn main() -> void { fn main() -> void {
@ -149,7 +149,7 @@ void initRender() {
} }
void initSim() { void initSim() {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
struct Particle { struct Particle {
pos : vec2<f32>; pos : vec2<f32>;
vel : vec2<f32>; vel : vec2<f32>;

4
examples/CppHelloTriangle.cpp
View File

@ -95,7 +95,7 @@ void init() {
initBuffers(); initBuffers();
initTextures(); initTextures();
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[location(0)]] var<in> pos : vec4<f32>; [[location(0)]] var<in> pos : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
@ -103,7 +103,7 @@ void init() {
return; return;
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>; [[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>;
[[group(0), binding(0)]] var mySampler: sampler; [[group(0), binding(0)]] var mySampler: sampler;
[[group(0), binding(1)]] var myTexture : texture_2d<f32>; [[group(0), binding(1)]] var myTexture : texture_2d<f32>;

6
examples/CubeReflection.cpp
View File

@ -101,7 +101,7 @@ void init() {
initBuffers(); initBuffers();
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[block]] struct Camera { [[block]] struct Camera {
view : mat4x4<f32>; view : mat4x4<f32>;
proj : mat4x4<f32>; proj : mat4x4<f32>;
@ -125,7 +125,7 @@ void init() {
return; return;
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> FragColor : vec4<f32>; [[location(0)]] var<out> FragColor : vec4<f32>;
[[location(2)]] var<in> f_col : vec3<f32>; [[location(2)]] var<in> f_col : vec3<f32>;
@ -134,7 +134,7 @@ void init() {
return; return;
})"); })");
wgpu::ShaderModule fsReflectionModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsReflectionModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> FragColor : vec4<f32>; [[location(0)]] var<out> FragColor : vec4<f32>;
[[location(2)]] var<in> f_col : vec3<f32>; [[location(2)]] var<in> f_col : vec3<f32>;

4
examples/ManualSwapChainTest.cpp
View File

@ -312,7 +312,7 @@ int main(int argc, const char* argv[]) {
// The hacky pipeline to render a triangle. // The hacky pipeline to render a triangle.
utils::ComboRenderPipelineDescriptor2 pipelineDesc; utils::ComboRenderPipelineDescriptor2 pipelineDesc;
pipelineDesc.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDesc.vertex.module = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
const pos : array<vec2<f32>, 3> = array<vec2<f32>, 3>( const pos : array<vec2<f32>, 3> = array<vec2<f32>, 3>(
@ -324,7 +324,7 @@ int main(int argc, const char* argv[]) {
Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
return; return;
})"); })");
pipelineDesc.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDesc.cFragment.module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0); fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);

32
src/tests/end2end/BindGroupTests.cpp
View File

@ -45,7 +45,7 @@ class BindGroupTests : public DawnTest {
} }
wgpu::ShaderModule MakeSimpleVSModule() const { wgpu::ShaderModule MakeSimpleVSModule() const {
return utils::CreateShaderModuleFromWGSL(device, R"( return utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -89,7 +89,7 @@ class BindGroupTests : public DawnTest {
fs << "fragColor = fragColor + buffer" << i << ".color;\n"; fs << "fragColor = fragColor + buffer" << i << ".color;\n";
} }
fs << "}\n"; fs << "}\n";
return utils::CreateShaderModuleFromWGSL(device, fs.str().c_str()); return utils::CreateShaderModule(device, fs.str().c_str());
} }
wgpu::RenderPipeline MakeTestPipeline(const utils::BasicRenderPass& renderPass, wgpu::RenderPipeline MakeTestPipeline(const utils::BasicRenderPass& renderPass,
@ -123,7 +123,7 @@ class BindGroupTests : public DawnTest {
// Test a bindgroup reused in two command buffers in the same call to queue.Submit(). // Test a bindgroup reused in two command buffers in the same call to queue.Submit().
// This test passes by not asserting or crashing. // This test passes by not asserting or crashing.
TEST_P(BindGroupTests, ReusedBindGroupSingleSubmit) { TEST_P(BindGroupTests, ReusedBindGroupSingleSubmit) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct Contents { [[block]] struct Contents {
f : f32; f : f32;
}; };
@ -156,7 +156,7 @@ TEST_P(BindGroupTests, ReusedBindGroupSingleSubmit) {
TEST_P(BindGroupTests, ReusedUBO) { TEST_P(BindGroupTests, ReusedUBO) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
// TODO(crbug.com/tint/369): Use a mat2x2 when Tint translates it correctly. // TODO(crbug.com/tint/369): Use a mat2x2 when Tint translates it correctly.
[[block]] struct VertexUniformBuffer { [[block]] struct VertexUniformBuffer {
transform : vec4<f32>; transform : vec4<f32>;
@ -179,7 +179,7 @@ TEST_P(BindGroupTests, ReusedUBO) {
Position = vec4<f32>(transform * pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(transform * pos[VertexIndex], 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct FragmentUniformBuffer { [[block]] struct FragmentUniformBuffer {
color : vec4<f32>; color : vec4<f32>;
}; };
@ -240,7 +240,7 @@ TEST_P(BindGroupTests, ReusedUBO) {
TEST_P(BindGroupTests, UBOSamplerAndTexture) { TEST_P(BindGroupTests, UBOSamplerAndTexture) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
// TODO(crbug.com/tint/369): Use a mat2x2 when Tint translates it correctly. // TODO(crbug.com/tint/369): Use a mat2x2 when Tint translates it correctly.
[[block]] struct VertexUniformBuffer { [[block]] struct VertexUniformBuffer {
transform : vec4<f32>; transform : vec4<f32>;
@ -262,7 +262,7 @@ TEST_P(BindGroupTests, UBOSamplerAndTexture) {
Position = vec4<f32>(transform * pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(transform * pos[VertexIndex], 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(1)]] var samp : sampler; [[group(0), binding(1)]] var samp : sampler;
[[group(0), binding(2)]] var tex : texture_2d<f32>; [[group(0), binding(2)]] var tex : texture_2d<f32>;
[[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>; [[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>;
@ -349,7 +349,7 @@ TEST_P(BindGroupTests, UBOSamplerAndTexture) {
TEST_P(BindGroupTests, MultipleBindLayouts) { TEST_P(BindGroupTests, MultipleBindLayouts) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
// TODO(crbug.com/tint/369): Use a mat2x2 when Tint translates it correctly. // TODO(crbug.com/tint/369): Use a mat2x2 when Tint translates it correctly.
// TODO(crbug.com/tint/386): Use the same struct. // TODO(crbug.com/tint/386): Use the same struct.
[[block]] struct VertexUniformBuffer1 { [[block]] struct VertexUniformBuffer1 {
@ -379,7 +379,7 @@ TEST_P(BindGroupTests, MultipleBindLayouts) {
) * pos[VertexIndex], 0.0, 1.0); ) * pos[VertexIndex], 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
// TODO(crbug.com/tint/386): Use the same struct // TODO(crbug.com/tint/386): Use the same struct
[[block]] struct FragmentUniformBuffer1 { [[block]] struct FragmentUniformBuffer1 {
color : vec4<f32>; color : vec4<f32>;
@ -835,7 +835,7 @@ TEST_P(BindGroupTests, DynamicOffsetOrder) {
}); });
wgpu::ComputePipelineDescriptor pipelineDescriptor; wgpu::ComputePipelineDescriptor pipelineDescriptor;
pipelineDescriptor.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.computeStage.module = utils::CreateShaderModule(device, R"(
// TODO(crbug.com/tint/386): Use the same struct // TODO(crbug.com/tint/386): Use the same struct
[[block]] struct Buffer0 { [[block]] struct Buffer0 {
value : u32; value : u32;
@ -950,7 +950,7 @@ TEST_P(BindGroupTests, DynamicBindingNoneVisibility) {
TEST_P(BindGroupTests, ArbitraryBindingNumbers) { TEST_P(BindGroupTests, ArbitraryBindingNumbers) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -963,7 +963,7 @@ TEST_P(BindGroupTests, ArbitraryBindingNumbers) {
Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
// TODO(crbug.com/tint/386): Use the same struct // TODO(crbug.com/tint/386): Use the same struct
[[block]] struct Ubo1 { [[block]] struct Ubo1 {
color : vec4<f32>; color : vec4<f32>;
@ -1083,7 +1083,7 @@ TEST_P(BindGroupTests, EmptyLayout) {
wgpu::ComputePipelineDescriptor pipelineDesc; wgpu::ComputePipelineDescriptor pipelineDesc;
pipelineDesc.layout = utils::MakeBasicPipelineLayout(device, &bgl); pipelineDesc.layout = utils::MakeBasicPipelineLayout(device, &bgl);
pipelineDesc.computeStage.entryPoint = "main"; pipelineDesc.computeStage.entryPoint = "main";
pipelineDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDesc.computeStage.module = utils::CreateShaderModule(device, R"(
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {
})"); })");
@ -1106,7 +1106,7 @@ TEST_P(BindGroupTests, EmptyLayout) {
TEST_P(BindGroupTests, ReadonlyStorage) { TEST_P(BindGroupTests, ReadonlyStorage) {
utils::ComboRenderPipelineDescriptor2 pipelineDescriptor; utils::ComboRenderPipelineDescriptor2 pipelineDescriptor;
pipelineDescriptor.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.vertex.module = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -1119,7 +1119,7 @@ TEST_P(BindGroupTests, ReadonlyStorage) {
Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
})"); })");
pipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"(
[[block]] struct Buffer0 { [[block]] struct Buffer0 {
color : vec4<f32>; color : vec4<f32>;
}; };
@ -1285,7 +1285,7 @@ TEST_P(BindGroupTests, ReallyLargeBindGroup) {
std::string shader = std::string shader =
interface.str() + "[[stage(compute)]] fn main() -> void {\n" + body.str() + "}\n"; interface.str() + "[[stage(compute)]] fn main() -> void {\n" + body.str() + "}\n";
wgpu::ComputePipelineDescriptor cpDesc; wgpu::ComputePipelineDescriptor cpDesc;
cpDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, shader.c_str()); cpDesc.computeStage.module = utils::CreateShaderModule(device, shader.c_str());
cpDesc.computeStage.entryPoint = "main"; cpDesc.computeStage.entryPoint = "main";
wgpu::ComputePipeline cp = device.CreateComputePipeline(&cpDesc); wgpu::ComputePipeline cp = device.CreateComputePipeline(&cpDesc);

13
src/tests/end2end/BufferZeroInitTests.cpp
View File

@ -204,9 +204,9 @@ class BufferZeroInitTest : public DawnTest {
uint32_t vertexBufferCount = 1u) { uint32_t vertexBufferCount = 1u) {
constexpr wgpu::TextureFormat kColorAttachmentFormat = wgpu::TextureFormat::RGBA8Unorm; constexpr wgpu::TextureFormat kColorAttachmentFormat = wgpu::TextureFormat::RGBA8Unorm;
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, vertexShader); wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, vertexShader);
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> i_color : vec4<f32>; [[location(0)]] var<in> i_color : vec4<f32>;
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
@ -424,8 +424,7 @@ class BufferZeroInitTest : public DawnTest {
wgpu::ComputePipelineDescriptor pipelineDescriptor; wgpu::ComputePipelineDescriptor pipelineDescriptor;
pipelineDescriptor.layout = nullptr; pipelineDescriptor.layout = nullptr;
pipelineDescriptor.computeStage.module = pipelineDescriptor.computeStage.module = utils::CreateShaderModule(device, computeShader);
utils::CreateShaderModuleFromWGSL(device, computeShader);
pipelineDescriptor.computeStage.entryPoint = "main"; pipelineDescriptor.computeStage.entryPoint = "main";
wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDescriptor); wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDescriptor);
@ -984,7 +983,7 @@ TEST_P(BufferZeroInitTest, BoundAsUniformBuffer) {
DAWN_SKIP_TEST_IF(IsOpenGLES() && IsBackendValidationEnabled()); DAWN_SKIP_TEST_IF(IsOpenGLES() && IsBackendValidationEnabled());
constexpr uint32_t kBoundBufferSize = 16u; constexpr uint32_t kBoundBufferSize = 16u;
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct UBO { [[block]] struct UBO {
value : vec4<u32>; value : vec4<u32>;
}; };
@ -1023,7 +1022,7 @@ TEST_P(BufferZeroInitTest, BoundAsReadonlyStorageBuffer) {
DAWN_SKIP_TEST_IF(IsOpenGLES() && IsBackendValidationEnabled()); DAWN_SKIP_TEST_IF(IsOpenGLES() && IsBackendValidationEnabled());
constexpr uint32_t kBoundBufferSize = 16u; constexpr uint32_t kBoundBufferSize = 16u;
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct SSBO { [[block]] struct SSBO {
value : vec4<u32>; value : vec4<u32>;
}; };
@ -1062,7 +1061,7 @@ TEST_P(BufferZeroInitTest, BoundAsStorageBuffer) {
DAWN_SKIP_TEST_IF(IsOpenGLES() && IsBackendValidationEnabled()); DAWN_SKIP_TEST_IF(IsOpenGLES() && IsBackendValidationEnabled());
constexpr uint32_t kBoundBufferSize = 32u; constexpr uint32_t kBoundBufferSize = 32u;
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct SSBO { [[block]] struct SSBO {
value : array<vec4<u32>, 2>; value : array<vec4<u32>, 2>;
}; };

4
src/tests/end2end/ClipSpaceTests.cpp
View File

@ -25,7 +25,7 @@ class ClipSpaceTest : public DawnTest {
// Draw two triangles: // Draw two triangles:
// 1. The depth value of the top-left one is >= 0.5 // 1. The depth value of the top-left one is >= 0.5
// 2. The depth value of the bottom-right one is <= 0.5 // 2. The depth value of the bottom-right one is <= 0.5
pipelineDescriptor.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.vertex.module = utils::CreateShaderModule(device, R"(
const pos : array<vec3<f32>, 6> = array<vec3<f32>, 6>( const pos : array<vec3<f32>, 6> = array<vec3<f32>, 6>(
vec3<f32>(-1.0, 1.0, 1.0), vec3<f32>(-1.0, 1.0, 1.0),
vec3<f32>(-1.0, -1.0, 0.5), vec3<f32>(-1.0, -1.0, 0.5),
@ -42,7 +42,7 @@ class ClipSpaceTest : public DawnTest {
return; return;
})"); })");
pipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>;; [[location(0)]] var<out> fragColor : vec4<f32>;;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0); fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);

10
src/tests/end2end/ColorStateTests.cpp
View File

@ -30,7 +30,7 @@ class ColorStateTest : public DawnTest {
void SetUp() override { void SetUp() override {
DawnTest::SetUp(); DawnTest::SetUp();
vsModule = utils::CreateShaderModuleFromWGSL(device, R"( vsModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -55,7 +55,7 @@ class ColorStateTest : public DawnTest {
// Set up basePipeline and testPipeline. testPipeline has the given blend state on the first // Set up basePipeline and testPipeline. testPipeline has the given blend state on the first
// attachment. basePipeline has no blending // attachment. basePipeline has no blending
void SetupSingleSourcePipelines(wgpu::ColorTargetState colorTargetState) { void SetupSingleSourcePipelines(wgpu::ColorTargetState colorTargetState) {
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct MyBlock { [[block]] struct MyBlock {
color : vec4<f32>; color : vec4<f32>;
}; };
@ -785,7 +785,7 @@ TEST_P(ColorStateTest, IndependentColorState) {
utils::ComboRenderPassDescriptor renderPass( utils::ComboRenderPassDescriptor renderPass(
{renderTargetViews[0], renderTargetViews[1], renderTargetViews[2], renderTargetViews[3]}); {renderTargetViews[0], renderTargetViews[1], renderTargetViews[2], renderTargetViews[3]});
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct MyBlock { [[block]] struct MyBlock {
color0 : vec4<f32>; color0 : vec4<f32>;
color1 : vec4<f32>; color1 : vec4<f32>;
@ -904,7 +904,7 @@ TEST_P(ColorStateTest, IndependentColorState) {
// Test that the default blend color is correctly set at the beginning of every subpass // Test that the default blend color is correctly set at the beginning of every subpass
TEST_P(ColorStateTest, DefaultBlendColor) { TEST_P(ColorStateTest, DefaultBlendColor) {
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct MyBlock { [[block]] struct MyBlock {
color : vec4<f32>; color : vec4<f32>;
}; };
@ -1031,7 +1031,7 @@ TEST_P(ColorStateTest, DefaultBlendColor) {
// persisted and prevented a render pass loadOp from fully clearing the output // persisted and prevented a render pass loadOp from fully clearing the output
// attachment. // attachment.
TEST_P(ColorStateTest, ColorWriteMaskDoesNotAffectRenderPassLoadOpClear) { TEST_P(ColorStateTest, ColorWriteMaskDoesNotAffectRenderPassLoadOpClear) {
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct MyBlock { [[block]] struct MyBlock {
color : vec4<f32>; color : vec4<f32>;
}; };

4
src/tests/end2end/CompressedTextureFormatTests.cpp
View File

@ -139,7 +139,7 @@ class CompressedTextureBCFormatTest : public DawnTest {
ASSERT(IsBCFormatSupported()); ASSERT(IsBCFormatSupported());
utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor; utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor;
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[location(0)]] var<out> texCoord : vec2 <f32>; [[location(0)]] var<out> texCoord : vec2 <f32>;
@ -155,7 +155,7 @@ class CompressedTextureBCFormatTest : public DawnTest {
texCoord = vec2<f32>(Position.x / 2.0, -Position.y / 2.0) + vec2<f32>(0.5, 0.5); texCoord = vec2<f32>(Position.x / 2.0, -Position.y / 2.0) + vec2<f32>(0.5, 0.5);
return; return;
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var sampler0 : sampler; [[group(0), binding(0)]] var sampler0 : sampler;
[[group(0), binding(1)]] var texture0 : texture_2d<f32>; [[group(0), binding(1)]] var texture0 : texture_2d<f32>;

2
src/tests/end2end/ComputeCopyStorageBufferTests.cpp
View File

@ -29,7 +29,7 @@ class ComputeCopyStorageBufferTests : public DawnTest {
void ComputeCopyStorageBufferTests::BasicTest(const char* shader) { void ComputeCopyStorageBufferTests::BasicTest(const char* shader) {
// Set up shader and pipeline // Set up shader and pipeline
auto module = utils::CreateShaderModuleFromWGSL(device, shader); auto module = utils::CreateShaderModule(device, shader);
wgpu::ComputePipelineDescriptor csDesc; wgpu::ComputePipelineDescriptor csDesc;
csDesc.computeStage.module = module; csDesc.computeStage.module = module;

2
src/tests/end2end/ComputeDispatchTests.cpp
View File

@ -28,7 +28,7 @@ class ComputeDispatchTests : public DawnTest {
// Write workgroup number into the output buffer if we saw the biggest dispatch // Write workgroup number into the output buffer if we saw the biggest dispatch
// This is a workaround since D3D12 doesn't have gl_NumWorkGroups // This is a workaround since D3D12 doesn't have gl_NumWorkGroups
// To make sure the dispatch was not called, write maximum u32 value for 0 dispatches // To make sure the dispatch was not called, write maximum u32 value for 0 dispatches
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct InputBuf { [[block]] struct InputBuf {
expectedDispatch : vec3<u32>; expectedDispatch : vec3<u32>;
}; };

2
src/tests/end2end/ComputeSharedMemoryTests.cpp
View File

@ -27,7 +27,7 @@ class ComputeSharedMemoryTests : public DawnTest {
void ComputeSharedMemoryTests::BasicTest(const char* shader) { void ComputeSharedMemoryTests::BasicTest(const char* shader) {
// Set up shader and pipeline // Set up shader and pipeline
auto module = utils::CreateShaderModuleFromWGSL(device, shader); auto module = utils::CreateShaderModule(device, shader);
wgpu::ComputePipelineDescriptor csDesc; wgpu::ComputePipelineDescriptor csDesc;
csDesc.computeStage.module = module; csDesc.computeStage.module = module;

10
src/tests/end2end/ComputeStorageBufferBarrierTests.cpp
View File

@ -31,7 +31,7 @@ TEST_P(ComputeStorageBufferBarrierTests, AddIncrement) {
wgpu::Buffer buffer = utils::CreateBufferFromData( wgpu::Buffer buffer = utils::CreateBufferFromData(
device, data.data(), bufferSize, wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopySrc); device, data.data(), bufferSize, wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopySrc);
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct Buf { [[block]] struct Buf {
data : array<u32, 100>; data : array<u32, 100>;
}; };
@ -82,7 +82,7 @@ TEST_P(ComputeStorageBufferBarrierTests, AddPingPong) {
wgpu::Buffer bufferB = utils::CreateBufferFromData( wgpu::Buffer bufferB = utils::CreateBufferFromData(
device, data.data(), bufferSize, wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopySrc); device, data.data(), bufferSize, wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopySrc);
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
// TODO(crbug.com/tint/386): Use the same struct. // TODO(crbug.com/tint/386): Use the same struct.
[[block]] struct Src { [[block]] struct Src {
data : array<u32, 100>; data : array<u32, 100>;
@ -153,7 +153,7 @@ TEST_P(ComputeStorageBufferBarrierTests, StorageAndReadonlyStoragePingPongInOneP
wgpu::Buffer bufferB = utils::CreateBufferFromData( wgpu::Buffer bufferB = utils::CreateBufferFromData(
device, data.data(), bufferSize, wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopySrc); device, data.data(), bufferSize, wgpu::BufferUsage::Storage | wgpu::BufferUsage::CopySrc);
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
// TODO(crbug.com/tint/386): Use the same struct. // TODO(crbug.com/tint/386): Use the same struct.
[[block]] struct Src { [[block]] struct Src {
data : array<u32, 100>; data : array<u32, 100>;
@ -227,7 +227,7 @@ TEST_P(ComputeStorageBufferBarrierTests, UniformToStorageAddPingPong) {
device, data.data(), bufferSize, device, data.data(), bufferSize,
wgpu::BufferUsage::Storage | wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopySrc); wgpu::BufferUsage::Storage | wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopySrc);
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct Buf { [[block]] struct Buf {
data : array<vec4<u32>, 25>; data : array<vec4<u32>, 25>;
}; };
@ -295,7 +295,7 @@ TEST_P(ComputeStorageBufferBarrierTests, UniformToStorageAddPingPongInOnePass) {
device, data.data(), bufferSize, device, data.data(), bufferSize,
wgpu::BufferUsage::Storage | wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopySrc); wgpu::BufferUsage::Storage | wgpu::BufferUsage::Uniform | wgpu::BufferUsage::CopySrc);
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct Buf { [[block]] struct Buf {
data : array<vec4<u32>, 25>; data : array<vec4<u32>, 25>;
}; };

2
src/tests/end2end/CopyTextureForBrowserTests.cpp
View File

@ -110,7 +110,7 @@ class CopyTextureForBrowserTests : public DawnTest {
// shader) instead of CPU after executing CopyTextureForBrowser() to avoid the errors caused by // shader) instead of CPU after executing CopyTextureForBrowser() to avoid the errors caused by
// comparing a value generated on CPU to the one generated on GPU. // comparing a value generated on CPU to the one generated on GPU.
wgpu::ComputePipeline MakeTestPipeline() { wgpu::ComputePipeline MakeTestPipeline() {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[block]] struct Uniforms { [[block]] struct Uniforms {
dstTextureFlipY : u32; dstTextureFlipY : u32;
channelCount : u32; channelCount : u32;

18
src/tests/end2end/CreatePipelineAsyncTests.cpp
View File

@ -34,7 +34,7 @@ class CreatePipelineAsyncTest : public DawnTest {
// Verify the basic use of CreateComputePipelineAsync works on all backends. // Verify the basic use of CreateComputePipelineAsync works on all backends.
TEST_P(CreatePipelineAsyncTest, BasicUseOfCreateComputePipelineAsync) { TEST_P(CreatePipelineAsyncTest, BasicUseOfCreateComputePipelineAsync) {
wgpu::ComputePipelineDescriptor csDesc; wgpu::ComputePipelineDescriptor csDesc;
csDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"( csDesc.computeStage.module = utils::CreateShaderModule(device, R"(
[[block]] struct SSBO { [[block]] struct SSBO {
value : u32; value : u32;
}; };
@ -101,7 +101,7 @@ TEST_P(CreatePipelineAsyncTest, CreateComputePipelineFailed) {
DAWN_SKIP_TEST_IF(HasToggleEnabled("skip_validation")); DAWN_SKIP_TEST_IF(HasToggleEnabled("skip_validation"));
wgpu::ComputePipelineDescriptor csDesc; wgpu::ComputePipelineDescriptor csDesc;
csDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"( csDesc.computeStage.module = utils::CreateShaderModule(device, R"(
[[block]] struct SSBO { [[block]] struct SSBO {
value : u32; value : u32;
}; };
@ -138,12 +138,12 @@ TEST_P(CreatePipelineAsyncTest, BasicUseOfCreateRenderPipelineAsync) {
constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::RGBA8Unorm; constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::RGBA8Unorm;
utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor; utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor;
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> o_color : vec4<f32>; [[location(0)]] var<out> o_color : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
o_color = vec4<f32>(0.0, 1.0, 0.0, 1.0); o_color = vec4<f32>(0.0, 1.0, 0.0, 1.0);
@ -208,12 +208,12 @@ TEST_P(CreatePipelineAsyncTest, CreateRenderPipelineFailed) {
constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::Depth32Float; constexpr wgpu::TextureFormat kRenderAttachmentFormat = wgpu::TextureFormat::Depth32Float;
utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor; utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor;
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> o_color : vec4<f32>; [[location(0)]] var<out> o_color : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
o_color = vec4<f32>(0.0, 1.0, 0.0, 1.0); o_color = vec4<f32>(0.0, 1.0, 0.0, 1.0);
@ -248,7 +248,7 @@ TEST_P(CreatePipelineAsyncTest, CreateRenderPipelineFailed) {
// CreateComputePipelineAsync() is called. // CreateComputePipelineAsync() is called.
TEST_P(CreatePipelineAsyncTest, ReleaseDeviceBeforeCallbackOfCreateComputePipelineAsync) { TEST_P(CreatePipelineAsyncTest, ReleaseDeviceBeforeCallbackOfCreateComputePipelineAsync) {
wgpu::ComputePipelineDescriptor csDesc; wgpu::ComputePipelineDescriptor csDesc;
csDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"( csDesc.computeStage.module = utils::CreateShaderModule(device, R"(
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {
})"); })");
csDesc.computeStage.entryPoint = "main"; csDesc.computeStage.entryPoint = "main";
@ -272,12 +272,12 @@ TEST_P(CreatePipelineAsyncTest, ReleaseDeviceBeforeCallbackOfCreateComputePipeli
// CreateRenderPipelineAsync() is called. // CreateRenderPipelineAsync() is called.
TEST_P(CreatePipelineAsyncTest, ReleaseDeviceBeforeCallbackOfCreateRenderPipelineAsync) { TEST_P(CreatePipelineAsyncTest, ReleaseDeviceBeforeCallbackOfCreateRenderPipelineAsync) {
utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor; utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor;
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> o_color : vec4<f32>; [[location(0)]] var<out> o_color : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
o_color = vec4<f32>(0.0, 1.0, 0.0, 1.0); o_color = vec4<f32>(0.0, 1.0, 0.0, 1.0);

4
src/tests/end2end/CullingTests.cpp
View File

@ -25,7 +25,7 @@ class CullingTest : public DawnTest {
// Draw two triangles with different winding orders: // Draw two triangles with different winding orders:
// 1. The top-left one is counterclockwise (CCW) // 1. The top-left one is counterclockwise (CCW)
// 2. The bottom-right one is clockwise (CW) // 2. The bottom-right one is clockwise (CW)
pipelineDescriptor.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.vertex.module = utils::CreateShaderModule(device, R"(
const pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>( const pos : array<vec2<f32>, 6> = array<vec2<f32>, 6>(
vec2<f32>(-1.0, 1.0), vec2<f32>(-1.0, 1.0),
vec2<f32>(-1.0, 0.0), vec2<f32>(-1.0, 0.0),
@ -45,7 +45,7 @@ class CullingTest : public DawnTest {
// FragCoord of pixel(x, y) in framebuffer coordinate is (x + 0.5, y + 0.5). And we use // FragCoord of pixel(x, y) in framebuffer coordinate is (x + 0.5, y + 0.5). And we use
// RGBA8 format for the back buffer. So (FragCoord.xy - vec2(0.5)) / 255 in shader code // RGBA8 format for the back buffer. So (FragCoord.xy - vec2(0.5)) / 255 in shader code
// will make the pixel's R and G channels exactly equal to the pixel's x and y coordinates. // will make the pixel's R and G channels exactly equal to the pixel's x and y coordinates.
pipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>;; [[location(0)]] var<out> fragColor : vec4<f32>;;
[[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>; [[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>;

8
src/tests/end2end/D3D12CachingTests.cpp
View File

@ -100,7 +100,7 @@ class D3D12CachingTests : public DawnTest {
TEST_P(D3D12CachingTests, SameShaderNoCache) { TEST_P(D3D12CachingTests, SameShaderNoCache) {
mPersistentCache.mIsDisabled = true; mPersistentCache.mIsDisabled = true;
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn vertex_main() -> void { [[stage(vertex)]] fn vertex_main() -> void {
@ -147,7 +147,7 @@ TEST_P(D3D12CachingTests, SameShaderNoCache) {
// of HLSL shaders. WGSL shader should result into caching 2 HLSL shaders (stage x // of HLSL shaders. WGSL shader should result into caching 2 HLSL shaders (stage x
// entrypoints) // entrypoints)
TEST_P(D3D12CachingTests, ReuseShaderWithMultipleEntryPointsPerStage) { TEST_P(D3D12CachingTests, ReuseShaderWithMultipleEntryPointsPerStage) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn vertex_main() -> void { [[stage(vertex)]] fn vertex_main() -> void {
@ -192,7 +192,7 @@ TEST_P(D3D12CachingTests, ReuseShaderWithMultipleEntryPointsPerStage) {
EXPECT_EQ(mPersistentCache.mCache.size(), 2u); EXPECT_EQ(mPersistentCache.mCache.size(), 2u);
// Modify the WGSL shader functions and make sure it doesn't hit. // Modify the WGSL shader functions and make sure it doesn't hit.
wgpu::ShaderModule newModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule newModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn vertex_main() -> void { [[stage(vertex)]] fn vertex_main() -> void {
@ -225,7 +225,7 @@ TEST_P(D3D12CachingTests, ReuseShaderWithMultipleEntryPointsPerStage) {
// Test creating a WGSL shader with two entrypoints in the same stage will cache the correct number // Test creating a WGSL shader with two entrypoints in the same stage will cache the correct number
// of HLSL shaders. WGSL shader should result into caching 1 HLSL shader (stage x entrypoints) // of HLSL shaders. WGSL shader should result into caching 1 HLSL shader (stage x entrypoints)
TEST_P(D3D12CachingTests, ReuseShaderWithMultipleEntryPoints) { TEST_P(D3D12CachingTests, ReuseShaderWithMultipleEntryPoints) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct Data { [[block]] struct Data {
data : u32; data : u32;
}; };

8
src/tests/end2end/D3D12VideoViewsTests.cpp
View File

@ -221,7 +221,7 @@ namespace {
// Vertex shader used to render a sampled texture into a quad. // Vertex shader used to render a sampled texture into a quad.
wgpu::ShaderModule GetTestVertexShaderModule() const { wgpu::ShaderModule GetTestVertexShaderModule() const {
return utils::CreateShaderModuleFromWGSL(device, R"( return utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[location(0)]] var<out> texCoord : vec2 <f32>; [[location(0)]] var<out> texCoord : vec2 <f32>;
@ -276,7 +276,7 @@ TEST_P(D3D12VideoViewsTests, NV12SampleYtoR) {
utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor; utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor;
renderPipelineDescriptor.vertex.module = GetTestVertexShaderModule(); renderPipelineDescriptor.vertex.module = GetTestVertexShaderModule();
renderPipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( renderPipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"(
[[set(0), binding(0)]] var sampler0 : sampler; [[set(0), binding(0)]] var sampler0 : sampler;
[[set(0), binding(1)]] var texture : texture_2d<f32>; [[set(0), binding(1)]] var texture : texture_2d<f32>;
@ -329,7 +329,7 @@ TEST_P(D3D12VideoViewsTests, NV12SampleUVtoRG) {
utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor; utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor;
renderPipelineDescriptor.vertex.module = GetTestVertexShaderModule(); renderPipelineDescriptor.vertex.module = GetTestVertexShaderModule();
renderPipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( renderPipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"(
[[set(0), binding(0)]] var sampler0 : sampler; [[set(0), binding(0)]] var sampler0 : sampler;
[[set(0), binding(1)]] var texture : texture_2d<f32>; [[set(0), binding(1)]] var texture : texture_2d<f32>;
@ -387,7 +387,7 @@ TEST_P(D3D12VideoViewsTests, NV12SampleYUVtoRGB) {
utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor; utils::ComboRenderPipelineDescriptor2 renderPipelineDescriptor;
renderPipelineDescriptor.vertex.module = GetTestVertexShaderModule(); renderPipelineDescriptor.vertex.module = GetTestVertexShaderModule();
renderPipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( renderPipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"(
[[set(0), binding(0)]] var sampler0 : sampler; [[set(0), binding(0)]] var sampler0 : sampler;
[[set(0), binding(1)]] var lumaTexture : texture_2d<f32>; [[set(0), binding(1)]] var lumaTexture : texture_2d<f32>;
[[set(0), binding(2)]] var chromaTexture : texture_2d<f32>; [[set(0), binding(2)]] var chromaTexture : texture_2d<f32>;

6
src/tests/end2end/DeprecatedAPITests.cpp
View File

@ -496,7 +496,7 @@ class VertexFormatDeprecationTests : public DeprecationTests {
? "vec4<f32>(f32(a.x), 0.0, 0.0, 1.0)" ? "vec4<f32>(f32(a.x), 0.0, 0.0, 1.0)"
: "vec4<f32>(f32(a), 0.0, 0.0, 1.0)"; : "vec4<f32>(f32(a), 0.0, 0.0, 1.0)";
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, (attribute + R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, (attribute + R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
@ -504,8 +504,8 @@ class VertexFormatDeprecationTests : public DeprecationTests {
return; return;
} }
)") )")
.c_str()); .c_str());
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> outColor : vec4<f32>; [[location(0)]] var<out> outColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {

4
src/tests/end2end/DepthBiasTests.cpp
View File

@ -70,9 +70,9 @@ class DepthBiasTests : public DawnTest {
break; break;
} }
wgpu::ShaderModule vertexModule = utils::CreateShaderModuleFromWGSL(device, vertexSource); wgpu::ShaderModule vertexModule = utils::CreateShaderModule(device, vertexSource);
wgpu::ShaderModule fragmentModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fragmentModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>;; [[location(0)]] var<out> fragColor : vec4<f32>;;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0); fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);

10
src/tests/end2end/DepthStencilCopyTests.cpp
View File

@ -28,7 +28,7 @@ class DepthStencilCopyTests : public DawnTest {
DawnTest::SetUp(); DawnTest::SetUp();
// Draw a square in the bottom left quarter of the screen. // Draw a square in the bottom left quarter of the screen.
mVertexModule = utils::CreateShaderModuleFromWGSL(device, R"( mVertexModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -79,7 +79,7 @@ class DepthStencilCopyTests : public DawnTest {
FragDepth = )" + std::to_string(regionDepth) + FragDepth = )" + std::to_string(regionDepth) +
";\n}"; ";\n}";
desc->cFragment.module = utils::CreateShaderModuleFromWGSL(device, fsSource.c_str()); desc->cFragment.module = utils::CreateShaderModule(device, fsSource.c_str());
wgpu::DepthStencilState* depthStencil = desc->EnableDepthStencil(format); wgpu::DepthStencilState* depthStencil = desc->EnableDepthStencil(format);
depthStencil->depthWriteEnabled = true; depthStencil->depthWriteEnabled = true;
desc->cFragment.targetCount = 0; desc->cFragment.targetCount = 0;
@ -238,7 +238,7 @@ class DepthStencilCopyTests : public DawnTest {
// Pipeline for a full screen quad. // Pipeline for a full screen quad.
utils::ComboRenderPipelineDescriptor2 pipelineDescriptor; utils::ComboRenderPipelineDescriptor2 pipelineDescriptor;
pipelineDescriptor.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.vertex.module = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -252,7 +252,7 @@ class DepthStencilCopyTests : public DawnTest {
// Sample the input texture and write out depth. |result| will only be set to 1 if we // Sample the input texture and write out depth. |result| will only be set to 1 if we
// pass the depth test. // pass the depth test.
pipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var texture0 : texture_2d<f32>; [[group(0), binding(0)]] var texture0 : texture_2d<f32>;
[[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>; [[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>;
@ -645,7 +645,7 @@ TEST_P(DepthStencilCopyTests, ToStencilAspect) {
// A quad is drawn in the bottom left. // A quad is drawn in the bottom left.
utils::ComboRenderPipelineDescriptor2 renderPipelineDesc; utils::ComboRenderPipelineDescriptor2 renderPipelineDesc;
renderPipelineDesc.vertex.module = mVertexModule; renderPipelineDesc.vertex.module = mVertexModule;
renderPipelineDesc.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( renderPipelineDesc.cFragment.module = utils::CreateShaderModule(device, R"(
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
wgpu::DepthStencilState* depthStencil = wgpu::DepthStencilState* depthStencil =

14
src/tests/end2end/DepthStencilSamplingTests.cpp
View File

@ -65,7 +65,7 @@ class DepthStencilSamplingTest : public DawnTest {
wgpu::RenderPipeline CreateSamplingRenderPipeline(std::vector<TestAspect> aspects, wgpu::RenderPipeline CreateSamplingRenderPipeline(std::vector<TestAspect> aspects,
uint32_t componentIndex) { uint32_t componentIndex) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
@ -108,8 +108,7 @@ class DepthStencilSamplingTest : public DawnTest {
shaderSource << "[[stage(fragment)]] fn main() -> void { " << shaderBody.str() << "\n}"; shaderSource << "[[stage(fragment)]] fn main() -> void { " << shaderBody.str() << "\n}";
wgpu::ShaderModule fsModule = wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, shaderSource.str().c_str());
utils::CreateShaderModuleFromWGSL(device, shaderSource.str().c_str());
pipelineDescriptor.vertex.module = vsModule; pipelineDescriptor.vertex.module = vsModule;
pipelineDescriptor.cFragment.module = fsModule; pipelineDescriptor.cFragment.module = fsModule;
pipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; pipelineDescriptor.primitive.topology = wgpu::PrimitiveTopology::PointList;
@ -163,8 +162,7 @@ class DepthStencilSamplingTest : public DawnTest {
shaderSource << "[[stage(compute)]] fn main() -> void { " << shaderBody.str() << "\n}"; shaderSource << "[[stage(compute)]] fn main() -> void { " << shaderBody.str() << "\n}";
wgpu::ShaderModule csModule = wgpu::ShaderModule csModule = utils::CreateShaderModule(device, shaderSource.str().c_str());
utils::CreateShaderModuleFromWGSL(device, shaderSource.str().c_str());
wgpu::ComputePipelineDescriptor pipelineDescriptor; wgpu::ComputePipelineDescriptor pipelineDescriptor;
pipelineDescriptor.computeStage.module = csModule; pipelineDescriptor.computeStage.module = csModule;
@ -174,13 +172,13 @@ class DepthStencilSamplingTest : public DawnTest {
} }
wgpu::RenderPipeline CreateComparisonRenderPipeline() { wgpu::RenderPipeline CreateComparisonRenderPipeline() {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var samp : sampler_comparison; [[group(0), binding(0)]] var samp : sampler_comparison;
[[group(0), binding(1)]] var tex : texture_depth_2d; [[group(0), binding(1)]] var tex : texture_depth_2d;
[[block]] struct Uniforms { [[block]] struct Uniforms {
@ -212,7 +210,7 @@ class DepthStencilSamplingTest : public DawnTest {
} }
wgpu::ComputePipeline CreateComparisonComputePipeline() { wgpu::ComputePipeline CreateComparisonComputePipeline() {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var samp : sampler_comparison; [[group(0), binding(0)]] var samp : sampler_comparison;
[[group(0), binding(1)]] var tex : texture_depth_2d; [[group(0), binding(1)]] var tex : texture_depth_2d;
[[block]] struct Uniforms { [[block]] struct Uniforms {

4
src/tests/end2end/DepthStencilStateTests.cpp
View File

@ -52,7 +52,7 @@ class DepthStencilStateTest : public DawnTest {
depthTextureView = depthTexture.CreateView(); depthTextureView = depthTexture.CreateView();
vsModule = utils::CreateShaderModuleFromWGSL(device, R"( vsModule = utils::CreateShaderModule(device, R"(
[[block]] struct UBO { [[block]] struct UBO {
color : vec3<f32>; color : vec3<f32>;
depth : f32; depth : f32;
@ -72,7 +72,7 @@ class DepthStencilStateTest : public DawnTest {
Position = vec4<f32>(pos[VertexIndex], ubo.depth, 1.0); Position = vec4<f32>(pos[VertexIndex], ubo.depth, 1.0);
})"); })");
fsModule = utils::CreateShaderModuleFromWGSL(device, R"( fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct UBO { [[block]] struct UBO {
color : vec3<f32>; color : vec3<f32>;
depth : f32; depth : f32;

4
src/tests/end2end/DestroyTests.cpp
View File

@ -27,14 +27,14 @@ class DestroyTest : public DawnTest {
renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec4<f32>; [[location(0)]] var<in> pos : vec4<f32>;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = pos; Position = pos;
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

4
src/tests/end2end/DeviceLostTests.cpp
View File

@ -124,7 +124,7 @@ TEST_P(DeviceLostTest, CreateBindGroupLayoutFails) {
// Test that GetBindGroupLayout fails when device is lost // Test that GetBindGroupLayout fails when device is lost
TEST_P(DeviceLostTest, GetBindGroupLayoutFails) { TEST_P(DeviceLostTest, GetBindGroupLayoutFails) {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[block]] struct UniformBuffer { [[block]] struct UniformBuffer {
pos : vec4<f32>; pos : vec4<f32>;
}; };
@ -211,7 +211,7 @@ TEST_P(DeviceLostTest, CreateSamplerFails) {
TEST_P(DeviceLostTest, CreateShaderModuleFails) { TEST_P(DeviceLostTest, CreateShaderModuleFails) {
SetCallbackAndLoseForTesting(); SetCallbackAndLoseForTesting();
ASSERT_DEVICE_ERROR(utils::CreateShaderModuleFromWGSL(device, R"( ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> color : vec4<f32>; [[location(0)]] var<in> color : vec4<f32>;
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {

4
src/tests/end2end/DrawIndexedIndirectTests.cpp
View File

@ -26,14 +26,14 @@ class DrawIndexedIndirectTest : public DawnTest {
renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec4<f32>; [[location(0)]] var<in> pos : vec4<f32>;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = pos; Position = pos;
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

4
src/tests/end2end/DrawIndexedTests.cpp
View File

@ -26,14 +26,14 @@ class DrawIndexedTest : public DawnTest {
renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec4<f32>; [[location(0)]] var<in> pos : vec4<f32>;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = pos; Position = pos;
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

4
src/tests/end2end/DrawIndirectTests.cpp
View File

@ -26,14 +26,14 @@ class DrawIndirectTest : public DawnTest {
renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec4<f32>; [[location(0)]] var<in> pos : vec4<f32>;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = pos; Position = pos;
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

4
src/tests/end2end/DrawTests.cpp
View File

@ -26,14 +26,14 @@ class DrawTest : public DawnTest {
renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec4<f32>; [[location(0)]] var<in> pos : vec4<f32>;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = pos; Position = pos;
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

6
src/tests/end2end/DynamicBufferOffsetTests.cpp
View File

@ -93,7 +93,7 @@ class DynamicBufferOffsetTests : public DawnTest {
wgpu::Texture mColorAttachment; wgpu::Texture mColorAttachment;
wgpu::RenderPipeline CreateRenderPipeline(bool isInheritedPipeline = false) { wgpu::RenderPipeline CreateRenderPipeline(bool isInheritedPipeline = false) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
@ -153,7 +153,7 @@ class DynamicBufferOffsetTests : public DawnTest {
} }
)"; )";
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, fs.str().c_str()); wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, fs.str().c_str());
utils::ComboRenderPipelineDescriptor2 pipelineDescriptor; utils::ComboRenderPipelineDescriptor2 pipelineDescriptor;
pipelineDescriptor.vertex.module = vsModule; pipelineDescriptor.vertex.module = vsModule;
@ -218,7 +218,7 @@ class DynamicBufferOffsetTests : public DawnTest {
} }
)"; )";
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, cs.str().c_str()); wgpu::ShaderModule csModule = utils::CreateShaderModule(device, cs.str().c_str());
wgpu::ComputePipelineDescriptor csDesc; wgpu::ComputePipelineDescriptor csDesc;
csDesc.computeStage.module = csModule; csDesc.computeStage.module = csModule;

4
src/tests/end2end/EntryPointTests.cpp
View File

@ -23,7 +23,7 @@ class EntryPointTests : public DawnTest {};
TEST_P(EntryPointTests, FragAndVertexSameModule) { TEST_P(EntryPointTests, FragAndVertexSameModule) {
// TODO(crbug.com/dawn/658): Crashes on bots // TODO(crbug.com/dawn/658): Crashes on bots
DAWN_SKIP_TEST_IF(IsOpenGL() || IsOpenGLES()); DAWN_SKIP_TEST_IF(IsOpenGL() || IsOpenGLES());
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn vertex_main() -> void { [[stage(vertex)]] fn vertex_main() -> void {
@ -70,7 +70,7 @@ TEST_P(EntryPointTests, TwoComputeInModule) {
// https://crbug.com/tint/297 // https://crbug.com/tint/297
DAWN_SKIP_TEST_IF(IsD3D12() && HasToggleEnabled("use_tint_generator")); DAWN_SKIP_TEST_IF(IsD3D12() && HasToggleEnabled("use_tint_generator"));
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct Data { [[block]] struct Data {
data : u32; data : u32;
}; };

6
src/tests/end2end/FirstIndexOffsetTests.cpp
View File

@ -155,10 +155,8 @@ void FirstIndexOffsetTests::TestImpl(DrawMode mode,
constexpr uint32_t kComponentsPerVertex = 4; constexpr uint32_t kComponentsPerVertex = 4;
utils::ComboRenderPipelineDescriptor2 pipelineDesc; utils::ComboRenderPipelineDescriptor2 pipelineDesc;
pipelineDesc.vertex.module = pipelineDesc.vertex.module = utils::CreateShaderModule(device, vertexShader.str().c_str());
utils::CreateShaderModuleFromWGSL(device, vertexShader.str().c_str()); pipelineDesc.cFragment.module = utils::CreateShaderModule(device, fragmentShader.str().c_str());
pipelineDesc.cFragment.module =
utils::CreateShaderModuleFromWGSL(device, fragmentShader.str().c_str());
pipelineDesc.primitive.topology = wgpu::PrimitiveTopology::PointList; pipelineDesc.primitive.topology = wgpu::PrimitiveTopology::PointList;
pipelineDesc.vertex.bufferCount = 1; pipelineDesc.vertex.bufferCount = 1;
pipelineDesc.cBuffers[0].arrayStride = kComponentsPerVertex * sizeof(float); pipelineDesc.cBuffers[0].arrayStride = kComponentsPerVertex * sizeof(float);

26
src/tests/end2end/GpuMemorySynchronizationTests.cpp
View File

@ -35,7 +35,7 @@ class GpuMemorySyncTests : public DawnTest {
std::tuple<wgpu::ComputePipeline, wgpu::BindGroup> CreatePipelineAndBindGroupForCompute( std::tuple<wgpu::ComputePipeline, wgpu::BindGroup> CreatePipelineAndBindGroupForCompute(
const wgpu::Buffer& buffer) { const wgpu::Buffer& buffer) {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[block]] struct Data { [[block]] struct Data {
a : i32; a : i32;
}; };
@ -57,13 +57,13 @@ class GpuMemorySyncTests : public DawnTest {
std::tuple<wgpu::RenderPipeline, wgpu::BindGroup> CreatePipelineAndBindGroupForRender( std::tuple<wgpu::RenderPipeline, wgpu::BindGroup> CreatePipelineAndBindGroupForRender(
const wgpu::Buffer& buffer, const wgpu::Buffer& buffer,
wgpu::TextureFormat colorFormat) { wgpu::TextureFormat colorFormat) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct Data { [[block]] struct Data {
i : i32; i : i32;
}; };
@ -252,7 +252,7 @@ TEST_P(GpuMemorySyncTests, SampledAndROStorageTextureInComputePass) {
// Create a pipeline that loads the texture from both the sampled and storage paths. // Create a pipeline that loads the texture from both the sampled and storage paths.
wgpu::ComputePipelineDescriptor pipelineDesc; wgpu::ComputePipelineDescriptor pipelineDesc;
pipelineDesc.computeStage.entryPoint = "main"; pipelineDesc.computeStage.entryPoint = "main";
pipelineDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDesc.computeStage.module = utils::CreateShaderModule(device, R"(
[[block]] struct Output { [[block]] struct Output {
sampledOut: u32; sampledOut: u32;
storageOut: u32; storageOut: u32;
@ -313,7 +313,7 @@ class StorageToUniformSyncTests : public DawnTest {
} }
std::tuple<wgpu::ComputePipeline, wgpu::BindGroup> CreatePipelineAndBindGroupForCompute() { std::tuple<wgpu::ComputePipeline, wgpu::BindGroup> CreatePipelineAndBindGroupForCompute() {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[block]] struct Data { [[block]] struct Data {
a : f32; a : f32;
}; };
@ -334,13 +334,13 @@ class StorageToUniformSyncTests : public DawnTest {
std::tuple<wgpu::RenderPipeline, wgpu::BindGroup> CreatePipelineAndBindGroupForRender( std::tuple<wgpu::RenderPipeline, wgpu::BindGroup> CreatePipelineAndBindGroupForRender(
wgpu::TextureFormat colorFormat) { wgpu::TextureFormat colorFormat) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct Contents { [[block]] struct Contents {
color : f32; color : f32;
}; };
@ -512,7 +512,7 @@ class MultipleWriteThenMultipleReadTests : public DawnTest {
// operation in compute pass. // operation in compute pass.
TEST_P(MultipleWriteThenMultipleReadTests, SeparateBuffers) { TEST_P(MultipleWriteThenMultipleReadTests, SeparateBuffers) {
// Create pipeline, bind group, and different buffers for compute pass. // Create pipeline, bind group, and different buffers for compute pass.
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[block]] struct VBContents { [[block]] struct VBContents {
pos : array<vec4<f32>, 4>; pos : array<vec4<f32>, 4>;
}; };
@ -573,14 +573,14 @@ TEST_P(MultipleWriteThenMultipleReadTests, SeparateBuffers) {
pass0.EndPass(); pass0.EndPass();
// Create pipeline, bind group, and reuse buffers in render pass. // Create pipeline, bind group, and reuse buffers in render pass.
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec4<f32>; [[location(0)]] var<in> pos : vec4<f32>;
[[builtin(position)]] var<out> Position: vec4<f32>; [[builtin(position)]] var<out> Position: vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = pos; Position = pos;
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct Buf { [[block]] struct Buf {
color : f32; color : f32;
}; };
@ -640,7 +640,7 @@ TEST_P(MultipleWriteThenMultipleReadTests, OneBuffer) {
DAWN_SKIP_TEST_IF(IsOpenGLES()); DAWN_SKIP_TEST_IF(IsOpenGLES());
// Create pipeline, bind group, and a complex buffer for compute pass. // Create pipeline, bind group, and a complex buffer for compute pass.
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[block]] struct Contents { [[block]] struct Contents {
[[align(256)]] pos : array<vec4<f32>, 4>; [[align(256)]] pos : array<vec4<f32>, 4>;
[[align(256)]] indices : array<vec4<i32>, 2>; [[align(256)]] indices : array<vec4<i32>, 2>;
@ -691,14 +691,14 @@ TEST_P(MultipleWriteThenMultipleReadTests, OneBuffer) {
pass0.EndPass(); pass0.EndPass();
// Create pipeline, bind group, and reuse the buffer in render pass. // Create pipeline, bind group, and reuse the buffer in render pass.
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec4<f32>; [[location(0)]] var<in> pos : vec4<f32>;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = pos; Position = pos;
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct Buf { [[block]] struct Buf {
color : f32; color : f32;
}; };

4
src/tests/end2end/IOSurfaceWrappingTests.cpp
View File

@ -247,7 +247,7 @@ class IOSurfaceUsageTests : public IOSurfaceTestBase {
// The simplest texture sampling pipeline. // The simplest texture sampling pipeline.
wgpu::RenderPipeline pipeline; wgpu::RenderPipeline pipeline;
{ {
wgpu::ShaderModule vs = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vs = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[location(0)]] var<out> o_texCoord : vec2<f32>; [[location(0)]] var<out> o_texCoord : vec2<f32>;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -273,7 +273,7 @@ class IOSurfaceUsageTests : public IOSurfaceTestBase {
o_texCoord = texCoord[VertexIndex]; o_texCoord = texCoord[VertexIndex];
} }
)"); )");
wgpu::ShaderModule fs = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fs = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var sampler0 : sampler; [[group(0), binding(0)]] var sampler0 : sampler;
[[group(0), binding(1)]] var texture0 : texture_2d<f32>; [[group(0), binding(1)]] var texture0 : texture_2d<f32>;

4
src/tests/end2end/IndexFormatTests.cpp
View File

@ -32,7 +32,7 @@ class IndexFormatTest : public DawnTest {
wgpu::RenderPipeline MakeTestPipeline(wgpu::IndexFormat format, wgpu::RenderPipeline MakeTestPipeline(wgpu::IndexFormat format,
wgpu::PrimitiveTopology primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip) { wgpu::PrimitiveTopology primitiveTopology = wgpu::PrimitiveTopology::TriangleStrip) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec4<f32>; [[location(0)]] var<in> pos : vec4<f32>;
[[builtin(vertex_index)]] var<in> idx : u32; [[builtin(vertex_index)]] var<in> idx : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -45,7 +45,7 @@ class IndexFormatTest : public DawnTest {
} }
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

6
src/tests/end2end/MultisampledRenderingTests.cpp
View File

@ -238,12 +238,12 @@ class MultisampledRenderingTest : public DawnTest {
})"; })";
if (flipTriangle) { if (flipTriangle) {
pipelineDescriptor.vertex.module = utils::CreateShaderModuleFromWGSL(device, vsFlipped); pipelineDescriptor.vertex.module = utils::CreateShaderModule(device, vsFlipped);
} else { } else {
pipelineDescriptor.vertex.module = utils::CreateShaderModuleFromWGSL(device, vs); pipelineDescriptor.vertex.module = utils::CreateShaderModule(device, vs);
} }
pipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, fs); pipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, fs);
if (hasDepthStencilAttachment) { if (hasDepthStencilAttachment) {
wgpu::DepthStencilState* depthStencil = wgpu::DepthStencilState* depthStencil =

6
src/tests/end2end/MultisampledSamplingTests.cpp
View File

@ -53,14 +53,14 @@ class MultisampledSamplingTest : public DawnTest {
{ {
utils::ComboRenderPipelineDescriptor2 desc; utils::ComboRenderPipelineDescriptor2 desc;
desc.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( desc.vertex.module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec2<f32>; [[location(0)]] var<in> pos : vec2<f32>;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(pos, 0.0, 1.0); Position = vec4<f32>(pos, 0.0, 1.0);
})"); })");
desc.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( desc.cFragment.module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : f32; [[location(0)]] var<out> fragColor : f32;
[[builtin(frag_depth)]] var<out> FragDepth : f32; [[builtin(frag_depth)]] var<out> FragDepth : f32;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
@ -88,7 +88,7 @@ class MultisampledSamplingTest : public DawnTest {
{ {
wgpu::ComputePipelineDescriptor desc = {}; wgpu::ComputePipelineDescriptor desc = {};
desc.computeStage.entryPoint = "main"; desc.computeStage.entryPoint = "main";
desc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"( desc.computeStage.module = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var texture0 : texture_multisampled_2d<f32>; [[group(0), binding(0)]] var texture0 : texture_multisampled_2d<f32>;
[[group(0), binding(1)]] var texture1 : texture_multisampled_2d<f32>; [[group(0), binding(1)]] var texture1 : texture_multisampled_2d<f32>;

34
src/tests/end2end/ObjectCachingTests.cpp
View File

@ -103,17 +103,17 @@ TEST_P(ObjectCachingTest, PipelineLayoutDeduplication) {
// Test that ShaderModules are correctly deduplicated. // Test that ShaderModules are correctly deduplicated.
TEST_P(ObjectCachingTest, ShaderModuleDeduplication) { TEST_P(ObjectCachingTest, ShaderModuleDeduplication) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);
})"); })");
wgpu::ShaderModule sameModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule sameModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);
})"); })");
wgpu::ShaderModule otherModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule otherModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 0.0, 0.0, 0.0); fragColor = vec4<f32>(0.0, 0.0, 0.0, 0.0);
@ -125,17 +125,17 @@ TEST_P(ObjectCachingTest, ShaderModuleDeduplication) {
// Test that ComputePipeline are correctly deduplicated wrt. their ShaderModule // Test that ComputePipeline are correctly deduplicated wrt. their ShaderModule
TEST_P(ObjectCachingTest, ComputePipelineDeduplicationOnShaderModule) { TEST_P(ObjectCachingTest, ComputePipelineDeduplicationOnShaderModule) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
var<workgroup> i : u32; var<workgroup> i : u32;
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {
i = 0u; i = 0u;
})"); })");
wgpu::ShaderModule sameModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule sameModule = utils::CreateShaderModule(device, R"(
var<workgroup> i : u32; var<workgroup> i : u32;
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {
i = 0u; i = 0u;
})"); })");
wgpu::ShaderModule otherModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule otherModule = utils::CreateShaderModule(device, R"(
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {
})"); })");
@ -177,7 +177,7 @@ TEST_P(ObjectCachingTest, ComputePipelineDeduplicationOnLayout) {
wgpu::ComputePipelineDescriptor desc; wgpu::ComputePipelineDescriptor desc;
desc.computeStage.entryPoint = "main"; desc.computeStage.entryPoint = "main";
desc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"( desc.computeStage.module = utils::CreateShaderModule(device, R"(
var<workgroup> i : u32; var<workgroup> i : u32;
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {
i = 0u; i = 0u;
@ -211,12 +211,12 @@ TEST_P(ObjectCachingTest, RenderPipelineDeduplicationOnLayout) {
EXPECT_EQ(pl.Get() == samePl.Get(), !UsesWire()); EXPECT_EQ(pl.Get() == samePl.Get(), !UsesWire());
utils::ComboRenderPipelineDescriptor2 desc; utils::ComboRenderPipelineDescriptor2 desc;
desc.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( desc.vertex.module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 0.0); Position = vec4<f32>(0.0, 0.0, 0.0, 0.0);
})"); })");
desc.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( desc.cFragment.module = utils::CreateShaderModule(device, R"(
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
@ -235,17 +235,17 @@ TEST_P(ObjectCachingTest, RenderPipelineDeduplicationOnLayout) {
// Test that RenderPipelines are correctly deduplicated wrt. their vertex module // Test that RenderPipelines are correctly deduplicated wrt. their vertex module
TEST_P(ObjectCachingTest, RenderPipelineDeduplicationOnVertexModule) { TEST_P(ObjectCachingTest, RenderPipelineDeduplicationOnVertexModule) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 0.0); Position = vec4<f32>(0.0, 0.0, 0.0, 0.0);
})"); })");
wgpu::ShaderModule sameModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule sameModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 0.0); Position = vec4<f32>(0.0, 0.0, 0.0, 0.0);
})"); })");
wgpu::ShaderModule otherModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule otherModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(1.0, 1.0, 1.0, 1.0); Position = vec4<f32>(1.0, 1.0, 1.0, 1.0);
@ -255,7 +255,7 @@ TEST_P(ObjectCachingTest, RenderPipelineDeduplicationOnVertexModule) {
EXPECT_EQ(module.Get() == sameModule.Get(), !UsesWire()); EXPECT_EQ(module.Get() == sameModule.Get(), !UsesWire());
utils::ComboRenderPipelineDescriptor2 desc; utils::ComboRenderPipelineDescriptor2 desc;
desc.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( desc.cFragment.module = utils::CreateShaderModule(device, R"(
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
@ -274,13 +274,13 @@ TEST_P(ObjectCachingTest, RenderPipelineDeduplicationOnVertexModule) {
// Test that RenderPipelines are correctly deduplicated wrt. their fragment module // Test that RenderPipelines are correctly deduplicated wrt. their fragment module
TEST_P(ObjectCachingTest, RenderPipelineDeduplicationOnFragmentModule) { TEST_P(ObjectCachingTest, RenderPipelineDeduplicationOnFragmentModule) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
wgpu::ShaderModule sameModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule sameModule = utils::CreateShaderModule(device, R"(
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
wgpu::ShaderModule otherModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule otherModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 0.0, 0.0, 0.0); fragColor = vec4<f32>(0.0, 0.0, 0.0, 0.0);
@ -290,7 +290,7 @@ TEST_P(ObjectCachingTest, RenderPipelineDeduplicationOnFragmentModule) {
EXPECT_EQ(module.Get() == sameModule.Get(), !UsesWire()); EXPECT_EQ(module.Get() == sameModule.Get(), !UsesWire());
utils::ComboRenderPipelineDescriptor2 desc; utils::ComboRenderPipelineDescriptor2 desc;
desc.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( desc.vertex.module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 0.0); Position = vec4<f32>(0.0, 0.0, 0.0, 0.0);

16
src/tests/end2end/OpArrayLengthTests.cpp
View File

@ -124,7 +124,7 @@ TEST_P(OpArrayLengthTest, Compute) {
wgpu::ComputePipelineDescriptor pipelineDesc; wgpu::ComputePipelineDescriptor pipelineDesc;
pipelineDesc.layout = pl; pipelineDesc.layout = pl;
pipelineDesc.computeStage.entryPoint = "main"; pipelineDesc.computeStage.entryPoint = "main";
pipelineDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, (R"( pipelineDesc.computeStage.module = utils::CreateShaderModule(device, (R"(
[[block]] struct ResultBuffer { [[block]] struct ResultBuffer {
data : [[stride(4)]] array<u32, 3>; data : [[stride(4)]] array<u32, 3>;
}; };
@ -135,7 +135,7 @@ TEST_P(OpArrayLengthTest, Compute) {
result.data[1] = arrayLength(buffer2.data); result.data[1] = arrayLength(buffer2.data);
result.data[2] = arrayLength(buffer3.data); result.data[2] = arrayLength(buffer3.data);
})") })")
.c_str()); .c_str());
wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc); wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc);
// Run a single instance of the compute shader // Run a single instance of the compute shader
@ -164,13 +164,13 @@ TEST_P(OpArrayLengthTest, Fragment) {
// Create the pipeline that computes the length of the buffers and writes it to the only render // Create the pipeline that computes the length of the buffers and writes it to the only render
// pass pixel. // pass pixel.
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, (mShaderInterface + R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, (mShaderInterface + R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor.r = f32(arrayLength(buffer1.data)) / 255.0; fragColor.r = f32(arrayLength(buffer1.data)) / 255.0;
@ -178,7 +178,7 @@ TEST_P(OpArrayLengthTest, Fragment) {
fragColor.b = f32(arrayLength(buffer3.data)) / 255.0; fragColor.b = f32(arrayLength(buffer3.data)) / 255.0;
fragColor.a = 0.0; fragColor.a = 0.0;
})") })")
.c_str()); .c_str());
utils::ComboRenderPipelineDescriptor2 descriptor; utils::ComboRenderPipelineDescriptor2 descriptor;
descriptor.vertex.module = vsModule; descriptor.vertex.module = vsModule;
@ -220,7 +220,7 @@ TEST_P(OpArrayLengthTest, Vertex) {
// Create the pipeline that computes the length of the buffers and writes it to the only render // Create the pipeline that computes the length of the buffers and writes it to the only render
// pass pixel. // pass pixel.
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, (mShaderInterface + R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, (mShaderInterface + R"(
[[location(0)]] var<out> pointColor : vec4<f32>; [[location(0)]] var<out> pointColor : vec4<f32>;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
@ -231,9 +231,9 @@ TEST_P(OpArrayLengthTest, Vertex) {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})") })")
.c_str()); .c_str());
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[location(0)]] var<in> pointColor : vec4<f32>; [[location(0)]] var<in> pointColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {

4
src/tests/end2end/PrimitiveTopologyTests.cpp
View File

@ -153,14 +153,14 @@ class PrimitiveTopologyTest : public DawnTest {
renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
vsModule = utils::CreateShaderModuleFromWGSL(device, R"( vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec4<f32>; [[location(0)]] var<in> pos : vec4<f32>;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = pos; Position = pos;
})"); })");
fsModule = utils::CreateShaderModuleFromWGSL(device, R"( fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

4
src/tests/end2end/QueryTests.cpp
View File

@ -78,7 +78,7 @@ class OcclusionQueryTests : public QueryTests {
void SetUp() override { void SetUp() override {
DawnTest::SetUp(); DawnTest::SetUp();
vsModule = utils::CreateShaderModuleFromWGSL(device, R"( vsModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
@ -89,7 +89,7 @@ class OcclusionQueryTests : public QueryTests {
Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
})"); })");
fsModule = utils::CreateShaderModuleFromWGSL(device, R"( fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

4
src/tests/end2end/RenderBundleTests.cpp
View File

@ -31,14 +31,14 @@ class RenderBundleTest : public DawnTest {
renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); renderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec4<f32>; [[location(0)]] var<in> pos : vec4<f32>;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = pos; Position = pos;
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[block]] struct Ubo { [[block]] struct Ubo {
color : vec4<f32>; color : vec4<f32>;

4
src/tests/end2end/RenderPassLoadOpTests.cpp
View File

@ -26,8 +26,8 @@ class DrawQuad {
DrawQuad() { DrawQuad() {
} }
DrawQuad(wgpu::Device device, const char* vsSource, const char* fsSource) : device(device) { DrawQuad(wgpu::Device device, const char* vsSource, const char* fsSource) : device(device) {
vsModule = utils::CreateShaderModuleFromWGSL(device, vsSource); vsModule = utils::CreateShaderModule(device, vsSource);
fsModule = utils::CreateShaderModuleFromWGSL(device, fsSource); fsModule = utils::CreateShaderModule(device, fsSource);
pipelineLayout = utils::MakeBasicPipelineLayout(device, nullptr); pipelineLayout = utils::MakeBasicPipelineLayout(device, nullptr);
} }

6
src/tests/end2end/RenderPassTests.cpp
View File

@ -26,7 +26,7 @@ class RenderPassTest : public DawnTest {
DawnTest::SetUp(); DawnTest::SetUp();
// Shaders to draw a bottom-left triangle in blue. // Shaders to draw a bottom-left triangle in blue.
mVSModule = utils::CreateShaderModuleFromWGSL(device, R"( mVSModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -39,7 +39,7 @@ class RenderPassTest : public DawnTest {
Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 0.0, 1.0, 1.0); fragColor = vec4<f32>(0.0, 0.0, 1.0, 1.0);
@ -140,7 +140,7 @@ TEST_P(RenderPassTest, NoCorrespondingFragmentShaderOutputs) {
{ {
// Next we use a pipeline whose fragment shader has no outputs. // Next we use a pipeline whose fragment shader has no outputs.
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
utils::ComboRenderPipelineDescriptor2 descriptor; utils::ComboRenderPipelineDescriptor2 descriptor;

4
src/tests/end2end/SamplerFilterAnisotropicTests.cpp
View File

@ -37,7 +37,7 @@ class SamplerFilterAnisotropicTest : public DawnTest {
DawnTest::SetUp(); DawnTest::SetUp();
mRenderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); mRenderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[block]] struct Uniforms { [[block]] struct Uniforms {
matrix : mat4x4<f32>; matrix : mat4x4<f32>;
}; };
@ -55,7 +55,7 @@ class SamplerFilterAnisotropicTest : public DawnTest {
Position = uniforms.matrix * position; Position = uniforms.matrix * position;
} }
)"); )");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var sampler0 : sampler; [[group(0), binding(0)]] var sampler0 : sampler;
[[group(0), binding(1)]] var texture0 : texture_2d<f32>; [[group(0), binding(1)]] var texture0 : texture_2d<f32>;

4
src/tests/end2end/SamplerTests.cpp
View File

@ -54,7 +54,7 @@ class SamplerTest : public DawnTest {
DawnTest::SetUp(); DawnTest::SetUp();
mRenderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize); mRenderPass = utils::CreateBasicRenderPass(device, kRTSize, kRTSize);
auto vsModule = utils::CreateShaderModuleFromWGSL(device, R"( auto vsModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -69,7 +69,7 @@ class SamplerTest : public DawnTest {
Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
} }
)"); )");
auto fsModule = utils::CreateShaderModuleFromWGSL(device, R"( auto fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var sampler0 : sampler; [[group(0), binding(0)]] var sampler0 : sampler;
[[group(0), binding(1)]] var texture0 : texture_2d<f32>; [[group(0), binding(1)]] var texture0 : texture_2d<f32>;

4
src/tests/end2end/ScissorTests.cpp
View File

@ -20,7 +20,7 @@
class ScissorTest : public DawnTest { class ScissorTest : public DawnTest {
protected: protected:
wgpu::RenderPipeline CreateQuadPipeline(wgpu::TextureFormat format) { wgpu::RenderPipeline CreateQuadPipeline(wgpu::TextureFormat format) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -36,7 +36,7 @@ class ScissorTest : public DawnTest {
Position = vec4<f32>(pos[VertexIndex], 0.5, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.5, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

2
src/tests/end2end/ShaderTests.cpp
View File

@ -62,7 +62,7 @@ TEST_P(ShaderTests, ComputeLog2) {
})"; })";
wgpu::ComputePipelineDescriptor csDesc; wgpu::ComputePipelineDescriptor csDesc;
csDesc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, shader.c_str()); csDesc.computeStage.module = utils::CreateShaderModule(device, shader.c_str());
csDesc.computeStage.entryPoint = "main"; csDesc.computeStage.entryPoint = "main";
wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&csDesc); wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&csDesc);

10
src/tests/end2end/StorageTextureTests.cpp
View File

@ -461,7 +461,7 @@ fn IsEqualTo(pixel : vec4<f32>, expected : vec4<f32>) -> bool {
} }
wgpu::ComputePipeline CreateComputePipeline(const char* computeShader) { wgpu::ComputePipeline CreateComputePipeline(const char* computeShader) {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, computeShader); wgpu::ShaderModule csModule = utils::CreateShaderModule(device, computeShader);
wgpu::ComputePipelineDescriptor computeDescriptor; wgpu::ComputePipelineDescriptor computeDescriptor;
computeDescriptor.layout = nullptr; computeDescriptor.layout = nullptr;
computeDescriptor.computeStage.module = csModule; computeDescriptor.computeStage.module = csModule;
@ -471,8 +471,8 @@ fn IsEqualTo(pixel : vec4<f32>, expected : vec4<f32>) -> bool {
wgpu::RenderPipeline CreateRenderPipeline(const char* vertexShader, wgpu::RenderPipeline CreateRenderPipeline(const char* vertexShader,
const char* fragmentShader) { const char* fragmentShader) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, vertexShader); wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, vertexShader);
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, fragmentShader); wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, fragmentShader);
utils::ComboRenderPipelineDescriptor2 desc; utils::ComboRenderPipelineDescriptor2 desc;
desc.vertex.module = vsModule; desc.vertex.module = vsModule;
@ -982,7 +982,7 @@ TEST_P(StorageTextureTests, ReadonlyAndWriteonlyStorageTexturePingPong) {
wgpu::Texture storageTexture2 = CreateTexture( wgpu::Texture storageTexture2 = CreateTexture(
kTextureFormat, wgpu::TextureUsage::Storage | wgpu::TextureUsage::CopySrc, 1u, 1u); kTextureFormat, wgpu::TextureUsage::Storage | wgpu::TextureUsage::CopySrc, 1u, 1u);
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var Src : [[access(read)]] texture_storage_2d<r32uint>; [[group(0), binding(0)]] var Src : [[access(read)]] texture_storage_2d<r32uint>;
[[group(0), binding(1)]] var Dst : [[access(write)]] texture_storage_2d<r32uint>; [[group(0), binding(1)]] var Dst : [[access(write)]] texture_storage_2d<r32uint>;
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {
@ -1056,7 +1056,7 @@ TEST_P(StorageTextureTests, SampledAndWriteonlyStorageTexturePingPong) {
1u); 1u);
wgpu::Texture storageTexture2 = CreateTexture( wgpu::Texture storageTexture2 = CreateTexture(
kTextureFormat, wgpu::TextureUsage::Sampled | wgpu::TextureUsage::Storage, 1u, 1u); kTextureFormat, wgpu::TextureUsage::Sampled | wgpu::TextureUsage::Storage, 1u, 1u);
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var Src : texture_2d<u32>; [[group(0), binding(0)]] var Src : texture_2d<u32>;
[[group(0), binding(1)]] var Dst : [[access(write)]] texture_storage_2d<r32uint>; [[group(0), binding(1)]] var Dst : [[access(write)]] texture_storage_2d<r32uint>;
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {

4
src/tests/end2end/SwapChainValidationTests.cpp
View File

@ -221,12 +221,12 @@ TEST_P(SwapChainValidationTests, ViewDestroyedAfterPresent) {
// Check that returned view is of the current format / usage / dimension / size / sample count // Check that returned view is of the current format / usage / dimension / size / sample count
TEST_P(SwapChainValidationTests, ReturnedViewCharacteristics) { TEST_P(SwapChainValidationTests, ReturnedViewCharacteristics) {
utils::ComboRenderPipelineDescriptor2 pipelineDesc; utils::ComboRenderPipelineDescriptor2 pipelineDesc;
pipelineDesc.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDesc.vertex.module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
pipelineDesc.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDesc.cFragment.module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

5
src/tests/end2end/TextureFormatTests.cpp
View File

@ -146,7 +146,7 @@ class TextureFormatTest : public DawnTest {
FormatTestInfo renderFormatInfo) { FormatTestInfo renderFormatInfo) {
utils::ComboRenderPipelineDescriptor2 desc; utils::ComboRenderPipelineDescriptor2 desc;
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -170,8 +170,7 @@ class TextureFormatTest : public DawnTest {
fsSource << " fragColor = textureLoad(myTexture, vec2<i32>(FragCoord.xy), 0);\n"; fsSource << " fragColor = textureLoad(myTexture, vec2<i32>(FragCoord.xy), 0);\n";
fsSource << "}"; fsSource << "}";
wgpu::ShaderModule fsModule = wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, fsSource.str().c_str());
utils::CreateShaderModuleFromWGSL(device, fsSource.str().c_str());
desc.vertex.module = vsModule; desc.vertex.module = vsModule;
desc.cFragment.module = fsModule; desc.cFragment.module = fsModule;

8
src/tests/end2end/TextureSubresourceTests.cpp
View File

@ -49,7 +49,7 @@ class TextureSubresourceTest : public DawnTest {
} }
void DrawTriangle(const wgpu::TextureView& view) { void DrawTriangle(const wgpu::TextureView& view) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -62,7 +62,7 @@ class TextureSubresourceTest : public DawnTest {
Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0); fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);
@ -89,7 +89,7 @@ class TextureSubresourceTest : public DawnTest {
} }
void SampleAndDraw(const wgpu::TextureView& samplerView, const wgpu::TextureView& renderView) { void SampleAndDraw(const wgpu::TextureView& samplerView, const wgpu::TextureView& renderView) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -105,7 +105,7 @@ class TextureSubresourceTest : public DawnTest {
Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var samp : sampler; [[group(0), binding(0)]] var samp : sampler;
[[group(0), binding(1)]] var tex : texture_2d<f32>; [[group(0), binding(1)]] var tex : texture_2d<f32>;

6
src/tests/end2end/TextureViewTests.cpp
View File

@ -60,7 +60,7 @@ namespace {
} }
wgpu::ShaderModule CreateDefaultVertexShaderModule(wgpu::Device device) { wgpu::ShaderModule CreateDefaultVertexShaderModule(wgpu::Device device) {
return utils::CreateShaderModuleFromWGSL(device, R"( return utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[location(0)]] var<out> TexCoord : vec2<f32>; [[location(0)]] var<out> TexCoord : vec2<f32>;
@ -163,7 +163,7 @@ class TextureViewSamplingTest : public DawnTest {
} }
void Verify(const wgpu::TextureView& textureView, const char* fragmentShader, int expected) { void Verify(const wgpu::TextureView& textureView, const char* fragmentShader, int expected) {
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, fragmentShader); wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, fragmentShader);
utils::ComboRenderPipelineDescriptor2 textureDescriptor; utils::ComboRenderPipelineDescriptor2 textureDescriptor;
textureDescriptor.vertex.module = mVSModule; textureDescriptor.vertex.module = mVSModule;
@ -503,7 +503,7 @@ class TextureViewRenderingTest : public DawnTest {
} }
)"; )";
wgpu::ShaderModule oneColorFsModule = wgpu::ShaderModule oneColorFsModule =
utils::CreateShaderModuleFromWGSL(device, oneColorFragmentShader); utils::CreateShaderModule(device, oneColorFragmentShader);
utils::ComboRenderPipelineDescriptor2 pipelineDescriptor; utils::ComboRenderPipelineDescriptor2 pipelineDescriptor;
pipelineDescriptor.vertex.module = vsModule; pipelineDescriptor.vertex.module = vsModule;

8
src/tests/end2end/TextureZeroInitTests.cpp
View File

@ -74,7 +74,7 @@ class TextureZeroInitTest : public DawnTest {
fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0); fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);
} }
)"; )";
pipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, fs); pipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, fs);
wgpu::DepthStencilState* depthStencil = pipelineDescriptor.EnableDepthStencil(); wgpu::DepthStencilState* depthStencil = pipelineDescriptor.EnableDepthStencil();
depthStencil->depthCompare = wgpu::CompareFunction::Equal; depthStencil->depthCompare = wgpu::CompareFunction::Equal;
depthStencil->stencilFront.compare = wgpu::CompareFunction::Equal; depthStencil->stencilFront.compare = wgpu::CompareFunction::Equal;
@ -99,10 +99,10 @@ class TextureZeroInitTest : public DawnTest {
Position = vec4<f32>(pos[VertexIndex], )" + Position = vec4<f32>(pos[VertexIndex], )" +
std::to_string(depth) + R"(, 1.0); std::to_string(depth) + R"(, 1.0);
})"; })";
return utils::CreateShaderModuleFromWGSL(device, source.c_str()); return utils::CreateShaderModule(device, source.c_str());
} }
wgpu::ShaderModule CreateSampledTextureFragmentShaderForTest() { wgpu::ShaderModule CreateSampledTextureFragmentShaderForTest() {
return utils::CreateShaderModuleFromWGSL(device, R"( return utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var texture0 : texture_2d<f32>; [[group(0), binding(0)]] var texture0 : texture_2d<f32>;
[[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>; [[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>;
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
@ -982,7 +982,7 @@ TEST_P(TextureZeroInitTest, ComputePassSampledTextureClear) {
result.value = textureLoad(tex, vec2<i32>(0,0), 0); result.value = textureLoad(tex, vec2<i32>(0,0), 0);
} }
)"; )";
computePipelineDescriptor.computeStage.module = utils::CreateShaderModuleFromWGSL(device, cs); computePipelineDescriptor.computeStage.module = utils::CreateShaderModule(device, cs);
computePipelineDescriptor.computeStage.entryPoint = "main"; computePipelineDescriptor.computeStage.entryPoint = "main";
wgpu::ComputePipeline computePipeline = wgpu::ComputePipeline computePipeline =
device.CreateComputePipeline(&computePipelineDescriptor); device.CreateComputePipeline(&computePipelineDescriptor);

6
src/tests/end2end/VertexBufferRobustnessTests.cpp
View File

@ -32,7 +32,7 @@ class VertexBufferRobustnessTest : public DawnTest {
// viewport. // viewport.
wgpu::ShaderModule CreateVertexModule(const std::string& attributes, wgpu::ShaderModule CreateVertexModule(const std::string& attributes,
const std::string& successExpression) { const std::string& successExpression) {
return utils::CreateShaderModuleFromWGSL(device, (attributes + R"( return utils::CreateShaderModule(device, (attributes + R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
@ -46,7 +46,7 @@ class VertexBufferRobustnessTest : public DawnTest {
return; return;
} }
)") )")
.c_str()); .c_str());
} }
// Runs the test, a true |expectation| meaning success // Runs the test, a true |expectation| meaning success
@ -57,7 +57,7 @@ class VertexBufferRobustnessTest : public DawnTest {
uint64_t bufferOffset, uint64_t bufferOffset,
bool expectation) { bool expectation) {
wgpu::ShaderModule vsModule = CreateVertexModule(attributes, successExpression); wgpu::ShaderModule vsModule = CreateVertexModule(attributes, successExpression);
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> outColor : vec4<f32>; [[location(0)]] var<out> outColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {

4
src/tests/end2end/VertexFormatTests.cpp
View File

@ -339,8 +339,8 @@ class VertexFormatTest : public DawnTest {
} }
})"; })";
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, vs.str().c_str()); wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, vs.str().c_str());
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> color : vec4<f32>; [[location(0)]] var<in> color : vec4<f32>;
[[location(0)]] var<out> FragColor : vec4<f32>; [[location(0)]] var<out> FragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {

12
src/tests/end2end/VertexStateTests.cpp
View File

@ -123,8 +123,8 @@ class VertexStateTest : public DawnTest {
vs << " }\n"; vs << " }\n";
vs << "}\n"; vs << "}\n";
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, vs.str().c_str()); wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, vs.str().c_str());
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> color : vec4<f32>; [[location(0)]] var<in> color : vec4<f32>;
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
@ -569,7 +569,7 @@ TEST_P(VertexStateTest, OverlappingVertexAttributes) {
utils::CreateBufferFromData(device, &data, sizeof(data), wgpu::BufferUsage::Vertex); utils::CreateBufferFromData(device, &data, sizeof(data), wgpu::BufferUsage::Vertex);
utils::ComboRenderPipelineDescriptor2 pipelineDesc; utils::ComboRenderPipelineDescriptor2 pipelineDesc;
pipelineDesc.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDesc.vertex.module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> attr0 : vec4<f32>; [[location(0)]] var<in> attr0 : vec4<f32>;
[[location(1)]] var<in> attr1 : vec2<u32>; [[location(1)]] var<in> attr1 : vec2<u32>;
[[location(2)]] var<in> attr2 : vec4<f32>; [[location(2)]] var<in> attr2 : vec4<f32>;
@ -595,7 +595,7 @@ TEST_P(VertexStateTest, OverlappingVertexAttributes) {
color = vec4<f32>(1.0, 0.0, 0.0, 1.0); color = vec4<f32>(1.0, 0.0, 0.0, 1.0);
} }
})"); })");
pipelineDesc.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDesc.cFragment.module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> color : vec4<f32>; [[location(0)]] var<in> color : vec4<f32>;
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
@ -641,13 +641,13 @@ class OptionalVertexStateTest : public DawnTest {};
TEST_P(OptionalVertexStateTest, Basic) { TEST_P(OptionalVertexStateTest, Basic) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 3, 3); utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 3, 3);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

4
src/tests/end2end/ViewportOrientationTests.cpp
View File

@ -23,14 +23,14 @@ class ViewportOrientationTests : public DawnTest {};
TEST_P(ViewportOrientationTests, OriginAt0x0) { TEST_P(ViewportOrientationTests, OriginAt0x0) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 2, 2); utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 2, 2);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(-0.5, 0.5, 0.0, 1.0); Position = vec4<f32>(-0.5, 0.5, 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

6
src/tests/end2end/ViewportTests.cpp
View File

@ -22,7 +22,7 @@ class ViewportTest : public DawnTest {
void SetUp() override { void SetUp() override {
DawnTest::SetUp(); DawnTest::SetUp();
mQuadVS = utils::CreateShaderModuleFromWGSL(device, R"( mQuadVS = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -38,7 +38,7 @@ class ViewportTest : public DawnTest {
Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
})"); })");
mQuadFS = utils::CreateShaderModuleFromWGSL(device, R"( mQuadFS = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(1.0, 1.0, 1.0, 1.0); fragColor = vec4<f32>(1.0, 1.0, 1.0, 1.0);
@ -95,7 +95,7 @@ class ViewportTest : public DawnTest {
void TestViewportDepth(float minDepth, float maxDepth, bool doViewportCall = true) { void TestViewportDepth(float minDepth, float maxDepth, bool doViewportCall = true) {
// Create a pipeline drawing 3 points at depth 1.0, 0.5 and 0.0. // Create a pipeline drawing 3 points at depth 1.0, 0.5 and 0.0.
utils::ComboRenderPipelineDescriptor2 pipelineDesc; utils::ComboRenderPipelineDescriptor2 pipelineDesc;
pipelineDesc.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDesc.vertex.module = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;

6
src/tests/perf_tests/DrawCallPerf.cpp
View File

@ -366,8 +366,8 @@ void DrawCallPerf::SetUp() {
wgpu::PipelineLayout pipelineLayout = device.CreatePipelineLayout(&pipelineLayoutDesc); wgpu::PipelineLayout pipelineLayout = device.CreatePipelineLayout(&pipelineLayoutDesc);
// Create the shaders for the first pipeline. // Create the shaders for the first pipeline.
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, kVertexShader); wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, kVertexShader);
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, kFragmentShaderA); wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, kFragmentShaderA);
// Create the first pipeline. // Create the first pipeline.
renderPipelineDesc.layout = pipelineLayout; renderPipelineDesc.layout = pipelineLayout;
@ -395,7 +395,7 @@ void DrawCallPerf::SetUp() {
// Create the fragment shader module. This shader matches the pipeline layout described // Create the fragment shader module. This shader matches the pipeline layout described
// above. // above.
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, kFragmentShaderB); wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, kFragmentShaderB);
// Create the pipeline. // Create the pipeline.
renderPipelineDesc.layout = pipelineLayout; renderPipelineDesc.layout = pipelineLayout;

4
src/tests/perf_tests/SubresourceTrackingPerf.cpp
View File

@ -70,13 +70,13 @@ class SubresourceTrackingPerf : public DawnPerfTestWithParams<SubresourceTrackin
mUploadTexture = device.CreateTexture(&uploadTexDesc); mUploadTexture = device.CreateTexture(&uploadTexDesc);
utils::ComboRenderPipelineDescriptor2 pipelineDesc; utils::ComboRenderPipelineDescriptor2 pipelineDesc;
pipelineDesc.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDesc.vertex.module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(1.0, 0.0, 0.0, 1.0); Position = vec4<f32>(1.0, 0.0, 0.0, 1.0);
} }
)"); )");
pipelineDesc.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDesc.cFragment.module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> FragColor : vec4<f32>; [[location(0)]] var<out> FragColor : vec4<f32>;
[[group(0), binding(0)]] var materials : texture_2d<f32>; [[group(0), binding(0)]] var materials : texture_2d<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {

20
src/tests/unittests/validation/BindGroupValidationTests.cpp
View File

@ -1083,11 +1083,11 @@ class SetBindGroupValidationTest : public ValidationTest {
wgpu::BindGroupLayout mBindGroupLayout; wgpu::BindGroupLayout mBindGroupLayout;
wgpu::RenderPipeline CreateRenderPipeline() { wgpu::RenderPipeline CreateRenderPipeline() {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
value : vec2<f32>; value : vec2<f32>;
}; };
@ -1110,7 +1110,7 @@ class SetBindGroupValidationTest : public ValidationTest {
} }
wgpu::ComputePipeline CreateComputePipeline() { wgpu::ComputePipeline CreateComputePipeline() {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
value : vec2<f32>; value : vec2<f32>;
}; };
@ -1486,7 +1486,7 @@ class SetBindGroupPersistenceValidationTest : public ValidationTest {
void SetUp() override { void SetUp() override {
ValidationTest::SetUp(); ValidationTest::SetUp();
mVsModule = utils::CreateShaderModuleFromWGSL(device, R"( mVsModule = utils::CreateShaderModule(device, R"(
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
} }
@ -1557,7 +1557,7 @@ class SetBindGroupPersistenceValidationTest : public ValidationTest {
ss << "[[stage(fragment)]] fn main() -> void {}"; ss << "[[stage(fragment)]] fn main() -> void {}";
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, ss.str().c_str()); wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, ss.str().c_str());
utils::ComboRenderPipelineDescriptor2 pipelineDescriptor; utils::ComboRenderPipelineDescriptor2 pipelineDescriptor;
pipelineDescriptor.vertex.module = mVsModule; pipelineDescriptor.vertex.module = mVsModule;
@ -1688,11 +1688,11 @@ class BindGroupLayoutCompatibilityTest : public ValidationTest {
wgpu::RenderPipeline CreateFSRenderPipeline( wgpu::RenderPipeline CreateFSRenderPipeline(
const char* fsShader, const char* fsShader,
std::vector<wgpu::BindGroupLayout> bindGroupLayout) { std::vector<wgpu::BindGroupLayout> bindGroupLayout) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, fsShader); wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, fsShader);
wgpu::PipelineLayoutDescriptor descriptor; wgpu::PipelineLayoutDescriptor descriptor;
descriptor.bindGroupLayoutCount = bindGroupLayout.size(); descriptor.bindGroupLayoutCount = bindGroupLayout.size();
@ -1722,7 +1722,7 @@ class BindGroupLayoutCompatibilityTest : public ValidationTest {
wgpu::ComputePipeline CreateComputePipeline( wgpu::ComputePipeline CreateComputePipeline(
const char* shader, const char* shader,
std::vector<wgpu::BindGroupLayout> bindGroupLayout) { std::vector<wgpu::BindGroupLayout> bindGroupLayout) {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, shader); wgpu::ShaderModule csModule = utils::CreateShaderModule(device, shader);
wgpu::PipelineLayoutDescriptor descriptor; wgpu::PipelineLayoutDescriptor descriptor;
descriptor.bindGroupLayoutCount = bindGroupLayout.size(); descriptor.bindGroupLayoutCount = bindGroupLayout.size();
@ -2052,11 +2052,11 @@ class ComparisonSamplerBindingTest : public ValidationTest {
protected: protected:
wgpu::RenderPipeline CreateFragmentPipeline(wgpu::BindGroupLayout* bindGroupLayout, wgpu::RenderPipeline CreateFragmentPipeline(wgpu::BindGroupLayout* bindGroupLayout,
const char* fragmentSource) { const char* fragmentSource) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, fragmentSource); wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, fragmentSource);
utils::ComboRenderPipelineDescriptor2 pipelineDescriptor; utils::ComboRenderPipelineDescriptor2 pipelineDescriptor;
pipelineDescriptor.vertex.module = vsModule; pipelineDescriptor.vertex.module = vsModule;

2
src/tests/unittests/validation/ComputeIndirectValidationTests.cpp
View File

@ -22,7 +22,7 @@ class ComputeIndirectValidationTest : public ValidationTest {
void SetUp() override { void SetUp() override {
ValidationTest::SetUp(); ValidationTest::SetUp();
wgpu::ShaderModule computeModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule computeModule = utils::CreateShaderModule(device, R"(
[[stage(compute), workgroup_size(1)]] fn main() -> void { [[stage(compute), workgroup_size(1)]] fn main() -> void {
})"); })");

4
src/tests/unittests/validation/DrawIndirectValidationTests.cpp
View File

@ -23,13 +23,13 @@ class DrawIndirectValidationTest : public ValidationTest {
void SetUp() override { void SetUp() override {
ValidationTest::SetUp(); ValidationTest::SetUp();
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 0.0); Position = vec4<f32>(0.0, 0.0, 0.0, 0.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 0.0, 0.0, 0.0); fragColor = vec4<f32>(0.0, 0.0, 0.0, 0.0);

52
src/tests/unittests/validation/GetBindGroupLayoutValidationTests.cpp
View File

@ -20,11 +20,11 @@
class GetBindGroupLayoutTests : public ValidationTest { class GetBindGroupLayoutTests : public ValidationTest {
protected: protected:
wgpu::RenderPipeline RenderPipelineFromFragmentShader(const char* shader) { wgpu::RenderPipeline RenderPipelineFromFragmentShader(const char* shader) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, shader); wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, shader);
utils::ComboRenderPipelineDescriptor2 descriptor; utils::ComboRenderPipelineDescriptor2 descriptor;
descriptor.layout = nullptr; descriptor.layout = nullptr;
@ -43,7 +43,7 @@ TEST_F(GetBindGroupLayoutTests, SameObject) {
// Native. // Native.
DAWN_SKIP_TEST_IF(UsesWire()); DAWN_SKIP_TEST_IF(UsesWire());
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
pos : vec4<f32>; pos : vec4<f32>;
}; };
@ -53,7 +53,7 @@ TEST_F(GetBindGroupLayoutTests, SameObject) {
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct S2 { [[block]] struct S2 {
pos : vec4<f32>; pos : vec4<f32>;
}; };
@ -139,7 +139,7 @@ TEST_F(GetBindGroupLayoutTests, ComputePipeline) {
// Native. // Native.
DAWN_SKIP_TEST_IF(UsesWire()); DAWN_SKIP_TEST_IF(UsesWire());
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
pos : vec4<f32>; pos : vec4<f32>;
}; };
@ -442,7 +442,7 @@ TEST_F(GetBindGroupLayoutTests, BindingIndices) {
// Test it is valid to have duplicate bindings in the shaders. // Test it is valid to have duplicate bindings in the shaders.
TEST_F(GetBindGroupLayoutTests, DuplicateBinding) { TEST_F(GetBindGroupLayoutTests, DuplicateBinding) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
pos : vec4<f32>; pos : vec4<f32>;
}; };
@ -452,7 +452,7 @@ TEST_F(GetBindGroupLayoutTests, DuplicateBinding) {
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
pos : vec4<f32>; pos : vec4<f32>;
}; };
@ -476,7 +476,7 @@ TEST_F(GetBindGroupLayoutTests, MinBufferSize) {
// Native. // Native.
DAWN_SKIP_TEST_IF(UsesWire()); DAWN_SKIP_TEST_IF(UsesWire());
wgpu::ShaderModule vsModule4 = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule4 = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
pos : f32; pos : f32;
}; };
@ -485,7 +485,7 @@ TEST_F(GetBindGroupLayoutTests, MinBufferSize) {
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule vsModule64 = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule64 = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
pos : mat4x4<f32>; pos : mat4x4<f32>;
}; };
@ -494,7 +494,7 @@ TEST_F(GetBindGroupLayoutTests, MinBufferSize) {
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule4 = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule4 = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
pos : f32; pos : f32;
}; };
@ -503,7 +503,7 @@ TEST_F(GetBindGroupLayoutTests, MinBufferSize) {
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule64 = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule64 = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
pos : mat4x4<f32>; pos : mat4x4<f32>;
}; };
@ -562,20 +562,20 @@ TEST_F(GetBindGroupLayoutTests, StageAggregation) {
// Native. // Native.
DAWN_SKIP_TEST_IF(UsesWire()); DAWN_SKIP_TEST_IF(UsesWire());
wgpu::ShaderModule vsModuleNoSampler = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModuleNoSampler = utils::CreateShaderModule(device, R"(
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule vsModuleSampler = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModuleSampler = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var mySampler: sampler; [[group(0), binding(0)]] var mySampler: sampler;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModuleNoSampler = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModuleNoSampler = utils::CreateShaderModule(device, R"(
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModuleSampler = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModuleSampler = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var mySampler: sampler; [[group(0), binding(0)]] var mySampler: sampler;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
@ -625,7 +625,7 @@ TEST_F(GetBindGroupLayoutTests, StageAggregation) {
// Test it is invalid to have conflicting binding types in the shaders. // Test it is invalid to have conflicting binding types in the shaders.
TEST_F(GetBindGroupLayoutTests, ConflictingBindingType) { TEST_F(GetBindGroupLayoutTests, ConflictingBindingType) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
pos : vec4<f32>; pos : vec4<f32>;
}; };
@ -634,7 +634,7 @@ TEST_F(GetBindGroupLayoutTests, ConflictingBindingType) {
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
pos : vec4<f32>; pos : vec4<f32>;
}; };
@ -653,13 +653,13 @@ TEST_F(GetBindGroupLayoutTests, ConflictingBindingType) {
// Test it is invalid to have conflicting binding texture multisampling in the shaders. // Test it is invalid to have conflicting binding texture multisampling in the shaders.
TEST_F(GetBindGroupLayoutTests, ConflictingBindingTextureMultisampling) { TEST_F(GetBindGroupLayoutTests, ConflictingBindingTextureMultisampling) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var myTexture : texture_2d<f32>; [[group(0), binding(0)]] var myTexture : texture_2d<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var myTexture : texture_multisampled_2d<f32>; [[group(0), binding(0)]] var myTexture : texture_multisampled_2d<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
@ -675,13 +675,13 @@ TEST_F(GetBindGroupLayoutTests, ConflictingBindingTextureMultisampling) {
// Test it is invalid to have conflicting binding texture dimension in the shaders. // Test it is invalid to have conflicting binding texture dimension in the shaders.
TEST_F(GetBindGroupLayoutTests, ConflictingBindingViewDimension) { TEST_F(GetBindGroupLayoutTests, ConflictingBindingViewDimension) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var myTexture : texture_2d<f32>; [[group(0), binding(0)]] var myTexture : texture_2d<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var myTexture : texture_3d<f32>; [[group(0), binding(0)]] var myTexture : texture_3d<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
@ -697,13 +697,13 @@ TEST_F(GetBindGroupLayoutTests, ConflictingBindingViewDimension) {
// Test it is invalid to have conflicting binding texture component type in the shaders. // Test it is invalid to have conflicting binding texture component type in the shaders.
TEST_F(GetBindGroupLayoutTests, ConflictingBindingTextureComponentType) { TEST_F(GetBindGroupLayoutTests, ConflictingBindingTextureComponentType) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var myTexture : texture_2d<f32>; [[group(0), binding(0)]] var myTexture : texture_2d<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var myTexture : texture_2d<i32>; [[group(0), binding(0)]] var myTexture : texture_2d<i32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
@ -784,7 +784,7 @@ TEST_F(GetBindGroupLayoutTests, Reflection) {
wgpu::PipelineLayout pipelineLayout = device.CreatePipelineLayout(&pipelineLayoutDesc); wgpu::PipelineLayout pipelineLayout = device.CreatePipelineLayout(&pipelineLayoutDesc);
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[block]] struct S { [[block]] struct S {
pos : vec4<f32>; pos : vec4<f32>;
}; };
@ -793,7 +793,7 @@ TEST_F(GetBindGroupLayoutTests, Reflection) {
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
@ -823,7 +823,7 @@ TEST_F(GetBindGroupLayoutTests, Reflection) {
// Test that fragment output validation is for the correct entryPoint // Test that fragment output validation is for the correct entryPoint
// TODO(dawn:216): Re-enable when we correctly reflect which bindings are used for an entryPoint. // TODO(dawn:216): Re-enable when we correctly reflect which bindings are used for an entryPoint.
TEST_F(GetBindGroupLayoutTests, DISABLED_FromCorrectEntryPoint) { TEST_F(GetBindGroupLayoutTests, DISABLED_FromCorrectEntryPoint) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct Data { [[block]] struct Data {
data : f32; data : f32;
}; };

4
src/tests/unittests/validation/IndexBufferValidationTests.cpp
View File

@ -22,13 +22,13 @@ class IndexBufferValidationTest : public ValidationTest {
protected: protected:
wgpu::RenderPipeline MakeTestPipeline(wgpu::IndexFormat format, wgpu::RenderPipeline MakeTestPipeline(wgpu::IndexFormat format,
wgpu::PrimitiveTopology primitiveTopology) { wgpu::PrimitiveTopology primitiveTopology) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);

7
src/tests/unittests/validation/MinimumBufferSizeValidationTests.cpp
View File

@ -142,7 +142,7 @@ class MinBufferSizeTestsBase : public ValidationTest {
// Creates compute pipeline given a layout and shader // Creates compute pipeline given a layout and shader
wgpu::ComputePipeline CreateComputePipeline(const std::vector<wgpu::BindGroupLayout>& layouts, wgpu::ComputePipeline CreateComputePipeline(const std::vector<wgpu::BindGroupLayout>& layouts,
const std::string& shader) { const std::string& shader) {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, shader.c_str()); wgpu::ShaderModule csModule = utils::CreateShaderModule(device, shader.c_str());
wgpu::ComputePipelineDescriptor csDesc; wgpu::ComputePipelineDescriptor csDesc;
csDesc.layout = nullptr; csDesc.layout = nullptr;
@ -167,10 +167,9 @@ class MinBufferSizeTestsBase : public ValidationTest {
wgpu::RenderPipeline CreateRenderPipeline(const std::vector<wgpu::BindGroupLayout>& layouts, wgpu::RenderPipeline CreateRenderPipeline(const std::vector<wgpu::BindGroupLayout>& layouts,
const std::string& vertexShader, const std::string& vertexShader,
const std::string& fragShader) { const std::string& fragShader) {
wgpu::ShaderModule vsModule = wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, vertexShader.c_str());
utils::CreateShaderModuleFromWGSL(device, vertexShader.c_str());
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, fragShader.c_str()); wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, fragShader.c_str());
utils::ComboRenderPipelineDescriptor2 pipelineDescriptor; utils::ComboRenderPipelineDescriptor2 pipelineDescriptor;
pipelineDescriptor.vertex.module = vsModule; pipelineDescriptor.vertex.module = vsModule;

4
src/tests/unittests/validation/RenderBundleValidationTests.cpp
View File

@ -27,7 +27,7 @@ namespace {
void SetUp() override { void SetUp() override {
ValidationTest::SetUp(); ValidationTest::SetUp();
vsModule = utils::CreateShaderModuleFromWGSL(device, R"( vsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<in> pos : vec2<f32>; [[location(0)]] var<in> pos : vec2<f32>;
[[block]] struct S { [[block]] struct S {
@ -38,7 +38,7 @@ namespace {
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
fsModule = utils::CreateShaderModuleFromWGSL(device, R"( fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct Uniforms { [[block]] struct Uniforms {
color : vec4<f32>; color : vec4<f32>;
}; };

23
src/tests/unittests/validation/RenderPipelineValidationTests.cpp
View File

@ -26,13 +26,13 @@ class RenderPipelineValidationTest : public ValidationTest {
void SetUp() override { void SetUp() override {
ValidationTest::SetUp(); ValidationTest::SetUp();
vsModule = utils::CreateShaderModuleFromWGSL(device, R"( vsModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
fsModule = utils::CreateShaderModuleFromWGSL(device, R"( fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);
@ -195,8 +195,7 @@ TEST_F(RenderPipelineValidationTest, FragmentOutputFormatCompatibility) {
<< kScalarTypes[i] << R"(>; << kScalarTypes[i] << R"(>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"; })";
descriptor.cFragment.module = descriptor.cFragment.module = utils::CreateShaderModule(device, stream.str().c_str());
utils::CreateShaderModuleFromWGSL(device, stream.str().c_str());
if (i == j) { if (i == j) {
device.CreateRenderPipeline2(&descriptor); device.CreateRenderPipeline2(&descriptor);
@ -414,8 +413,7 @@ TEST_F(RenderPipelineValidationTest, TextureComponentTypeCompatibility) {
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"; })";
descriptor.cFragment.module = descriptor.cFragment.module = utils::CreateShaderModule(device, stream.str().c_str());
utils::CreateShaderModuleFromWGSL(device, stream.str().c_str());
wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout( wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout(
device, {{0, wgpu::ShaderStage::Fragment, kTextureComponentTypes[j]}}); device, {{0, wgpu::ShaderStage::Fragment, kTextureComponentTypes[j]}});
@ -462,8 +460,7 @@ TEST_F(RenderPipelineValidationTest, TextureViewDimensionCompatibility) {
<< kTextureKeywords[i] << R"(<f32>; << kTextureKeywords[i] << R"(<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"; })";
descriptor.cFragment.module = descriptor.cFragment.module = utils::CreateShaderModule(device, stream.str().c_str());
utils::CreateShaderModuleFromWGSL(device, stream.str().c_str());
wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout( wgpu::BindGroupLayout bgl = utils::MakeBindGroupLayout(
device, {{0, wgpu::ShaderStage::Fragment, wgpu::TextureSampleType::Float, device, {{0, wgpu::ShaderStage::Fragment, wgpu::TextureSampleType::Float,
@ -482,7 +479,7 @@ TEST_F(RenderPipelineValidationTest, TextureViewDimensionCompatibility) {
// Test that declaring a storage buffer in the vertex shader without setting pipeline layout won't // Test that declaring a storage buffer in the vertex shader without setting pipeline layout won't
// cause crash. // cause crash.
TEST_F(RenderPipelineValidationTest, StorageBufferInVertexShaderNoLayout) { TEST_F(RenderPipelineValidationTest, StorageBufferInVertexShaderNoLayout) {
wgpu::ShaderModule vsModuleWithStorageBuffer = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModuleWithStorageBuffer = utils::CreateShaderModule(device, R"(
[[block]] struct Dst { [[block]] struct Dst {
data : array<u32, 100>; data : array<u32, 100>;
}; };
@ -555,7 +552,7 @@ TEST_F(RenderPipelineValidationTest, StripIndexFormatRequired) {
// Test that the entryPoint names must be present for the correct stage in the shader module. // Test that the entryPoint names must be present for the correct stage in the shader module.
TEST_F(RenderPipelineValidationTest, EntryPointNameValidation) { TEST_F(RenderPipelineValidationTest, EntryPointNameValidation) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> position : vec4<f32>; [[builtin(position)]] var<out> position : vec4<f32>;
[[stage(vertex)]] fn vertex_main() -> void { [[stage(vertex)]] fn vertex_main() -> void {
position = vec4<f32>(0.0, 0.0, 0.0, 1.0); position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
@ -605,7 +602,7 @@ TEST_F(RenderPipelineValidationTest, EntryPointNameValidation) {
// Test that vertex attrib validation is for the correct entryPoint // Test that vertex attrib validation is for the correct entryPoint
TEST_F(RenderPipelineValidationTest, VertexAttribCorrectEntryPoint) { TEST_F(RenderPipelineValidationTest, VertexAttribCorrectEntryPoint) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> position : vec4<f32>; [[builtin(position)]] var<out> position : vec4<f32>;
[[location(0)]] var<in> attrib0 : vec4<f32>; [[location(0)]] var<in> attrib0 : vec4<f32>;
[[location(1)]] var<in> attrib1 : vec4<f32>; [[location(1)]] var<in> attrib1 : vec4<f32>;
@ -651,7 +648,7 @@ TEST_F(RenderPipelineValidationTest, VertexAttribCorrectEntryPoint) {
// Test that fragment output validation is for the correct entryPoint // Test that fragment output validation is for the correct entryPoint
TEST_F(RenderPipelineValidationTest, FragmentOutputCorrectEntryPoint) { TEST_F(RenderPipelineValidationTest, FragmentOutputCorrectEntryPoint) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> colorFloat : vec4<f32>; [[location(0)]] var<out> colorFloat : vec4<f32>;
[[location(0)]] var<out> colorUint : vec4<u32>; [[location(0)]] var<out> colorUint : vec4<u32>;
@ -691,7 +688,7 @@ TEST_F(RenderPipelineValidationTest, FragmentOutputCorrectEntryPoint) {
// Test that fragment output validation is for the correct entryPoint // Test that fragment output validation is for the correct entryPoint
// TODO(dawn:216): Re-enable when we correctly reflect which bindings are used for an entryPoint. // TODO(dawn:216): Re-enable when we correctly reflect which bindings are used for an entryPoint.
TEST_F(RenderPipelineValidationTest, DISABLED_BindingsFromCorrectEntryPoint) { TEST_F(RenderPipelineValidationTest, DISABLED_BindingsFromCorrectEntryPoint) {
wgpu::ShaderModule module = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule module = utils::CreateShaderModule(device, R"(
[[block]] struct Uniforms { [[block]] struct Uniforms {
data : vec4<f32>; data : vec4<f32>;
}; };

18
src/tests/unittests/validation/ResourceUsageTrackingTests.cpp
View File

@ -46,11 +46,11 @@ namespace {
// in the caller, so it is always correct for binding validation between bind groups and // in the caller, so it is always correct for binding validation between bind groups and
// pipeline. But those bind groups in caller can be used for validation for other purposes. // pipeline. But those bind groups in caller can be used for validation for other purposes.
wgpu::RenderPipeline CreateNoOpRenderPipeline() { wgpu::RenderPipeline CreateNoOpRenderPipeline() {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
utils::ComboRenderPipelineDescriptor2 pipelineDescriptor; utils::ComboRenderPipelineDescriptor2 pipelineDescriptor;
@ -61,7 +61,7 @@ namespace {
} }
wgpu::ComputePipeline CreateNoOpComputePipeline() { wgpu::ComputePipeline CreateNoOpComputePipeline() {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {
})"); })");
wgpu::ComputePipelineDescriptor pipelineDescriptor; wgpu::ComputePipelineDescriptor pipelineDescriptor;
@ -771,11 +771,11 @@ namespace {
wgpu::BindGroup bg1 = utils::MakeBindGroup(device, bgl1, {{0, buffer}}); wgpu::BindGroup bg1 = utils::MakeBindGroup(device, bgl1, {{0, buffer}});
// Create a passthrough render pipeline with a readonly buffer // Create a passthrough render pipeline with a readonly buffer
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[block]] struct RBuffer { [[block]] struct RBuffer {
value : f32; value : f32;
}; };
@ -815,7 +815,7 @@ namespace {
wgpu::BindGroup bg1 = utils::MakeBindGroup(device, bgl1, {{0, buffer}}); wgpu::BindGroup bg1 = utils::MakeBindGroup(device, bgl1, {{0, buffer}});
// Create a passthrough compute pipeline with a readonly buffer // Create a passthrough compute pipeline with a readonly buffer
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[block]] struct RBuffer { [[block]] struct RBuffer {
value : f32; value : f32;
}; };
@ -1549,11 +1549,11 @@ namespace {
// Test render pass // Test render pass
{ {
// Create a passthrough render pipeline with a readonly storage texture // Create a passthrough render pipeline with a readonly storage texture
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})"); })");
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var tex : [[access(read)]] texture_storage_2d<rgba8unorm>; [[group(0), binding(0)]] var tex : [[access(read)]] texture_storage_2d<rgba8unorm>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})"); })");
@ -1579,7 +1579,7 @@ namespace {
// Test compute pass // Test compute pass
{ {
// Create a passthrough compute pipeline with a readonly storage texture // Create a passthrough compute pipeline with a readonly storage texture
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var tex : [[access(read)]] texture_storage_2d<rgba8unorm>; [[group(0), binding(0)]] var tex : [[access(read)]] texture_storage_2d<rgba8unorm>;
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {
})"); })");

2
src/tests/unittests/validation/ShaderModuleValidationTests.cpp
View File

@ -62,7 +62,7 @@ TEST_F(ShaderModuleValidationTest, FragmentOutputLocationExceedsMaxColorAttachme
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);
})"; })";
ASSERT_DEVICE_ERROR(utils::CreateShaderModuleFromWGSL(device, stream.str().c_str())); ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, stream.str().c_str()));
} }
// Test that it is invalid to create a shader module with no chained descriptor. (It must be // Test that it is invalid to create a shader module with no chained descriptor. (It must be

42
src/tests/unittests/validation/StorageTextureValidationTests.cpp
View File

@ -23,12 +23,12 @@ class StorageTextureValidationTests : public ValidationTest {
void SetUp() override { void SetUp() override {
ValidationTest::SetUp(); ValidationTest::SetUp();
mDefaultVSModule = utils::CreateShaderModuleFromWGSL(device, R"( mDefaultVSModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
mDefaultFSModule = utils::CreateShaderModuleFromWGSL(device, R"( mDefaultFSModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0); fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);
@ -120,7 +120,7 @@ class StorageTextureValidationTests : public ValidationTest {
TEST_F(StorageTextureValidationTests, RenderPipeline) { TEST_F(StorageTextureValidationTests, RenderPipeline) {
// Readonly storage texture can be declared in a vertex shader. // Readonly storage texture can be declared in a vertex shader.
{ {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var image0 : [[access(read)]] texture_storage_2d<rgba8unorm>; [[group(0), binding(0)]] var image0 : [[access(read)]] texture_storage_2d<rgba8unorm>;
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
@ -137,7 +137,7 @@ TEST_F(StorageTextureValidationTests, RenderPipeline) {
// Read-only storage textures can be declared in a fragment shader. // Read-only storage textures can be declared in a fragment shader.
{ {
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var image0 : [[access(read)]] texture_storage_2d<rgba8unorm>; [[group(0), binding(0)]] var image0 : [[access(read)]] texture_storage_2d<rgba8unorm>;
[[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>; [[builtin(frag_coord)]] var<in> FragCoord : vec4<f32>;
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
@ -154,7 +154,7 @@ TEST_F(StorageTextureValidationTests, RenderPipeline) {
// Write-only storage textures cannot be declared in a vertex shader. // Write-only storage textures cannot be declared in a vertex shader.
if ((false) /* TODO(https://crbug.com/tint/449) */) { if ((false) /* TODO(https://crbug.com/tint/449) */) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, R"(
[[builtin(vertex_index)]] var<in> vertex_index : u32; [[builtin(vertex_index)]] var<in> vertex_index : u32;
[[group(0), binding(0)]] var image0 : [[access(write)]] texture_storage_2d<rgba8unorm>; [[group(0), binding(0)]] var image0 : [[access(write)]] texture_storage_2d<rgba8unorm>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
@ -170,7 +170,7 @@ TEST_F(StorageTextureValidationTests, RenderPipeline) {
// Write-only storage textures can be declared in a fragment shader. // Write-only storage textures can be declared in a fragment shader.
{ {
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[builtin(frag_coord)]] var<in> frag_coord : vec4<f32>; [[builtin(frag_coord)]] var<in> frag_coord : vec4<f32>;
[[group(0), binding(0)]] var image0 : [[access(write)]] texture_storage_2d<rgba8unorm>; [[group(0), binding(0)]] var image0 : [[access(write)]] texture_storage_2d<rgba8unorm>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
@ -190,7 +190,7 @@ TEST_F(StorageTextureValidationTests, RenderPipeline) {
TEST_F(StorageTextureValidationTests, ComputePipeline) { TEST_F(StorageTextureValidationTests, ComputePipeline) {
// Read-only storage textures can be declared in a compute shader. // Read-only storage textures can be declared in a compute shader.
{ {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var image0 : [[access(read)]] texture_storage_2d<rgba8unorm>; [[group(0), binding(0)]] var image0 : [[access(read)]] texture_storage_2d<rgba8unorm>;
[[builtin(local_invocation_id)]] var<in> LocalInvocationID : vec3<u32>; [[builtin(local_invocation_id)]] var<in> LocalInvocationID : vec3<u32>;
@ -213,7 +213,7 @@ TEST_F(StorageTextureValidationTests, ComputePipeline) {
// Write-only storage textures can be declared in a compute shader. // Write-only storage textures can be declared in a compute shader.
{ {
wgpu::ShaderModule csModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule csModule = utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var image0 : [[access(write)]] texture_storage_2d<rgba8unorm>; [[group(0), binding(0)]] var image0 : [[access(write)]] texture_storage_2d<rgba8unorm>;
[[builtin(local_invocation_id)]] var<in> LocalInvocationID : vec3<u32>; [[builtin(local_invocation_id)]] var<in> LocalInvocationID : vec3<u32>;
@ -234,7 +234,7 @@ TEST_F(StorageTextureValidationTests, ComputePipeline) {
TEST_F(StorageTextureValidationTests, ReadWriteStorageTexture) { TEST_F(StorageTextureValidationTests, ReadWriteStorageTexture) {
// Read-write storage textures cannot be declared in a vertex shader by default. // Read-write storage textures cannot be declared in a vertex shader by default.
{ {
ASSERT_DEVICE_ERROR(utils::CreateShaderModuleFromWGSL(device, R"( ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var image0 : [[access(read_write)]] texture_storage_2d<rgba8unorm>; [[group(0), binding(0)]] var image0 : [[access(read_write)]] texture_storage_2d<rgba8unorm>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
})")); })"));
@ -242,7 +242,7 @@ TEST_F(StorageTextureValidationTests, ReadWriteStorageTexture) {
// Read-write storage textures cannot be declared in a fragment shader by default. // Read-write storage textures cannot be declared in a fragment shader by default.
{ {
ASSERT_DEVICE_ERROR(utils::CreateShaderModuleFromWGSL(device, R"( ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var image0 : [[access(read_write)]] texture_storage_2d<rgba8unorm>; [[group(0), binding(0)]] var image0 : [[access(read_write)]] texture_storage_2d<rgba8unorm>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
})")); })"));
@ -250,7 +250,7 @@ TEST_F(StorageTextureValidationTests, ReadWriteStorageTexture) {
// Read-write storage textures cannot be declared in a compute shader by default. // Read-write storage textures cannot be declared in a compute shader by default.
{ {
ASSERT_DEVICE_ERROR(utils::CreateShaderModuleFromWGSL(device, R"( ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, R"(
[[group(0), binding(0)]] var image0 : [[access(read_write)]] texture_storage_2d<rgba8unorm>; [[group(0), binding(0)]] var image0 : [[access(read_write)]] texture_storage_2d<rgba8unorm>;
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {
})")); })"));
@ -317,10 +317,9 @@ TEST_F(StorageTextureValidationTests, StorageTextureFormatInShaders) {
std::string computeShader = std::string computeShader =
CreateComputeShaderWithStorageTexture(storageTextureBindingType, format); CreateComputeShaderWithStorageTexture(storageTextureBindingType, format);
if (utils::TextureFormatSupportsStorageTexture(format)) { if (utils::TextureFormatSupportsStorageTexture(format)) {
utils::CreateShaderModuleFromWGSL(device, computeShader.c_str()); utils::CreateShaderModule(device, computeShader.c_str());
} else { } else {
ASSERT_DEVICE_ERROR( ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, computeShader.c_str()));
utils::CreateShaderModuleFromWGSL(device, computeShader.c_str()));
} }
} }
} }
@ -343,7 +342,7 @@ TEST_F(StorageTextureValidationTests, UnsupportedWGSLStorageTextureFormat) {
for (wgpu::StorageTextureAccess bindingType : kSupportedStorageTextureAccess) { for (wgpu::StorageTextureAccess bindingType : kSupportedStorageTextureAccess) {
for (wgpu::TextureFormat format : kUnsupportedTextureFormats) { for (wgpu::TextureFormat format : kUnsupportedTextureFormats) {
std::string computeShader = CreateComputeShaderWithStorageTexture(bindingType, format); std::string computeShader = CreateComputeShaderWithStorageTexture(bindingType, format);
ASSERT_DEVICE_ERROR(utils::CreateShaderModuleFromWGSL(device, computeShader.c_str())); ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, computeShader.c_str()));
} }
} }
} }
@ -360,7 +359,7 @@ TEST_F(StorageTextureValidationTests, UnsupportedTextureViewDimensionInShader) {
for (wgpu::TextureViewDimension dimension : kUnsupportedTextureViewDimensions) { for (wgpu::TextureViewDimension dimension : kUnsupportedTextureViewDimensions) {
std::string computeShader = std::string computeShader =
CreateComputeShaderWithStorageTexture(bindingType, kFormat, dimension); CreateComputeShaderWithStorageTexture(bindingType, kFormat, dimension);
ASSERT_DEVICE_ERROR(utils::CreateShaderModuleFromWGSL(device, computeShader.c_str())); ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, computeShader.c_str()));
} }
} }
} }
@ -402,8 +401,7 @@ TEST_F(StorageTextureValidationTests, BindGroupLayoutEntryTypeMatchesShaderDecla
// Create the compute shader with the given binding type. // Create the compute shader with the given binding type.
std::string computeShader = std::string computeShader =
CreateComputeShaderWithStorageTexture(bindingTypeInShader, kStorageTextureFormat); CreateComputeShaderWithStorageTexture(bindingTypeInShader, kStorageTextureFormat);
wgpu::ShaderModule csModule = wgpu::ShaderModule csModule = utils::CreateShaderModule(device, computeShader.c_str());
utils::CreateShaderModuleFromWGSL(device, computeShader.c_str());
// Set common fields of compute pipeline descriptor. // Set common fields of compute pipeline descriptor.
wgpu::ComputePipelineDescriptor defaultComputePipelineDescriptor; wgpu::ComputePipelineDescriptor defaultComputePipelineDescriptor;
@ -479,8 +477,7 @@ TEST_F(StorageTextureValidationTests, BindGroupLayoutStorageTextureFormatMatches
// format. // format.
std::string computeShader = std::string computeShader =
CreateComputeShaderWithStorageTexture(bindingType, storageTextureFormatInShader); CreateComputeShaderWithStorageTexture(bindingType, storageTextureFormatInShader);
wgpu::ShaderModule csModule = wgpu::ShaderModule csModule = utils::CreateShaderModule(device, computeShader.c_str());
utils::CreateShaderModuleFromWGSL(device, computeShader.c_str());
// Set common fields of compute pipeline descriptor. // Set common fields of compute pipeline descriptor.
wgpu::ComputePipelineDescriptor defaultComputePipelineDescriptor; wgpu::ComputePipelineDescriptor defaultComputePipelineDescriptor;
@ -536,8 +533,7 @@ TEST_F(StorageTextureValidationTests, BindGroupLayoutViewDimensionMatchesShaderD
// Create the compute shader with the given texture view dimension. // Create the compute shader with the given texture view dimension.
std::string computeShader = CreateComputeShaderWithStorageTexture( std::string computeShader = CreateComputeShaderWithStorageTexture(
bindingType, kStorageTextureFormat, dimensionInShader); bindingType, kStorageTextureFormat, dimensionInShader);
wgpu::ShaderModule csModule = wgpu::ShaderModule csModule = utils::CreateShaderModule(device, computeShader.c_str());
utils::CreateShaderModuleFromWGSL(device, computeShader.c_str());
// Set common fields of compute pipeline descriptor. // Set common fields of compute pipeline descriptor.
wgpu::ComputePipelineDescriptor defaultComputePipelineDescriptor; wgpu::ComputePipelineDescriptor defaultComputePipelineDescriptor;
@ -768,7 +764,7 @@ TEST_F(StorageTextureValidationTests, MultisampledStorageTexture) {
for (wgpu::StorageTextureAccess bindingType : kSupportedStorageTextureAccess) { for (wgpu::StorageTextureAccess bindingType : kSupportedStorageTextureAccess) {
std::string computeShader = std::string computeShader =
CreateComputeShaderWithStorageTexture(bindingType, "", "image2DMS"); CreateComputeShaderWithStorageTexture(bindingType, "", "image2DMS");
ASSERT_DEVICE_ERROR(utils::CreateShaderModuleFromWGSL(device, computeShader.c_str())); ASSERT_DEVICE_ERROR(utils::CreateShaderModule(device, computeShader.c_str()));
} }
} }

12
src/tests/unittests/validation/UnsafeAPIValidationTests.cpp
View File

@ -50,9 +50,9 @@ TEST_F(UnsafeAPIValidationTest, DrawIndexedIndirectDisallowed) {
utils::ComboRenderPipelineDescriptor2 desc; utils::ComboRenderPipelineDescriptor2 desc;
desc.vertex.module = desc.vertex.module =
utils::CreateShaderModuleFromWGSL(device, "[[stage(vertex)]] fn main() -> void {}"); utils::CreateShaderModule(device, "[[stage(vertex)]] fn main() -> void {}");
desc.cFragment.module = desc.cFragment.module =
utils::CreateShaderModuleFromWGSL(device, "[[stage(fragment)]] fn main() -> void {}"); utils::CreateShaderModule(device, "[[stage(fragment)]] fn main() -> void {}");
wgpu::RenderPipeline pipeline = device.CreateRenderPipeline2(&desc); wgpu::RenderPipeline pipeline = device.CreateRenderPipeline2(&desc);
// Control cases: DrawIndirect and DrawIndexed are allowed inside a render pass. // Control cases: DrawIndirect and DrawIndexed are allowed inside a render pass.
@ -118,7 +118,7 @@ TEST_F(UnsafeAPIValidationTest, DispatchIndirectDisallowed) {
wgpu::ComputePipelineDescriptor pipelineDesc; wgpu::ComputePipelineDescriptor pipelineDesc;
pipelineDesc.computeStage.entryPoint = "main"; pipelineDesc.computeStage.entryPoint = "main";
pipelineDesc.computeStage.module = pipelineDesc.computeStage.module =
utils::CreateShaderModuleFromWGSL(device, "[[stage(compute)]] fn main() -> void {}"); utils::CreateShaderModule(device, "[[stage(compute)]] fn main() -> void {}");
wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc); wgpu::ComputePipeline pipeline = device.CreateComputePipeline(&pipelineDesc);
// Control case: dispatch is allowed. // Control case: dispatch is allowed.
@ -216,7 +216,7 @@ TEST_F(UnsafeAPIValidationTest, OcclusionQueryDisallowed) {
// Check that CreateComputePipelineAsync is disallowed as part of unsafe APIs // Check that CreateComputePipelineAsync is disallowed as part of unsafe APIs
TEST_F(UnsafeAPIValidationTest, CreateComputePipelineAsyncDisallowed) { TEST_F(UnsafeAPIValidationTest, CreateComputePipelineAsyncDisallowed) {
wgpu::ComputePipelineDescriptor desc; wgpu::ComputePipelineDescriptor desc;
desc.computeStage.module = utils::CreateShaderModuleFromWGSL(device, R"( desc.computeStage.module = utils::CreateShaderModule(device, R"(
[[stage(compute)]] fn main() -> void { [[stage(compute)]] fn main() -> void {
})"); })");
desc.computeStage.entryPoint = "main"; desc.computeStage.entryPoint = "main";
@ -236,12 +236,12 @@ TEST_F(UnsafeAPIValidationTest, CreateComputePipelineAsyncDisallowed) {
// Check that CreateRenderPipelineAsync is disallowed as part of unsafe APIs // Check that CreateRenderPipelineAsync is disallowed as part of unsafe APIs
TEST_F(UnsafeAPIValidationTest, CreateRenderPipelineAsyncDisallowed) { TEST_F(UnsafeAPIValidationTest, CreateRenderPipelineAsyncDisallowed) {
utils::ComboRenderPipelineDescriptor2 desc; utils::ComboRenderPipelineDescriptor2 desc;
desc.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( desc.vertex.module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
desc.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( desc.cFragment.module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> o_color : vec4<f32>; [[location(0)]] var<out> o_color : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
o_color = vec4<f32>(0.0, 1.0, 0.0, 1.0); o_color = vec4<f32>(0.0, 1.0, 0.0, 1.0);

4
src/tests/unittests/validation/VertexBufferValidationTests.cpp
View File

@ -25,7 +25,7 @@ class VertexBufferValidationTest : public ValidationTest {
void SetUp() override { void SetUp() override {
ValidationTest::SetUp(); ValidationTest::SetUp();
fsModule = utils::CreateShaderModuleFromWGSL(device, R"( fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0); fragColor = vec4<f32>(0.0, 1.0, 0.0, 1.0);
@ -59,7 +59,7 @@ class VertexBufferValidationTest : public ValidationTest {
vs << "}\n"; vs << "}\n";
return utils::CreateShaderModuleFromWGSL(device, vs.str().c_str()); return utils::CreateShaderModule(device, vs.str().c_str());
} }
wgpu::RenderPipeline MakeRenderPipeline(const wgpu::ShaderModule& vsModule, wgpu::RenderPipeline MakeRenderPipeline(const wgpu::ShaderModule& vsModule,

4
src/tests/unittests/validation/VertexStateValidationTests.cpp
View File

@ -22,8 +22,8 @@ class VertexStateTest : public ValidationTest {
void CreatePipeline(bool success, void CreatePipeline(bool success,
const utils::ComboVertexStateDescriptor& state, const utils::ComboVertexStateDescriptor& state,
const char* vertexSource) { const char* vertexSource) {
wgpu::ShaderModule vsModule = utils::CreateShaderModuleFromWGSL(device, vertexSource); wgpu::ShaderModule vsModule = utils::CreateShaderModule(device, vertexSource);
wgpu::ShaderModule fsModule = utils::CreateShaderModuleFromWGSL(device, R"( wgpu::ShaderModule fsModule = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> fragColor : vec4<f32>; [[location(0)]] var<out> fragColor : vec4<f32>;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0); fragColor = vec4<f32>(1.0, 0.0, 0.0, 1.0);

14
src/tests/white_box/D3D12DescriptorHeapTests.cpp
View File

@ -39,7 +39,7 @@ class D3D12DescriptorHeapTests : public DawnTest {
DAWN_SKIP_TEST_IF(UsesWire()); DAWN_SKIP_TEST_IF(UsesWire());
mD3DDevice = reinterpret_cast<Device*>(device.Get()); mD3DDevice = reinterpret_cast<Device*>(device.Get());
mSimpleVSModule = utils::CreateShaderModuleFromWGSL(device, R"( mSimpleVSModule = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
@ -52,7 +52,7 @@ class D3D12DescriptorHeapTests : public DawnTest {
Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
})"); })");
mSimpleFSModule = utils::CreateShaderModuleFromWGSL(device, R"( mSimpleFSModule = utils::CreateShaderModule(device, R"(
[[block]] struct U { [[block]] struct U {
color : vec4<f32>; color : vec4<f32>;
}; };
@ -176,13 +176,13 @@ TEST_P(D3D12DescriptorHeapTests, NoSwitchOverSamplerHeap) {
// Fill in a sampler heap with "sampler only" bindgroups (1x sampler per group) by creating a // Fill in a sampler heap with "sampler only" bindgroups (1x sampler per group) by creating a
// sampler bindgroup each draw. After HEAP_SIZE + 1 draws, the heaps WILL NOT switch over // sampler bindgroup each draw. After HEAP_SIZE + 1 draws, the heaps WILL NOT switch over
// because the sampler heap allocations are de-duplicated. // because the sampler heap allocations are de-duplicated.
renderPipelineDescriptor.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( renderPipelineDescriptor.vertex.module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[stage(vertex)]] fn main() -> void { [[stage(vertex)]] fn main() -> void {
Position = vec4<f32>(0.0, 0.0, 0.0, 1.0); Position = vec4<f32>(0.0, 0.0, 0.0, 1.0);
})"); })");
renderPipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( renderPipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"(
[[location(0)]] var<out> FragColor : vec4<f32>; [[location(0)]] var<out> FragColor : vec4<f32>;
[[group(0), binding(0)]] var sampler0 : sampler; [[group(0), binding(0)]] var sampler0 : sampler;
[[stage(fragment)]] fn main() -> void { [[stage(fragment)]] fn main() -> void {
@ -445,7 +445,7 @@ TEST_P(D3D12DescriptorHeapTests, EncodeManyUBO) {
utils::ComboRenderPipelineDescriptor2 pipelineDescriptor; utils::ComboRenderPipelineDescriptor2 pipelineDescriptor;
pipelineDescriptor.vertex.module = mSimpleVSModule; pipelineDescriptor.vertex.module = mSimpleVSModule;
pipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"(
[[block]] struct U { [[block]] struct U {
heapSize : f32; heapSize : f32;
}; };
@ -778,7 +778,7 @@ TEST_P(D3D12DescriptorHeapTests, EncodeManyUBOAndSamplers) {
{ {
utils::ComboRenderPipelineDescriptor2 pipelineDescriptor; utils::ComboRenderPipelineDescriptor2 pipelineDescriptor;
pipelineDescriptor.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.vertex.module = utils::CreateShaderModule(device, R"(
[[block]] struct U { [[block]] struct U {
transform : mat2x2<f32>; transform : mat2x2<f32>;
}; };
@ -794,7 +794,7 @@ TEST_P(D3D12DescriptorHeapTests, EncodeManyUBOAndSamplers) {
); );
Position = vec4<f32>(buffer0.transform * (pos[VertexIndex]), 0.0, 1.0); Position = vec4<f32>(buffer0.transform * (pos[VertexIndex]), 0.0, 1.0);
})"); })");
pipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( pipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"(
[[block]] struct U { [[block]] struct U {
color : vec4<f32>; color : vec4<f32>;
}; };

4
src/tests/white_box/D3D12ResidencyTests.cpp
View File

@ -334,7 +334,7 @@ TEST_P(D3D12DescriptorResidencyTests, SwitchedViewHeapResidency) {
// Fill in a view heap with "view only" bindgroups (1x view per group) by creating a // Fill in a view heap with "view only" bindgroups (1x view per group) by creating a
// view bindgroup each draw. After HEAP_SIZE + 1 draws, the heaps must switch over. // view bindgroup each draw. After HEAP_SIZE + 1 draws, the heaps must switch over.
renderPipelineDescriptor.vertex.module = utils::CreateShaderModuleFromWGSL(device, R"( renderPipelineDescriptor.vertex.module = utils::CreateShaderModule(device, R"(
[[builtin(position)]] var<out> Position : vec4<f32>; [[builtin(position)]] var<out> Position : vec4<f32>;
[[builtin(vertex_index)]] var<in> VertexIndex : u32; [[builtin(vertex_index)]] var<in> VertexIndex : u32;
@ -347,7 +347,7 @@ TEST_P(D3D12DescriptorResidencyTests, SwitchedViewHeapResidency) {
Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0); Position = vec4<f32>(pos[VertexIndex], 0.0, 1.0);
})"); })");
renderPipelineDescriptor.cFragment.module = utils::CreateShaderModuleFromWGSL(device, R"( renderPipelineDescriptor.cFragment.module = utils::CreateShaderModule(device, R"(
[[block]] struct U { [[block]] struct U {
color : vec4<f32>; color : vec4<f32>;
}; };

106
src/utils/WGPUHelpers.cpp
View File

@ -28,39 +28,6 @@ namespace utils {
namespace { namespace {
shaderc_shader_kind ShadercShaderKind(SingleShaderStage stage) {
switch (stage) {
case SingleShaderStage::Vertex:
return shaderc_glsl_vertex_shader;
case SingleShaderStage::Fragment:
return shaderc_glsl_fragment_shader;
case SingleShaderStage::Compute:
return shaderc_glsl_compute_shader;
default:
UNREACHABLE();
}
}
wgpu::ShaderModule CreateShaderModuleFromResult(
const wgpu::Device& device,
const shaderc::SpvCompilationResult& result) {
// result.cend and result.cbegin return pointers to uint32_t.
const uint32_t* resultBegin = result.cbegin();
const uint32_t* resultEnd = result.cend();
// So this size is in units of sizeof(uint32_t).
ptrdiff_t resultSize = resultEnd - resultBegin;
// SetSource takes data as uint32_t*.
wgpu::ShaderModuleSPIRVDescriptor spirvDesc;
spirvDesc.codeSize = static_cast<uint32_t>(resultSize);
spirvDesc.code = result.cbegin();
wgpu::ShaderModuleDescriptor descriptor;
descriptor.nextInChain = &spirvDesc;
return device.CreateShaderModule(&descriptor);
}
class CompilerSingleton { class CompilerSingleton {
public: public:
static shaderc::Compiler* Get() { static shaderc::Compiler* Get() {
@ -87,49 +54,6 @@ namespace utils {
} // anonymous namespace } // anonymous namespace
wgpu::ShaderModule CreateShaderModule(const wgpu::Device& device,
SingleShaderStage stage,
const char* source) {
shaderc_shader_kind kind = ShadercShaderKind(stage);
shaderc::Compiler* compiler = CompilerSingleton::Get();
auto result = compiler->CompileGlslToSpv(source, strlen(source), kind, "myshader?");
if (result.GetCompilationStatus() != shaderc_compilation_status_success) {
dawn::ErrorLog() << result.GetErrorMessage();
return {};
}
#ifdef DUMP_SPIRV_ASSEMBLY
{
shaderc::CompileOptions options;
auto resultAsm = compiler->CompileGlslToSpvAssembly(source, strlen(source), kind,
"myshader?", options);
size_t sizeAsm = (resultAsm.cend() - resultAsm.cbegin());
char* buffer = reinterpret_cast<char*>(malloc(sizeAsm + 1));
memcpy(buffer, resultAsm.cbegin(), sizeAsm);
buffer[sizeAsm] = '\0';
printf("SPIRV ASSEMBLY DUMP START\n%s\nSPIRV ASSEMBLY DUMP END\n", buffer);
free(buffer);
}
#endif
#ifdef DUMP_SPIRV_JS_ARRAY
printf("SPIRV JS ARRAY DUMP START\n");
for (size_t i = 0; i < size; i++) {
printf("%#010x", result.cbegin()[i]);
if ((i + 1) % 4 == 0) {
printf(",\n");
} else {
printf(", ");
}
}
printf("\n");
printf("SPIRV JS ARRAY DUMP END\n");
#endif
return CreateShaderModuleFromResult(device, result);
}
wgpu::ShaderModule CreateShaderModuleFromASM(const wgpu::Device& device, const char* source) { wgpu::ShaderModule CreateShaderModuleFromASM(const wgpu::Device& device, const char* source) {
shaderc::Compiler* compiler = CompilerSingleton::Get(); shaderc::Compiler* compiler = CompilerSingleton::Get();
shaderc::SpvCompilationResult result = compiler->AssembleToSpv(source, strlen(source)); shaderc::SpvCompilationResult result = compiler->AssembleToSpv(source, strlen(source));
@ -138,10 +62,24 @@ namespace utils {
return {}; return {};
} }
return CreateShaderModuleFromResult(device, result); // result.cend and result.cbegin return pointers to uint32_t.
const uint32_t* resultBegin = result.cbegin();
const uint32_t* resultEnd = result.cend();
// So this size is in units of sizeof(uint32_t).
ptrdiff_t resultSize = resultEnd - resultBegin;
// SetSource takes data as uint32_t*.
wgpu::ShaderModuleSPIRVDescriptor spirvDesc;
spirvDesc.codeSize = static_cast<uint32_t>(resultSize);
spirvDesc.code = result.cbegin();
wgpu::ShaderModuleDescriptor descriptor;
descriptor.nextInChain = &spirvDesc;
return device.CreateShaderModule(&descriptor);
} }
wgpu::ShaderModule CreateShaderModuleFromWGSL(const wgpu::Device& device, const char* source) { wgpu::ShaderModule CreateShaderModule(const wgpu::Device& device, const char* source) {
wgpu::ShaderModuleWGSLDescriptor wgslDesc; wgpu::ShaderModuleWGSLDescriptor wgslDesc;
wgslDesc.source = source; wgslDesc.source = source;
wgpu::ShaderModuleDescriptor descriptor; wgpu::ShaderModuleDescriptor descriptor;
@ -149,18 +87,6 @@ namespace utils {
return device.CreateShaderModule(&descriptor); return device.CreateShaderModule(&descriptor);
} }
std::vector<uint32_t> CompileGLSLToSpirv(SingleShaderStage stage, const char* source) {
shaderc_shader_kind kind = ShadercShaderKind(stage);
shaderc::Compiler* compiler = CompilerSingleton::Get();
auto result = compiler->CompileGlslToSpv(source, strlen(source), kind, "myshader?");
if (result.GetCompilationStatus() != shaderc_compilation_status_success) {
dawn::ErrorLog() << result.GetErrorMessage();
return {};
}
return {result.cbegin(), result.cend()};
}
wgpu::Buffer CreateBufferFromData(const wgpu::Device& device, wgpu::Buffer CreateBufferFromData(const wgpu::Device& device,
const void* data, const void* data,
uint64_t size, uint64_t size,

7
src/utils/WGPUHelpers.h
View File

@ -30,13 +30,8 @@ namespace utils {
enum class SingleShaderStage { Vertex, Fragment, Compute }; enum class SingleShaderStage { Vertex, Fragment, Compute };
wgpu::ShaderModule CreateShaderModule(const wgpu::Device& device,
SingleShaderStage stage,
const char* source);
wgpu::ShaderModule CreateShaderModuleFromASM(const wgpu::Device& device, const char* source); wgpu::ShaderModule CreateShaderModuleFromASM(const wgpu::Device& device, const char* source);
wgpu::ShaderModule CreateShaderModuleFromWGSL(const wgpu::Device& device, const char* source); wgpu::ShaderModule CreateShaderModule(const wgpu::Device& device, const char* source);
std::vector<uint32_t> CompileGLSLToSpirv(SingleShaderStage stage, const char* source);
wgpu::Buffer CreateBufferFromData(const wgpu::Device& device, wgpu::Buffer CreateBufferFromData(const wgpu::Device& device,
const void* data, const void* data,