blob: 6d34a0108a8c45dda3271a853c1dd846f0754965 [file] [log] [blame] [edit]
// Copyright 2017 The Dawn & Tint Authors
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
//
// 1. Redistributions of source code must retain the above copyright notice, this
// list of conditions and the following disclaimer.
//
// 2. Redistributions in binary form must reproduce the above copyright notice,
// this list of conditions and the following disclaimer in the documentation
// and/or other materials provided with the distribution.
//
// 3. Neither the name of the copyright holder nor the names of its
// contributors may be used to endorse or promote products derived from
// this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
// FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
// DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
// SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
// CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
// OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
#include "dawn/native/CommandBuffer.h"
#include "dawn/common/BitSetIterator.h"
#include "dawn/native/Buffer.h"
#include "dawn/native/CommandEncoder.h"
#include "dawn/native/CommandValidation.h"
#include "dawn/native/Commands.h"
#include "dawn/native/Format.h"
#include "dawn/native/ObjectType_autogen.h"
#include "dawn/native/Texture.h"
namespace dawn::native {
CommandBufferBase::CommandBufferBase(CommandEncoder* encoder,
const CommandBufferDescriptor* descriptor)
: ApiObjectBase(encoder->GetDevice(), descriptor->label),
mCommands(encoder->AcquireCommands()),
mResourceUsages(encoder->AcquireResourceUsages()),
mEncoderLabel(encoder->GetLabel()) {
GetObjectTrackingList()->Track(this);
}
CommandBufferBase::CommandBufferBase(DeviceBase* device,
ObjectBase::ErrorTag tag,
const char* label)
: ApiObjectBase(device, tag, label) {}
// static
Ref<CommandBufferBase> CommandBufferBase::MakeError(DeviceBase* device, const char* label) {
return AcquireRef(new CommandBufferBase(device, ObjectBase::kError, label));
}
ObjectType CommandBufferBase::GetType() const {
return ObjectType::CommandBuffer;
}
void CommandBufferBase::FormatLabel(absl::FormatSink* s) const {
s->Append(ObjectTypeAsString(GetType()));
const std::string& label = GetLabel();
if (!label.empty()) {
s->Append(absl::StrFormat(" \"%s\"", label));
}
if (!mEncoderLabel.empty()) {
s->Append(absl::StrFormat(" from %s \"%s\"", ObjectTypeAsString(ObjectType::CommandEncoder),
mEncoderLabel));
}
}
const std::string& CommandBufferBase::GetEncoderLabel() const {
return mEncoderLabel;
}
void CommandBufferBase::SetEncoderLabel(std::string encoderLabel) {
mEncoderLabel = encoderLabel;
}
MaybeError CommandBufferBase::ValidateCanUseInSubmitNow() const {
DAWN_ASSERT(!IsError());
DAWN_INVALID_IF(!IsAlive(), "%s cannot be submitted more than once.", this);
return {};
}
void CommandBufferBase::DestroyImpl() {
FreeCommands(&mCommands);
mResourceUsages = {};
}
const CommandBufferResourceUsage& CommandBufferBase::GetResourceUsages() const {
return mResourceUsages;
}
CommandIterator* CommandBufferBase::GetCommandIteratorForTesting() {
return &mCommands;
}
bool IsCompleteSubresourceCopiedTo(const TextureBase* texture,
const Extent3D& copySize,
const uint32_t mipLevel,
Aspect aspect) {
DAWN_ASSERT(HasOneBit(aspect) || aspect == (Aspect::Depth | Aspect::Stencil));
Extent3D extent = texture->GetMipLevelSingleSubresourcePhysicalSize(mipLevel, aspect);
switch (texture->GetDimension()) {
case wgpu::TextureDimension::e1D:
return extent.width == copySize.width;
case wgpu::TextureDimension::e2D:
return extent.width == copySize.width && extent.height == copySize.height;
case wgpu::TextureDimension::e3D:
return extent.width == copySize.width && extent.height == copySize.height &&
extent.depthOrArrayLayers == copySize.depthOrArrayLayers;
case wgpu::TextureDimension::Undefined:
break;
}
DAWN_UNREACHABLE();
}
bool IsCompleteSubresourceCopiedTo(const TextureBase* texture,
const Extent3D& copySize,
const uint32_t mipLevel,
wgpu::TextureAspect textureAspect) {
auto aspect = SelectFormatAspects(texture->GetFormat(), textureAspect);
return IsCompleteSubresourceCopiedTo(texture, copySize, mipLevel, aspect);
}
SubresourceRange GetSubresourcesAffectedByCopy(const TextureCopy& copy, const Extent3D& copySize) {
switch (copy.texture->GetDimension()) {
case wgpu::TextureDimension::e1D:
DAWN_ASSERT(copy.origin.z == 0 && copySize.depthOrArrayLayers == 1);
DAWN_ASSERT(copy.mipLevel == 0);
return {copy.aspect, {0, 1}, {0, 1}};
case wgpu::TextureDimension::e2D:
return {copy.aspect, {copy.origin.z, copySize.depthOrArrayLayers}, {copy.mipLevel, 1}};
case wgpu::TextureDimension::e3D:
return {copy.aspect, {0, 1}, {copy.mipLevel, 1}};
case wgpu::TextureDimension::Undefined:
DAWN_UNREACHABLE();
}
DAWN_UNREACHABLE();
}
void LazyClearRenderPassAttachments(BeginRenderPassCmd* renderPass) {
for (auto i : IterateBitSet(renderPass->attachmentState->GetColorAttachmentsMask())) {
auto& attachmentInfo = renderPass->colorAttachments[i];
TextureViewBase* view = attachmentInfo.view.Get();
bool hasResolveTarget = attachmentInfo.resolveTarget != nullptr;
DAWN_ASSERT(view->GetLayerCount() == 1);
DAWN_ASSERT(view->GetLevelCount() == 1);
SubresourceRange range = view->GetSubresourceRange();
// If the loadOp is Load, but the subresource is not initialized, use Clear instead.
if (attachmentInfo.loadOp == wgpu::LoadOp::Load &&
!view->GetTexture()->IsSubresourceContentInitialized(range)) {
attachmentInfo.loadOp = wgpu::LoadOp::Clear;
attachmentInfo.clearColor = {0.f, 0.f, 0.f, 0.f};
}
if (hasResolveTarget) {
// We need to set the resolve target to initialized so that it does not get
// cleared later in the pipeline. The texture will be resolved from the
// source color attachment, which will be correctly initialized.
TextureViewBase* resolveView = attachmentInfo.resolveTarget.Get();
DAWN_ASSERT(resolveView->GetLayerCount() == 1);
DAWN_ASSERT(resolveView->GetLevelCount() == 1);
resolveView->GetTexture()->SetIsSubresourceContentInitialized(
true, resolveView->GetSubresourceRange());
}
switch (attachmentInfo.storeOp) {
case wgpu::StoreOp::Store:
view->GetTexture()->SetIsSubresourceContentInitialized(true, range);
break;
case wgpu::StoreOp::Discard:
view->GetTexture()->SetIsSubresourceContentInitialized(false, range);
break;
case wgpu::StoreOp::Undefined:
DAWN_UNREACHABLE();
break;
}
}
if (renderPass->attachmentState->HasDepthStencilAttachment()) {
auto& attachmentInfo = renderPass->depthStencilAttachment;
TextureViewBase* view = attachmentInfo.view.Get();
DAWN_ASSERT(view->GetLayerCount() == 1);
DAWN_ASSERT(view->GetLevelCount() == 1);
SubresourceRange range = view->GetSubresourceRange();
SubresourceRange depthRange = range;
depthRange.aspects = range.aspects & Aspect::Depth;
SubresourceRange stencilRange = range;
stencilRange.aspects = range.aspects & Aspect::Stencil;
// If the depth stencil texture has not been initialized, we want to use loadop
// clear to init the contents to 0's
if (!view->GetTexture()->IsSubresourceContentInitialized(depthRange) &&
attachmentInfo.depthLoadOp == wgpu::LoadOp::Load) {
attachmentInfo.clearDepth = 0.0f;
attachmentInfo.depthLoadOp = wgpu::LoadOp::Clear;
}
if (!view->GetTexture()->IsSubresourceContentInitialized(stencilRange) &&
attachmentInfo.stencilLoadOp == wgpu::LoadOp::Load) {
attachmentInfo.clearStencil = 0u;
attachmentInfo.stencilLoadOp = wgpu::LoadOp::Clear;
}
view->GetTexture()->SetIsSubresourceContentInitialized(
attachmentInfo.depthStoreOp == wgpu::StoreOp::Store, depthRange);
view->GetTexture()->SetIsSubresourceContentInitialized(
attachmentInfo.stencilStoreOp == wgpu::StoreOp::Store, stencilRange);
}
if (renderPass->attachmentState->HasPixelLocalStorage()) {
for (auto& attachmentInfo : renderPass->storageAttachments) {
TextureViewBase* view = attachmentInfo.storage.Get();
if (view == nullptr) {
continue;
}
DAWN_ASSERT(view->GetLayerCount() == 1);
DAWN_ASSERT(view->GetLevelCount() == 1);
const SubresourceRange& range = view->GetSubresourceRange();
// If the loadOp is Load, but the subresource is not initialized, use Clear instead.
if (attachmentInfo.loadOp == wgpu::LoadOp::Load &&
!view->GetTexture()->IsSubresourceContentInitialized(range)) {
attachmentInfo.loadOp = wgpu::LoadOp::Clear;
attachmentInfo.clearColor = {0.f, 0.f, 0.f, 0.f};
}
switch (attachmentInfo.storeOp) {
case wgpu::StoreOp::Store:
view->GetTexture()->SetIsSubresourceContentInitialized(true, range);
break;
case wgpu::StoreOp::Discard:
view->GetTexture()->SetIsSubresourceContentInitialized(false, range);
break;
case wgpu::StoreOp::Undefined:
DAWN_UNREACHABLE();
break;
}
}
}
}
bool IsFullBufferOverwrittenInTextureToBufferCopy(const CopyTextureToBufferCmd* copy) {
DAWN_ASSERT(copy != nullptr);
if (copy->destination.offset > 0) {
// The copy doesn't touch the start of the buffer.
return false;
}
const TextureBase* texture = copy->source.texture.Get();
const TexelBlockInfo& blockInfo = texture->GetFormat().GetAspectInfo(copy->source.aspect).block;
const uint64_t widthInBlocks = copy->copySize.width / blockInfo.width;
const uint64_t heightInBlocks = copy->copySize.height / blockInfo.height;
const bool multiSlice = copy->copySize.depthOrArrayLayers > 1;
const bool multiRow = multiSlice || heightInBlocks > 1;
if (multiSlice && copy->destination.rowsPerImage > heightInBlocks) {
// There are gaps between slices that aren't overwritten
return false;
}
const uint64_t copyTextureDataSizePerRow = widthInBlocks * blockInfo.byteSize;
if (multiRow && copy->destination.bytesPerRow > copyTextureDataSizePerRow) {
// There are gaps between rows that aren't overwritten
return false;
}
// After the above checks, we're sure the copy has no gaps.
// Now, compute the total number of bytes written.
const uint64_t writtenBytes =
ComputeRequiredBytesInCopy(blockInfo, copy->copySize, copy->destination.bytesPerRow,
copy->destination.rowsPerImage)
.AcquireSuccess();
if (!copy->destination.buffer->IsFullBufferRange(copy->destination.offset, writtenBytes)) {
// The written bytes don't cover the whole buffer.
return false;
}
return true;
}
std::array<float, 4> ConvertToFloatColor(dawn::native::Color color) {
const std::array<float, 4> outputValue = {
static_cast<float>(color.r), static_cast<float>(color.g), static_cast<float>(color.b),
static_cast<float>(color.a)};
return outputValue;
}
std::array<int32_t, 4> ConvertToSignedIntegerColor(dawn::native::Color color) {
const std::array<int32_t, 4> outputValue = {
static_cast<int32_t>(color.r), static_cast<int32_t>(color.g), static_cast<int32_t>(color.b),
static_cast<int32_t>(color.a)};
return outputValue;
}
std::array<uint32_t, 4> ConvertToUnsignedIntegerColor(dawn::native::Color color) {
const std::array<uint32_t, 4> outputValue = {
static_cast<uint32_t>(color.r), static_cast<uint32_t>(color.g),
static_cast<uint32_t>(color.b), static_cast<uint32_t>(color.a)};
return outputValue;
}
} // namespace dawn::native