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/Format.cpp

294 lines
14 KiB
C++
Raw Normal View History

Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
// Copyright 2019 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/Format.h"
Rephrase Format::aspect enum as an enum class mask Format::aspect should be a mask so that it is easier to iterate over and test if an aspect is present. This CL also re-exports wgpu's EnumClassBitMask helpers in dawn_native. It also adds an EnumMaskIterator which wraps BitSetIterator to allow iterating over the enums in an enum mask. Bug: dawn:439 Change-Id: I08180a45b27c6031e2f80b0fa1801716677fd813 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24682 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-07-30 15:25:37 +00:00
Support BC formats as the first extension in Dawn This patch refactors the current implementation of BC formats to treat it as the first extension in Dawn and adds all the related tests. Note that in Dawn all the extensions are disabled unless we enable them when we create the device, which means the BC formats can only be used when we enable the related extension on the creation of the device, and the creation of the device will fail if the adapter does not support the extension BUG=dawn:42 TEST=dawn_end2end_tests TEST=dawn_unittests Change-Id: I04d818b0218ebb3b1b7a70a4fea71779f308f85f Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9520 Commit-Queue: Jiawei Shao <jiawei.shao@intel.com> Reviewed-by: Austin Eng <enga@chromium.org>
2019-08-02 00:06:38 +00:00
#include "dawn_native/Device.h"
#include "dawn_native/Extensions.h"
Rephrase Format::aspect enum as an enum class mask Format::aspect should be a mask so that it is easier to iterate over and test if an aspect is present. This CL also re-exports wgpu's EnumClassBitMask helpers in dawn_native. It also adds an EnumMaskIterator which wraps BitSetIterator to allow iterating over the enums in an enum mask. Bug: dawn:439 Change-Id: I08180a45b27c6031e2f80b0fa1801716677fd813 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24682 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-07-30 15:25:37 +00:00
#include "dawn_native/Texture.h"
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
#include <bitset>
namespace dawn_native {
Format: Move the TexelBlockInfo inside an AspectInfo. In follow up CLs additional will be added to the AspectInfo, like the supported component types. Also simplify the logic for GetTexelInfo since all aspects are the first aspects, except stencil which is always stencil8. Bug: dawn:517 Change-Id: Iebbcb8a7f8fa2c4b7b06f65d6e4e8917c0a85366 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30100 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org>
2020-10-15 09:05:03 +00:00
namespace {
Format: Move the baseType to be per-aspect. This also introduces a per-aspect supportedComponentTypes that exactly mirrors baseType for now but will contain additional bits in the future (like DepthComparison for depth textures). It is also a step towards being able to create single-aspect view of depth-stencil textures to sample either the depth or the stencil component. Bug: dawn:527 Change-Id: I3ab224d07c136c682cc2993b9a8599237d318130 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30103 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2020-10-16 14:07:06 +00:00
static const AspectInfo kStencil8AspectInfo = {{1, 1, 1},
wgpu::TextureComponentType::Uint,
ComponentTypeBit::Uint};
Format: Move the TexelBlockInfo inside an AspectInfo. In follow up CLs additional will be added to the AspectInfo, like the supported component types. Also simplify the logic for GetTexelInfo since all aspects are the first aspects, except stencil which is always stencil8. Bug: dawn:517 Change-Id: Iebbcb8a7f8fa2c4b7b06f65d6e4e8917c0a85366 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30100 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org>
2020-10-15 09:05:03 +00:00
}
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
// Format
Update BindingInfo to reflect new BindGroupLayoutEntry structure Changes the internal BindingInfo structure and any references to it. The BindGroupLayoutEntry information is normalized when converting it into the internal representation, but still accepted as either the old or new layout. A "bindingType" member is added to the BindingInfo that's not present in the BindGroupLayoutEntry itself to indicate which of buffer, sampler, texture, or storageTexture is populated. This proves useful for a myriad of switch statements in the various backends. Bug: dawn:527 Change-Id: I6ae65adae61d0005fc50ed6d1bc2ec9b2a1295ad Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/35862 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Auto-Submit: Brandon Jones <bajones@chromium.org>
2020-12-21 20:14:26 +00:00
// TODO(dawn:527): Remove when unused.
Format: Move the baseType to be per-aspect. This also introduces a per-aspect supportedComponentTypes that exactly mirrors baseType for now but will contain additional bits in the future (like DepthComparison for depth textures). It is also a step towards being able to create single-aspect view of depth-stencil textures to sample either the depth or the stencil component. Bug: dawn:527 Change-Id: I3ab224d07c136c682cc2993b9a8599237d318130 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30103 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2020-10-16 14:07:06 +00:00
ComponentTypeBit ToComponentTypeBit(wgpu::TextureComponentType type) {
switch (type) {
Implement getBindGroupLayout This patch makes the |layout| member of the Render|ComputePipelineDescriptor optional. If it is not provided, a default layout is created from the ShaderModules provided and used to replace the layout in the descriptor. Then, pipeline.GetBindGroupLayout may be called to get the existing, or the computed bind group layout. If no bind group layout exists at the provided index, an empty bind group layout is returned. Bug: dawn:276 Change-Id: I276ed0296a2f1f2d8131fa906a4aefe85d75b3a7 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/13741 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com>
2019-11-22 17:02:22 +00:00
case wgpu::TextureComponentType::Float:
case wgpu::TextureComponentType::Sint:
case wgpu::TextureComponentType::Uint:
Add wgpu::TextureComponentType::DepthComparison And deprecate using ::Float in the bind group layout for "shadow textures" in the pipeline (along with a deprecation test). Adds the ability to be used with DepthComparison only to depth textures, this could potentially a breaking change if users where doing depth-comparison on float32 textures but that's not supported in WebGPU. Bug: dawn:527 Change-Id: Ib28b0443e3002e0aa2811713b9e843c2417e13e7 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30240 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org>
2020-10-16 14:13:16 +00:00
case wgpu::TextureComponentType::DepthComparison:
Format: Move the baseType to be per-aspect. This also introduces a per-aspect supportedComponentTypes that exactly mirrors baseType for now but will contain additional bits in the future (like DepthComparison for depth textures). It is also a step towards being able to create single-aspect view of depth-stencil textures to sample either the depth or the stencil component. Bug: dawn:527 Change-Id: I3ab224d07c136c682cc2993b9a8599237d318130 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30103 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2020-10-16 14:07:06 +00:00
// When the compiler complains that you need to add a case statement here, please
// also add a corresponding static assert below!
Implement getBindGroupLayout This patch makes the |layout| member of the Render|ComputePipelineDescriptor optional. If it is not provided, a default layout is created from the ShaderModules provided and used to replace the layout in the descriptor. Then, pipeline.GetBindGroupLayout may be called to get the existing, or the computed bind group layout. If no bind group layout exists at the provided index, an empty bind group layout is returned. Bug: dawn:276 Change-Id: I276ed0296a2f1f2d8131fa906a4aefe85d75b3a7 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/13741 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com>
2019-11-22 17:02:22 +00:00
break;
}
Validate texture component type in BGL against its shader module declaration We have already been validating the component type of a texture matches the bind group layout. Here is another constraint introduced by https://github.com/gpuweb/gpuweb/pull/384. For better code reuse, conversion from wgpu::TextureComponentType to dawn_native::Format::Type is factored out as a helper function. Bug: dawn:202 Change-Id: I394497722b4043dc109eca60116224b7a617e02e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12860 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2019-10-31 09:51:11 +00:00
Format: Move the baseType to be per-aspect. This also introduces a per-aspect supportedComponentTypes that exactly mirrors baseType for now but will contain additional bits in the future (like DepthComparison for depth textures). It is also a step towards being able to create single-aspect view of depth-stencil textures to sample either the depth or the stencil component. Bug: dawn:527 Change-Id: I3ab224d07c136c682cc2993b9a8599237d318130 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30103 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2020-10-16 14:07:06 +00:00
// Check that ComponentTypeBit bits are in the same position / order as the respective
// wgpu::TextureComponentType value.
static_assert(ComponentTypeBit::Float ==
static_cast<ComponentTypeBit>(
1 << static_cast<uint32_t>(wgpu::TextureComponentType::Float)),
"");
static_assert(ComponentTypeBit::Uint ==
static_cast<ComponentTypeBit>(
1 << static_cast<uint32_t>(wgpu::TextureComponentType::Uint)),
"");
static_assert(ComponentTypeBit::Sint ==
static_cast<ComponentTypeBit>(
1 << static_cast<uint32_t>(wgpu::TextureComponentType::Sint)),
"");
Add wgpu::TextureComponentType::DepthComparison And deprecate using ::Float in the bind group layout for "shadow textures" in the pipeline (along with a deprecation test). Adds the ability to be used with DepthComparison only to depth textures, this could potentially a breaking change if users where doing depth-comparison on float32 textures but that's not supported in WebGPU. Bug: dawn:527 Change-Id: Ib28b0443e3002e0aa2811713b9e843c2417e13e7 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30240 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org>
2020-10-16 14:13:16 +00:00
static_assert(
ComponentTypeBit::DepthComparison ==
static_cast<ComponentTypeBit>(
1 << static_cast<uint32_t>(wgpu::TextureComponentType::DepthComparison)),
"");
Format: Move the baseType to be per-aspect. This also introduces a per-aspect supportedComponentTypes that exactly mirrors baseType for now but will contain additional bits in the future (like DepthComparison for depth textures). It is also a step towards being able to create single-aspect view of depth-stencil textures to sample either the depth or the stencil component. Bug: dawn:527 Change-Id: I3ab224d07c136c682cc2993b9a8599237d318130 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30103 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2020-10-16 14:07:06 +00:00
return static_cast<ComponentTypeBit>(1 << static_cast<uint32_t>(type));
Implement getBindGroupLayout This patch makes the |layout| member of the Render|ComputePipelineDescriptor optional. If it is not provided, a default layout is created from the ShaderModules provided and used to replace the layout in the descriptor. Then, pipeline.GetBindGroupLayout may be called to get the existing, or the computed bind group layout. If no bind group layout exists at the provided index, an empty bind group layout is returned. Bug: dawn:276 Change-Id: I276ed0296a2f1f2d8131fa906a4aefe85d75b3a7 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/13741 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com>
2019-11-22 17:02:22 +00:00
}
Update BindingInfo to reflect new BindGroupLayoutEntry structure Changes the internal BindingInfo structure and any references to it. The BindGroupLayoutEntry information is normalized when converting it into the internal representation, but still accepted as either the old or new layout. A "bindingType" member is added to the BindingInfo that's not present in the BindGroupLayoutEntry itself to indicate which of buffer, sampler, texture, or storageTexture is populated. This proves useful for a myriad of switch statements in the various backends. Bug: dawn:527 Change-Id: I6ae65adae61d0005fc50ed6d1bc2ec9b2a1295ad Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/35862 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Auto-Submit: Brandon Jones <bajones@chromium.org>
2020-12-21 20:14:26 +00:00
ComponentTypeBit SampleTypeToComponentTypeBit(wgpu::TextureSampleType sampleType) {
switch (sampleType) {
case wgpu::TextureSampleType::Float:
case wgpu::TextureSampleType::UnfilterableFloat:
return ComponentTypeBit::Float;
case wgpu::TextureSampleType::Sint:
return ComponentTypeBit::Sint;
case wgpu::TextureSampleType::Uint:
return ComponentTypeBit::Uint;
case wgpu::TextureSampleType::Depth:
return ComponentTypeBit::DepthComparison;
case wgpu::TextureSampleType::Undefined:
UNREACHABLE();
}
// TODO(dawn:527): Ideally we can get this path to use that static_cast method as well.
}
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
bool Format::IsColor() const {
Rephrase Format::aspect enum as an enum class mask Format::aspect should be a mask so that it is easier to iterate over and test if an aspect is present. This CL also re-exports wgpu's EnumClassBitMask helpers in dawn_native. It also adds an EnumMaskIterator which wraps BitSetIterator to allow iterating over the enums in an enum mask. Bug: dawn:439 Change-Id: I08180a45b27c6031e2f80b0fa1801716677fd813 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24682 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-07-30 15:25:37 +00:00
return aspects == Aspect::Color;
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
}
bool Format::HasDepth() const {
Rephrase Format::aspect enum as an enum class mask Format::aspect should be a mask so that it is easier to iterate over and test if an aspect is present. This CL also re-exports wgpu's EnumClassBitMask helpers in dawn_native. It also adds an EnumMaskIterator which wraps BitSetIterator to allow iterating over the enums in an enum mask. Bug: dawn:439 Change-Id: I08180a45b27c6031e2f80b0fa1801716677fd813 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24682 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-07-30 15:25:37 +00:00
return (aspects & Aspect::Depth) != 0;
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
}
bool Format::HasStencil() const {
Rephrase Format::aspect enum as an enum class mask Format::aspect should be a mask so that it is easier to iterate over and test if an aspect is present. This CL also re-exports wgpu's EnumClassBitMask helpers in dawn_native. It also adds an EnumMaskIterator which wraps BitSetIterator to allow iterating over the enums in an enum mask. Bug: dawn:439 Change-Id: I08180a45b27c6031e2f80b0fa1801716677fd813 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24682 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-07-30 15:25:37 +00:00
return (aspects & Aspect::Stencil) != 0;
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
}
bool Format::HasDepthOrStencil() const {
Rephrase Format::aspect enum as an enum class mask Format::aspect should be a mask so that it is easier to iterate over and test if an aspect is present. This CL also re-exports wgpu's EnumClassBitMask helpers in dawn_native. It also adds an EnumMaskIterator which wraps BitSetIterator to allow iterating over the enums in an enum mask. Bug: dawn:439 Change-Id: I08180a45b27c6031e2f80b0fa1801716677fd813 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24682 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-07-30 15:25:37 +00:00
return (aspects & (Aspect::Depth | Aspect::Stencil)) != 0;
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
}
Format: Move the TexelBlockInfo inside an AspectInfo. In follow up CLs additional will be added to the AspectInfo, like the supported component types. Also simplify the logic for GetTexelInfo since all aspects are the first aspects, except stencil which is always stencil8. Bug: dawn:517 Change-Id: Iebbcb8a7f8fa2c4b7b06f65d6e4e8917c0a85366 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30100 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org>
2020-10-15 09:05:03 +00:00
const AspectInfo& Format::GetAspectInfo(wgpu::TextureAspect aspect) const {
return GetAspectInfo(ConvertAspect(*this, aspect));
Add texture aspect to texture copy view and validation tests Bug: dawn:439 Change-Id: I0ca283f58fe2b63ac3a8c468f8ea1bb2d300856f Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24683 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Reviewed-by: Corentin Wallez <cwallez@chromium.org>
2020-07-30 15:29:57 +00:00
}
Format: Move the TexelBlockInfo inside an AspectInfo. In follow up CLs additional will be added to the AspectInfo, like the supported component types. Also simplify the logic for GetTexelInfo since all aspects are the first aspects, except stencil which is always stencil8. Bug: dawn:517 Change-Id: Iebbcb8a7f8fa2c4b7b06f65d6e4e8917c0a85366 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30100 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org>
2020-10-15 09:05:03 +00:00
const AspectInfo& Format::GetAspectInfo(Aspect aspect) const {
Track depth/stencil aspects independently This enables depth-stencil textures to track per aspect state independently. It lifts the restriction that depth and stencil store ops must be the same as they now have independent clear states. It will also enable correct barriers on Vulkan and D3D12. Bug: dawn:439 Change-Id: I8a73187df57a1d7eee6790cb4395bdecf42b63aa Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/26127 Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-08-06 17:00:29 +00:00
ASSERT(HasOneBit(aspect));
ASSERT(aspects & aspect);
Standardize the use of UNREACHABLE in switches. A lot of our switches over enum values use the following pattern: default: UNREACHABLE(); return foo; This is problematic because when adding a new value to one of the WebGPU enums, there is no compilation error for switches that are missing it. Currently we're supposed to write code and tests and fix UNREACHABLEs when we see them. Instead we should strive to have most switches on enums to be complete and explicitily tag unreachable values as UNREACHABLE. Some switches might still want to use default: UNREACHABLE() if only a couple values need to be handled out of very many. In this CL we go through all the UNRAECHABLEs and change them if need be. Also an ErrorQueue class is added to avoid having QueueBase::SubmitImpl just be UNREACHABLE (and force overriding instead). Bug: dawn:527 Change-Id: I33dfb4703104912cc5f001f9faf907a61324de68 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/28501 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com>
2020-09-24 14:56:50 +00:00
Fix a small typo in Format.cpp alwaus -> always Bug: dawn:527 Change-Id: I8008dce9bfdfc3dc2782ce70d53eecec011d2316 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30241 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org>
2020-10-15 16:42:03 +00:00
// The stencil aspect is the only aspect that's not the first aspect. Since it is always the
Format: Move the TexelBlockInfo inside an AspectInfo. In follow up CLs additional will be added to the AspectInfo, like the supported component types. Also simplify the logic for GetTexelInfo since all aspects are the first aspects, except stencil which is always stencil8. Bug: dawn:517 Change-Id: Iebbcb8a7f8fa2c4b7b06f65d6e4e8917c0a85366 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30100 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org>
2020-10-15 09:05:03 +00:00
// same aspect information, special case it to return a constant AspectInfo.
if (aspect == Aspect::Stencil) {
return kStencil8AspectInfo;
} else {
return firstAspect;
Track depth/stencil aspects independently This enables depth-stencil textures to track per aspect state independently. It lifts the restriction that depth and stencil store ops must be the same as they now have independent clear states. It will also enable correct barriers on Vulkan and D3D12. Bug: dawn:439 Change-Id: I8a73187df57a1d7eee6790cb4395bdecf42b63aa Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/26127 Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-08-06 17:00:29 +00:00
}
}
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
size_t Format::GetIndex() const {
return ComputeFormatIndex(format);
}
// Implementation details of the format table of the DeviceBase
// For the enum for formats are packed but this might change when we have a broader extension
Make TextureFormat/ViewDimension::None Undefined and value 0. This matches the conclusion the changes in the webgpu-header pull request where we discussed these values: https://github.com/webgpu-native/webgpu-headers/pull/5 BUG=dawn:22 Bug=dawn:214 Change-Id: I7e9168c2b5e09dcb4c1882725a5cc0580a73d853 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/10860 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-09-05 09:12:32 +00:00
// mechanism for webgpu.h. Formats start at 1 because 0 is the undefined format.
Make dawn_native use the webgpu.h header BUG=dawn:22 Change-Id: I66e2d998f5e09030e40ec88813cd65c492018fd0 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12541 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2019-10-23 11:57:41 +00:00
size_t ComputeFormatIndex(wgpu::TextureFormat format) {
Make TextureFormat/ViewDimension::None Undefined and value 0. This matches the conclusion the changes in the webgpu-header pull request where we discussed these values: https://github.com/webgpu-native/webgpu-headers/pull/5 BUG=dawn:22 Bug=dawn:214 Change-Id: I7e9168c2b5e09dcb4c1882725a5cc0580a73d853 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/10860 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-09-05 09:12:32 +00:00
// This takes advantage of overflows to make the index of TextureFormat::Undefined outside
// of the range of the FormatTable.
Make dawn_native use the webgpu.h header BUG=dawn:22 Change-Id: I66e2d998f5e09030e40ec88813cd65c492018fd0 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12541 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2019-10-23 11:57:41 +00:00
static_assert(static_cast<uint32_t>(wgpu::TextureFormat::Undefined) - 1 > kKnownFormatCount,
Make TextureFormat/ViewDimension::None Undefined and value 0. This matches the conclusion the changes in the webgpu-header pull request where we discussed these values: https://github.com/webgpu-native/webgpu-headers/pull/5 BUG=dawn:22 Bug=dawn:214 Change-Id: I7e9168c2b5e09dcb4c1882725a5cc0580a73d853 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/10860 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-09-05 09:12:32 +00:00
"");
return static_cast<size_t>(static_cast<uint32_t>(format) - 1);
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
}
Support BC formats as the first extension in Dawn This patch refactors the current implementation of BC formats to treat it as the first extension in Dawn and adds all the related tests. Note that in Dawn all the extensions are disabled unless we enable them when we create the device, which means the BC formats can only be used when we enable the related extension on the creation of the device, and the creation of the device will fail if the adapter does not support the extension BUG=dawn:42 TEST=dawn_end2end_tests TEST=dawn_unittests Change-Id: I04d818b0218ebb3b1b7a70a4fea71779f308f85f Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9520 Commit-Queue: Jiawei Shao <jiawei.shao@intel.com> Reviewed-by: Austin Eng <enga@chromium.org>
2019-08-02 00:06:38 +00:00
FormatTable BuildFormatTable(const DeviceBase* device) {
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
FormatTable table;
std::bitset<kKnownFormatCount> formatsSet;
Format: Move the baseType to be per-aspect. This also introduces a per-aspect supportedComponentTypes that exactly mirrors baseType for now but will contain additional bits in the future (like DepthComparison for depth textures). It is also a step towards being able to create single-aspect view of depth-stencil textures to sample either the depth or the stencil component. Bug: dawn:527 Change-Id: I3ab224d07c136c682cc2993b9a8599237d318130 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30103 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2020-10-16 14:07:06 +00:00
using Type = wgpu::TextureComponentType;
Add BGLBinding::textureComponentType This is a new compatibility constraint that the texture component type must match between what's declared in the shader and the bind group. - Format is updated to include the component type of the format. - Validation and state tracking is updated to reflect the new BGLBinding member. - TextureFormat tests are updated to pass with the added validation and to remove a redundant enum definition. - BGLBinding::multisampled validation is added because it was next to modified code for the BGLBinding::textureComponentType validation. - A redundant BGL caching test was removed. BUG=dawn:128 Change-Id: I9c4ae92062769c3ecf74caf46f27415344dfad77 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/10281 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-08-21 12:16:33 +00:00
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
auto AddFormat = [&table, &formatsSet](Format format) {
size_t index = ComputeFormatIndex(format.format);
ASSERT(index < table.size());
// This checks that each format is set at most once, the first part of checking that all
// formats are set exactly once.
ASSERT(!formatsSet[index]);
Add WGPU_STRIDE_UNDEFINED and update bytesPerRow/rowsPerImage validation This makes a nearly one-to-one mapping between the JS and C APIs, which benefits projects like Blink and Emscripten. - JavaScript's `undefined` is equivalent to C `WGPU_STRIDE_UNDEFINED`. - JavaScript's `0` is equivalent to C `0`. - To implement the API correctly, Blink must special-case an actual value coming in from JS that is equal to WGPU_STRIDE_UNDEFINED (0xFFFF'FFFF), and inject an error. Keeps but deprecates a reasonable approximation of the old behavior. Bug: dawn:520 Change-Id: Ie9c992ffab82830090d0dfc3120731e89cd9691c Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/31140 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org>
2020-11-06 13:41:50 +00:00
// Vulkan describes bytesPerRow in units of texels. If there's any format for which this
// ASSERT isn't true, then additional validation on bytesPerRow must be added.
ASSERT((kTextureBytesPerRowAlignment % format.firstAspect.block.byteSize) == 0);
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
table[index] = format;
formatsSet.set(index);
};
Make dawn_native use the webgpu.h header BUG=dawn:22 Change-Id: I66e2d998f5e09030e40ec88813cd65c492018fd0 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12541 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2019-10-23 11:57:41 +00:00
auto AddColorFormat = [&AddFormat](wgpu::TextureFormat format, bool renderable,
Add checks to TextureUsage::Storage This patch adds validations to the texture usage "Storage" when creating a texture. 1. "Storage" usage cannot be used when SampleCount > 1 2. "Storage" usage can only be used with some texture formats. The list of the formats can be found through the following link: https://github.com/gpuweb/gpuweb/issues/513 BUG=dawn:267 TEST=dawn_unittests Change-Id: Ifc7296d966ac0c600433948a63c3dd6a436c8d8b Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15040 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
2020-01-15 00:09:42 +00:00
bool supportsStorageUsage, uint32_t byteSize,
Type type) {
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
Format internalFormat;
internalFormat.format = format;
internalFormat.isRenderable = renderable;
internalFormat.isCompressed = false;
internalFormat.isSupported = true;
Add checks to TextureUsage::Storage This patch adds validations to the texture usage "Storage" when creating a texture. 1. "Storage" usage cannot be used when SampleCount > 1 2. "Storage" usage can only be used with some texture formats. The list of the formats can be found through the following link: https://github.com/gpuweb/gpuweb/issues/513 BUG=dawn:267 TEST=dawn_unittests Change-Id: Ifc7296d966ac0c600433948a63c3dd6a436c8d8b Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15040 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
2020-01-15 00:09:42 +00:00
internalFormat.supportsStorageUsage = supportsStorageUsage;
Rephrase Format::aspect enum as an enum class mask Format::aspect should be a mask so that it is easier to iterate over and test if an aspect is present. This CL also re-exports wgpu's EnumClassBitMask helpers in dawn_native. It also adds an EnumMaskIterator which wraps BitSetIterator to allow iterating over the enums in an enum mask. Bug: dawn:439 Change-Id: I08180a45b27c6031e2f80b0fa1801716677fd813 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24682 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-07-30 15:25:37 +00:00
internalFormat.aspects = Aspect::Color;
Format: Move the TexelBlockInfo inside an AspectInfo. In follow up CLs additional will be added to the AspectInfo, like the supported component types. Also simplify the logic for GetTexelInfo since all aspects are the first aspects, except stencil which is always stencil8. Bug: dawn:517 Change-Id: Iebbcb8a7f8fa2c4b7b06f65d6e4e8917c0a85366 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30100 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org>
2020-10-15 09:05:03 +00:00
internalFormat.firstAspect.block.byteSize = byteSize;
internalFormat.firstAspect.block.width = 1;
internalFormat.firstAspect.block.height = 1;
Format: Move the baseType to be per-aspect. This also introduces a per-aspect supportedComponentTypes that exactly mirrors baseType for now but will contain additional bits in the future (like DepthComparison for depth textures). It is also a step towards being able to create single-aspect view of depth-stencil textures to sample either the depth or the stencil component. Bug: dawn:527 Change-Id: I3ab224d07c136c682cc2993b9a8599237d318130 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30103 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2020-10-16 14:07:06 +00:00
internalFormat.firstAspect.baseType = type;
internalFormat.firstAspect.supportedComponentTypes = ToComponentTypeBit(type);
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
AddFormat(internalFormat);
};
Rephrase Format::aspect enum as an enum class mask Format::aspect should be a mask so that it is easier to iterate over and test if an aspect is present. This CL also re-exports wgpu's EnumClassBitMask helpers in dawn_native. It also adds an EnumMaskIterator which wraps BitSetIterator to allow iterating over the enums in an enum mask. Bug: dawn:439 Change-Id: I08180a45b27c6031e2f80b0fa1801716677fd813 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24682 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-07-30 15:25:37 +00:00
auto AddDepthStencilFormat = [&AddFormat](wgpu::TextureFormat format, Aspect aspects,
Support sampling depth and stencil of combined d/s formats This CL adds sampling of depth-only and stencil-only texture views on all backends. However, Metal on macOS <= 10.11 will need a workaround to use separate depth/stencil textures for each aspect since it is impossible to sample the stencil aspect of a combined depth/stencil texture. Also fixes sampling of depth24plus on D3D12 which had an incomplete check for determining if a TYPELESS format is necessary. Bug: dawn:439, dawn:553 Change-Id: Id4991c565f822add200054296714e2dcd330119a Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30725 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org>
2020-11-04 15:27:11 +00:00
uint32_t byteSize) {
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
Format internalFormat;
internalFormat.format = format;
internalFormat.isRenderable = true;
internalFormat.isCompressed = false;
internalFormat.isSupported = true;
Add checks to TextureUsage::Storage This patch adds validations to the texture usage "Storage" when creating a texture. 1. "Storage" usage cannot be used when SampleCount > 1 2. "Storage" usage can only be used with some texture formats. The list of the formats can be found through the following link: https://github.com/gpuweb/gpuweb/issues/513 BUG=dawn:267 TEST=dawn_unittests Change-Id: Ifc7296d966ac0c600433948a63c3dd6a436c8d8b Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15040 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
2020-01-15 00:09:42 +00:00
internalFormat.supportsStorageUsage = false;
Rephrase Format::aspect enum as an enum class mask Format::aspect should be a mask so that it is easier to iterate over and test if an aspect is present. This CL also re-exports wgpu's EnumClassBitMask helpers in dawn_native. It also adds an EnumMaskIterator which wraps BitSetIterator to allow iterating over the enums in an enum mask. Bug: dawn:439 Change-Id: I08180a45b27c6031e2f80b0fa1801716677fd813 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24682 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-07-30 15:25:37 +00:00
internalFormat.aspects = aspects;
Format: Move the TexelBlockInfo inside an AspectInfo. In follow up CLs additional will be added to the AspectInfo, like the supported component types. Also simplify the logic for GetTexelInfo since all aspects are the first aspects, except stencil which is always stencil8. Bug: dawn:517 Change-Id: Iebbcb8a7f8fa2c4b7b06f65d6e4e8917c0a85366 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30100 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org>
2020-10-15 09:05:03 +00:00
internalFormat.firstAspect.block.byteSize = byteSize;
internalFormat.firstAspect.block.width = 1;
internalFormat.firstAspect.block.height = 1;
Format: Move the baseType to be per-aspect. This also introduces a per-aspect supportedComponentTypes that exactly mirrors baseType for now but will contain additional bits in the future (like DepthComparison for depth textures). It is also a step towards being able to create single-aspect view of depth-stencil textures to sample either the depth or the stencil component. Bug: dawn:527 Change-Id: I3ab224d07c136c682cc2993b9a8599237d318130 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30103 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2020-10-16 14:07:06 +00:00
internalFormat.firstAspect.baseType = wgpu::TextureComponentType::Float;
Support sampling depth and stencil of combined d/s formats This CL adds sampling of depth-only and stencil-only texture views on all backends. However, Metal on macOS <= 10.11 will need a workaround to use separate depth/stencil textures for each aspect since it is impossible to sample the stencil aspect of a combined depth/stencil texture. Also fixes sampling of depth24plus on D3D12 which had an incomplete check for determining if a TYPELESS format is necessary. Bug: dawn:439, dawn:553 Change-Id: Id4991c565f822add200054296714e2dcd330119a Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30725 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org>
2020-11-04 15:27:11 +00:00
internalFormat.firstAspect.supportedComponentTypes =
ComponentTypeBit::Float | ComponentTypeBit::DepthComparison;
Add depth texture sampling and tests for only depth32float This is currently the only depth format that can be sampled. Bug: dawn:367 Change-Id: Ie35c3f7eeee03661838e301453f387ae99e671d9 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/19702 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2020-04-22 19:54:00 +00:00
AddFormat(internalFormat);
};
Make dawn_native use the webgpu.h header BUG=dawn:22 Change-Id: I66e2d998f5e09030e40ec88813cd65c492018fd0 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12541 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2019-10-23 11:57:41 +00:00
auto AddCompressedFormat = [&AddFormat](wgpu::TextureFormat format, uint32_t byteSize,
Support BC formats as the first extension in Dawn This patch refactors the current implementation of BC formats to treat it as the first extension in Dawn and adds all the related tests. Note that in Dawn all the extensions are disabled unless we enable them when we create the device, which means the BC formats can only be used when we enable the related extension on the creation of the device, and the creation of the device will fail if the adapter does not support the extension BUG=dawn:42 TEST=dawn_end2end_tests TEST=dawn_unittests Change-Id: I04d818b0218ebb3b1b7a70a4fea71779f308f85f Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9520 Commit-Queue: Jiawei Shao <jiawei.shao@intel.com> Reviewed-by: Austin Eng <enga@chromium.org>
2019-08-02 00:06:38 +00:00
uint32_t width, uint32_t height, bool isSupported) {
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
Format internalFormat;
internalFormat.format = format;
internalFormat.isRenderable = false;
internalFormat.isCompressed = true;
Support BC formats as the first extension in Dawn This patch refactors the current implementation of BC formats to treat it as the first extension in Dawn and adds all the related tests. Note that in Dawn all the extensions are disabled unless we enable them when we create the device, which means the BC formats can only be used when we enable the related extension on the creation of the device, and the creation of the device will fail if the adapter does not support the extension BUG=dawn:42 TEST=dawn_end2end_tests TEST=dawn_unittests Change-Id: I04d818b0218ebb3b1b7a70a4fea71779f308f85f Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9520 Commit-Queue: Jiawei Shao <jiawei.shao@intel.com> Reviewed-by: Austin Eng <enga@chromium.org>
2019-08-02 00:06:38 +00:00
internalFormat.isSupported = isSupported;
Add checks to TextureUsage::Storage This patch adds validations to the texture usage "Storage" when creating a texture. 1. "Storage" usage cannot be used when SampleCount > 1 2. "Storage" usage can only be used with some texture formats. The list of the formats can be found through the following link: https://github.com/gpuweb/gpuweb/issues/513 BUG=dawn:267 TEST=dawn_unittests Change-Id: Ifc7296d966ac0c600433948a63c3dd6a436c8d8b Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15040 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
2020-01-15 00:09:42 +00:00
internalFormat.supportsStorageUsage = false;
Rephrase Format::aspect enum as an enum class mask Format::aspect should be a mask so that it is easier to iterate over and test if an aspect is present. This CL also re-exports wgpu's EnumClassBitMask helpers in dawn_native. It also adds an EnumMaskIterator which wraps BitSetIterator to allow iterating over the enums in an enum mask. Bug: dawn:439 Change-Id: I08180a45b27c6031e2f80b0fa1801716677fd813 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24682 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-07-30 15:25:37 +00:00
internalFormat.aspects = Aspect::Color;
Format: Move the TexelBlockInfo inside an AspectInfo. In follow up CLs additional will be added to the AspectInfo, like the supported component types. Also simplify the logic for GetTexelInfo since all aspects are the first aspects, except stencil which is always stencil8. Bug: dawn:517 Change-Id: Iebbcb8a7f8fa2c4b7b06f65d6e4e8917c0a85366 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30100 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org>
2020-10-15 09:05:03 +00:00
internalFormat.firstAspect.block.byteSize = byteSize;
internalFormat.firstAspect.block.width = width;
internalFormat.firstAspect.block.height = height;
Format: Move the baseType to be per-aspect. This also introduces a per-aspect supportedComponentTypes that exactly mirrors baseType for now but will contain additional bits in the future (like DepthComparison for depth textures). It is also a step towards being able to create single-aspect view of depth-stencil textures to sample either the depth or the stencil component. Bug: dawn:527 Change-Id: I3ab224d07c136c682cc2993b9a8599237d318130 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30103 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2020-10-16 14:07:06 +00:00
internalFormat.firstAspect.baseType = wgpu::TextureComponentType::Float;
internalFormat.firstAspect.supportedComponentTypes = ComponentTypeBit::Float;
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
AddFormat(internalFormat);
};
// clang-format off
// 1 byte color formats
Add checks to TextureUsage::Storage This patch adds validations to the texture usage "Storage" when creating a texture. 1. "Storage" usage cannot be used when SampleCount > 1 2. "Storage" usage can only be used with some texture formats. The list of the formats can be found through the following link: https://github.com/gpuweb/gpuweb/issues/513 BUG=dawn:267 TEST=dawn_unittests Change-Id: Ifc7296d966ac0c600433948a63c3dd6a436c8d8b Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15040 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
2020-01-15 00:09:42 +00:00
AddColorFormat(wgpu::TextureFormat::R8Unorm, true, false, 1, Type::Float);
AddColorFormat(wgpu::TextureFormat::R8Snorm, false, false, 1, Type::Float);
AddColorFormat(wgpu::TextureFormat::R8Uint, true, false, 1, Type::Uint);
AddColorFormat(wgpu::TextureFormat::R8Sint, true, false, 1, Type::Sint);
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
// 2 bytes color formats
Add checks to TextureUsage::Storage This patch adds validations to the texture usage "Storage" when creating a texture. 1. "Storage" usage cannot be used when SampleCount > 1 2. "Storage" usage can only be used with some texture formats. The list of the formats can be found through the following link: https://github.com/gpuweb/gpuweb/issues/513 BUG=dawn:267 TEST=dawn_unittests Change-Id: Ifc7296d966ac0c600433948a63c3dd6a436c8d8b Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15040 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
2020-01-15 00:09:42 +00:00
AddColorFormat(wgpu::TextureFormat::R16Uint, true, false, 2, Type::Uint);
AddColorFormat(wgpu::TextureFormat::R16Sint, true, false, 2, Type::Sint);
AddColorFormat(wgpu::TextureFormat::R16Float, true, false, 2, Type::Float);
AddColorFormat(wgpu::TextureFormat::RG8Unorm, true, false, 2, Type::Float);
AddColorFormat(wgpu::TextureFormat::RG8Snorm, false, false, 2, Type::Float);
AddColorFormat(wgpu::TextureFormat::RG8Uint, true, false, 2, Type::Uint);
AddColorFormat(wgpu::TextureFormat::RG8Sint, true, false, 2, Type::Sint);
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
// 4 bytes color formats
Add checks to TextureUsage::Storage This patch adds validations to the texture usage "Storage" when creating a texture. 1. "Storage" usage cannot be used when SampleCount > 1 2. "Storage" usage can only be used with some texture formats. The list of the formats can be found through the following link: https://github.com/gpuweb/gpuweb/issues/513 BUG=dawn:267 TEST=dawn_unittests Change-Id: Ifc7296d966ac0c600433948a63c3dd6a436c8d8b Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15040 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
2020-01-15 00:09:42 +00:00
AddColorFormat(wgpu::TextureFormat::R32Uint, true, true, 4, Type::Uint);
AddColorFormat(wgpu::TextureFormat::R32Sint, true, true, 4, Type::Sint);
AddColorFormat(wgpu::TextureFormat::R32Float, true, true, 4, Type::Float);
AddColorFormat(wgpu::TextureFormat::RG16Uint, true, false, 4, Type::Uint);
AddColorFormat(wgpu::TextureFormat::RG16Sint, true, false, 4, Type::Sint);
AddColorFormat(wgpu::TextureFormat::RG16Float, true, false, 4, Type::Float);
AddColorFormat(wgpu::TextureFormat::RGBA8Unorm, true, true, 4, Type::Float);
AddColorFormat(wgpu::TextureFormat::RGBA8UnormSrgb, true, false, 4, Type::Float);
AddColorFormat(wgpu::TextureFormat::RGBA8Snorm, false, true, 4, Type::Float);
AddColorFormat(wgpu::TextureFormat::RGBA8Uint, true, true, 4, Type::Uint);
AddColorFormat(wgpu::TextureFormat::RGBA8Sint, true, true, 4, Type::Sint);
AddColorFormat(wgpu::TextureFormat::BGRA8Unorm, true, false, 4, Type::Float);
AddColorFormat(wgpu::TextureFormat::BGRA8UnormSrgb, true, false, 4, Type::Float);
AddColorFormat(wgpu::TextureFormat::RGB10A2Unorm, true, false, 4, Type::Float);
Add wgpu::TextureFormat::RGB9E5Ufloat Also update RG11B10Float to be name RG11B10Ufloat Bug: dawn:22 Change-Id: I0ea76dc25c37ebaeb4c2c2c2a119d00940acc145 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/25760 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Commit-Queue: Kai Ninomiya <kainino@chromium.org>
2020-08-19 21:51:20 +00:00
AddColorFormat(wgpu::TextureFormat::RG11B10Ufloat, false, false, 4, Type::Float);
AddColorFormat(wgpu::TextureFormat::RGB9E5Ufloat, false, false, 4, Type::Float);
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
// 8 bytes color formats
Add checks to TextureUsage::Storage This patch adds validations to the texture usage "Storage" when creating a texture. 1. "Storage" usage cannot be used when SampleCount > 1 2. "Storage" usage can only be used with some texture formats. The list of the formats can be found through the following link: https://github.com/gpuweb/gpuweb/issues/513 BUG=dawn:267 TEST=dawn_unittests Change-Id: Ifc7296d966ac0c600433948a63c3dd6a436c8d8b Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15040 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
2020-01-15 00:09:42 +00:00
AddColorFormat(wgpu::TextureFormat::RG32Uint, true, true, 8, Type::Uint);
AddColorFormat(wgpu::TextureFormat::RG32Sint, true, true, 8, Type::Sint);
AddColorFormat(wgpu::TextureFormat::RG32Float, true, true, 8, Type::Float);
AddColorFormat(wgpu::TextureFormat::RGBA16Uint, true, true, 8, Type::Uint);
AddColorFormat(wgpu::TextureFormat::RGBA16Sint, true, true, 8, Type::Sint);
AddColorFormat(wgpu::TextureFormat::RGBA16Float, true, true, 8, Type::Float);
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
// 16 bytes color formats
Add checks to TextureUsage::Storage This patch adds validations to the texture usage "Storage" when creating a texture. 1. "Storage" usage cannot be used when SampleCount > 1 2. "Storage" usage can only be used with some texture formats. The list of the formats can be found through the following link: https://github.com/gpuweb/gpuweb/issues/513 BUG=dawn:267 TEST=dawn_unittests Change-Id: Ifc7296d966ac0c600433948a63c3dd6a436c8d8b Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/15040 Reviewed-by: Kai Ninomiya <kainino@chromium.org> Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Austin Eng <enga@chromium.org> Commit-Queue: Jiawei Shao <jiawei.shao@intel.com>
2020-01-15 00:09:42 +00:00
AddColorFormat(wgpu::TextureFormat::RGBA32Uint, true, true, 16, Type::Uint);
AddColorFormat(wgpu::TextureFormat::RGBA32Sint, true, true, 16, Type::Sint);
AddColorFormat(wgpu::TextureFormat::RGBA32Float, true, true, 16, Type::Float);
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
Format: Move the baseType to be per-aspect. This also introduces a per-aspect supportedComponentTypes that exactly mirrors baseType for now but will contain additional bits in the future (like DepthComparison for depth textures). It is also a step towards being able to create single-aspect view of depth-stencil textures to sample either the depth or the stencil component. Bug: dawn:527 Change-Id: I3ab224d07c136c682cc2993b9a8599237d318130 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30103 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2020-10-16 14:07:06 +00:00
// Depth-stencil formats
Support sampling depth and stencil of combined d/s formats This CL adds sampling of depth-only and stencil-only texture views on all backends. However, Metal on macOS <= 10.11 will need a workaround to use separate depth/stencil textures for each aspect since it is impossible to sample the stencil aspect of a combined depth/stencil texture. Also fixes sampling of depth24plus on D3D12 which had an incomplete check for determining if a TYPELESS format is necessary. Bug: dawn:439, dawn:553 Change-Id: Id4991c565f822add200054296714e2dcd330119a Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30725 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org>
2020-11-04 15:27:11 +00:00
AddDepthStencilFormat(wgpu::TextureFormat::Depth32Float, Aspect::Depth, 4);
AddDepthStencilFormat(wgpu::TextureFormat::Depth24Plus, Aspect::Depth, 4);
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
// TODO(cwallez@chromium.org): It isn't clear if this format should be copyable
// because its size isn't well defined, is it 4, 5 or 8?
Rephrase Format::aspect enum as an enum class mask Format::aspect should be a mask so that it is easier to iterate over and test if an aspect is present. This CL also re-exports wgpu's EnumClassBitMask helpers in dawn_native. It also adds an EnumMaskIterator which wraps BitSetIterator to allow iterating over the enums in an enum mask. Bug: dawn:439 Change-Id: I08180a45b27c6031e2f80b0fa1801716677fd813 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/24682 Reviewed-by: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Austin Eng <enga@chromium.org>
2020-07-30 15:25:37 +00:00
AddDepthStencilFormat(wgpu::TextureFormat::Depth24PlusStencil8,
Support sampling depth and stencil of combined d/s formats This CL adds sampling of depth-only and stencil-only texture views on all backends. However, Metal on macOS <= 10.11 will need a workaround to use separate depth/stencil textures for each aspect since it is impossible to sample the stencil aspect of a combined depth/stencil texture. Also fixes sampling of depth24plus on D3D12 which had an incomplete check for determining if a TYPELESS format is necessary. Bug: dawn:439, dawn:553 Change-Id: Id4991c565f822add200054296714e2dcd330119a Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/30725 Commit-Queue: Austin Eng <enga@chromium.org> Reviewed-by: Stephen White <senorblanco@chromium.org>
2020-11-04 15:27:11 +00:00
Aspect::Depth | Aspect::Stencil, 4);
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
// BC compressed formats
Support BC formats as the first extension in Dawn This patch refactors the current implementation of BC formats to treat it as the first extension in Dawn and adds all the related tests. Note that in Dawn all the extensions are disabled unless we enable them when we create the device, which means the BC formats can only be used when we enable the related extension on the creation of the device, and the creation of the device will fail if the adapter does not support the extension BUG=dawn:42 TEST=dawn_end2end_tests TEST=dawn_unittests Change-Id: I04d818b0218ebb3b1b7a70a4fea71779f308f85f Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9520 Commit-Queue: Jiawei Shao <jiawei.shao@intel.com> Reviewed-by: Austin Eng <enga@chromium.org>
2019-08-02 00:06:38 +00:00
bool isBCFormatSupported = device->IsExtensionEnabled(Extension::TextureCompressionBC);
Make dawn_native use the webgpu.h header BUG=dawn:22 Change-Id: I66e2d998f5e09030e40ec88813cd65c492018fd0 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12541 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2019-10-23 11:57:41 +00:00
AddCompressedFormat(wgpu::TextureFormat::BC1RGBAUnorm, 8, 4, 4, isBCFormatSupported);
AddCompressedFormat(wgpu::TextureFormat::BC1RGBAUnormSrgb, 8, 4, 4, isBCFormatSupported);
AddCompressedFormat(wgpu::TextureFormat::BC4RSnorm, 8, 4, 4, isBCFormatSupported);
AddCompressedFormat(wgpu::TextureFormat::BC4RUnorm, 8, 4, 4, isBCFormatSupported);
AddCompressedFormat(wgpu::TextureFormat::BC2RGBAUnorm, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(wgpu::TextureFormat::BC2RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(wgpu::TextureFormat::BC3RGBAUnorm, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(wgpu::TextureFormat::BC3RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(wgpu::TextureFormat::BC5RGSnorm, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(wgpu::TextureFormat::BC5RGUnorm, 16, 4, 4, isBCFormatSupported);
Rename BC6HRGBSfloat to BC6HRGBFloat Bug: dawn:22 Change-Id: Ib579e15ff923cbd7c4f523a58c2ef582d39ba7c4 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/27200 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2020-09-10 08:48:57 +00:00
AddCompressedFormat(wgpu::TextureFormat::BC6HRGBFloat, 16, 4, 4, isBCFormatSupported);
Make dawn_native use the webgpu.h header BUG=dawn:22 Change-Id: I66e2d998f5e09030e40ec88813cd65c492018fd0 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/12541 Commit-Queue: Corentin Wallez <cwallez@chromium.org> Reviewed-by: Kai Ninomiya <kainino@chromium.org>
2019-10-23 11:57:41 +00:00
AddCompressedFormat(wgpu::TextureFormat::BC6HRGBUfloat, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(wgpu::TextureFormat::BC7RGBAUnorm, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(wgpu::TextureFormat::BC7RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported);
Precompute all the Formats at Device creation in the FormatTable This is needed for two reasons: - TextureBase and TextureViewBase stored Formats by value which isn't too much overhead at this time but will get bigger in the future. - The OpenGL backends needs its own GLFormat structure to store data about each format which will eventually contain complicated logic to detect support in the GL driver so it shouldn't be duplicated in Textures. The computations of the information about Format is moved from being done whenever they are needed to being precomputed at DeviceBase initialization. This makes each format have a constant "index" in that can be used in the backends to address their own structure, for example a GLFormat table. Also some DeviceBase pointers were made const for validation. BUG=dawn:128 Change-Id: I37d1e9c739b87cddcea09cb1759e175704d90f9e Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/9101 Reviewed-by: Austin Eng <enga@chromium.org> Reviewed-by: Jiawei Shao <jiawei.shao@intel.com> Commit-Queue: Corentin Wallez <cwallez@chromium.org>
2019-07-18 09:25:04 +00:00
// clang-format on
// This checks that each format is set at least once, the second part of checking that all
// formats are checked exactly once.
ASSERT(formatsSet.all());
return table;
}
} // namespace dawn_native