Make CommandBufferValidation use Error.h
diff --git a/src/backend/CommandBuffer.cpp b/src/backend/CommandBuffer.cpp
index 04ec426..2d140ab 100644
--- a/src/backend/CommandBuffer.cpp
+++ b/src/backend/CommandBuffer.cpp
@@ -32,12 +32,10 @@
namespace {
- bool ValidateCopyLocationFitsInTexture(CommandBufferBuilder* builder,
- const TextureCopyLocation& location) {
+ MaybeError ValidateCopyLocationFitsInTexture(const TextureCopyLocation& location) {
const TextureBase* texture = location.texture.Get();
if (location.level >= texture->GetNumMipLevels()) {
- builder->HandleError("Copy mip-level out of range");
- return false;
+ NXT_RETURN_ERROR("Copy mip-level out of range");
}
// All texture dimensions are in uint32_t so by doing checks in uint64_t we avoid
@@ -47,18 +45,16 @@
(static_cast<uint64_t>(texture->GetWidth()) >> level) ||
uint64_t(location.y) + uint64_t(location.height) >
(static_cast<uint64_t>(texture->GetHeight()) >> level)) {
- builder->HandleError("Copy would touch outside of the texture");
- return false;
+ NXT_RETURN_ERROR("Copy would touch outside of the texture");
}
// TODO(cwallez@chromium.org): Check the depth bound differently for 2D arrays and 3D
// textures
if (location.z != 0 || location.depth != 1) {
- builder->HandleError("No support for z != 0 and depth != 1 for now");
- return false;
+ NXT_RETURN_ERROR("No support for z != 0 and depth != 1 for now");
}
- return true;
+ return {};
}
bool FitsInBuffer(const BufferBase* buffer, uint32_t offset, uint32_t size) {
@@ -66,38 +62,33 @@
return offset <= bufferSize && (size <= (bufferSize - offset));
}
- bool ValidateCopySizeFitsInBuffer(CommandBufferBuilder* builder,
- const BufferCopyLocation& location,
- uint32_t dataSize) {
+ MaybeError ValidateCopySizeFitsInBuffer(const BufferCopyLocation& location,
+ uint32_t dataSize) {
if (!FitsInBuffer(location.buffer.Get(), location.offset, dataSize)) {
- builder->HandleError("Copy would overflow the buffer");
- return false;
+ NXT_RETURN_ERROR("Copy would overflow the buffer");
}
- return true;
+ return {};
}
- bool ValidateTexelBufferOffset(CommandBufferBuilder* builder,
- TextureBase* texture,
- const BufferCopyLocation& location) {
+ MaybeError ValidateTexelBufferOffset(TextureBase* texture,
+ const BufferCopyLocation& location) {
uint32_t texelSize =
static_cast<uint32_t>(TextureFormatPixelSize(texture->GetFormat()));
if (location.offset % texelSize != 0) {
- builder->HandleError("Buffer offset must be a multiple of the texel size");
- return false;
+ NXT_RETURN_ERROR("Buffer offset must be a multiple of the texel size");
}
- return true;
+ return {};
}
- bool ComputeTextureCopyBufferSize(CommandBufferBuilder*,
- const TextureCopyLocation& location,
- uint32_t rowPitch,
- uint32_t* bufferSize) {
+ MaybeError ComputeTextureCopyBufferSize(const TextureCopyLocation& location,
+ uint32_t rowPitch,
+ uint32_t* bufferSize) {
// TODO(cwallez@chromium.org): check for overflows
*bufferSize = (rowPitch * (location.height - 1) + location.width) * location.depth;
- return true;
+ return {};
}
uint32_t ComputeDefaultRowPitch(TextureBase* texture, uint32_t width) {
@@ -105,45 +96,35 @@
return texelSize * width;
}
- bool ValidateRowPitch(CommandBufferBuilder* builder,
- const TextureCopyLocation& location,
- uint32_t rowPitch) {
+ MaybeError ValidateRowPitch(const TextureCopyLocation& location, uint32_t rowPitch) {
if (rowPitch % kTextureRowPitchAlignment != 0) {
- builder->HandleError("Row pitch must be a multiple of 256");
- return false;
+ NXT_RETURN_ERROR("Row pitch must be a multiple of 256");
}
uint32_t texelSize = TextureFormatPixelSize(location.texture.Get()->GetFormat());
if (rowPitch < location.width * texelSize) {
- builder->HandleError("Row pitch must not be less than the number of bytes per row");
- return false;
+ NXT_RETURN_ERROR("Row pitch must not be less than the number of bytes per row");
}
- return true;
+ return {};
}
- bool ValidateCanUseAs(CommandBufferBuilder* builder,
- BufferBase* buffer,
- nxt::BufferUsageBit usage) {
+ MaybeError ValidateCanUseAs(BufferBase* buffer, nxt::BufferUsageBit usage) {
ASSERT(HasZeroOrOneBits(usage));
if (!(buffer->GetAllowedUsage() & usage)) {
- builder->HandleError("buffer doesn't have the required usage.");
- return false;
+ NXT_RETURN_ERROR("buffer doesn't have the required usage.");
}
- return true;
+ return {};
}
- bool ValidateCanUseAs(CommandBufferBuilder* builder,
- TextureBase* texture,
- nxt::TextureUsageBit usage) {
+ MaybeError ValidateCanUseAs(TextureBase* texture, nxt::TextureUsageBit usage) {
ASSERT(HasZeroOrOneBits(usage));
if (!(texture->GetAllowedUsage() & usage)) {
- builder->HandleError("texture doesn't have the required usage.");
- return false;
+ NXT_RETURN_ERROR("texture doesn't have the required usage.");
}
- return true;
+ return {};
}
enum class PassType {
@@ -184,10 +165,10 @@
}
// Performs the per-pass usage validation checks
- bool AreUsagesValid(PassType pass) const {
+ MaybeError ValidateUsages(PassType pass) const {
// Storage resources cannot be used twice in the same compute pass
if (pass == PassType::Compute && mStorageUsedMultipleTimes) {
- return false;
+ NXT_RETURN_ERROR("Storage resource used multiple times in compute pass");
}
// Buffers can only be used as single-write or multiple read.
@@ -196,14 +177,15 @@
nxt::BufferUsageBit usage = it.second;
if (usage & ~buffer->GetAllowedUsage()) {
- return false;
+ NXT_RETURN_ERROR("Buffer missing usage for the pass");
}
bool readOnly = (usage & kReadOnlyBufferUsages) == usage;
bool singleUse = nxt::HasZeroOrOneBits(usage);
if (!readOnly && !singleUse) {
- return false;
+ NXT_RETURN_ERROR(
+ "Buffer used as writeable usage and another usage in pass");
}
}
@@ -214,17 +196,17 @@
nxt::TextureUsageBit usage = it.second;
if (usage & ~texture->GetAllowedUsage()) {
- return false;
+ NXT_RETURN_ERROR("Texture missing usage for the pass");
}
// For textures the only read-only usage in a pass is Sampled, so checking the
// usage constraint simplifies to checking a single usage bit is set.
if (!nxt::HasZeroOrOneBits(it.second)) {
- return false;
+ NXT_RETURN_ERROR("Texture used with more than one usage in pass");
}
}
- return true;
+ return {};
}
// Returns the per-pass usage for use by backends for APIs with explicit barriers.
@@ -297,7 +279,7 @@
// CommandBufferBuilder
CommandBufferBuilder::CommandBufferBuilder(DeviceBase* device)
- : Builder(device), mState(std::make_unique<CommandBufferStateTracker>(this)) {
+ : Builder(device), mState(std::make_unique<CommandBufferStateTracker>()) {
}
CommandBufferBuilder::~CommandBufferBuilder() {
@@ -333,7 +315,7 @@
// Implementation of the command buffer validation that can be precomputed before submit
- bool CommandBufferBuilder::ValidateGetResult() {
+ MaybeError CommandBufferBuilder::ValidateGetResult() {
MoveToIterator();
mIterator.Reset();
@@ -342,78 +324,73 @@
switch (type) {
case Command::BeginComputePass: {
mIterator.NextCommand<BeginComputePassCmd>();
- if (!ValidateComputePass()) {
- return false;
- }
+ NXT_TRY(ValidateComputePass());
} break;
case Command::BeginRenderPass: {
BeginRenderPassCmd* cmd = mIterator.NextCommand<BeginRenderPassCmd>();
- if (!ValidateRenderPass(cmd->info.Get())) {
- return false;
- }
+ NXT_TRY(ValidateRenderPass(cmd->info.Get()));
} break;
case Command::CopyBufferToBuffer: {
CopyBufferToBufferCmd* copy = mIterator.NextCommand<CopyBufferToBufferCmd>();
- if (!ValidateCopySizeFitsInBuffer(this, copy->source, copy->size) ||
- !ValidateCopySizeFitsInBuffer(this, copy->destination, copy->size) ||
- !ValidateCanUseAs(this, copy->source.buffer.Get(),
- nxt::BufferUsageBit::TransferSrc) ||
- !ValidateCanUseAs(this, copy->destination.buffer.Get(),
- nxt::BufferUsageBit::TransferDst)) {
- return false;
- }
+
+ NXT_TRY(ValidateCopySizeFitsInBuffer(copy->source, copy->size));
+ NXT_TRY(ValidateCopySizeFitsInBuffer(copy->destination, copy->size));
+
+ NXT_TRY(ValidateCanUseAs(copy->source.buffer.Get(),
+ nxt::BufferUsageBit::TransferSrc));
+ NXT_TRY(ValidateCanUseAs(copy->destination.buffer.Get(),
+ nxt::BufferUsageBit::TransferDst));
} break;
case Command::CopyBufferToTexture: {
CopyBufferToTextureCmd* copy = mIterator.NextCommand<CopyBufferToTextureCmd>();
uint32_t bufferCopySize = 0;
- if (!ValidateRowPitch(this, copy->destination, copy->rowPitch) ||
- !ComputeTextureCopyBufferSize(this, copy->destination, copy->rowPitch,
- &bufferCopySize) ||
- !ValidateCopyLocationFitsInTexture(this, copy->destination) ||
- !ValidateCopySizeFitsInBuffer(this, copy->source, bufferCopySize) ||
- !ValidateTexelBufferOffset(this, copy->destination.texture.Get(),
- copy->source) ||
- !ValidateCanUseAs(this, copy->source.buffer.Get(),
- nxt::BufferUsageBit::TransferSrc) ||
- !ValidateCanUseAs(this, copy->destination.texture.Get(),
- nxt::TextureUsageBit::TransferDst)) {
- return false;
- }
+ NXT_TRY(ValidateRowPitch(copy->destination, copy->rowPitch));
+ NXT_TRY(ComputeTextureCopyBufferSize(copy->destination, copy->rowPitch,
+ &bufferCopySize));
+
+ NXT_TRY(ValidateCopyLocationFitsInTexture(copy->destination));
+ NXT_TRY(ValidateCopySizeFitsInBuffer(copy->source, bufferCopySize));
+ NXT_TRY(
+ ValidateTexelBufferOffset(copy->destination.texture.Get(), copy->source));
+
+ NXT_TRY(ValidateCanUseAs(copy->source.buffer.Get(),
+ nxt::BufferUsageBit::TransferSrc));
+ NXT_TRY(ValidateCanUseAs(copy->destination.texture.Get(),
+ nxt::TextureUsageBit::TransferDst));
} break;
case Command::CopyTextureToBuffer: {
CopyTextureToBufferCmd* copy = mIterator.NextCommand<CopyTextureToBufferCmd>();
uint32_t bufferCopySize = 0;
- if (!ValidateRowPitch(this, copy->source, copy->rowPitch) ||
- !ComputeTextureCopyBufferSize(this, copy->source, copy->rowPitch,
- &bufferCopySize) ||
- !ValidateCopyLocationFitsInTexture(this, copy->source) ||
- !ValidateCopySizeFitsInBuffer(this, copy->destination, bufferCopySize) ||
- !ValidateTexelBufferOffset(this, copy->source.texture.Get(),
- copy->destination) ||
- !ValidateCanUseAs(this, copy->source.texture.Get(),
- nxt::TextureUsageBit::TransferSrc) ||
- !ValidateCanUseAs(this, copy->destination.buffer.Get(),
- nxt::BufferUsageBit::TransferDst)) {
- return false;
- }
+ NXT_TRY(ValidateRowPitch(copy->source, copy->rowPitch));
+ NXT_TRY(ComputeTextureCopyBufferSize(copy->source, copy->rowPitch,
+ &bufferCopySize));
+
+ NXT_TRY(ValidateCopyLocationFitsInTexture(copy->source));
+ NXT_TRY(ValidateCopySizeFitsInBuffer(copy->destination, bufferCopySize));
+ NXT_TRY(
+ ValidateTexelBufferOffset(copy->source.texture.Get(), copy->destination));
+
+ NXT_TRY(ValidateCanUseAs(copy->source.texture.Get(),
+ nxt::TextureUsageBit::TransferSrc));
+ NXT_TRY(ValidateCanUseAs(copy->destination.buffer.Get(),
+ nxt::BufferUsageBit::TransferDst));
} break;
default:
- HandleError("Command disallowed outside of a pass");
- return false;
+ NXT_RETURN_ERROR("Command disallowed outside of a pass");
}
}
- return true;
+ return {};
}
- bool CommandBufferBuilder::ValidateComputePass() {
+ MaybeError CommandBufferBuilder::ValidateComputePass() {
PassResourceUsageTracker usageTracker;
Command type;
@@ -422,28 +399,22 @@
case Command::EndComputePass: {
mIterator.NextCommand<EndComputePassCmd>();
- if (!usageTracker.AreUsagesValid(PassType::Compute)) {
- return false;
- }
+ NXT_TRY(usageTracker.ValidateUsages(PassType::Compute));
mPassResourceUsages.push_back(usageTracker.AcquireResourceUsage());
mState->EndPass();
- return true;
+ return {};
} break;
case Command::Dispatch: {
mIterator.NextCommand<DispatchCmd>();
- if (!mState->ValidateCanDispatch()) {
- return false;
- }
+ NXT_TRY(mState->ValidateCanDispatch());
} break;
case Command::SetComputePipeline: {
SetComputePipelineCmd* cmd = mIterator.NextCommand<SetComputePipelineCmd>();
ComputePipelineBase* pipeline = cmd->pipeline.Get();
- if (!mState->SetComputePipeline(pipeline)) {
- return false;
- }
+ mState->SetComputePipeline(pipeline);
} break;
case Command::SetPushConstants: {
@@ -453,9 +424,8 @@
// recorded because it impacts the size of an allocation in the
// CommandAllocator.
if (cmd->stages & ~nxt::ShaderStageBit::Compute) {
- HandleError(
+ NXT_RETURN_ERROR(
"SetPushConstants stage must be compute or 0 in compute passes");
- return false;
}
} break;
@@ -467,16 +437,14 @@
} break;
default:
- HandleError("Command disallowed inside a compute pass");
- return false;
+ NXT_RETURN_ERROR("Command disallowed inside a compute pass");
}
}
- HandleError("Unfinished compute pass");
- return false;
+ NXT_RETURN_ERROR("Unfinished compute pass");
}
- bool CommandBufferBuilder::ValidateRenderPass(RenderPassDescriptorBase* renderPass) {
+ MaybeError CommandBufferBuilder::ValidateRenderPass(RenderPassDescriptorBase* renderPass) {
PassResourceUsageTracker usageTracker;
// Track usage of the render pass attachments
@@ -496,27 +464,21 @@
case Command::EndRenderPass: {
mIterator.NextCommand<EndRenderPassCmd>();
- if (!usageTracker.AreUsagesValid(PassType::Render)) {
- return false;
- }
+ NXT_TRY(usageTracker.ValidateUsages(PassType::Render));
mPassResourceUsages.push_back(usageTracker.AcquireResourceUsage());
mState->EndPass();
- return true;
+ return {};
} break;
case Command::DrawArrays: {
mIterator.NextCommand<DrawArraysCmd>();
- if (!mState->ValidateCanDrawArrays()) {
- return false;
- }
+ NXT_TRY(mState->ValidateCanDrawArrays());
} break;
case Command::DrawElements: {
mIterator.NextCommand<DrawElementsCmd>();
- if (!mState->ValidateCanDrawElements()) {
- return false;
- }
+ NXT_TRY(mState->ValidateCanDrawElements());
} break;
case Command::SetRenderPipeline: {
@@ -524,13 +486,10 @@
RenderPipelineBase* pipeline = cmd->pipeline.Get();
if (!pipeline->IsCompatibleWith(renderPass)) {
- HandleError("Pipeline is incompatible with this render pass");
- return false;
+ NXT_RETURN_ERROR("Pipeline is incompatible with this render pass");
}
- if (!mState->SetRenderPipeline(pipeline)) {
- return false;
- }
+ mState->SetRenderPipeline(pipeline);
} break;
case Command::SetPushConstants: {
@@ -541,10 +500,9 @@
// CommandAllocator.
if (cmd->stages &
~(nxt::ShaderStageBit::Vertex | nxt::ShaderStageBit::Fragment)) {
- HandleError(
+ NXT_RETURN_ERROR(
"SetPushConstants stage must be a subset of (vertex|fragment) in "
"render passes");
- return false;
}
} break;
@@ -571,9 +529,7 @@
SetIndexBufferCmd* cmd = mIterator.NextCommand<SetIndexBufferCmd>();
usageTracker.BufferUsedAs(cmd->buffer.Get(), nxt::BufferUsageBit::Index);
- if (!mState->SetIndexBuffer()) {
- return false;
- }
+ NXT_TRY(mState->SetIndexBuffer());
} break;
case Command::SetVertexBuffers: {
@@ -583,18 +539,16 @@
for (uint32_t i = 0; i < cmd->count; ++i) {
usageTracker.BufferUsedAs(buffers[i].Get(), nxt::BufferUsageBit::Vertex);
- mState->SetVertexBuffer(cmd->startSlot + i);
+ NXT_TRY(mState->SetVertexBuffer(cmd->startSlot + i));
}
} break;
default:
- HandleError("Command disallowed inside a render pass");
- return false;
+ NXT_RETURN_ERROR("Command disallowed inside a render pass");
}
}
- HandleError("Unfinished render pass");
- return false;
+ NXT_RETURN_ERROR("Unfinished render pass");
}
// Implementation of the API's command recording methods
diff --git a/src/backend/CommandBuffer.h b/src/backend/CommandBuffer.h
index 7c0ef96..926353c 100644
--- a/src/backend/CommandBuffer.h
+++ b/src/backend/CommandBuffer.h
@@ -19,6 +19,7 @@
#include "backend/Builder.h"
#include "backend/CommandAllocator.h"
+#include "backend/Error.h"
#include "backend/PassResourceUsage.h"
#include "backend/RefCounted.h"
@@ -54,7 +55,7 @@
CommandBufferBuilder(DeviceBase* device);
~CommandBufferBuilder();
- bool ValidateGetResult();
+ MaybeError ValidateGetResult();
CommandIterator AcquireCommands();
std::vector<PassResourceUsage> AcquirePassResourceUsage();
@@ -134,8 +135,8 @@
CommandBufferBase* GetResultImpl() override;
void MoveToIterator();
- bool ValidateComputePass();
- bool ValidateRenderPass(RenderPassDescriptorBase* renderPass);
+ MaybeError ValidateComputePass();
+ MaybeError ValidateRenderPass(RenderPassDescriptorBase* renderPass);
std::unique_ptr<CommandBufferStateTracker> mState;
CommandAllocator mAllocator;
diff --git a/src/backend/CommandBufferStateTracker.cpp b/src/backend/CommandBufferStateTracker.cpp
index d8a60eb..5ffcac3 100644
--- a/src/backend/CommandBufferStateTracker.cpp
+++ b/src/backend/CommandBufferStateTracker.cpp
@@ -29,54 +29,47 @@
namespace backend {
- CommandBufferStateTracker::CommandBufferStateTracker(CommandBufferBuilder* mBuilder)
- : mBuilder(mBuilder) {
- }
-
- bool CommandBufferStateTracker::ValidateCanDispatch() {
+ MaybeError CommandBufferStateTracker::ValidateCanDispatch() {
constexpr ValidationAspects requiredAspects =
1 << VALIDATION_ASPECT_PIPELINE | 1 << VALIDATION_ASPECT_BIND_GROUPS;
if ((requiredAspects & ~mAspects).none()) {
// Fast return-true path if everything is good
- return true;
+ return {};
}
if (!mAspects[VALIDATION_ASPECT_PIPELINE]) {
- mBuilder->HandleError("No active compute pipeline");
- return false;
+ NXT_RETURN_ERROR("No active compute pipeline");
}
// Compute the lazily computed mAspects
if (!RecomputeHaveAspectBindGroups()) {
- mBuilder->HandleError("Bind group state not valid");
- return false;
+ NXT_RETURN_ERROR("Bind group state not valid");
}
- return true;
+ return {};
}
- bool CommandBufferStateTracker::ValidateCanDrawArrays() {
+ MaybeError CommandBufferStateTracker::ValidateCanDrawArrays() {
constexpr ValidationAspects requiredAspects = 1 << VALIDATION_ASPECT_PIPELINE |
1 << VALIDATION_ASPECT_BIND_GROUPS |
1 << VALIDATION_ASPECT_VERTEX_BUFFERS;
if ((requiredAspects & ~mAspects).none()) {
// Fast return-true path if everything is good
- return true;
+ return {};
}
return RevalidateCanDraw();
}
- bool CommandBufferStateTracker::ValidateCanDrawElements() {
+ MaybeError CommandBufferStateTracker::ValidateCanDrawElements() {
constexpr ValidationAspects requiredAspects =
1 << VALIDATION_ASPECT_PIPELINE | 1 << VALIDATION_ASPECT_BIND_GROUPS |
1 << VALIDATION_ASPECT_VERTEX_BUFFERS | 1 << VALIDATION_ASPECT_INDEX_BUFFER;
if ((requiredAspects & ~mAspects).none()) {
// Fast return-true path if everything is good
- return true;
+ return {};
}
if (!mAspects[VALIDATION_ASPECT_INDEX_BUFFER]) {
- mBuilder->HandleError("Cannot DrawElements without index buffer set");
- return false;
+ NXT_RETURN_ERROR("Cannot DrawElements without index buffer set");
}
return RevalidateCanDraw();
}
@@ -87,15 +80,13 @@
mBindgroups.fill(nullptr);
}
- bool CommandBufferStateTracker::SetComputePipeline(ComputePipelineBase* pipeline) {
+ void CommandBufferStateTracker::SetComputePipeline(ComputePipelineBase* pipeline) {
SetPipelineCommon(pipeline);
- return true;
}
- bool CommandBufferStateTracker::SetRenderPipeline(RenderPipelineBase* pipeline) {
+ void CommandBufferStateTracker::SetRenderPipeline(RenderPipelineBase* pipeline) {
mLastRenderPipeline = pipeline;
SetPipelineCommon(pipeline);
- return true;
}
void CommandBufferStateTracker::SetBindGroup(uint32_t index, BindGroupBase* bindgroup) {
@@ -103,24 +94,22 @@
mBindgroups[index] = bindgroup;
}
- bool CommandBufferStateTracker::SetIndexBuffer() {
+ MaybeError CommandBufferStateTracker::SetIndexBuffer() {
if (!HavePipeline()) {
- mBuilder->HandleError("Can't set the index buffer without a pipeline");
- return false;
+ NXT_RETURN_ERROR("Can't set the index buffer without a pipeline");
}
mAspects.set(VALIDATION_ASPECT_INDEX_BUFFER);
- return true;
+ return {};
}
- bool CommandBufferStateTracker::SetVertexBuffer(uint32_t index) {
+ MaybeError CommandBufferStateTracker::SetVertexBuffer(uint32_t index) {
if (!HavePipeline()) {
- mBuilder->HandleError("Can't set vertex buffers without a pipeline");
- return false;
+ NXT_RETURN_ERROR("Can't set vertex buffers without a pipeline");
}
mInputsSet.set(index);
- return true;
+ return {};
}
bool CommandBufferStateTracker::RecomputeHaveAspectBindGroups() {
@@ -161,21 +150,18 @@
return mAspects[VALIDATION_ASPECT_PIPELINE];
}
- bool CommandBufferStateTracker::RevalidateCanDraw() {
+ MaybeError CommandBufferStateTracker::RevalidateCanDraw() {
if (!mAspects[VALIDATION_ASPECT_PIPELINE]) {
- mBuilder->HandleError("No active render pipeline");
- return false;
+ NXT_RETURN_ERROR("No active render pipeline");
}
// Compute the lazily computed mAspects
if (!RecomputeHaveAspectBindGroups()) {
- mBuilder->HandleError("Bind group state not valid");
- return false;
+ NXT_RETURN_ERROR("Bind group state not valid");
}
if (!RecomputeHaveAspectVertexBuffers()) {
- mBuilder->HandleError("Some vertex buffers are not set");
- return false;
+ NXT_RETURN_ERROR("Some vertex buffers are not set");
}
- return true;
+ return {};
}
void CommandBufferStateTracker::SetPipelineCommon(PipelineBase* pipeline) {
diff --git a/src/backend/CommandBufferStateTracker.h b/src/backend/CommandBufferStateTracker.h
index 5a5f561..b097ad9 100644
--- a/src/backend/CommandBufferStateTracker.h
+++ b/src/backend/CommandBufferStateTracker.h
@@ -27,21 +27,19 @@
class CommandBufferStateTracker {
public:
- explicit CommandBufferStateTracker(CommandBufferBuilder* builder);
-
// Non-state-modifying validation functions
- bool ValidateCanCopy() const;
- bool ValidateCanDispatch();
- bool ValidateCanDrawArrays();
- bool ValidateCanDrawElements();
+ MaybeError ValidateCanCopy() const;
+ MaybeError ValidateCanDispatch();
+ MaybeError ValidateCanDrawArrays();
+ MaybeError ValidateCanDrawElements();
// State-modifying methods
void EndPass();
- bool SetComputePipeline(ComputePipelineBase* pipeline);
- bool SetRenderPipeline(RenderPipelineBase* pipeline);
+ void SetComputePipeline(ComputePipelineBase* pipeline);
+ void SetRenderPipeline(RenderPipelineBase* pipeline);
void SetBindGroup(uint32_t index, BindGroupBase* bindgroup);
- bool SetIndexBuffer();
- bool SetVertexBuffer(uint32_t index);
+ MaybeError SetIndexBuffer();
+ MaybeError SetVertexBuffer(uint32_t index);
private:
enum ValidationAspect {
@@ -59,12 +57,10 @@
bool RecomputeHaveAspectVertexBuffers();
bool HavePipeline() const;
- bool RevalidateCanDraw();
+ MaybeError RevalidateCanDraw();
void SetPipelineCommon(PipelineBase* pipeline);
- CommandBufferBuilder* mBuilder;
-
ValidationAspects mAspects;
std::bitset<kMaxBindGroups> mBindgroupsSet;
diff --git a/src/backend/Queue.cpp b/src/backend/Queue.cpp
index 7b3d26d..837b572 100644
--- a/src/backend/Queue.cpp
+++ b/src/backend/Queue.cpp
@@ -28,9 +28,9 @@
return mDevice;
}
- bool QueueBase::ValidateSubmitCommand(CommandBufferBase*) {
+ MaybeError QueueBase::ValidateSubmitCommand(CommandBufferBase*) {
// TODO(cwallez@chromium.org): Validate resources referenced by command buffers can be used
- return true;
+ return {};
}
} // namespace backend
diff --git a/src/backend/Queue.h b/src/backend/Queue.h
index 3ae10ef..86d1ba6 100644
--- a/src/backend/Queue.h
+++ b/src/backend/Queue.h
@@ -16,6 +16,7 @@
#define BACKEND_QUEUE_H_
#include "backend/Builder.h"
+#include "backend/Error.h"
#include "backend/Forward.h"
#include "backend/RefCounted.h"
@@ -30,20 +31,18 @@
DeviceBase* GetDevice();
template <typename T>
- bool ValidateSubmit(uint32_t numCommands, T* const* commands) {
+ MaybeError ValidateSubmit(uint32_t numCommands, T* const* commands) {
static_assert(std::is_base_of<CommandBufferBase, T>::value,
"invalid command buffer type");
for (uint32_t i = 0; i < numCommands; ++i) {
- if (!ValidateSubmitCommand(commands[i])) {
- return false;
- }
+ NXT_TRY(ValidateSubmitCommand(commands[i]));
}
- return true;
+ return {};
}
private:
- bool ValidateSubmitCommand(CommandBufferBase* command);
+ MaybeError ValidateSubmitCommand(CommandBufferBase* command);
DeviceBase* mDevice;
};
