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

222 lines
10 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"
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"
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
bool Format::IsColor() const {
return aspect == Aspect::Color;
}
bool Format::HasDepth() const {
return aspect == Depth || aspect == DepthStencil;
}
bool Format::HasStencil() const {
return aspect == Stencil || aspect == DepthStencil;
}
bool Format::HasDepthOrStencil() const {
return aspect != Color;
}
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
bool Format::HasComponentType(dawn::TextureComponentType componentType) const {
// Depth stencil textures need to be special cased but we don't support sampling them yet.
if (aspect != Color) {
return false;
}
// Check that Type is correctly mirrors TextureComponentType except for "Other".
static_assert(static_cast<dawn::TextureComponentType>(Type::Float) ==
dawn::TextureComponentType::Float,
"");
static_assert(
static_cast<dawn::TextureComponentType>(Type::Sint) == dawn::TextureComponentType::Sint,
"");
static_assert(
static_cast<dawn::TextureComponentType>(Type::Uint) == dawn::TextureComponentType::Uint,
"");
return static_cast<dawn::TextureComponentType>(type) == componentType;
}
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.
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 ComputeFormatIndex(dawn::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.
static_assert(static_cast<uint32_t>(dawn::TextureFormat::Undefined) - 1 > kKnownFormatCount,
"");
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;
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
using Type = Format::Type;
using Aspect = Format::Aspect;
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]);
table[index] = format;
formatsSet.set(index);
};
auto AddColorFormat = [&AddFormat](dawn::TextureFormat format, bool renderable,
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
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 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
internalFormat.aspect = Aspect::Color;
internalFormat.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
internalFormat.blockByteSize = byteSize;
internalFormat.blockWidth = 1;
internalFormat.blockHeight = 1;
AddFormat(internalFormat);
};
auto AddDepthStencilFormat = [&AddFormat](dawn::TextureFormat format, Format::Aspect aspect,
uint32_t byteSize) {
Format internalFormat;
internalFormat.format = format;
internalFormat.isRenderable = true;
internalFormat.isCompressed = false;
internalFormat.isSupported = true;
internalFormat.aspect = aspect;
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
internalFormat.type = Type::Other;
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
internalFormat.blockByteSize = byteSize;
internalFormat.blockWidth = 1;
internalFormat.blockHeight = 1;
AddFormat(internalFormat);
};
auto AddCompressedFormat = [&AddFormat](dawn::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 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
internalFormat.aspect = Aspect::Color;
internalFormat.type = 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
internalFormat.blockByteSize = byteSize;
internalFormat.blockWidth = width;
internalFormat.blockHeight = height;
AddFormat(internalFormat);
};
// clang-format off
// 1 byte color formats
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
AddColorFormat(dawn::TextureFormat::R8Unorm, true, 1, Type::Float);
AddColorFormat(dawn::TextureFormat::R8Snorm, false, 1, Type::Float);
AddColorFormat(dawn::TextureFormat::R8Uint, true, 1, Type::Uint);
AddColorFormat(dawn::TextureFormat::R8Sint, true, 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 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
AddColorFormat(dawn::TextureFormat::R16Uint, true, 2, Type::Uint);
AddColorFormat(dawn::TextureFormat::R16Sint, true, 2, Type::Sint);
AddColorFormat(dawn::TextureFormat::R16Float, true, 2, Type::Float);
AddColorFormat(dawn::TextureFormat::RG8Unorm, true, 2, Type::Float);
AddColorFormat(dawn::TextureFormat::RG8Snorm, false, 2, Type::Float);
AddColorFormat(dawn::TextureFormat::RG8Uint, true, 2, Type::Uint);
AddColorFormat(dawn::TextureFormat::RG8Sint, true, 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 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
AddColorFormat(dawn::TextureFormat::R32Uint, true, 4, Type::Uint);
AddColorFormat(dawn::TextureFormat::R32Sint, true, 4, Type::Sint);
AddColorFormat(dawn::TextureFormat::R32Float, true, 4, Type::Float);
AddColorFormat(dawn::TextureFormat::RG16Uint, true, 4, Type::Uint);
AddColorFormat(dawn::TextureFormat::RG16Sint, true, 4, Type::Sint);
AddColorFormat(dawn::TextureFormat::RG16Float, true, 4, Type::Float);
AddColorFormat(dawn::TextureFormat::RGBA8Unorm, true, 4, Type::Float);
AddColorFormat(dawn::TextureFormat::RGBA8UnormSrgb, true, 4, Type::Float);
AddColorFormat(dawn::TextureFormat::RGBA8Snorm, false, 4, Type::Float);
AddColorFormat(dawn::TextureFormat::RGBA8Uint, true, 4, Type::Uint);
AddColorFormat(dawn::TextureFormat::RGBA8Sint, true, 4, Type::Sint);
AddColorFormat(dawn::TextureFormat::BGRA8Unorm, true, 4, Type::Float);
AddColorFormat(dawn::TextureFormat::BGRA8UnormSrgb, true, 4, Type::Float);
AddColorFormat(dawn::TextureFormat::RGB10A2Unorm, true, 4, Type::Float);
AddColorFormat(dawn::TextureFormat::RG11B10Float, 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 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
AddColorFormat(dawn::TextureFormat::RG32Uint, true, 8, Type::Uint);
AddColorFormat(dawn::TextureFormat::RG32Sint, true, 8, Type::Sint);
AddColorFormat(dawn::TextureFormat::RG32Float, true, 8, Type::Float);
AddColorFormat(dawn::TextureFormat::RGBA16Uint, true, 8, Type::Uint);
AddColorFormat(dawn::TextureFormat::RGBA16Sint, true, 8, Type::Sint);
AddColorFormat(dawn::TextureFormat::RGBA16Float, 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 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
AddColorFormat(dawn::TextureFormat::RGBA32Uint, true, 16, Type::Uint);
AddColorFormat(dawn::TextureFormat::RGBA32Sint, true, 16, Type::Sint);
AddColorFormat(dawn::TextureFormat::RGBA32Float, 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
// Depth stencil formats
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
AddDepthStencilFormat(dawn::TextureFormat::Depth32Float, Aspect::Depth, 4);
AddDepthStencilFormat(dawn::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?
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
AddDepthStencilFormat(dawn::TextureFormat::Depth24PlusStencil8, Aspect::DepthStencil, 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);
AddCompressedFormat(dawn::TextureFormat::BC1RGBAUnorm, 8, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC1RGBAUnormSrgb, 8, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC4RSnorm, 8, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC4RUnorm, 8, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC2RGBAUnorm, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC2RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC3RGBAUnorm, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC3RGBAUnormSrgb, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC5RGSnorm, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC5RGUnorm, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC6HRGBSfloat, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC6HRGBUfloat, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::TextureFormat::BC7RGBAUnorm, 16, 4, 4, isBCFormatSupported);
AddCompressedFormat(dawn::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