mirror of
https://github.com/encounter/dawn-cmake.git
synced 2025-05-29 18:51:41 +00:00
a0f1725c4f
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>
306 lines
9.5 KiB
C++
306 lines
9.5 KiB
C++
// Copyright 2017 The Dawn Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
#include <gtest/gtest.h>
|
|
|
|
#include "common/Math.h"
|
|
#include "dawn/EnumClassBitmasks.h"
|
|
|
|
#include <cmath>
|
|
|
|
namespace wgpu {
|
|
enum class TestEnum {
|
|
A = 0x1,
|
|
B = 0x2,
|
|
C = 0x4,
|
|
};
|
|
} // namespace wgpu
|
|
|
|
template <>
|
|
struct wgpu::IsDawnBitmask<wgpu::TestEnum> {
|
|
static constexpr bool enable = true;
|
|
};
|
|
|
|
// Tests for ScanForward
|
|
TEST(Math, ScanForward) {
|
|
// Test extrema
|
|
ASSERT_EQ(ScanForward(1), 0u);
|
|
ASSERT_EQ(ScanForward(0x80000000), 31u);
|
|
|
|
// Test with more than one bit set.
|
|
ASSERT_EQ(ScanForward(256), 8u);
|
|
ASSERT_EQ(ScanForward(256 + 32), 5u);
|
|
ASSERT_EQ(ScanForward(1024 + 256 + 32), 5u);
|
|
}
|
|
|
|
// Tests for Log2
|
|
TEST(Math, Log2) {
|
|
// Test extrema
|
|
ASSERT_EQ(Log2(1u), 0u);
|
|
ASSERT_EQ(Log2(0xFFFFFFFFu), 31u);
|
|
ASSERT_EQ(Log2(static_cast<uint64_t>(0xFFFFFFFFFFFFFFFF)), 63u);
|
|
|
|
static_assert(ConstexprLog2(1u) == 0u, "");
|
|
static_assert(ConstexprLog2(0xFFFFFFFFu) == 31u, "");
|
|
static_assert(ConstexprLog2(static_cast<uint64_t>(0xFFFFFFFFFFFFFFFF)) == 63u, "");
|
|
|
|
// Test boundary between two logs
|
|
ASSERT_EQ(Log2(0x80000000u), 31u);
|
|
ASSERT_EQ(Log2(0x7FFFFFFFu), 30u);
|
|
ASSERT_EQ(Log2(static_cast<uint64_t>(0x8000000000000000)), 63u);
|
|
ASSERT_EQ(Log2(static_cast<uint64_t>(0x7FFFFFFFFFFFFFFF)), 62u);
|
|
|
|
static_assert(ConstexprLog2(0x80000000u) == 31u, "");
|
|
static_assert(ConstexprLog2(0x7FFFFFFFu) == 30u, "");
|
|
static_assert(ConstexprLog2(static_cast<uint64_t>(0x8000000000000000)) == 63u, "");
|
|
static_assert(ConstexprLog2(static_cast<uint64_t>(0x7FFFFFFFFFFFFFFF)) == 62u, "");
|
|
|
|
ASSERT_EQ(Log2(16u), 4u);
|
|
ASSERT_EQ(Log2(15u), 3u);
|
|
|
|
static_assert(ConstexprLog2(16u) == 4u, "");
|
|
static_assert(ConstexprLog2(15u) == 3u, "");
|
|
}
|
|
|
|
// Tests for Log2Ceil
|
|
TEST(Math, Log2Ceil) {
|
|
// Test extrema
|
|
ASSERT_EQ(Log2Ceil(1u), 0u);
|
|
ASSERT_EQ(Log2Ceil(0xFFFFFFFFu), 32u);
|
|
ASSERT_EQ(Log2Ceil(static_cast<uint64_t>(0xFFFFFFFFFFFFFFFF)), 64u);
|
|
|
|
static_assert(ConstexprLog2Ceil(1u) == 0u, "");
|
|
static_assert(ConstexprLog2Ceil(0xFFFFFFFFu) == 32u, "");
|
|
static_assert(ConstexprLog2Ceil(static_cast<uint64_t>(0xFFFFFFFFFFFFFFFF)) == 64u, "");
|
|
|
|
// Test boundary between two logs
|
|
ASSERT_EQ(Log2Ceil(0x80000001u), 32u);
|
|
ASSERT_EQ(Log2Ceil(0x80000000u), 31u);
|
|
ASSERT_EQ(Log2Ceil(0x7FFFFFFFu), 31u);
|
|
ASSERT_EQ(Log2Ceil(static_cast<uint64_t>(0x8000000000000001)), 64u);
|
|
ASSERT_EQ(Log2Ceil(static_cast<uint64_t>(0x8000000000000000)), 63u);
|
|
ASSERT_EQ(Log2Ceil(static_cast<uint64_t>(0x7FFFFFFFFFFFFFFF)), 63u);
|
|
|
|
static_assert(ConstexprLog2Ceil(0x80000001u) == 32u, "");
|
|
static_assert(ConstexprLog2Ceil(0x80000000u) == 31u, "");
|
|
static_assert(ConstexprLog2Ceil(0x7FFFFFFFu) == 31u, "");
|
|
static_assert(ConstexprLog2Ceil(static_cast<uint64_t>(0x8000000000000001)) == 64u, "");
|
|
static_assert(ConstexprLog2Ceil(static_cast<uint64_t>(0x8000000000000000)) == 63u, "");
|
|
static_assert(ConstexprLog2Ceil(static_cast<uint64_t>(0x7FFFFFFFFFFFFFFF)) == 63u, "");
|
|
|
|
ASSERT_EQ(Log2Ceil(17u), 5u);
|
|
ASSERT_EQ(Log2Ceil(16u), 4u);
|
|
ASSERT_EQ(Log2Ceil(15u), 4u);
|
|
|
|
static_assert(ConstexprLog2Ceil(17u) == 5u, "");
|
|
static_assert(ConstexprLog2Ceil(16u) == 4u, "");
|
|
static_assert(ConstexprLog2Ceil(15u) == 4u, "");
|
|
}
|
|
|
|
// Tests for IsPowerOfTwo
|
|
TEST(Math, IsPowerOfTwo) {
|
|
ASSERT_TRUE(IsPowerOfTwo(1));
|
|
ASSERT_TRUE(IsPowerOfTwo(2));
|
|
ASSERT_FALSE(IsPowerOfTwo(3));
|
|
|
|
ASSERT_TRUE(IsPowerOfTwo(0x8000000));
|
|
ASSERT_FALSE(IsPowerOfTwo(0x8000400));
|
|
}
|
|
|
|
// Tests for NextPowerOfTwo
|
|
TEST(Math, NextPowerOfTwo) {
|
|
// Test extrema
|
|
ASSERT_EQ(NextPowerOfTwo(0), 1ull);
|
|
ASSERT_EQ(NextPowerOfTwo(0x7FFFFFFFFFFFFFFF), 0x8000000000000000);
|
|
|
|
// Test boundary between powers-of-two.
|
|
ASSERT_EQ(NextPowerOfTwo(31), 32ull);
|
|
ASSERT_EQ(NextPowerOfTwo(33), 64ull);
|
|
|
|
ASSERT_EQ(NextPowerOfTwo(32), 32ull);
|
|
}
|
|
|
|
// Tests for AlignPtr
|
|
TEST(Math, AlignPtr) {
|
|
constexpr size_t kTestAlignment = 8;
|
|
|
|
char buffer[kTestAlignment * 4];
|
|
|
|
for (size_t i = 0; i < 2 * kTestAlignment; ++i) {
|
|
char* unaligned = &buffer[i];
|
|
char* aligned = AlignPtr(unaligned, kTestAlignment);
|
|
|
|
ASSERT_GE(aligned - unaligned, 0);
|
|
ASSERT_LT(static_cast<size_t>(aligned - unaligned), kTestAlignment);
|
|
ASSERT_EQ(reinterpret_cast<uintptr_t>(aligned) & (kTestAlignment - 1), 0u);
|
|
}
|
|
}
|
|
|
|
// Tests for Align
|
|
TEST(Math, Align) {
|
|
// 0 aligns to 0
|
|
ASSERT_EQ(Align(0u, 4), 0u);
|
|
ASSERT_EQ(Align(0u, 256), 0u);
|
|
ASSERT_EQ(Align(0u, 512), 0u);
|
|
|
|
// Multiples align to self
|
|
ASSERT_EQ(Align(8u, 8), 8u);
|
|
ASSERT_EQ(Align(16u, 8), 16u);
|
|
ASSERT_EQ(Align(24u, 8), 24u);
|
|
ASSERT_EQ(Align(256u, 256), 256u);
|
|
ASSERT_EQ(Align(512u, 256), 512u);
|
|
ASSERT_EQ(Align(768u, 256), 768u);
|
|
|
|
// Alignment with 1 is self
|
|
for (uint32_t i = 0; i < 128; ++i) {
|
|
ASSERT_EQ(Align(i, 1), i);
|
|
}
|
|
|
|
// Everything in the range (align, 2*align] aligns to 2*align
|
|
for (uint32_t i = 1; i <= 64; ++i) {
|
|
ASSERT_EQ(Align(64 + i, 64), 128u);
|
|
}
|
|
|
|
// Test extrema
|
|
ASSERT_EQ(Align(static_cast<uint64_t>(0xFFFFFFFF), 4), 0x100000000u);
|
|
ASSERT_EQ(Align(static_cast<uint64_t>(0xFFFFFFFFFFFFFFFF), 1), 0xFFFFFFFFFFFFFFFFull);
|
|
}
|
|
|
|
// Tests for IsPtrAligned
|
|
TEST(Math, IsPtrAligned) {
|
|
constexpr size_t kTestAlignment = 8;
|
|
|
|
char buffer[kTestAlignment * 4];
|
|
|
|
for (size_t i = 0; i < 2 * kTestAlignment; ++i) {
|
|
char* unaligned = &buffer[i];
|
|
char* aligned = AlignPtr(unaligned, kTestAlignment);
|
|
|
|
ASSERT_EQ(IsPtrAligned(unaligned, kTestAlignment), unaligned == aligned);
|
|
}
|
|
}
|
|
|
|
// Tests for IsAligned
|
|
TEST(Math, IsAligned) {
|
|
// 0 is aligned
|
|
ASSERT_TRUE(IsAligned(0, 4));
|
|
ASSERT_TRUE(IsAligned(0, 256));
|
|
ASSERT_TRUE(IsAligned(0, 512));
|
|
|
|
// Multiples are aligned
|
|
ASSERT_TRUE(IsAligned(8, 8));
|
|
ASSERT_TRUE(IsAligned(16, 8));
|
|
ASSERT_TRUE(IsAligned(24, 8));
|
|
ASSERT_TRUE(IsAligned(256, 256));
|
|
ASSERT_TRUE(IsAligned(512, 256));
|
|
ASSERT_TRUE(IsAligned(768, 256));
|
|
|
|
// Alignment with 1 is always aligned
|
|
for (uint32_t i = 0; i < 128; ++i) {
|
|
ASSERT_TRUE(IsAligned(i, 1));
|
|
}
|
|
|
|
// Everything in the range (align, 2*align) is not aligned
|
|
for (uint32_t i = 1; i < 64; ++i) {
|
|
ASSERT_FALSE(IsAligned(64 + i, 64));
|
|
}
|
|
}
|
|
|
|
// Tests for float32 to float16 conversion
|
|
TEST(Math, Float32ToFloat16) {
|
|
ASSERT_EQ(Float32ToFloat16(0.0f), 0x0000);
|
|
ASSERT_EQ(Float32ToFloat16(-0.0f), 0x8000);
|
|
|
|
ASSERT_EQ(Float32ToFloat16(INFINITY), 0x7C00);
|
|
ASSERT_EQ(Float32ToFloat16(-INFINITY), 0xFC00);
|
|
|
|
// Check that NaN is converted to a value in one of the float16 NaN ranges
|
|
uint16_t nan16 = Float32ToFloat16(NAN);
|
|
ASSERT_TRUE(nan16 > 0xFC00 || (nan16 < 0x8000 && nan16 > 0x7C00));
|
|
|
|
ASSERT_EQ(Float32ToFloat16(1.0f), 0x3C00);
|
|
}
|
|
|
|
// Tests for IsFloat16NaN
|
|
TEST(Math, IsFloat16NaN) {
|
|
ASSERT_FALSE(IsFloat16NaN(0u));
|
|
ASSERT_FALSE(IsFloat16NaN(0u));
|
|
ASSERT_FALSE(IsFloat16NaN(Float32ToFloat16(1.0f)));
|
|
ASSERT_FALSE(IsFloat16NaN(Float32ToFloat16(INFINITY)));
|
|
ASSERT_FALSE(IsFloat16NaN(Float32ToFloat16(-INFINITY)));
|
|
|
|
ASSERT_TRUE(IsFloat16NaN(Float32ToFloat16(INFINITY) + 1));
|
|
ASSERT_TRUE(IsFloat16NaN(Float32ToFloat16(-INFINITY) + 1));
|
|
ASSERT_TRUE(IsFloat16NaN(0x7FFF));
|
|
ASSERT_TRUE(IsFloat16NaN(0xFFFF));
|
|
}
|
|
|
|
// Tests for SRGBToLinear
|
|
TEST(Math, SRGBToLinear) {
|
|
ASSERT_EQ(SRGBToLinear(0.0f), 0.0f);
|
|
ASSERT_EQ(SRGBToLinear(1.0f), 1.0f);
|
|
|
|
ASSERT_EQ(SRGBToLinear(-1.0f), 0.0f);
|
|
ASSERT_EQ(SRGBToLinear(2.0f), 1.0f);
|
|
|
|
ASSERT_FLOAT_EQ(SRGBToLinear(0.5f), 0.21404114f);
|
|
}
|
|
|
|
// Tests for RoundUp
|
|
TEST(Math, RoundUp) {
|
|
ASSERT_EQ(RoundUp(2, 2), 2u);
|
|
ASSERT_EQ(RoundUp(2, 4), 4u);
|
|
ASSERT_EQ(RoundUp(6, 2), 6u);
|
|
ASSERT_EQ(RoundUp(8, 4), 8u);
|
|
ASSERT_EQ(RoundUp(12, 6), 12u);
|
|
|
|
ASSERT_EQ(RoundUp(3, 3), 3u);
|
|
ASSERT_EQ(RoundUp(3, 5), 5u);
|
|
ASSERT_EQ(RoundUp(5, 3), 6u);
|
|
ASSERT_EQ(RoundUp(9, 5), 10u);
|
|
|
|
// Test extrema
|
|
ASSERT_EQ(RoundUp(0x7FFFFFFFFFFFFFFFull, 0x8000000000000000ull), 0x8000000000000000ull);
|
|
ASSERT_EQ(RoundUp(1, 1), 1u);
|
|
}
|
|
|
|
// Tests for IsSubset
|
|
TEST(Math, IsSubset) {
|
|
// single value is a subset
|
|
ASSERT_TRUE(IsSubset(0b100, 0b101));
|
|
ASSERT_FALSE(IsSubset(0b010, 0b101));
|
|
ASSERT_TRUE(IsSubset(0b001, 0b101));
|
|
|
|
// empty set is a subset
|
|
ASSERT_TRUE(IsSubset(0b000, 0b101));
|
|
|
|
// equal-to is a subset
|
|
ASSERT_TRUE(IsSubset(0b101, 0b101));
|
|
|
|
// superset is not a subset
|
|
ASSERT_FALSE(IsSubset(0b111, 0b101));
|
|
|
|
// only empty is a subset of empty
|
|
ASSERT_FALSE(IsSubset(0b100, 0b000));
|
|
ASSERT_FALSE(IsSubset(0b010, 0b000));
|
|
ASSERT_FALSE(IsSubset(0b001, 0b000));
|
|
ASSERT_TRUE(IsSubset(0b000, 0b000));
|
|
|
|
// Test with enums
|
|
ASSERT_TRUE(IsSubset(wgpu::TestEnum::A, wgpu::TestEnum::A));
|
|
ASSERT_TRUE(IsSubset(wgpu::TestEnum::A, wgpu::TestEnum::A | wgpu::TestEnum::B));
|
|
ASSERT_FALSE(IsSubset(wgpu::TestEnum::C, wgpu::TestEnum::A | wgpu::TestEnum::B));
|
|
ASSERT_FALSE(IsSubset(wgpu::TestEnum::A | wgpu::TestEnum::C, wgpu::TestEnum::A));
|
|
}
|