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

681 lines
28 KiB
C++
Raw Normal View History

Rename the copyright authors from NXT to Dawn
2018-07-18 09:40:26 +00:00
// Copyright 2017 The Dawn Authors
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
Move src/backend to src/dawn_native
2018-07-24 11:53:51 +00:00
#include "dawn_native/CommandBuffer.h"
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
Move src/backend to src/dawn_native
2018-07-24 11:53:51 +00:00
#include "dawn_native/BindGroup.h"
#include "dawn_native/Buffer.h"
#include "dawn_native/CommandBufferStateTracker.h"
#include "dawn_native/Commands.h"
Introduce [Render|Compute]PassEncoder. 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>
2018-09-21 00:24:37 +00:00
#include "dawn_native/ComputePassEncoder.h"
Move src/backend to src/dawn_native
2018-07-24 11:53:51 +00:00
#include "dawn_native/ComputePipeline.h"
#include "dawn_native/Device.h"
Introduce [Render|Compute]PassEncoder. 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>
2018-09-21 00:24:37 +00:00
#include "dawn_native/ErrorData.h"
Move src/backend to src/dawn_native
2018-07-24 11:53:51 +00:00
#include "dawn_native/InputState.h"
#include "dawn_native/PipelineLayout.h"
Introduce [Render|Compute]PassEncoder. 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>
2018-09-21 00:24:37 +00:00
#include "dawn_native/RenderPassEncoder.h"
Move src/backend to src/dawn_native
2018-07-24 11:53:51 +00:00
#include "dawn_native/RenderPipeline.h"
#include "dawn_native/Texture.h"
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
#include <cstring>
#include <map>
dawn_native: Fixup namespace from backend:: to dawn_native::
2018-07-24 14:45:45 +00:00
namespace dawn_native {
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
namespace {
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
MaybeError ValidateCopyLocationFitsInTexture(const TextureCopyLocation& location) {
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
const TextureBase* texture = location.texture.Get();
if (location.level >= texture->GetNumMipLevels()) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Copy mip-level out of range");
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
}
Implement copying between a buffer and a texture 2D array on Vulkan (#257) Implement copying between a buffer and a texture 2D array on Vulkan This patch implements the creation of a 2D array texture and data copying between a buffer and a layer of a 2D array texture on Vulkan back-ends. TEST=dawn_end2end_tests
2018-08-30 08:27:38 +00:00
if (location.slice >= texture->GetArrayLayers()) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Copy array-layer out of range");
Implement copying between a buffer and a texture 2D array on Vulkan (#257) Implement copying between a buffer and a texture 2D array on Vulkan This patch implements the creation of a 2D array texture and data copying between a buffer and a layer of a 2D array texture on Vulkan back-ends. TEST=dawn_end2end_tests
2018-08-30 08:27:38 +00:00
}
Format: src/backend
2017-11-24 18:59:42 +00:00
// All texture dimensions are in uint32_t so by doing checks in uint64_t we avoid
// overflows.
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
uint64_t level = location.level;
Format: src/backend
2017-11-24 18:59:42 +00:00
if (uint64_t(location.x) + uint64_t(location.width) >
TextureBase: return size as an Extent3D to match dawn.json BUG=dawn:13 Change-Id: I1104cb2038e0e77814b036868c50030fc8186bf8 Reviewed-on: https://dawn-review.googlesource.com/1522 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2018-09-18 12:51:42 +00:00
(static_cast<uint64_t>(texture->GetSize().width) >> level) ||
Format: src/backend
2017-11-24 18:59:42 +00:00
uint64_t(location.y) + uint64_t(location.height) >
TextureBase: return size as an Extent3D to match dawn.json BUG=dawn:13 Change-Id: I1104cb2038e0e77814b036868c50030fc8186bf8 Reviewed-on: https://dawn-review.googlesource.com/1522 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2018-09-18 12:51:42 +00:00
(static_cast<uint64_t>(texture->GetSize().height) >> level)) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Copy would touch outside of the texture");
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
}
Format: src/backend
2017-11-24 18:59:42 +00:00
// TODO(cwallez@chromium.org): Check the depth bound differently for 2D arrays and 3D
// textures
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
if (location.z != 0 || location.depth != 1) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("No support for z != 0 and depth != 1 for now");
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
return {};
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
}
bool FitsInBuffer(const BufferBase* buffer, uint32_t offset, uint32_t size) {
uint32_t bufferSize = buffer->GetSize();
return offset <= bufferSize && (size <= (bufferSize - offset));
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
MaybeError ValidateCopySizeFitsInBuffer(const BufferCopyLocation& location,
uint32_t dataSize) {
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
if (!FitsInBuffer(location.buffer.Get(), location.offset, dataSize)) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Copy would overflow the buffer");
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
return {};
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
MaybeError ValidateTexelBufferOffset(TextureBase* texture,
const BufferCopyLocation& location) {
Format: src/backend
2017-11-24 18:59:42 +00:00
uint32_t texelSize =
static_cast<uint32_t>(TextureFormatPixelSize(texture->GetFormat()));
Add validation for buffer offset
2017-07-18 17:18:58 +00:00
if (location.offset % texelSize != 0) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Buffer offset must be a multiple of the texel size");
Add validation for buffer offset
2017-07-18 17:18:58 +00:00
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
return {};
Add validation for buffer offset
2017-07-18 17:18:58 +00:00
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
MaybeError ComputeTextureCopyBufferSize(const TextureCopyLocation& location,
uint32_t rowPitch,
uint32_t* bufferSize) {
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
// TODO(cwallez@chromium.org): check for overflows
Add row pitch validation and default computation
2017-07-13 14:23:26 +00:00
*bufferSize = (rowPitch * (location.height - 1) + location.width) * location.depth;
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
return {};
Add row pitch validation and default computation
2017-07-13 14:23:26 +00:00
}
uint32_t ComputeDefaultRowPitch(TextureBase* texture, uint32_t width) {
clang/gcc: enable a bunch more warnings (#91) * clang/gcc: enable -pedantic warnings * suppress a GCC-specific warning in stb_image * And some clang-specific warnings * -Wconversion (clang) -Wold-style-cast (clang+gcc) and fix a few warnings that show up with these (and a few more with -Wconversion on gcc, even though that's not enabled by default) * bunch more warnings * fixes * remove merge error
2017-07-22 00:00:22 +00:00
uint32_t texelSize = TextureFormatPixelSize(texture->GetFormat());
Add row pitch validation and default computation
2017-07-13 14:23:26 +00:00
return texelSize * width;
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
MaybeError ValidateRowPitch(const TextureCopyLocation& location, uint32_t rowPitch) {
Add row pitch validation and default computation
2017-07-13 14:23:26 +00:00
if (rowPitch % kTextureRowPitchAlignment != 0) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Row pitch must be a multiple of 256");
Add row pitch validation and default computation
2017-07-13 14:23:26 +00:00
}
clang/gcc: enable a bunch more warnings (#91) * clang/gcc: enable -pedantic warnings * suppress a GCC-specific warning in stb_image * And some clang-specific warnings * -Wconversion (clang) -Wold-style-cast (clang+gcc) and fix a few warnings that show up with these (and a few more with -Wconversion on gcc, even though that's not enabled by default) * bunch more warnings * fixes * remove merge error
2017-07-22 00:00:22 +00:00
uint32_t texelSize = TextureFormatPixelSize(location.texture.Get()->GetFormat());
Add row pitch validation and default computation
2017-07-13 14:23:26 +00:00
if (rowPitch < location.width * texelSize) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR(
"Row pitch must not be less than the number of bytes per row");
Add row pitch validation and default computation
2017-07-13 14:23:26 +00:00
}
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
return {};
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
}
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
MaybeError ValidateCanUseAs(BufferBase* buffer, dawn::BufferUsageBit usage) {
Remove explicit usage transition from the API and validation This removes the following for both Buffer and Texture: - The builder's SetInitialUsage - The object's FreezeUsage and TransitionUsage methods - The CommandBuffer Transition<Object>Usage methods All samples and tests are simplified as a result. This also obsoletes the UsageValidationTest which is removed. Some validation was dependent on "current usage" and hasn't been reintroduced for implicit transitions yet: - Buffers can be used while mapped - Swapchain textures can be used after they have been presented. Validation for these will involve collecting all the resources used by a command buffer and will be done in a follow-up patch.
2018-07-09 13:15:07 +00:00
ASSERT(HasZeroOrOneBits(usage));
Rename GetAllowedUsage to GetUsage. Resources used to have both a current and an allowed usage but the concept of current usage has been removed so we can rename "allowed usage" to "usage" to make the name match WebGPU's WebGPUBufferDescriptor::usage and WebGPUTextureDescriptor::usage Change-Id: I5190950bf7f7f5b86c92247ef0240fead9886268
2018-08-22 13:08:02 +00:00
if (!(buffer->GetUsage() & usage)) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("buffer doesn't have the required usage.");
Remove explicit usage transition from the API and validation This removes the following for both Buffer and Texture: - The builder's SetInitialUsage - The object's FreezeUsage and TransitionUsage methods - The CommandBuffer Transition<Object>Usage methods All samples and tests are simplified as a result. This also obsoletes the UsageValidationTest which is removed. Some validation was dependent on "current usage" and hasn't been reintroduced for implicit transitions yet: - Buffers can be used while mapped - Swapchain textures can be used after they have been presented. Validation for these will involve collecting all the resources used by a command buffer and will be done in a follow-up patch.
2018-07-09 13:15:07 +00:00
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
return {};
Remove explicit usage transition from the API and validation This removes the following for both Buffer and Texture: - The builder's SetInitialUsage - The object's FreezeUsage and TransitionUsage methods - The CommandBuffer Transition<Object>Usage methods All samples and tests are simplified as a result. This also obsoletes the UsageValidationTest which is removed. Some validation was dependent on "current usage" and hasn't been reintroduced for implicit transitions yet: - Buffers can be used while mapped - Swapchain textures can be used after they have been presented. Validation for these will involve collecting all the resources used by a command buffer and will be done in a follow-up patch.
2018-07-09 13:15:07 +00:00
}
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
MaybeError ValidateCanUseAs(TextureBase* texture, dawn::TextureUsageBit usage) {
Remove explicit usage transition from the API and validation This removes the following for both Buffer and Texture: - The builder's SetInitialUsage - The object's FreezeUsage and TransitionUsage methods - The CommandBuffer Transition<Object>Usage methods All samples and tests are simplified as a result. This also obsoletes the UsageValidationTest which is removed. Some validation was dependent on "current usage" and hasn't been reintroduced for implicit transitions yet: - Buffers can be used while mapped - Swapchain textures can be used after they have been presented. Validation for these will involve collecting all the resources used by a command buffer and will be done in a follow-up patch.
2018-07-09 13:15:07 +00:00
ASSERT(HasZeroOrOneBits(usage));
Rename GetAllowedUsage to GetUsage. Resources used to have both a current and an allowed usage but the concept of current usage has been removed so we can rename "allowed usage" to "usage" to make the name match WebGPU's WebGPUBufferDescriptor::usage and WebGPUTextureDescriptor::usage Change-Id: I5190950bf7f7f5b86c92247ef0240fead9886268
2018-08-22 13:08:02 +00:00
if (!(texture->GetUsage() & usage)) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("texture doesn't have the required usage.");
Remove explicit usage transition from the API and validation This removes the following for both Buffer and Texture: - The builder's SetInitialUsage - The object's FreezeUsage and TransitionUsage methods - The CommandBuffer Transition<Object>Usage methods All samples and tests are simplified as a result. This also obsoletes the UsageValidationTest which is removed. Some validation was dependent on "current usage" and hasn't been reintroduced for implicit transitions yet: - Buffers can be used while mapped - Swapchain textures can be used after they have been presented. Validation for these will involve collecting all the resources used by a command buffer and will be done in a follow-up patch.
2018-07-09 13:15:07 +00:00
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
return {};
Remove explicit usage transition from the API and validation This removes the following for both Buffer and Texture: - The builder's SetInitialUsage - The object's FreezeUsage and TransitionUsage methods - The CommandBuffer Transition<Object>Usage methods All samples and tests are simplified as a result. This also obsoletes the UsageValidationTest which is removed. Some validation was dependent on "current usage" and hasn't been reintroduced for implicit transitions yet: - Buffers can be used while mapped - Swapchain textures can be used after they have been presented. Validation for these will involve collecting all the resources used by a command buffer and will be done in a follow-up patch.
2018-07-09 13:15:07 +00:00
}
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
enum class PassType {
Render,
Compute,
};
// Helper class to encapsulate the logic of tracking per-resource usage during the
// validation of command buffer passes. It is used both to know if there are validation
// errors, and to get a list of resources used per pass for backends that need the
// information.
class PassResourceUsageTracker {
public:
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
void BufferUsedAs(BufferBase* buffer, dawn::BufferUsageBit usage) {
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
// std::map's operator[] will create the key and return 0 if the key didn't exist
// before.
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
dawn::BufferUsageBit& storedUsage = mBufferUsages[buffer];
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
if (usage == dawn::BufferUsageBit::Storage &&
storedUsage & dawn::BufferUsageBit::Storage) {
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
mStorageUsedMultipleTimes = true;
}
storedUsage |= usage;
}
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
void TextureUsedAs(TextureBase* texture, dawn::TextureUsageBit usage) {
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
// std::map's operator[] will create the key and return 0 if the key didn't exist
// before.
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
dawn::TextureUsageBit& storedUsage = mTextureUsages[texture];
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
if (usage == dawn::TextureUsageBit::Storage &&
storedUsage & dawn::TextureUsageBit::Storage) {
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
mStorageUsedMultipleTimes = true;
}
storedUsage |= usage;
}
// Performs the per-pass usage validation checks
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
MaybeError ValidateUsages(PassType pass) const {
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
// Storage resources cannot be used twice in the same compute pass
if (pass == PassType::Compute && mStorageUsedMultipleTimes) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR(
"Storage resource used multiple times in compute pass");
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
}
// Buffers can only be used as single-write or multiple read.
for (auto& it : mBufferUsages) {
BufferBase* buffer = it.first;
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
dawn::BufferUsageBit usage = it.second;
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
Rename GetAllowedUsage to GetUsage. Resources used to have both a current and an allowed usage but the concept of current usage has been removed so we can rename "allowed usage" to "usage" to make the name match WebGPU's WebGPUBufferDescriptor::usage and WebGPUTextureDescriptor::usage Change-Id: I5190950bf7f7f5b86c92247ef0240fead9886268
2018-08-22 13:08:02 +00:00
if (usage & ~buffer->GetUsage()) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Buffer missing usage for the pass");
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
}
bool readOnly = (usage & kReadOnlyBufferUsages) == usage;
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
bool singleUse = dawn::HasZeroOrOneBits(usage);
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
if (!readOnly && !singleUse) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR(
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
"Buffer used as writeable usage and another usage in pass");
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
}
}
// Textures can only be used as single-write or multiple read.
// TODO(cwallez@chromium.org): implement per-subresource tracking
for (auto& it : mTextureUsages) {
TextureBase* texture = it.first;
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
dawn::TextureUsageBit usage = it.second;
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
Rename GetAllowedUsage to GetUsage. Resources used to have both a current and an allowed usage but the concept of current usage has been removed so we can rename "allowed usage" to "usage" to make the name match WebGPU's WebGPUBufferDescriptor::usage and WebGPUTextureDescriptor::usage Change-Id: I5190950bf7f7f5b86c92247ef0240fead9886268
2018-08-22 13:08:02 +00:00
if (usage & ~texture->GetUsage()) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Texture missing usage for the pass");
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
}
// 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.
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
if (!dawn::HasZeroOrOneBits(it.second)) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR(
"Texture used with more than one usage in pass");
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
}
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
return {};
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
}
// Returns the per-pass usage for use by backends for APIs with explicit barriers.
PassResourceUsage AcquireResourceUsage() {
PassResourceUsage result;
result.buffers.reserve(mBufferUsages.size());
result.bufferUsages.reserve(mBufferUsages.size());
result.textures.reserve(mTextureUsages.size());
result.textureUsages.reserve(mTextureUsages.size());
for (auto& it : mBufferUsages) {
result.buffers.push_back(it.first);
result.bufferUsages.push_back(it.second);
}
for (auto& it : mTextureUsages) {
result.textures.push_back(it.first);
result.textureUsages.push_back(it.second);
}
return result;
}
private:
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
std::map<BufferBase*, dawn::BufferUsageBit> mBufferUsages;
std::map<TextureBase*, dawn::TextureUsageBit> mTextureUsages;
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
bool mStorageUsedMultipleTimes = false;
};
void TrackBindGroupResourceUsage(BindGroupBase* group, PassResourceUsageTracker* tracker) {
const auto& layoutInfo = group->GetLayout()->GetBindingInfo();
for (uint32_t i : IterateBitSet(layoutInfo.mask)) {
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
dawn::BindingType type = layoutInfo.types[i];
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
switch (type) {
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
case dawn::BindingType::UniformBuffer: {
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
BufferBase* buffer = group->GetBindingAsBufferView(i)->GetBuffer();
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
tracker->BufferUsedAs(buffer, dawn::BufferUsageBit::Uniform);
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
} break;
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
case dawn::BindingType::StorageBuffer: {
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
BufferBase* buffer = group->GetBindingAsBufferView(i)->GetBuffer();
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
tracker->BufferUsedAs(buffer, dawn::BufferUsageBit::Storage);
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
} break;
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
case dawn::BindingType::SampledTexture: {
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
TextureBase* texture = group->GetBindingAsTextureView(i)->GetTexture();
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
tracker->TextureUsedAs(texture, dawn::TextureUsageBit::Sampled);
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
} break;
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
case dawn::BindingType::Sampler:
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
break;
}
}
}
Format: src/backend
2017-11-24 18:59:42 +00:00
} // namespace
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
Introduce [Render|Compute]PassEncoder. 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>
2018-09-21 00:24:37 +00:00
enum class CommandBufferBuilder::EncodingState : uint8_t {
TopLevel,
ComputePass,
RenderPass,
Finished
};
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
// CommandBuffer
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
CommandBufferBase::CommandBufferBase(CommandBufferBuilder* builder)
Put the reference to DeviceBase in a new ObjectBase ObjectBase will contain data that all WebGPU objects have such as a pointer back to the device, a refcount (via inheriting from RefCounted), a name, an error status etc. BUG=dawn:24 Change-Id: I919e1a6d4a68811ceb6e503b2a793815c92f2528 Reviewed-on: https://dawn-review.googlesource.com/c/1620 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2018-10-15 12:54:30 +00:00
: ObjectBase(builder->GetDevice()) {
OpenGL backend: implement render passes (#73) Probably not the most efficient implementation, but works. Issues: * Doesn't seem to render until the second frame. No clue why, yet. * Hardcoded 640x480 in more places. * Creates new FBOs for every subpass every frame. Should be done at Framebuffer build or CommandBuffer build time.
2017-07-12 00:49:20 +00:00
}
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
// CommandBufferBuilder
Introduce [Render|Compute]PassEncoder. 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>
2018-09-21 00:24:37 +00:00
CommandBufferBuilder::CommandBufferBuilder(DeviceBase* device)
: Builder(device), mEncodingState(EncodingState::TopLevel) {
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
}
CommandBufferBuilder::~CommandBufferBuilder() {
Member rename: src/backend
2017-11-23 18:32:51 +00:00
if (!mWereCommandsAcquired) {
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
MoveToIterator();
Member rename: src/backend
2017-11-23 18:32:51 +00:00
FreeCommands(&mIterator);
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
}
}
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
CommandIterator CommandBufferBuilder::AcquireCommands() {
ASSERT(!mWereCommandsAcquired);
mWereCommandsAcquired = true;
return std::move(mIterator);
}
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
std::vector<PassResourceUsage> CommandBufferBuilder::AcquirePassResourceUsage() {
ASSERT(!mWerePassUsagesAcquired);
mWerePassUsagesAcquired = true;
return std::move(mPassResourceUsages);
}
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
CommandBufferBase* CommandBufferBuilder::GetResultImpl() {
Introduce [Render|Compute]PassEncoder. 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>
2018-09-21 00:24:37 +00:00
mEncodingState = EncodingState::Finished;
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
MoveToIterator();
Put the reference to DeviceBase in a new ObjectBase ObjectBase will contain data that all WebGPU objects have such as a pointer back to the device, a refcount (via inheriting from RefCounted), a name, an error status etc. BUG=dawn:24 Change-Id: I919e1a6d4a68811ceb6e503b2a793815c92f2528 Reviewed-on: https://dawn-review.googlesource.com/c/1620 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2018-10-15 12:54:30 +00:00
return GetDevice()->CreateCommandBuffer(this);
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
}
void CommandBufferBuilder::MoveToIterator() {
if (!mWasMovedToIterator) {
mIterator = std::move(mAllocator);
mWasMovedToIterator = true;
}
}
Introduce [Render|Compute]PassEncoder. 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>
2018-09-21 00:24:37 +00:00
void CommandBufferBuilder::PassEnded() {
if (mEncodingState == EncodingState::ComputePass) {
mAllocator.Allocate<EndComputePassCmd>(Command::EndComputePass);
} else {
ASSERT(mEncodingState == EncodingState::RenderPass);
mAllocator.Allocate<EndRenderPassCmd>(Command::EndRenderPass);
}
mEncodingState = EncodingState::TopLevel;
}
void CommandBufferBuilder::ConsumeError(ErrorData* error) {
HandleError(error->GetMessage().c_str());
delete error;
}
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
// Implementation of the command buffer validation that can be precomputed before submit
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
MaybeError CommandBufferBuilder::ValidateGetResult() {
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
MoveToIterator();
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
mIterator.Reset();
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
Command type;
Member rename: src/backend
2017-11-23 18:32:51 +00:00
while (mIterator.NextCommandId(&type)) {
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
switch (type) {
Format: src/backend
2017-11-24 18:59:42 +00:00
case Command::BeginComputePass: {
mIterator.NextCommand<BeginComputePassCmd>();
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(ValidateComputePass());
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
case Command::BeginRenderPass: {
BeginRenderPassCmd* cmd = mIterator.NextCommand<BeginRenderPassCmd>();
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(ValidateRenderPass(cmd->info.Get()));
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
case Command::CopyBufferToBuffer: {
CopyBufferToBufferCmd* copy = mIterator.NextCommand<CopyBufferToBufferCmd>();
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(ValidateCopySizeFitsInBuffer(copy->source, copy->size));
DAWN_TRY(ValidateCopySizeFitsInBuffer(copy->destination, copy->size));
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(ValidateCanUseAs(copy->source.buffer.Get(),
dawn::BufferUsageBit::TransferSrc));
DAWN_TRY(ValidateCanUseAs(copy->destination.buffer.Get(),
dawn::BufferUsageBit::TransferDst));
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
case Command::CopyBufferToTexture: {
CopyBufferToTextureCmd* copy = mIterator.NextCommand<CopyBufferToTextureCmd>();
uint32_t bufferCopySize = 0;
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(ValidateRowPitch(copy->destination, copy->rowPitch));
DAWN_TRY(ComputeTextureCopyBufferSize(copy->destination, copy->rowPitch,
&bufferCopySize));
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(ValidateCopyLocationFitsInTexture(copy->destination));
DAWN_TRY(ValidateCopySizeFitsInBuffer(copy->source, bufferCopySize));
DAWN_TRY(
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
ValidateTexelBufferOffset(copy->destination.texture.Get(), copy->source));
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(ValidateCanUseAs(copy->source.buffer.Get(),
dawn::BufferUsageBit::TransferSrc));
DAWN_TRY(ValidateCanUseAs(copy->destination.texture.Get(),
dawn::TextureUsageBit::TransferDst));
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
case Command::CopyTextureToBuffer: {
CopyTextureToBufferCmd* copy = mIterator.NextCommand<CopyTextureToBufferCmd>();
uint32_t bufferCopySize = 0;
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(ValidateRowPitch(copy->source, copy->rowPitch));
DAWN_TRY(ComputeTextureCopyBufferSize(copy->source, copy->rowPitch,
&bufferCopySize));
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(ValidateCopyLocationFitsInTexture(copy->source));
DAWN_TRY(ValidateCopySizeFitsInBuffer(copy->destination, bufferCopySize));
DAWN_TRY(
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
ValidateTexelBufferOffset(copy->source.texture.Get(), copy->destination));
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(ValidateCanUseAs(copy->source.texture.Get(),
dawn::TextureUsageBit::TransferSrc));
DAWN_TRY(ValidateCanUseAs(copy->destination.buffer.Get(),
dawn::BufferUsageBit::TransferDst));
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
default:
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Command disallowed outside of a pass");
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
}
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
return {};
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
MaybeError CommandBufferBuilder::ValidateComputePass() {
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
PassResourceUsageTracker usageTracker;
CommandBuffer: have a state tracker per-pass Also perform small code simplifications of the CommandBufferStateTracker now that it only tracks aspects.
2018-07-18 16:23:08 +00:00
CommandBufferStateTracker persistentState;
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
Command type;
while (mIterator.NextCommandId(&type)) {
switch (type) {
case Command::EndComputePass: {
mIterator.NextCommand<EndComputePassCmd>();
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(usageTracker.ValidateUsages(PassType::Compute));
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
mPassResourceUsages.push_back(usageTracker.AcquireResourceUsage());
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
return {};
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
} break;
Format: src/backend
2017-11-24 18:59:42 +00:00
case Command::Dispatch: {
mIterator.NextCommand<DispatchCmd>();
CommandBuffer: have a state tracker per-pass Also perform small code simplifications of the CommandBufferStateTracker now that it only tracks aspects.
2018-07-18 16:23:08 +00:00
DAWN_TRY(persistentState.ValidateCanDispatch());
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
case Command::SetComputePipeline: {
SetComputePipelineCmd* cmd = mIterator.NextCommand<SetComputePipelineCmd>();
ComputePipelineBase* pipeline = cmd->pipeline.Get();
CommandBuffer: have a state tracker per-pass Also perform small code simplifications of the CommandBufferStateTracker now that it only tracks aspects.
2018-07-18 16:23:08 +00:00
persistentState.SetComputePipeline(pipeline);
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
case Command::SetPushConstants: {
SetPushConstantsCmd* cmd = mIterator.NextCommand<SetPushConstantsCmd>();
mIterator.NextData<uint32_t>(cmd->count);
// Validation of count and offset has already been done when the command was
// recorded because it impacts the size of an allocation in the
// CommandAllocator.
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
if (cmd->stages & ~dawn::ShaderStageBit::Compute) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR(
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
"SetPushConstants stage must be compute or 0 in compute passes");
Format: src/backend
2017-11-24 18:59:42 +00:00
}
} break;
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
case Command::SetBindGroup: {
SetBindGroupCmd* cmd = mIterator.NextCommand<SetBindGroupCmd>();
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
TrackBindGroupResourceUsage(cmd->group.Get(), &usageTracker);
CommandBuffer: have a state tracker per-pass Also perform small code simplifications of the CommandBufferStateTracker now that it only tracks aspects.
2018-07-18 16:23:08 +00:00
persistentState.SetBindGroup(cmd->index, cmd->group.Get());
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
default:
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Command disallowed inside a compute pass");
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
}
}
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Unfinished compute pass");
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
}
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
MaybeError CommandBufferBuilder::ValidateRenderPass(RenderPassDescriptorBase* renderPass) {
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
PassResourceUsageTracker usageTracker;
CommandBuffer: have a state tracker per-pass Also perform small code simplifications of the CommandBufferStateTracker now that it only tracks aspects.
2018-07-18 16:23:08 +00:00
CommandBufferStateTracker persistentState;
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
// Track usage of the render pass attachments
for (uint32_t i : IterateBitSet(renderPass->GetColorAttachmentMask())) {
TextureBase* texture = renderPass->GetColorAttachment(i).view->GetTexture();
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
usageTracker.TextureUsedAs(texture, dawn::TextureUsageBit::OutputAttachment);
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
}
if (renderPass->HasDepthStencilAttachment()) {
TextureBase* texture = renderPass->GetDepthStencilAttachment().view->GetTexture();
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
usageTracker.TextureUsedAs(texture, dawn::TextureUsageBit::OutputAttachment);
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
}
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
Command type;
while (mIterator.NextCommandId(&type)) {
switch (type) {
Format: src/backend
2017-11-24 18:59:42 +00:00
case Command::EndRenderPass: {
mIterator.NextCommand<EndRenderPassCmd>();
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
Rename Error.h macros from NXT to DAWN
2018-07-18 09:45:17 +00:00
DAWN_TRY(usageTracker.ValidateUsages(PassType::Render));
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
mPassResourceUsages.push_back(usageTracker.AcquireResourceUsage());
Make CommandBufferValidation use Error.h
2018-07-16 16:20:09 +00:00
return {};
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
} break;
case Command::DrawArrays: {
mIterator.NextCommand<DrawArraysCmd>();
CommandBuffer: have a state tracker per-pass Also perform small code simplifications of the CommandBufferStateTracker now that it only tracks aspects.
2018-07-18 16:23:08 +00:00
DAWN_TRY(persistentState.ValidateCanDrawArrays());
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
case Command::DrawElements: {
mIterator.NextCommand<DrawElementsCmd>();
CommandBuffer: have a state tracker per-pass Also perform small code simplifications of the CommandBufferStateTracker now that it only tracks aspects.
2018-07-18 16:23:08 +00:00
DAWN_TRY(persistentState.ValidateCanDrawElements());
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
case Command::SetRenderPipeline: {
SetRenderPipelineCmd* cmd = mIterator.NextCommand<SetRenderPipelineCmd>();
RenderPipelineBase* pipeline = cmd->pipeline.Get();
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
if (!pipeline->IsCompatibleWith(renderPass)) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR(
"Pipeline is incompatible with this render pass");
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
}
CommandBuffer: have a state tracker per-pass Also perform small code simplifications of the CommandBufferStateTracker now that it only tracks aspects.
2018-07-18 16:23:08 +00:00
persistentState.SetRenderPipeline(pipeline);
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
case Command::SetPushConstants: {
SetPushConstantsCmd* cmd = mIterator.NextCommand<SetPushConstantsCmd>();
mIterator.NextData<uint32_t>(cmd->count);
// Validation of count and offset has already been done when the command was
// recorded because it impacts the size of an allocation in the
// CommandAllocator.
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
if (cmd->stages &
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
~(dawn::ShaderStageBit::Vertex | dawn::ShaderStageBit::Fragment)) {
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR(
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
"SetPushConstants stage must be a subset of (vertex|fragment) in "
"render passes");
Format: src/backend
2017-11-24 18:59:42 +00:00
}
} break;
case Command::SetStencilReference: {
mIterator.NextCommand<SetStencilReferenceCmd>();
} break;
case Command::SetBlendColor: {
mIterator.NextCommand<SetBlendColorCmd>();
} break;
Add and Implement CommandBuffer::SetScissorRect
2018-02-13 19:57:13 +00:00
case Command::SetScissorRect: {
mIterator.NextCommand<SetScissorRectCmd>();
} break;
Format: src/backend
2017-11-24 18:59:42 +00:00
case Command::SetBindGroup: {
SetBindGroupCmd* cmd = mIterator.NextCommand<SetBindGroupCmd>();
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
TrackBindGroupResourceUsage(cmd->group.Get(), &usageTracker);
CommandBuffer: have a state tracker per-pass Also perform small code simplifications of the CommandBufferStateTracker now that it only tracks aspects.
2018-07-18 16:23:08 +00:00
persistentState.SetBindGroup(cmd->index, cmd->group.Get());
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
case Command::SetIndexBuffer: {
SetIndexBufferCmd* cmd = mIterator.NextCommand<SetIndexBufferCmd>();
Make the Vulkan backend support implicit barriers. With this commit the Vulkan backend completely ignores the explicit barrier commands passed from the frontend, and generates its own pipeline barriers. Right now it encodes each barrier just before the resources are used, which is quite bad but will be optimized later. This commit also makes the frontend command buffer validation perform the checks necessary for implicit barriers (although they are redundant with checks for explicit barriers) because the tracking can pre-compute pass usage information that's useful for the Vulkan backend. Tests for usage validation inside passes will be added once the concept of transition is removed from the API.
2018-07-10 16:03:22 +00:00
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
usageTracker.BufferUsedAs(cmd->buffer.Get(), dawn::BufferUsageBit::Index);
CommandBuffer: have a state tracker per-pass Also perform small code simplifications of the CommandBufferStateTracker now that it only tracks aspects.
2018-07-18 16:23:08 +00:00
persistentState.SetIndexBuffer();
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
Format: src/backend
2017-11-24 18:59:42 +00:00
case Command::SetVertexBuffers: {
SetVertexBuffersCmd* cmd = mIterator.NextCommand<SetVertexBuffersCmd>();
auto buffers = mIterator.NextData<Ref<BufferBase>>(cmd->count);
mIterator.NextData<uint32_t>(cmd->count);
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
Format: src/backend
2017-11-24 18:59:42 +00:00
for (uint32_t i = 0; i < cmd->count; ++i) {
Rename nxt:: to dawn:: in the backends
2018-07-18 09:38:11 +00:00
usageTracker.BufferUsedAs(buffers[i].Get(), dawn::BufferUsageBit::Vertex);
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
}
CommandBuffer: have a state tracker per-pass Also perform small code simplifications of the CommandBufferStateTracker now that it only tracks aspects.
2018-07-18 16:23:08 +00:00
persistentState.SetVertexBuffer(cmd->startSlot, cmd->count);
Format: src/backend
2017-11-24 18:59:42 +00:00
} break;
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
default:
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Command disallowed inside a render pass");
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
}
}
Make Dawn error macro more explicit and have an "error type" The error type will help distinguish between validation errors, context losts and others which should be handled differently. Take advantage of advantage of this to change DAWN_RETURN_ERROR to "return DAWN_FOO_ERROR" to have the return be more explicit. Also removes usage of DAWN_TRY_ASSERT for more explicit checks. Change-Id: Icbce16b0c8d8eb084b0af2fc132acee776909a36
2018-09-10 14:17:24 +00:00
return DAWN_VALIDATION_ERROR("Unfinished render pass");
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
}
CommandBufferBuilder::Validate: Iterate per pass This changes the validation to have one iteration loop for the main buffer that calls to pass-specific iteration loops for compute passes and render passes. This is done to simplify code a bit and will help implement implicit transitions that are "precomputed" per pass in the command buffer validation and re-used in the backends. A number of code simplifications were made to CommandBufferStateTracker since it doesn't need to know if we are in a pass anymore. Further simplifications will happen when implicit barriers are implemented.
2018-07-04 13:20:19 +00:00
// Implementation of the API's command recording methods
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
Introduce [Render|Compute]PassEncoder. 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>
2018-09-21 00:24:37 +00:00
ComputePassEncoderBase* CommandBufferBuilder::BeginComputePass() {
Member rename: src/backend
2017-11-23 18:32:51 +00:00
mAllocator.Allocate<BeginComputePassCmd>(Command::BeginComputePass);
Introduce [Render|Compute]PassEncoder. 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>
2018-09-21 00:24:37 +00:00
mEncodingState = EncodingState::ComputePass;
Put the reference to DeviceBase in a new ObjectBase ObjectBase will contain data that all WebGPU objects have such as a pointer back to the device, a refcount (via inheriting from RefCounted), a name, an error status etc. BUG=dawn:24 Change-Id: I919e1a6d4a68811ceb6e503b2a793815c92f2528 Reviewed-on: https://dawn-review.googlesource.com/c/1620 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2018-10-15 12:54:30 +00:00
return new ComputePassEncoderBase(GetDevice(), this, &mAllocator);
Introduce render passes * First API design (many features missing, including input attachments) * Metal implementation (no OpenGL yet) * Render-to-texture demo (a little broken until we have depth buffers) * Update examples to use render passes
2017-05-16 21:04:22 +00:00
}
Introduce [Render|Compute]PassEncoder. 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>
2018-09-21 00:24:37 +00:00
RenderPassEncoderBase* CommandBufferBuilder::BeginRenderPass(RenderPassDescriptorBase* info) {
Member rename: src/backend
2017-11-23 18:32:51 +00:00
BeginRenderPassCmd* cmd = mAllocator.Allocate<BeginRenderPassCmd>(Command::BeginRenderPass);
Format: src/backend
2017-11-24 18:59:42 +00:00
new (cmd) BeginRenderPassCmd;
Change render passes from multi to single pass. This as an API change to get closer to the direction in which WebGPU is headed. The API change in next.json caused a ton of files to be changed in the same commit to keep things compiling. API: the Framebuffer and RenderPass objects are now merged in a single RenderPassInfo that contains the attachments, loadOps and clear values for a BeginRenderPass command. The concept of subpass is removed. The RenderPass creation argument to RenderPipelines is replaced by explicitly setting the format of attachments for RenderPipeline. Validation: SetPipeline checks are changed to check that the attachments info set on a RenderPipeline matches the attachments of the render pass. Backends: Most changes are simplifications of the backends that no longer require and indirection to query the current subpass out of the render pass in BeginSubpass, and don't need to get the attachment info from a RenderPass when creating RenderPipelines. In the Vulkan backend, a VkRenderPass cache is added to reuse VkRenderPasses between RenderPassInfos and RenderPipelines. Tests and examples: they are updated with the simplified API. Tests specific to the Framebuffer and RenderPass objects were removed and validation tests for RenderPassInfo were added. Tested by running CppHelloTriangle on all backends, end2end tests on all platforms and all examples on the GL backend.
2018-05-02 22:10:13 +00:00
cmd->info = info;
Introduce [Render|Compute]PassEncoder. 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>
2018-09-21 00:24:37 +00:00
mEncodingState = EncodingState::RenderPass;
Put the reference to DeviceBase in a new ObjectBase ObjectBase will contain data that all WebGPU objects have such as a pointer back to the device, a refcount (via inheriting from RefCounted), a name, an error status etc. BUG=dawn:24 Change-Id: I919e1a6d4a68811ceb6e503b2a793815c92f2528 Reviewed-on: https://dawn-review.googlesource.com/c/1620 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2018-10-15 12:54:30 +00:00
return new RenderPassEncoderBase(GetDevice(), this, &mAllocator);
Introduce Begin/EndComputePass (#70)
2017-07-10 21:07:24 +00:00
}
Format: src/backend
2017-11-24 18:59:42 +00:00
void CommandBufferBuilder::CopyBufferToBuffer(BufferBase* source,
uint32_t sourceOffset,
BufferBase* destination,
uint32_t destinationOffset,
uint32_t size) {
CopyBufferToBufferCmd* copy =
mAllocator.Allocate<CopyBufferToBufferCmd>(Command::CopyBufferToBuffer);
new (copy) CopyBufferToBufferCmd;
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
copy->source.buffer = source;
copy->source.offset = sourceOffset;
copy->destination.buffer = destination;
copy->destination.offset = destinationOffset;
Add buffer to buffer copies
2017-06-12 22:12:29 +00:00
copy->size = size;
}
Format: src/backend
2017-11-24 18:59:42 +00:00
void CommandBufferBuilder::CopyBufferToTexture(BufferBase* buffer,
uint32_t bufferOffset,
uint32_t rowPitch,
TextureBase* texture,
uint32_t x,
uint32_t y,
uint32_t z,
uint32_t width,
uint32_t height,
uint32_t depth,
Implement copying between a buffer and a texture 2D array on Vulkan (#257) Implement copying between a buffer and a texture 2D array on Vulkan This patch implements the creation of a 2D array texture and data copying between a buffer and a layer of a 2D array texture on Vulkan back-ends. TEST=dawn_end2end_tests
2018-08-30 08:27:38 +00:00
uint32_t level,
uint32_t slice) {
Add row pitch validation and default computation
2017-07-13 14:23:26 +00:00
if (rowPitch == 0) {
rowPitch = ComputeDefaultRowPitch(texture, width);
}
Format: src/backend
2017-11-24 18:59:42 +00:00
CopyBufferToTextureCmd* copy =
mAllocator.Allocate<CopyBufferToTextureCmd>(Command::CopyBufferToTexture);
new (copy) CopyBufferToTextureCmd;
Refactor copy validation to add helper functions useful for T->B too. Also fixes validation not taking the mip-level into account when checking if the copy would fit in the texture.
2017-06-26 15:43:51 +00:00
copy->source.buffer = buffer;
copy->source.offset = bufferOffset;
copy->destination.texture = texture;
copy->destination.x = x;
copy->destination.y = y;
copy->destination.z = z;
copy->destination.width = width;
copy->destination.height = height;
copy->destination.depth = depth;
copy->destination.level = level;
Implement copying between a buffer and a texture 2D array on Vulkan (#257) Implement copying between a buffer and a texture 2D array on Vulkan This patch implements the creation of a 2D array texture and data copying between a buffer and a layer of a 2D array texture on Vulkan back-ends. TEST=dawn_end2end_tests
2018-08-30 08:27:38 +00:00
copy->destination.slice = slice;
Add row pitch to Texture->Buffer and Buffer->Texture copy commands
2017-07-13 14:04:23 +00:00
copy->rowPitch = rowPitch;
Initial commit of all the NXT integration. More like squashed history, contributors were: - Kai Ninomiya - Corentin Wallez
2017-04-20 18:38:20 +00:00
}
Format: src/backend
2017-11-24 18:59:42 +00:00
void CommandBufferBuilder::CopyTextureToBuffer(TextureBase* texture,
uint32_t x,
uint32_t y,
uint32_t z,
uint32_t width,
uint32_t height,
uint32_t depth,
uint32_t level,
Implement copying between a buffer and a texture 2D array on Vulkan (#257) Implement copying between a buffer and a texture 2D array on Vulkan This patch implements the creation of a 2D array texture and data copying between a buffer and a layer of a 2D array texture on Vulkan back-ends. TEST=dawn_end2end_tests
2018-08-30 08:27:38 +00:00
uint32_t slice,
Format: src/backend
2017-11-24 18:59:42 +00:00
BufferBase* buffer,
uint32_t bufferOffset,
uint32_t rowPitch) {
Add row pitch validation and default computation
2017-07-13 14:23:26 +00:00
if (rowPitch == 0) {
rowPitch = ComputeDefaultRowPitch(texture, width);
}
Format: src/backend
2017-11-24 18:59:42 +00:00
CopyTextureToBufferCmd* copy =
mAllocator.Allocate<CopyTextureToBufferCmd>(Command::CopyTextureToBuffer);
new (copy) CopyTextureToBufferCmd;
Add T->B copies. This implements T->B copies on the Metal backend only and while it adds validation tests, end2end tests will be done in a follow-up commit.
2017-06-26 20:23:03 +00:00
copy->source.texture = texture;
copy->source.x = x;
copy->source.y = y;
copy->source.z = z;
copy->source.width = width;
copy->source.height = height;
copy->source.depth = depth;
copy->source.level = level;
Implement copying between a buffer and a texture 2D array on Vulkan (#257) Implement copying between a buffer and a texture 2D array on Vulkan This patch implements the creation of a 2D array texture and data copying between a buffer and a layer of a 2D array texture on Vulkan back-ends. TEST=dawn_end2end_tests
2018-08-30 08:27:38 +00:00
copy->source.slice = slice;
Add T->B copies. This implements T->B copies on the Metal backend only and while it adds validation tests, end2end tests will be done in a follow-up commit.
2017-06-26 20:23:03 +00:00
copy->destination.buffer = buffer;
copy->destination.offset = bufferOffset;
Add row pitch to Texture->Buffer and Buffer->Texture copy commands
2017-07-13 14:04:23 +00:00
copy->rowPitch = rowPitch;
Add T->B copies. This implements T->B copies on the Metal backend only and while it adds validation tests, end2end tests will be done in a follow-up commit.
2017-06-26 20:23:03 +00:00
}
dawn_native: Fixup namespace from backend:: to dawn_native::
2018-07-24 14:45:45 +00:00
} // namespace dawn_native