encounter/dawn-cmake
1
0
Fork 0
mirror of https://github.com/encounter/dawn-cmake.git synced 2025-12-16 08:27:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

Introduce [Render|Compute]PassEncoder.

Browse Source 
This splits off part of CommandBufferBuilder in separate
RenderPassEncoder and ComputePassEncoder objects. To match the WebGPU
IDL and factor some code, both these encoders inherit from
ProgrammablePassEncoder.

These encoders are pure frontend objects and record into the
CommandBufferBuilder command allocator objects, so no changes to the
backends were needed.

Error handling is still ew, because the "builder" mechanism we had
doesn't allow for "split builders". Nicer error handling will have to
wait on Dawn matching WebGPU.

All the tests and samples were updated to the new structure.

BUG=dawn:5

Change-Id: I5f5d4ad866e2c07fedd1ba7a122258c6610941f1
Reviewed-on: https://dawn-review.googlesource.com/1543
Commit-Queue: Corentin Wallez <cwallez@chromium.org>
Reviewed-by: Corentin Wallez <cwallez@chromium.org>
This commit is contained in:
Corentin Wallez
2018-09-21 00:24:37 +00:00
committed by Commit Bot service account
parent 31d1e78d57
commit 82fbccbd78
35 changed files with 1303 additions and 863 deletions
Download Patch File Download Diff File Expand all files Collapse all files

156
src/tests/end2end/BlendStateTests.cpp
View File

@@ -109,22 +109,23 @@ class BlendStateTest : public DawnTest {
// Test that after drawing a triangle with the base color, and then the given triangle spec, the color is as expected
void DoSingleSourceTest(RGBA8 base, const TriangleSpec& triangle, const RGBA8& expected) {
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
// First use the base pipeline to draw a triangle with no blending
.SetRenderPipeline(basePipeline)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { base } })))
.DrawArrays(3, 1, 0, 0)
// Then use the test pipeline to draw the test triangle with blending
.SetRenderPipeline(testPipeline)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { triangle.color } })))
.SetBlendColor(triangle.blendFactor[0], triangle.blendFactor[1], triangle.blendFactor[2], triangle.blendFactor[3])
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
// First use the base pipeline to draw a triangle with no blending
pass.SetRenderPipeline(basePipeline);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { base } })));
pass.DrawArrays(3, 1, 0, 0);
// Then use the test pipeline to draw the test triangle with blending
pass.SetRenderPipeline(testPipeline);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { triangle.color } })));
pass.SetBlendColor(triangle.blendFactor[0], triangle.blendFactor[1], triangle.blendFactor[2], triangle.blendFactor[3]);
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(expected, renderPass.color, kRTSize / 2, kRTSize / 2);
@@ -671,14 +672,17 @@ TEST_P(BlendStateTest, ColorWriteMaskBlendingDisabled) {
RGBA8 base(32, 64, 128, 192);
RGBA8 expected(32, 0, 0, 0);
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(testPipeline)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { base } })))
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(testPipeline);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { base } })));
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(expected, renderPass.color, kRTSize / 2, kRTSize / 2);
}
@@ -790,18 +794,20 @@ TEST_P(BlendStateTest, IndependentBlendState) {
RGBA8 expected2 = color2;
RGBA8 expected3 = min(color3, base);
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderpass)
.SetRenderPipeline(basePipeline)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 4>({ { base, base, base, base } })))
.DrawArrays(3, 1, 0, 0)
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpass);
pass.SetRenderPipeline(basePipeline);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 4>({ { base, base, base, base } })));
pass.DrawArrays(3, 1, 0, 0);
.SetRenderPipeline(testPipeline)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 4>({ { color0, color1, color2, color3 } })))
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
pass.SetRenderPipeline(testPipeline);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 4>({ { color0, color1, color2, color3 } })));
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(expected0, renderTargets[0], kRTSize / 2, kRTSize / 2) << "Attachment slot 0 should have been " << color0 << " + " << base << " = " << expected0;
@@ -849,17 +855,19 @@ TEST_P(BlendStateTest, DefaultBlendColor) {
// Check that the initial blend color is (0,0,0,0)
{
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(basePipeline)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(0, 0, 0, 0) } })))
.DrawArrays(3, 1, 0, 0)
.SetRenderPipeline(testPipeline)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(255, 255, 255, 255) } })))
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(basePipeline);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(0, 0, 0, 0) } })));
pass.DrawArrays(3, 1, 0, 0);
pass.SetRenderPipeline(testPipeline);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(255, 255, 255, 255) } })));
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 0, 0, 0), renderPass.color, kRTSize / 2, kRTSize / 2);
@@ -867,18 +875,20 @@ TEST_P(BlendStateTest, DefaultBlendColor) {
// Check that setting the blend color works
{
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(basePipeline)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(0, 0, 0, 0) } })))
.DrawArrays(3, 1, 0, 0)
.SetRenderPipeline(testPipeline)
.SetBlendColor(1, 1, 1, 1)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(255, 255, 255, 255) } })))
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(basePipeline);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(0, 0, 0, 0) } })));
pass.DrawArrays(3, 1, 0, 0);
pass.SetRenderPipeline(testPipeline);
pass.SetBlendColor(1, 1, 1, 1);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(255, 255, 255, 255) } })));
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(255, 255, 255, 255), renderPass.color, kRTSize / 2, kRTSize / 2);
@@ -886,26 +896,30 @@ TEST_P(BlendStateTest, DefaultBlendColor) {
// Check that the blend color is not inherited between render passes
{
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(basePipeline)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(0, 0, 0, 0) } })))
.DrawArrays(3, 1, 0, 0)
.SetRenderPipeline(testPipeline)
.SetBlendColor(1, 1, 1, 1)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(255, 255, 255, 255) } })))
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(basePipeline)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(0, 0, 0, 0) } })))
.DrawArrays(3, 1, 0, 0)
.SetRenderPipeline(testPipeline)
.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(255, 255, 255, 255) } })))
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(basePipeline);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(0, 0, 0, 0) } })));
pass.DrawArrays(3, 1, 0, 0);
pass.SetRenderPipeline(testPipeline);
pass.SetBlendColor(1, 1, 1, 1);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(255, 255, 255, 255) } })));
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(basePipeline);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(0, 0, 0, 0) } })));
pass.DrawArrays(3, 1, 0, 0);
pass.SetRenderPipeline(testPipeline);
pass.SetBindGroup(0, MakeBindGroupForColors(std::array<RGBA8, 1>({ { RGBA8(255, 255, 255, 255) } })));
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 0, 0, 0), renderPass.color, kRTSize / 2, kRTSize / 2);

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

@@ -78,13 +78,18 @@ void ComputeCopyStorageBufferTests::BasicTest(const char* shader) {
.SetBufferViews(0, 1, &srcView)
.SetBufferViews(1, 1, &dstView)
.GetResult();
auto commands = device.CreateCommandBufferBuilder()
.BeginComputePass()
.SetComputePipeline(pipeline)
.SetBindGroup(0, bindGroup)
.Dispatch(kInstances, 1, 1)
.EndComputePass()
.GetResult();
dawn::CommandBuffer commands;
{
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetComputePipeline(pipeline);
pass.SetBindGroup(0, bindGroup);
pass.Dispatch(kInstances, 1, 1);
pass.EndPass();
commands = builder.GetResult();
}
queue.Submit(1, &commands);

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

@@ -197,7 +197,7 @@ class DepthStencilStateTest : public DawnTest {
float depth;
};
builder.BeginRenderPass(renderpass);
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpass);
for (size_t i = 0; i < testParams.size(); ++i) {
const TestSpec& test = testParams[i];
@@ -229,16 +229,14 @@ class DepthStencilStateTest : public DawnTest {
.SetDepthStencilState(test.depthStencilState)
.GetResult();
builder.SetRenderPipeline(pipeline)
.SetStencilReference(test.stencil) // Set the stencil reference
.SetBindGroup(0, bindGroup) // Set the bind group which contains color and depth data
.DrawArrays(6, 1, 0, 0);
pass.SetRenderPipeline(pipeline);
pass.SetStencilReference(test.stencil); // Set the stencil reference
pass.SetBindGroup(0, bindGroup); // Set the bind group which contains color and depth data
pass.DrawArrays(6, 1, 0, 0);
}
pass.EndPass();
dawn::CommandBuffer commands = builder
.EndRenderPass()
.GetResult();
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(expectedFront, renderTarget, kRTSize / 4, kRTSize / 2) << "Front face check failed";

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

@@ -74,15 +74,17 @@ class DrawElementsTest : public DawnTest {
void Test(uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex,
uint32_t firstInstance, RGBA8 bottomLeftExpected, RGBA8 topRightExpected) {
uint32_t zeroOffset = 0;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset)
.SetIndexBuffer(indexBuffer, 0)
.DrawElements(indexCount, instanceCount, firstIndex, firstInstance)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset);
pass.SetIndexBuffer(indexBuffer, 0);
pass.DrawElements(indexCount, instanceCount, firstIndex, firstInstance);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(bottomLeftExpected, renderPass.color, 1, 3);

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

@@ -78,15 +78,17 @@ TEST_P(IndexFormatTest, Uint32) {
});
uint32_t zeroOffset = 0;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset)
.SetIndexBuffer(indexBuffer, 0)
.DrawElements(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset);
pass.SetIndexBuffer(indexBuffer, 0);
pass.DrawElements(3, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 100, 300);
@@ -107,15 +109,17 @@ TEST_P(IndexFormatTest, Uint16) {
});
uint32_t zeroOffset = 0;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset)
.SetIndexBuffer(indexBuffer, 0)
.DrawElements(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset);
pass.SetIndexBuffer(indexBuffer, 0);
pass.DrawElements(3, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 100, 300);
@@ -149,15 +153,17 @@ TEST_P(IndexFormatTest, Uint32PrimitiveRestart) {
});
uint32_t zeroOffset = 0;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset)
.SetIndexBuffer(indexBuffer, 0)
.DrawElements(7, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset);
pass.SetIndexBuffer(indexBuffer, 0);
pass.DrawElements(7, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 190, 190); // A
@@ -181,15 +187,17 @@ TEST_P(IndexFormatTest, Uint16PrimitiveRestart) {
});
uint32_t zeroOffset = 0;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset)
.SetIndexBuffer(indexBuffer, 0)
.DrawElements(7, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset);
pass.SetIndexBuffer(indexBuffer, 0);
pass.DrawElements(7, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 190, 190); // A
@@ -218,16 +226,18 @@ TEST_P(IndexFormatTest, ChangePipelineAfterSetIndexBuffer) {
});
uint32_t zeroOffset = 0;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline16)
.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset)
.SetIndexBuffer(indexBuffer, 0)
.SetRenderPipeline(pipeline32)
.DrawElements(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline16);
pass.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset);
pass.SetIndexBuffer(indexBuffer, 0);
pass.SetRenderPipeline(pipeline32);
pass.DrawElements(3, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 100, 300);
@@ -251,15 +261,17 @@ TEST_P(IndexFormatTest, DISABLED_SetIndexBufferBeforeSetPipeline) {
});
uint32_t zeroOffset = 0;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetIndexBuffer(indexBuffer, 0)
.SetRenderPipeline(pipeline)
.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset)
.DrawElements(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetIndexBuffer(indexBuffer, 0);
pass.SetRenderPipeline(pipeline);
pass.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset);
pass.DrawElements(3, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 100, 300);

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

@@ -168,19 +168,18 @@ class InputStateTest : public DawnTest {
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
builder.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline);
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
uint32_t zeroOffset = 0;
for (const auto& buffer : vertexBuffers) {
builder.SetVertexBuffers(buffer.location, 1, buffer.buffer, &zeroOffset);
pass.SetVertexBuffers(buffer.location, 1, buffer.buffer, &zeroOffset);
}
dawn::CommandBuffer commands = builder
.DrawArrays(triangles * 3, instances, 0, 0)
.EndRenderPass()
.GetResult();
pass.DrawArrays(triangles * 3, instances, 0, 0);
pass.EndPass();
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
// Check that the center of each triangle is pure green, so that if a single vertex shader

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

@@ -194,14 +194,16 @@ class PrimitiveTopologyTest : public DawnTest {
.GetResult();
static const uint32_t zeroOffset = 0;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset)
.DrawArrays(6, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.SetVertexBuffers(0, 1, &vertexBuffer, &zeroOffset);
pass.DrawArrays(6, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
for (auto& locationSpec : locationSpecs) {

162
src/tests/end2end/PushConstantTests.cpp
View File

@@ -207,23 +207,31 @@ TEST_P(PushConstantTest, ComputePassDefaultsToZero) {
dawn::ComputePipeline pipeline = MakeTestComputePipeline(binding.layout, MakeAllZeroSpec());
uint32_t notZero = 42;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginComputePass()
// Test compute push constants are set to zero by default.
.SetComputePipeline(pipeline)
.SetBindGroup(0, binding.bindGroup)
.Dispatch(1, 1, 1)
// Set push constants to non-zero value to check they will be reset to zero
// on the next BeginComputePass
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, &notZero)
.EndComputePass()
.BeginComputePass()
.SetComputePipeline(pipeline)
.SetBindGroup(0, binding.bindGroup)
.Dispatch(1, 1, 1)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::ComputePassEncoder pass = builder.BeginComputePass();
// Test compute push constants are set to zero by default.
pass.SetComputePipeline(pipeline);
pass.SetBindGroup(0, binding.bindGroup);
pass.Dispatch(1, 1, 1);
// Set push constants to non-zero value to check they will be reset to zero
// on the next BeginComputePass
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, &notZero);
pass.EndPass();
}
{
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetComputePipeline(pipeline);
pass.SetBindGroup(0, binding.bindGroup);
pass.Dispatch(1, 1, 1);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_BUFFER_U32_EQ(1, binding.resultBuffer, 0);
@@ -238,14 +246,16 @@ TEST_P(PushConstantTest, RenderPassDefaultsToZero) {
dawn::PipelineLayout layout = MakeEmptyLayout();
dawn::RenderPipeline pipeline = MakeTestRenderPipeline(layout, MakeAllZeroSpec(), MakeAllZeroSpec());
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
// Test render push constants are set to zero by default.
.SetRenderPipeline(pipeline)
.DrawArrays(1, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
// Test render push constants are set to zero by default.
pass.SetRenderPipeline(pipeline);
pass.DrawArrays(1, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(1, 1, 0, 0), renderPass.color, 0, 0);
@@ -266,15 +276,19 @@ TEST_P(PushConstantTest, VariousConstantTypes) {
dawn::ComputePipeline pipeline = MakeTestComputePipeline(binding.layout, spec);
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginComputePass()
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 3, reinterpret_cast<uint32_t*>(&values))
.SetComputePipeline(pipeline)
.SetBindGroup(0, binding.bindGroup)
.Dispatch(1, 1, 1)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 3, reinterpret_cast<uint32_t*>(&values));
pass.SetComputePipeline(pipeline);
pass.SetBindGroup(0, binding.bindGroup);
pass.Dispatch(1, 1, 1);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_BUFFER_U32_EQ(1, binding.resultBuffer, 0);
@@ -292,21 +306,25 @@ TEST_P(PushConstantTest, InheritThroughPipelineLayoutChange) {
uint32_t one = 1;
uint32_t two = 2;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginComputePass()
// Set Push constant before there is a pipeline set
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, &one)
.SetComputePipeline(pipeline1)
.SetBindGroup(0, binding1.bindGroup)
.Dispatch(1, 1, 1)
// Change the push constant before changing pipeline layout
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, &two)
.SetComputePipeline(pipeline2)
.SetBindGroup(0, binding2.bindGroup)
.Dispatch(1, 1, 1)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::ComputePassEncoder pass = builder.BeginComputePass();
// Set Push constant before there is a pipeline set
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, &one);
pass.SetComputePipeline(pipeline1);
pass.SetBindGroup(0, binding1.bindGroup);
pass.Dispatch(1, 1, 1);
// Change the push constant before changing pipeline layout
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, &two);
pass.SetComputePipeline(pipeline2);
pass.SetBindGroup(0, binding2.bindGroup);
pass.Dispatch(1, 1, 1);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_BUFFER_U32_EQ(1, binding1.resultBuffer, 0);
@@ -325,15 +343,19 @@ TEST_P(PushConstantTest, SetAllConstantsToNonZero) {
auto binding = MakeTestBindings(false);
dawn::ComputePipeline pipeline = MakeTestComputePipeline(binding.layout, spec);
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginComputePass()
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, kMaxPushConstants, &values[0])
.SetComputePipeline(pipeline)
.SetBindGroup(0, binding.bindGroup)
.Dispatch(1, 1, 1)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 0, kMaxPushConstants, &values[0]);
pass.SetComputePipeline(pipeline);
pass.SetBindGroup(0, binding.bindGroup);
pass.Dispatch(1, 1, 1);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_BUFFER_U32_EQ(1, binding.resultBuffer, 0);
@@ -351,15 +373,17 @@ TEST_P(PushConstantTest, SeparateVertexAndFragmentConstants) {
uint32_t one = 1;
uint32_t two = 2;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetPushConstants(dawn::ShaderStageBit::Vertex, 0, 1, &one)
.SetPushConstants(dawn::ShaderStageBit::Fragment, 0, 1, &two)
.SetRenderPipeline(pipeline)
.DrawArrays(1, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetPushConstants(dawn::ShaderStageBit::Vertex, 0, 1, &one);
pass.SetPushConstants(dawn::ShaderStageBit::Fragment, 0, 1, &two);
pass.SetRenderPipeline(pipeline);
pass.DrawArrays(1, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(1, 1, 0, 0), renderPass.color, 0, 0);
@@ -375,14 +399,16 @@ TEST_P(PushConstantTest, SimultaneousVertexAndFragmentConstants) {
dawn::RenderPipeline pipeline = MakeTestRenderPipeline(layout, spec, spec);
uint32_t two = 2;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetPushConstants(dawn::ShaderStageBit::Vertex | dawn::ShaderStageBit::Fragment, 0, 1, &two)
.SetRenderPipeline(pipeline)
.DrawArrays(1, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetPushConstants(dawn::ShaderStageBit::Vertex | dawn::ShaderStageBit::Fragment, 0, 1, &two);
pass.SetRenderPipeline(pipeline);
pass.DrawArrays(1, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(1, 1, 0, 0), renderPass.color, 0, 0);

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

@@ -31,7 +31,7 @@ class DrawQuad {
pipelineLayout = utils::MakeBasicPipelineLayout(*device, nullptr);
}
void Draw(dawn::CommandBufferBuilder* builder) {
void Draw(dawn::RenderPassEncoder* pass) {
auto renderPipeline = device->CreateRenderPipelineBuilder()
.SetColorAttachmentFormat(0, dawn::TextureFormat::R8G8B8A8Unorm)
.SetLayout(pipelineLayout)
@@ -39,8 +39,8 @@ class DrawQuad {
.SetStage(dawn::ShaderStage::Fragment, fsModule, "main")
.GetResult();
builder->SetRenderPipeline(renderPipeline);
builder->DrawArrays(6, 1, 0, 0);
pass->SetRenderPipeline(renderPipeline);
pass->DrawArrays(6, 1, 0, 0);
}
private:
@@ -117,24 +117,20 @@ TEST_P(RenderPassLoadOpTests, ColorClearThenLoadAndDraw) {
.SetColorAttachmentClearColor(0, 0.0f, 0.0f, 0.0f, 0.0f)
.GetResult();
auto commandsClearZero = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPassClearZero)
// Clear should occur implicitly
// Store should occur implicitly
.EndRenderPass()
.GetResult();
auto commandsClearZeroBuilder = device.CreateCommandBufferBuilder();
auto clearZeroPass = commandsClearZeroBuilder.BeginRenderPass(renderPassClearZero);
clearZeroPass.EndPass();
auto commandsClearZero = commandsClearZeroBuilder.GetResult();
auto renderPassClearGreen = device.CreateRenderPassDescriptorBuilder()
.SetColorAttachment(0, renderTargetView, dawn::LoadOp::Clear)
.SetColorAttachmentClearColor(0, 0.0f, 1.0f, 0.0f, 1.0f)
.GetResult();
auto commandsClearGreen = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPassClearGreen)
// Clear should occur implicitly
// Store should occur implicitly
.EndRenderPass()
.GetResult();
auto commandsClearGreenBuilder = device.CreateCommandBufferBuilder();
auto clearGreenPass = commandsClearGreenBuilder.BeginRenderPass(renderPassClearGreen);
clearGreenPass.EndPass();
auto commandsClearGreen = commandsClearGreenBuilder.GetResult();
queue.Submit(1, &commandsClearZero);
EXPECT_TEXTURE_RGBA8_EQ(expectZero.data(), renderTarget, 0, 0, kRTSize, kRTSize, 0);
@@ -150,15 +146,11 @@ TEST_P(RenderPassLoadOpTests, ColorClearThenLoadAndDraw) {
dawn::CommandBuffer commandsLoad;
{
auto builder = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPassLoad)
// Load should occur implicitly
.Clone();
blueQuad.Draw(&builder);
commandsLoad = builder
// Store should occur implicitly
.EndRenderPass()
.GetResult();
auto builder = device.CreateCommandBufferBuilder();
auto pass = builder.BeginRenderPass(renderPassLoad);
blueQuad.Draw(&pass);
pass.EndPass();
commandsLoad = builder.GetResult();
}
queue.Submit(1, &commandsLoad);

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

@@ -127,14 +127,16 @@ protected:
.SetTextureViews(1, 1, &mTextureView)
.GetResult();
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(mRenderPass.renderPassInfo)
.SetRenderPipeline(mPipeline)
.SetBindGroup(0, bindGroup)
.DrawArrays(6, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(mRenderPass.renderPassInfo);
pass.SetRenderPipeline(mPipeline);
pass.SetBindGroup(0, bindGroup);
pass.DrawArrays(6, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
RGBA8 expectedU2(u.mExpected2, u.mExpected2, u.mExpected2, 255);

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

@@ -51,13 +51,15 @@ TEST_P(ScissorTest, DefaultsToWholeRenderTarget) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 100, 100);
dawn::RenderPipeline pipeline = CreateQuadPipeline(renderPass.colorFormat);
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.DrawArrays(6, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.DrawArrays(6, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 0, 0);
@@ -71,14 +73,16 @@ TEST_P(ScissorTest, LargerThanAttachment) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 100, 100);
dawn::RenderPipeline pipeline = CreateQuadPipeline(renderPass.colorFormat);
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.SetScissorRect(0, 0, 200, 200)
.DrawArrays(6, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.SetScissorRect(0, 0, 200, 200);
pass.DrawArrays(6, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 0, 0);
@@ -95,14 +99,16 @@ TEST_P(ScissorTest, EmptyRect) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 2, 2);
dawn::RenderPipeline pipeline = CreateQuadPipeline(renderPass.colorFormat);
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.SetScissorRect(0, 0, 0, 0)
.DrawArrays(6, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.SetScissorRect(0, 0, 0, 0);
pass.DrawArrays(6, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 0, 0, 0), renderPass.color, 0, 0);
@@ -121,14 +127,16 @@ TEST_P(ScissorTest, PartialRect) {
constexpr uint32_t kW = 5;
constexpr uint32_t kH = 13;
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.SetScissorRect(kX, kY, kW, kH)
.DrawArrays(6, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.SetScissorRect(kX, kY, kW, kH);
pass.DrawArrays(6, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
// Test the two opposite corners of the scissor box. With one pixel inside and on outside
@@ -144,18 +152,22 @@ TEST_P(ScissorTest, NoInheritanceBetweenRenderPass) {
utils::BasicRenderPass renderPass = utils::CreateBasicRenderPass(device, 100, 100);
dawn::RenderPipeline pipeline = CreateQuadPipeline(renderPass.colorFormat);
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
// RenderPass 1 set the scissor
.BeginRenderPass(renderPass.renderPassInfo)
.SetScissorRect(0, 0, 0, 0)
.EndRenderPass()
// RenderPass 2 draw a full quad, it shouldn't be scissored
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.DrawArrays(6, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
// RenderPass 1 set the scissor
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetScissorRect(0, 0, 0, 0);
pass.EndPass();
}
// RenderPass 2 draw a full quad, it shouldn't be scissored
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.DrawArrays(6, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 0, 0);

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

@@ -42,13 +42,15 @@ TEST_P(ViewportOrientationTests, OriginAt0x0) {
.SetPrimitiveTopology(dawn::PrimitiveTopology::PointList)
.GetResult();
dawn::CommandBuffer commands = device.CreateCommandBufferBuilder()
.BeginRenderPass(renderPass.renderPassInfo)
.SetRenderPipeline(pipeline)
.DrawArrays(1, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = device.CreateCommandBufferBuilder();
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPassInfo);
pass.SetRenderPipeline(pipeline);
pass.DrawArrays(1, 1, 0, 0);
pass.EndPass();
}
dawn::CommandBuffer commands = builder.GetResult();
queue.Submit(1, &commands);
EXPECT_PIXEL_RGBA8_EQ(RGBA8(0, 255, 0, 255), renderPass.color, 0, 0);

61
src/tests/unittests/WireTests.cpp
View File

@@ -250,13 +250,18 @@ TEST_F(WireTests, ReleaseCalledOnRefCount0) {
// Test that the wire is able to send numerical values
TEST_F(WireTests, ValueArgument) {
dawnCommandBufferBuilder builder = dawnDeviceCreateCommandBufferBuilder(device);
dawnCommandBufferBuilderDispatch(builder, 1, 2, 3);
dawnComputePassEncoder pass = dawnCommandBufferBuilderBeginComputePass(builder);
dawnComputePassEncoderDispatch(pass, 1, 2, 3);
dawnCommandBufferBuilder apiBuilder = api.GetNewCommandBufferBuilder();
EXPECT_CALL(api, DeviceCreateCommandBufferBuilder(apiDevice))
.WillOnce(Return(apiBuilder));
EXPECT_CALL(api, CommandBufferBuilderDispatch(apiBuilder, 1, 2, 3))
dawnComputePassEncoder apiPass = api.GetNewComputePassEncoder();
EXPECT_CALL(api, CommandBufferBuilderBeginComputePass(apiBuilder))
.WillOnce(Return(apiPass));
EXPECT_CALL(api, ComputePassEncoderDispatch(apiPass, 1, 2, 3))
.Times(1);
FlushClient();
@@ -281,13 +286,18 @@ bool CheckPushConstantValues(const uint32_t* values) {
TEST_F(WireTests, ValueArrayArgument) {
dawnCommandBufferBuilder builder = dawnDeviceCreateCommandBufferBuilder(device);
dawnCommandBufferBuilderSetPushConstants(builder, DAWN_SHADER_STAGE_BIT_VERTEX, 0, 4, testPushConstantValues);
dawnComputePassEncoder pass = dawnCommandBufferBuilderBeginComputePass(builder);
dawnComputePassEncoderSetPushConstants(pass, DAWN_SHADER_STAGE_BIT_VERTEX, 0, 4, testPushConstantValues);
dawnCommandBufferBuilder apiBuilder = api.GetNewCommandBufferBuilder();
EXPECT_CALL(api, DeviceCreateCommandBufferBuilder(apiDevice))
.WillOnce(Return(apiBuilder));
EXPECT_CALL(api, CommandBufferBuilderSetPushConstants(apiBuilder, DAWN_SHADER_STAGE_BIT_VERTEX, 0, 4, ResultOf(CheckPushConstantValues, Eq(true))));
dawnComputePassEncoder apiPass = api.GetNewComputePassEncoder();
EXPECT_CALL(api, CommandBufferBuilderBeginComputePass(apiBuilder))
.WillOnce(Return(apiPass));
EXPECT_CALL(api, ComputePassEncoderSetPushConstants(apiPass, DAWN_SHADER_STAGE_BIT_VERTEX, 0, 4, ResultOf(CheckPushConstantValues, Eq(true))));
FlushClient();
}
@@ -318,28 +328,33 @@ TEST_F(WireTests, CStringArgument) {
}
// Test that the wire is able to send objects as value arguments
TEST_F(WireTests, ObjectAsValueArgument) {
TEST_F(WireTests, DISABLED_ObjectAsValueArgument) {
// Create pipeline
dawnRenderPipelineBuilder pipelineBuilder = dawnDeviceCreateRenderPipelineBuilder(device);
dawnRenderPipeline pipeline = dawnRenderPipelineBuilderGetResult(pipelineBuilder);
dawnComputePipelineDescriptor pipelineDesc;
pipelineDesc.nextInChain = nullptr;
pipelineDesc.layout = nullptr;
pipelineDesc.entryPoint = "main";
pipelineDesc.module = nullptr;
dawnComputePipeline pipeline = dawnDeviceCreateComputePipeline(device, &pipelineDesc);
dawnRenderPipelineBuilder apiPipelineBuilder = api.GetNewRenderPipelineBuilder();
EXPECT_CALL(api, DeviceCreateRenderPipelineBuilder(apiDevice))
.WillOnce(Return(apiPipelineBuilder));
dawnRenderPipeline apiPipeline = api.GetNewRenderPipeline();
EXPECT_CALL(api, RenderPipelineBuilderGetResult(apiPipelineBuilder))
dawnComputePipeline apiPipeline = api.GetNewComputePipeline();
EXPECT_CALL(api, DeviceCreateComputePipeline(apiDevice, _))
.WillOnce(Return(apiPipeline));
// Create command buffer builder, setting pipeline
dawnCommandBufferBuilder cmdBufBuilder = dawnDeviceCreateCommandBufferBuilder(device);
dawnCommandBufferBuilderSetRenderPipeline(cmdBufBuilder, pipeline);
dawnComputePassEncoder pass = dawnCommandBufferBuilderBeginComputePass(cmdBufBuilder);
dawnComputePassEncoderSetComputePipeline(pass, pipeline);
dawnCommandBufferBuilder apiCmdBufBuilder = api.GetNewCommandBufferBuilder();
EXPECT_CALL(api, DeviceCreateCommandBufferBuilder(apiDevice))
.WillOnce(Return(apiCmdBufBuilder));
EXPECT_CALL(api, CommandBufferBuilderSetRenderPipeline(apiCmdBufBuilder, apiPipeline));
dawnComputePassEncoder apiPass = api.GetNewComputePassEncoder();
EXPECT_CALL(api, CommandBufferBuilderBeginComputePass(apiCmdBufBuilder))
.WillOnce(Return(apiPass));
EXPECT_CALL(api, ComputePassEncoderSetComputePipeline(apiPass, apiPipeline));
FlushClient();
}
@@ -472,23 +487,33 @@ TEST_F(WireTests, StructureOfStructureArrayArgument) {
// Test that the server doesn't forward calls to error objects or with error objects
// Also test that when GetResult is called on an error builder, the error callback is fired
TEST_F(WireTests, CallsSkippedAfterBuilderError) {
// TODO(cwallez@chromium.org): This test is disabled because the introduction of encoders breaks
// the assumptions of the "builder error" handling that a builder is self-contained. We need to
// revisit this once the new error handling is in place.
TEST_F(WireTests, DISABLED_CallsSkippedAfterBuilderError) {
dawnCommandBufferBuilder cmdBufBuilder = dawnDeviceCreateCommandBufferBuilder(device);
dawnCommandBufferBuilderSetErrorCallback(cmdBufBuilder, ToMockBuilderErrorCallback, 1, 2);
dawnRenderPassEncoder pass = dawnCommandBufferBuilderBeginRenderPass(cmdBufBuilder, nullptr);
dawnBufferBuilder bufferBuilder = dawnDeviceCreateBufferBuilderForTesting(device);
dawnBufferBuilderSetErrorCallback(bufferBuilder, ToMockBuilderErrorCallback, 3, 4);
dawnBuffer buffer = dawnBufferBuilderGetResult(bufferBuilder); // Hey look an error!
// These calls will be skipped because of the error
dawnBufferSetSubData(buffer, 0, 0, nullptr);
dawnCommandBufferBuilderSetIndexBuffer(cmdBufBuilder, buffer, 0);
dawnRenderPassEncoderSetIndexBuffer(pass, buffer, 0);
dawnRenderPassEncoderEndPass(pass);
dawnCommandBufferBuilderGetResult(cmdBufBuilder);
dawnCommandBufferBuilder apiCmdBufBuilder = api.GetNewCommandBufferBuilder();
EXPECT_CALL(api, DeviceCreateCommandBufferBuilder(apiDevice))
.WillOnce(Return(apiCmdBufBuilder));
dawnRenderPassEncoder apiPass = api.GetNewRenderPassEncoder();
EXPECT_CALL(api, CommandBufferBuilderBeginRenderPass(apiCmdBufBuilder, _))
.WillOnce(Return(apiPass));
dawnBufferBuilder apiBufferBuilder = api.GetNewBufferBuilder();
EXPECT_CALL(api, DeviceCreateBufferBuilderForTesting(apiDevice))
.WillOnce(Return(apiBufferBuilder));
@@ -501,7 +526,7 @@ TEST_F(WireTests, CallsSkippedAfterBuilderError) {
}));
EXPECT_CALL(api, BufferSetSubData(_, _, _, _)).Times(0);
EXPECT_CALL(api, CommandBufferBuilderSetIndexBuffer(_, _, _)).Times(0);
EXPECT_CALL(api, RenderPassEncoderSetIndexBuffer(_, _, _)).Times(0);
EXPECT_CALL(api, CommandBufferBuilderGetResult(_)).Times(0);
FlushClient();

19
src/tests/unittests/validation/CommandBufferValidationTests.cpp
View File

@@ -27,11 +27,16 @@ TEST_F(CommandBufferValidationTest, Empty) {
TEST_F(CommandBufferValidationTest, RenderPass) {
auto renderpass = CreateSimpleRenderPass();
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderpass)
.EndRenderPass()
.GetResult();
AssertWillBeError(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderpass)
.GetResult();
{
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpass);
pass.EndPass();
builder.GetResult();
}
{
dawn::CommandBufferBuilder builder = AssertWillBeError(device.CreateCommandBufferBuilder());
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpass);
builder.GetResult();
}
}

126
src/tests/unittests/validation/DynamicStateCommandValidationTests.cpp
View File

@@ -17,36 +17,30 @@
class SetScissorRectTest : public ValidationTest {
};
// Test to check that SetScissor can only be used inside render passes
TEST_F(SetScissorRectTest, AllowedOnlyInRenderPass) {
// Test to check basic use of SetScissor
TEST_F(SetScissorRectTest, Success) {
DummyRenderPass renderPass = CreateDummyRenderPass();
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderPass.renderPass)
.SetScissorRect(0, 0, 1, 1)
.EndRenderPass()
.GetResult();
AssertWillBeError(device.CreateCommandBufferBuilder())
.SetScissorRect(0, 0, 1, 1)
.GetResult();
AssertWillBeError(device.CreateCommandBufferBuilder())
.BeginComputePass()
.SetScissorRect(0, 0, 1, 1)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPass);
pass.SetScissorRect(0, 0, 1, 1);
pass.EndPass();
}
builder.GetResult();
}
// Test to check that an empty scissor is allowed
TEST_F(SetScissorRectTest, EmptyScissor) {
DummyRenderPass renderPass = CreateDummyRenderPass();
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderPass.renderPass)
.SetScissorRect(0, 0, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPass);
pass.SetScissorRect(0, 0, 0, 0);
pass.EndPass();
}
builder.GetResult();
}
// Test to check that a scissor larger than the framebuffer is allowed
@@ -55,79 +49,69 @@ TEST_F(SetScissorRectTest, EmptyScissor) {
TEST_F(SetScissorRectTest, ScissorLargerThanFramebuffer) {
DummyRenderPass renderPass = CreateDummyRenderPass();
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderPass.renderPass)
.SetScissorRect(0, 0, renderPass.width + 1, renderPass.height + 1)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPass);
pass.SetScissorRect(0, 0, renderPass.width + 1, renderPass.height + 1);
pass.EndPass();
}
builder.GetResult();
}
class SetBlendColorTest : public ValidationTest {
};
// Test to check that SetBlendColor can only be used inside render passes
TEST_F(SetBlendColorTest, AllowedOnlyInRenderPass) {
// Test to check basic use of SetBlendColor
TEST_F(SetBlendColorTest, Success) {
DummyRenderPass renderPass = CreateDummyRenderPass();
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderPass.renderPass)
.SetBlendColor(0.0f, 0.0f, 0.0f, 0.0f)
.EndRenderPass()
.GetResult();
AssertWillBeError(device.CreateCommandBufferBuilder())
.SetBlendColor(0.0f, 0.0f, 0.0f, 0.0f)
.GetResult();
AssertWillBeError(device.CreateCommandBufferBuilder())
.BeginComputePass()
.SetBlendColor(0.0f, 0.0f, 0.0f, 0.0f)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPass);
pass.SetBlendColor(0.0f, 0.0f, 0.0f, 0.0f);
pass.EndPass();
}
builder.GetResult();
}
// Test that SetBlendColor allows any value, large, small or negative
TEST_F(SetBlendColorTest, AnyValueAllowed) {
DummyRenderPass renderPass = CreateDummyRenderPass();
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderPass.renderPass)
.SetBlendColor(-1.0f, 42.0f, -0.0f, 0.0f)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPass);
pass.SetBlendColor(-1.0f, 42.0f, -0.0f, 0.0f);
pass.EndPass();
}
builder.GetResult();
}
class SetStencilReferenceTest : public ValidationTest {
};
// Test to check that SetStencilReference can only be used inside render passes
TEST_F(SetStencilReferenceTest, AllowedOnlyInRenderPass) {
// Test to check basic use of SetBlendColor
TEST_F(SetStencilReferenceTest, Success) {
DummyRenderPass renderPass = CreateDummyRenderPass();
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderPass.renderPass)
.SetStencilReference(0)
.EndRenderPass()
.GetResult();
AssertWillBeError(device.CreateCommandBufferBuilder())
.SetStencilReference(0)
.GetResult();
AssertWillBeError(device.CreateCommandBufferBuilder())
.BeginComputePass()
.SetStencilReference(0)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPass);
pass.SetStencilReference(0);
pass.EndPass();
}
builder.GetResult();
}
// Test that SetStencilReference allows any bit to be set
TEST_F(SetStencilReferenceTest, AllBitsAllowed) {
DummyRenderPass renderPass = CreateDummyRenderPass();
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderPass.renderPass)
.SetStencilReference(0xFFFFFFFF)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderPass.renderPass);
pass.SetStencilReference(0xFFFFFFFF);
pass.EndPass();
}
builder.GetResult();
}

150
src/tests/unittests/validation/PushConstantsValidationTests.cpp
View File

@@ -46,28 +46,36 @@ class PushConstantTest : public ValidationTest {
TEST_F(PushConstantTest, Success) {
DummyRenderPass renderpassData = CreateDummyRenderPass();
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
// PushConstants in a compute pass
.BeginComputePass()
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, constants)
.EndComputePass()
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
// PushConstants in a compute pass
{
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, constants);
pass.EndPass();
}
// PushConstants in a render pass
.BeginRenderPass(renderpassData.renderPass)
.SetPushConstants(dawn::ShaderStageBit::Vertex | dawn::ShaderStageBit::Fragment, 0, 1, constants)
.EndRenderPass()
// PushConstants in a render pass
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpassData.renderPass);
pass.SetPushConstants(dawn::ShaderStageBit::Vertex | dawn::ShaderStageBit::Fragment, 0, 1, constants);
pass.EndPass();
}
// Setting all constants
.BeginComputePass()
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, kMaxPushConstants, constants)
.EndComputePass()
// Setting all constants
{
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 0, kMaxPushConstants, constants);
pass.EndPass();
}
// Setting constants at an offset
.BeginComputePass()
.SetPushConstants(dawn::ShaderStageBit::Compute, kMaxPushConstants - 1, 1, constants)
.EndComputePass()
// Setting constants at an offset
{
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetPushConstants(dawn::ShaderStageBit::Compute, kMaxPushConstants - 1, 1, constants);
pass.EndPass();
}
.GetResult();
builder.GetResult();
}
// Test check for constants being set out of bounds
@@ -76,45 +84,29 @@ TEST_F(PushConstantTest, SetPushConstantsOOB) {
// Control case: setting all constants
{
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginComputePass()
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, kMaxPushConstants, constants)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 0, kMaxPushConstants, constants);
pass.EndPass();
builder.GetResult();
}
// OOB because count is too big.
{
AssertWillBeError(device.CreateCommandBufferBuilder())
.BeginComputePass()
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, kMaxPushConstants + 1, constants)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeError(device.CreateCommandBufferBuilder());
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 0, kMaxPushConstants + 1, constants);
pass.EndPass();
builder.GetResult();
}
// OOB because of the offset.
{
AssertWillBeError(device.CreateCommandBufferBuilder())
.BeginComputePass()
.SetPushConstants(dawn::ShaderStageBit::Compute, 1, kMaxPushConstants, constants)
.EndComputePass()
.GetResult();
}
}
// Test which places push constants can be set
TEST_F(PushConstantTest, NotInPass) {
DummyRenderPass renderpassData = CreateDummyRenderPass();
// Setting outside of any pass is invalid.
{
AssertWillBeError(device.CreateCommandBufferBuilder())
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, constants)
.GetResult();
AssertWillBeError(device.CreateCommandBufferBuilder())
.SetPushConstants(dawn::ShaderStageBit::Vertex, 0, 1, constants)
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeError(device.CreateCommandBufferBuilder());
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 1, kMaxPushConstants, constants);
pass.EndPass();
builder.GetResult();
}
}
@@ -122,29 +114,29 @@ TEST_F(PushConstantTest, NotInPass) {
TEST_F(PushConstantTest, StageForComputePass) {
// Control case: setting to the compute stage in compute passes
{
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginComputePass()
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, constants)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, constants);
pass.EndPass();
builder.GetResult();
}
// Graphics stages are disallowed
{
AssertWillBeError(device.CreateCommandBufferBuilder())
.BeginComputePass()
.SetPushConstants(dawn::ShaderStageBit::Vertex, 0, 1, constants)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeError(device.CreateCommandBufferBuilder());
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetPushConstants(dawn::ShaderStageBit::Vertex, 0, 1, constants);
pass.EndPass();
builder.GetResult();
}
// A None shader stage mask is valid.
{
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginComputePass()
.SetPushConstants(dawn::ShaderStageBit::None, 0, 1, constants)
.EndComputePass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
dawn::ComputePassEncoder pass = builder.BeginComputePass();
pass.SetPushConstants(dawn::ShaderStageBit::None, 0, 1, constants);
pass.EndPass();
builder.GetResult();
}
}
@@ -154,29 +146,29 @@ TEST_F(PushConstantTest, StageForRenderPass) {
// Control case: setting to vertex and fragment in render pass
{
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderpassData.renderPass)
.SetPushConstants(dawn::ShaderStageBit::Vertex | dawn::ShaderStageBit::Fragment, 0, 1, constants)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpassData.renderPass);
pass.SetPushConstants(dawn::ShaderStageBit::Vertex | dawn::ShaderStageBit::Fragment, 0, 1, constants);
pass.EndPass();
builder.GetResult();
}
// Compute stage is disallowed
{
AssertWillBeError(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderpassData.renderPass)
.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, constants)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeError(device.CreateCommandBufferBuilder());
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpassData.renderPass);
pass.SetPushConstants(dawn::ShaderStageBit::Compute, 0, 1, constants);
pass.EndPass();
builder.GetResult();
}
// A None shader stage mask is valid.
{
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderpassData.renderPass)
.SetPushConstants(dawn::ShaderStageBit::None, 0, 1, constants)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpassData.renderPass);
pass.SetPushConstants(dawn::ShaderStageBit::None, 0, 1, constants);
pass.EndPass();
builder.GetResult();
}
}

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

@@ -104,23 +104,27 @@ TEST_F(VertexBufferValidationTest, VertexInputsInheritedBetweenPipelines) {
uint32_t offsets[] = { 0, 0 };
// Check failure when vertex buffer is not set
AssertWillBeError(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderpass)
.SetRenderPipeline(pipeline1)
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeError(device.CreateCommandBufferBuilder());
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpass);
pass.SetRenderPipeline(pipeline1);
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
builder.GetResult();
// Check success when vertex buffer is inherited from previous pipeline
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderpass)
.SetRenderPipeline(pipeline2)
.SetVertexBuffers(0, 2, vertexBuffers.data(), offsets)
.DrawArrays(3, 1, 0, 0)
.SetRenderPipeline(pipeline1)
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpass);
pass.SetRenderPipeline(pipeline2);
pass.SetVertexBuffers(0, 2, vertexBuffers.data(), offsets);
pass.DrawArrays(3, 1, 0, 0);
pass.SetRenderPipeline(pipeline1);
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
builder.GetResult();
}
TEST_F(VertexBufferValidationTest, VertexInputsNotInheritedBetweenRendePasses) {
@@ -137,29 +141,37 @@ TEST_F(VertexBufferValidationTest, VertexInputsNotInheritedBetweenRendePasses) {
uint32_t offsets[] = { 0, 0 };
// Check success when vertex buffer is set for each render pass
AssertWillBeSuccess(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderpass)
.SetRenderPipeline(pipeline2)
.SetVertexBuffers(0, 2, vertexBuffers.data(), offsets)
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.BeginRenderPass(renderpass)
.SetRenderPipeline(pipeline1)
.SetVertexBuffers(0, 1, vertexBuffers.data(), offsets)
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
dawn::CommandBufferBuilder builder = AssertWillBeSuccess(device.CreateCommandBufferBuilder());
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpass);
pass.SetRenderPipeline(pipeline2);
pass.SetVertexBuffers(0, 2, vertexBuffers.data(), offsets);
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpass);
pass.SetRenderPipeline(pipeline1);
pass.SetVertexBuffers(0, 1, vertexBuffers.data(), offsets);
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
builder.GetResult();
// Check failure because vertex buffer is not inherited in second subpass
AssertWillBeError(device.CreateCommandBufferBuilder())
.BeginRenderPass(renderpass)
.SetRenderPipeline(pipeline2)
.SetVertexBuffers(0, 2, vertexBuffers.data(), offsets)
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.BeginRenderPass(renderpass)
.SetRenderPipeline(pipeline1)
.DrawArrays(3, 1, 0, 0)
.EndRenderPass()
.GetResult();
builder = AssertWillBeError(device.CreateCommandBufferBuilder());
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpass);
pass.SetRenderPipeline(pipeline2);
pass.SetVertexBuffers(0, 2, vertexBuffers.data(), offsets);
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
{
dawn::RenderPassEncoder pass = builder.BeginRenderPass(renderpass);
pass.SetRenderPipeline(pipeline1);
pass.DrawArrays(3, 1, 0, 0);
pass.EndPass();
}
builder.GetResult();
}