| // Copyright 2017 The Dawn Authors |
| // |
| // 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. |
| |
| #include "dawn_native/SwapChain.h" |
| |
| #include "common/Constants.h" |
| #include "dawn_native/Adapter.h" |
| #include "dawn_native/Device.h" |
| #include "dawn_native/ObjectType_autogen.h" |
| #include "dawn_native/Surface.h" |
| #include "dawn_native/Texture.h" |
| #include "dawn_native/ValidationUtils_autogen.h" |
| |
| namespace dawn::native { |
| |
| namespace { |
| |
| class ErrorSwapChain final : public SwapChainBase { |
| public: |
| ErrorSwapChain(DeviceBase* device) : SwapChainBase(device, ObjectBase::kError) { |
| } |
| |
| private: |
| void APIConfigure(wgpu::TextureFormat format, |
| wgpu::TextureUsage allowedUsage, |
| uint32_t width, |
| uint32_t height) override { |
| GetDevice()->ConsumedError( |
| DAWN_FORMAT_VALIDATION_ERROR("%s is an error swapchain.", this)); |
| } |
| |
| TextureViewBase* APIGetCurrentTextureView() override { |
| GetDevice()->ConsumedError( |
| DAWN_FORMAT_VALIDATION_ERROR("%s is an error swapchain.", this)); |
| return TextureViewBase::MakeError(GetDevice()); |
| } |
| |
| void APIPresent() override { |
| GetDevice()->ConsumedError( |
| DAWN_FORMAT_VALIDATION_ERROR("%s is an error swapchain.", this)); |
| } |
| }; |
| |
| } // anonymous namespace |
| |
| MaybeError ValidateSwapChainDescriptor(const DeviceBase* device, |
| const Surface* surface, |
| const SwapChainDescriptor* descriptor) { |
| if (descriptor->implementation != 0) { |
| DAWN_INVALID_IF(surface != nullptr, |
| "Exactly one of surface or implementation must be set"); |
| |
| DawnSwapChainImplementation* impl = |
| reinterpret_cast<DawnSwapChainImplementation*>(descriptor->implementation); |
| |
| DAWN_INVALID_IF(!impl->Init || !impl->Destroy || !impl->Configure || |
| !impl->GetNextTexture || !impl->Present, |
| "Implementation is incomplete"); |
| |
| } else { |
| DAWN_INVALID_IF(surface == nullptr, |
| "At least one of surface or implementation must be set"); |
| |
| DAWN_TRY(ValidatePresentMode(descriptor->presentMode)); |
| |
| // TODO(crbug.com/dawn/160): Lift this restriction once |
| // wgpu::Instance::GetPreferredSurfaceFormat is implemented. |
| DAWN_INVALID_IF(descriptor->format != wgpu::TextureFormat::BGRA8Unorm, |
| "Format (%s) is not %s, which is (currently) the only accepted format.", |
| descriptor->format, wgpu::TextureFormat::BGRA8Unorm); |
| |
| DAWN_INVALID_IF(descriptor->usage != wgpu::TextureUsage::RenderAttachment, |
| "Usage (%s) is not %s, which is (currently) the only accepted usage.", |
| descriptor->usage, wgpu::TextureUsage::RenderAttachment); |
| |
| DAWN_INVALID_IF(descriptor->width == 0 || descriptor->height == 0, |
| "Swap Chain size (width: %u, height: %u) is empty.", descriptor->width, |
| descriptor->height); |
| |
| DAWN_INVALID_IF( |
| descriptor->width > device->GetLimits().v1.maxTextureDimension2D || |
| descriptor->height > device->GetLimits().v1.maxTextureDimension2D, |
| "Swap Chain size (width: %u, height: %u) is greater than the maximum 2D texture " |
| "size (width: %u, height: %u).", |
| descriptor->width, descriptor->height, device->GetLimits().v1.maxTextureDimension2D, |
| device->GetLimits().v1.maxTextureDimension2D); |
| } |
| |
| return {}; |
| } |
| |
| TextureDescriptor GetSwapChainBaseTextureDescriptor(NewSwapChainBase* swapChain) { |
| TextureDescriptor desc; |
| desc.usage = swapChain->GetUsage(); |
| desc.dimension = wgpu::TextureDimension::e2D; |
| desc.size = {swapChain->GetWidth(), swapChain->GetHeight(), 1}; |
| desc.format = swapChain->GetFormat(); |
| desc.mipLevelCount = 1; |
| desc.sampleCount = 1; |
| |
| return desc; |
| } |
| |
| // SwapChainBase |
| |
| SwapChainBase::SwapChainBase(DeviceBase* device) : ApiObjectBase(device, kLabelNotImplemented) { |
| TrackInDevice(); |
| } |
| |
| SwapChainBase::SwapChainBase(DeviceBase* device, ObjectBase::ErrorTag tag) |
| : ApiObjectBase(device, tag) { |
| } |
| |
| SwapChainBase::~SwapChainBase() { |
| } |
| |
| void SwapChainBase::DestroyImpl() { |
| } |
| |
| // static |
| SwapChainBase* SwapChainBase::MakeError(DeviceBase* device) { |
| return new ErrorSwapChain(device); |
| } |
| |
| ObjectType SwapChainBase::GetType() const { |
| return ObjectType::SwapChain; |
| } |
| |
| // OldSwapChainBase |
| |
| OldSwapChainBase::OldSwapChainBase(DeviceBase* device, const SwapChainDescriptor* descriptor) |
| : SwapChainBase(device), |
| mImplementation( |
| *reinterpret_cast<DawnSwapChainImplementation*>(descriptor->implementation)) { |
| } |
| |
| OldSwapChainBase::~OldSwapChainBase() { |
| if (!IsError()) { |
| const auto& im = GetImplementation(); |
| im.Destroy(im.userData); |
| } |
| } |
| |
| void OldSwapChainBase::APIConfigure(wgpu::TextureFormat format, |
| wgpu::TextureUsage allowedUsage, |
| uint32_t width, |
| uint32_t height) { |
| if (GetDevice()->ConsumedError(ValidateConfigure(format, allowedUsage, width, height))) { |
| return; |
| } |
| ASSERT(!IsError()); |
| |
| allowedUsage |= wgpu::TextureUsage::Present; |
| |
| mFormat = format; |
| mAllowedUsage = allowedUsage; |
| mWidth = width; |
| mHeight = height; |
| mImplementation.Configure(mImplementation.userData, static_cast<WGPUTextureFormat>(format), |
| static_cast<WGPUTextureUsage>(allowedUsage), width, height); |
| } |
| |
| TextureViewBase* OldSwapChainBase::APIGetCurrentTextureView() { |
| if (GetDevice()->ConsumedError(ValidateGetCurrentTextureView())) { |
| return TextureViewBase::MakeError(GetDevice()); |
| } |
| ASSERT(!IsError()); |
| |
| // Return the same current texture view until Present is called. |
| if (mCurrentTextureView != nullptr) { |
| // Calling GetCurrentTextureView always returns a new reference so add it even when |
| // reuse the existing texture view. |
| mCurrentTextureView->Reference(); |
| return mCurrentTextureView.Get(); |
| } |
| |
| // Create the backing texture and the view. |
| TextureDescriptor descriptor; |
| descriptor.dimension = wgpu::TextureDimension::e2D; |
| descriptor.size.width = mWidth; |
| descriptor.size.height = mHeight; |
| descriptor.size.depthOrArrayLayers = 1; |
| descriptor.sampleCount = 1; |
| descriptor.format = mFormat; |
| descriptor.mipLevelCount = 1; |
| descriptor.usage = mAllowedUsage; |
| |
| // Get the texture but remove the external refcount because it is never passed outside |
| // of dawn_native |
| mCurrentTexture = AcquireRef(GetNextTextureImpl(&descriptor)); |
| |
| mCurrentTextureView = mCurrentTexture->APICreateView(); |
| return mCurrentTextureView.Get(); |
| } |
| |
| void OldSwapChainBase::APIPresent() { |
| if (GetDevice()->ConsumedError(ValidatePresent())) { |
| return; |
| } |
| ASSERT(!IsError()); |
| |
| if (GetDevice()->ConsumedError(OnBeforePresent(mCurrentTextureView.Get()))) { |
| return; |
| } |
| |
| mImplementation.Present(mImplementation.userData); |
| |
| mCurrentTexture = nullptr; |
| mCurrentTextureView = nullptr; |
| } |
| |
| const DawnSwapChainImplementation& OldSwapChainBase::GetImplementation() { |
| ASSERT(!IsError()); |
| return mImplementation; |
| } |
| |
| MaybeError OldSwapChainBase::ValidateConfigure(wgpu::TextureFormat format, |
| wgpu::TextureUsage allowedUsage, |
| uint32_t width, |
| uint32_t height) const { |
| DAWN_TRY(GetDevice()->ValidateIsAlive()); |
| DAWN_TRY(GetDevice()->ValidateObject(this)); |
| |
| DAWN_TRY(ValidateTextureUsage(allowedUsage)); |
| DAWN_TRY(ValidateTextureFormat(format)); |
| |
| DAWN_INVALID_IF(width == 0 || height == 0, |
| "Configuration size (width: %u, height: %u) for %s is empty.", width, |
| height, this); |
| |
| return {}; |
| } |
| |
| MaybeError OldSwapChainBase::ValidateGetCurrentTextureView() const { |
| DAWN_TRY(GetDevice()->ValidateIsAlive()); |
| DAWN_TRY(GetDevice()->ValidateObject(this)); |
| |
| // If width is 0, it implies swap chain has never been configured |
| DAWN_INVALID_IF(mWidth == 0, "%s was not configured prior to calling GetNextTexture.", |
| this); |
| |
| return {}; |
| } |
| |
| MaybeError OldSwapChainBase::ValidatePresent() const { |
| DAWN_TRY(GetDevice()->ValidateIsAlive()); |
| DAWN_TRY(GetDevice()->ValidateObject(this)); |
| |
| DAWN_INVALID_IF( |
| mCurrentTextureView == nullptr, |
| "GetCurrentTextureView was not called on %s this frame prior to calling Present.", |
| this); |
| |
| return {}; |
| } |
| |
| // Implementation of NewSwapChainBase |
| |
| NewSwapChainBase::NewSwapChainBase(DeviceBase* device, |
| Surface* surface, |
| const SwapChainDescriptor* descriptor) |
| : SwapChainBase(device), |
| mAttached(false), |
| mWidth(descriptor->width), |
| mHeight(descriptor->height), |
| mFormat(descriptor->format), |
| mUsage(descriptor->usage), |
| mPresentMode(descriptor->presentMode), |
| mSurface(surface) { |
| } |
| |
| NewSwapChainBase::~NewSwapChainBase() { |
| if (mCurrentTextureView != nullptr) { |
| ASSERT(mCurrentTextureView->GetTexture()->GetTextureState() == |
| TextureBase::TextureState::Destroyed); |
| } |
| |
| ASSERT(!mAttached); |
| } |
| |
| void NewSwapChainBase::DetachFromSurface() { |
| if (mAttached) { |
| DetachFromSurfaceImpl(); |
| mSurface = nullptr; |
| mAttached = false; |
| } |
| } |
| |
| void NewSwapChainBase::SetIsAttached() { |
| mAttached = true; |
| } |
| |
| void NewSwapChainBase::APIConfigure(wgpu::TextureFormat format, |
| wgpu::TextureUsage allowedUsage, |
| uint32_t width, |
| uint32_t height) { |
| GetDevice()->ConsumedError( |
| DAWN_FORMAT_VALIDATION_ERROR("Configure is invalid for surface-based swapchains.")); |
| } |
| |
| TextureViewBase* NewSwapChainBase::APIGetCurrentTextureView() { |
| if (GetDevice()->ConsumedError(ValidateGetCurrentTextureView())) { |
| return TextureViewBase::MakeError(GetDevice()); |
| } |
| |
| if (mCurrentTextureView != nullptr) { |
| // Calling GetCurrentTextureView always returns a new reference so add it even when |
| // reusing the existing texture view. |
| mCurrentTextureView->Reference(); |
| return mCurrentTextureView.Get(); |
| } |
| |
| TextureViewBase* view = nullptr; |
| if (GetDevice()->ConsumedError(GetCurrentTextureViewImpl(), &view)) { |
| return TextureViewBase::MakeError(GetDevice()); |
| } |
| |
| // Check that the return texture view matches exactly what was given for this descriptor. |
| ASSERT(view->GetTexture()->GetFormat().format == mFormat); |
| ASSERT(IsSubset(mUsage, view->GetTexture()->GetUsage())); |
| ASSERT(view->GetLevelCount() == 1); |
| ASSERT(view->GetLayerCount() == 1); |
| ASSERT(view->GetDimension() == wgpu::TextureViewDimension::e2D); |
| ASSERT(view->GetTexture()->GetMipLevelVirtualSize(view->GetBaseMipLevel()).width == mWidth); |
| ASSERT(view->GetTexture()->GetMipLevelVirtualSize(view->GetBaseMipLevel()).height == |
| mHeight); |
| |
| mCurrentTextureView = view; |
| return view; |
| } |
| |
| void NewSwapChainBase::APIPresent() { |
| if (GetDevice()->ConsumedError(ValidatePresent())) { |
| return; |
| } |
| |
| if (GetDevice()->ConsumedError(PresentImpl())) { |
| return; |
| } |
| |
| ASSERT(mCurrentTextureView->GetTexture()->GetTextureState() == |
| TextureBase::TextureState::Destroyed); |
| mCurrentTextureView = nullptr; |
| } |
| |
| uint32_t NewSwapChainBase::GetWidth() const { |
| return mWidth; |
| } |
| |
| uint32_t NewSwapChainBase::GetHeight() const { |
| return mHeight; |
| } |
| |
| wgpu::TextureFormat NewSwapChainBase::GetFormat() const { |
| return mFormat; |
| } |
| |
| wgpu::TextureUsage NewSwapChainBase::GetUsage() const { |
| return mUsage; |
| } |
| |
| wgpu::PresentMode NewSwapChainBase::GetPresentMode() const { |
| return mPresentMode; |
| } |
| |
| Surface* NewSwapChainBase::GetSurface() const { |
| return mSurface; |
| } |
| |
| bool NewSwapChainBase::IsAttached() const { |
| return mAttached; |
| } |
| |
| wgpu::BackendType NewSwapChainBase::GetBackendType() const { |
| return GetDevice()->GetAdapter()->GetBackendType(); |
| } |
| |
| MaybeError NewSwapChainBase::ValidatePresent() const { |
| DAWN_TRY(GetDevice()->ValidateIsAlive()); |
| DAWN_TRY(GetDevice()->ValidateObject(this)); |
| |
| DAWN_INVALID_IF(!mAttached, "Cannot call Present called on detached %s.", this); |
| |
| DAWN_INVALID_IF( |
| mCurrentTextureView == nullptr, |
| "GetCurrentTextureView was not called on %s this frame prior to calling Present.", |
| this); |
| |
| return {}; |
| } |
| |
| MaybeError NewSwapChainBase::ValidateGetCurrentTextureView() const { |
| DAWN_TRY(GetDevice()->ValidateIsAlive()); |
| DAWN_TRY(GetDevice()->ValidateObject(this)); |
| |
| DAWN_INVALID_IF(!mAttached, "Cannot call GetCurrentTextureView on detached %s.", this); |
| |
| return {}; |
| } |
| |
| } // namespace dawn::native |
