From 8d73198aca5f1a83283068298c9bfd79640ca36b Mon Sep 17 00:00:00 2001 From: Austin Eng Date: Mon, 18 Jul 2022 20:38:05 +0000 Subject: [PATCH] Remove depth-clamping and add depth-clip-control feature Fixed: dawn:1178 Change-Id: I251a7e05fec9ecef44300d4f948b2d0611888109 Reviewed-on: https://dawn-review.googlesource.com/c/dawn/+/96320 Commit-Queue: Austin Eng Reviewed-by: Corentin Wallez Kokoro: Kokoro --- dawn.json | 12 - src/dawn/native/Features.cpp | 7 - src/dawn/native/Features.h | 1 - src/dawn/native/RenderPipeline.cpp | 24 +- src/dawn/native/RenderPipeline.h | 4 +- src/dawn/native/d3d12/RenderPipelineD3D12.cpp | 2 +- src/dawn/native/metal/BackendMTL.mm | 2 +- src/dawn/native/metal/CommandBufferMTL.mm | 2 +- src/dawn/native/vulkan/AdapterVk.cpp | 9 +- src/dawn/native/vulkan/CacheKeyVk.cpp | 9 +- src/dawn/native/vulkan/DeviceVk.cpp | 15 +- src/dawn/native/vulkan/RenderPipelineVk.cpp | 14 +- src/dawn/native/vulkan/VulkanExtensions.cpp | 2 + src/dawn/native/vulkan/VulkanExtensions.h | 1 + src/dawn/native/vulkan/VulkanInfo.cpp | 5 + src/dawn/native/vulkan/VulkanInfo.h | 1 + .../tests/end2end/PrimitiveStateTests.cpp | 236 +++++++++++------- src/dawn/tests/unittests/ChainUtilsTests.cpp | 34 +-- .../validation/DeviceValidationTests.cpp | 4 +- .../RenderPipelineValidationTests.cpp | 54 ++-- .../unittests/wire/WireExtensionTests.cpp | 58 ++--- src/dawn/wire/SupportedFeatures.cpp | 1 - webgpu-cts/expectations.txt | 5 +- 23 files changed, 279 insertions(+), 223 deletions(-) diff --git a/dawn.json b/dawn.json index 23d4c4a849..29632dda96 100644 --- a/dawn.json +++ b/dawn.json @@ -1365,7 +1365,6 @@ {"value": 6, "name": "texture compression ETC2"}, {"value": 7, "name": "texture compression ASTC"}, {"value": 8, "name": "indirect first instance"}, - {"value": 1000, "name": "depth clamping", "tags": ["emscripten", "dawn"]}, {"value": 1001, "name": "dawn shader float 16", "tags": ["dawn"]}, {"value": 1002, "name": "dawn internal usages", "tags": ["dawn"]}, {"value": 1003, "name": "dawn multi planar formats", "tags": ["dawn"]}, @@ -2150,16 +2149,6 @@ ] }, - "primitive depth clamping state": { - "category": "structure", - "chained": "in", - "chain roots": ["primitive state"], - "tags": ["dawn", "emscripten"], - "members": [ - {"name": "clamp depth", "type": "bool", "default": "false"} - ] - }, - "primitive depth clip control": { "category": "structure", "chained": "in", @@ -2512,7 +2501,6 @@ {"value": 14, "name": "surface descriptor from windows swap chain panel", "tags": ["dawn"]}, {"value": 15, "name": "render pass descriptor max draw count"}, {"value": 1000, "name": "dawn texture internal usage descriptor", "tags": ["dawn"]}, - {"value": 1001, "name": "primitive depth clamping state", "tags": ["dawn", "emscripten"]}, {"value": 1002, "name": "dawn toggles device descriptor", "tags": ["dawn", "native"]}, {"value": 1003, "name": "dawn encoder internal usage descriptor", "tags": ["dawn"]}, {"value": 1004, "name": "dawn instance descriptor", "tags": ["dawn", "native"]}, diff --git a/src/dawn/native/Features.cpp b/src/dawn/native/Features.cpp index 16b845dfa0..e43da124e8 100644 --- a/src/dawn/native/Features.cpp +++ b/src/dawn/native/Features.cpp @@ -58,9 +58,6 @@ static constexpr FeatureEnumAndInfoList kFeatureNameAndInfoList = {{ {Feature::DepthClipControl, {"depth-clip-control", "Disable depth clipping of primitives to the clip volume", "https://bugs.chromium.org/p/dawn/issues/detail?id=1178"}}, - {Feature::DepthClamping, - {"depth-clamping", "Clamp depth to [0, 1] in NDC space instead of clipping", - "https://bugs.chromium.org/p/dawn/issues/detail?id=716"}}, {Feature::Depth32FloatStencil8, {"depth32float-stencil8", "Support depth32float-stencil8 texture format", "https://bugs.chromium.org/p/dawn/issues/detail?id=690"}}, @@ -102,8 +99,6 @@ Feature FromAPIFeature(wgpu::FeatureName feature) { return Feature::TextureCompressionASTC; case wgpu::FeatureName::DepthClipControl: return Feature::DepthClipControl; - case wgpu::FeatureName::DepthClamping: - return Feature::DepthClamping; case wgpu::FeatureName::Depth32FloatStencil8: return Feature::Depth32FloatStencil8; case wgpu::FeatureName::IndirectFirstInstance: @@ -136,8 +131,6 @@ wgpu::FeatureName ToAPIFeature(Feature feature) { return wgpu::FeatureName::TimestampQuery; case Feature::DepthClipControl: return wgpu::FeatureName::DepthClipControl; - case Feature::DepthClamping: - return wgpu::FeatureName::DepthClamping; case Feature::Depth32FloatStencil8: return wgpu::FeatureName::Depth32FloatStencil8; case Feature::IndirectFirstInstance: diff --git a/src/dawn/native/Features.h b/src/dawn/native/Features.h index e3913f1b07..f97fd9df67 100644 --- a/src/dawn/native/Features.h +++ b/src/dawn/native/Features.h @@ -34,7 +34,6 @@ enum class Feature { PipelineStatisticsQuery, TimestampQuery, DepthClipControl, - DepthClamping, Depth32FloatStencil8, ChromiumExperimentalDp4a, IndirectFirstInstance, diff --git a/src/dawn/native/RenderPipeline.cpp b/src/dawn/native/RenderPipeline.cpp index 1df3c4cee0..256cb62cd0 100644 --- a/src/dawn/native/RenderPipeline.cpp +++ b/src/dawn/native/RenderPipeline.cpp @@ -153,12 +153,7 @@ MaybeError ValidateVertexState(DeviceBase* device, } MaybeError ValidatePrimitiveState(const DeviceBase* device, const PrimitiveState* descriptor) { - DAWN_TRY(ValidateSingleSType(descriptor->nextInChain, wgpu::SType::PrimitiveDepthClampingState, - wgpu::SType::PrimitiveDepthClipControl)); - const PrimitiveDepthClampingState* clampInfo = nullptr; - FindInChain(descriptor->nextInChain, &clampInfo); - DAWN_INVALID_IF(clampInfo && !device->IsFeatureEnabled(Feature::DepthClamping), - "%s is not supported", wgpu::FeatureName::DepthClamping); + DAWN_TRY(ValidateSingleSType(descriptor->nextInChain, wgpu::SType::PrimitiveDepthClipControl)); const PrimitiveDepthClipControl* depthClipControl = nullptr; FindInChain(descriptor->nextInChain, &depthClipControl); DAWN_INVALID_IF(depthClipControl && !device->IsFeatureEnabled(Feature::DepthClipControl), @@ -564,11 +559,12 @@ RenderPipelineBase::RenderPipelineBase(DeviceBase* device, } mPrimitive = descriptor->primitive; - const PrimitiveDepthClampingState* clampInfo = nullptr; - FindInChain(mPrimitive.nextInChain, &clampInfo); - if (clampInfo) { - mClampDepth = clampInfo->clampDepth; + const PrimitiveDepthClipControl* depthClipControl = nullptr; + FindInChain(mPrimitive.nextInChain, &depthClipControl); + if (depthClipControl) { + mUnclippedDepth = depthClipControl->unclippedDepth; } + mMultisample = descriptor->multisample; if (mAttachmentState->HasDepthStencilAttachment()) { @@ -763,9 +759,9 @@ float RenderPipelineBase::GetDepthBiasClamp() const { return mDepthStencil.depthBiasClamp; } -bool RenderPipelineBase::ShouldClampDepth() const { +bool RenderPipelineBase::HasUnclippedDepth() const { ASSERT(!IsError()); - return mClampDepth; + return mUnclippedDepth; } ityp::bitset @@ -872,7 +868,7 @@ size_t RenderPipelineBase::ComputeContentHash() { // Record primitive state recorder.Record(mPrimitive.topology, mPrimitive.stripIndexFormat, mPrimitive.frontFace, - mPrimitive.cullMode, mClampDepth); + mPrimitive.cullMode, mUnclippedDepth); // Record multisample state // Sample count hashed as part of the attachment state @@ -989,7 +985,7 @@ bool RenderPipelineBase::EqualityFunc::operator()(const RenderPipelineBase* a, if (stateA.topology != stateB.topology || stateA.stripIndexFormat != stateB.stripIndexFormat || stateA.frontFace != stateB.frontFace || stateA.cullMode != stateB.cullMode || - a->mClampDepth != b->mClampDepth) { + a->mUnclippedDepth != b->mUnclippedDepth) { return false; } } diff --git a/src/dawn/native/RenderPipeline.h b/src/dawn/native/RenderPipeline.h index f904f8a893..afba4a7590 100644 --- a/src/dawn/native/RenderPipeline.h +++ b/src/dawn/native/RenderPipeline.h @@ -90,7 +90,7 @@ class RenderPipelineBase : public PipelineBase { int32_t GetDepthBias() const; float GetDepthBiasSlopeScale() const; float GetDepthBiasClamp() const; - bool ShouldClampDepth() const; + bool HasUnclippedDepth() const; ityp::bitset GetColorAttachmentsMask() const; bool HasDepthStencilAttachment() const; @@ -137,7 +137,7 @@ class RenderPipelineBase : public PipelineBase { PrimitiveState mPrimitive; DepthStencilState mDepthStencil; MultisampleState mMultisample; - bool mClampDepth = false; + bool mUnclippedDepth = false; bool mWritesDepth = false; bool mWritesStencil = false; }; diff --git a/src/dawn/native/d3d12/RenderPipelineD3D12.cpp b/src/dawn/native/d3d12/RenderPipelineD3D12.cpp index 00fc77b2dd..1ec8e0225f 100644 --- a/src/dawn/native/d3d12/RenderPipelineD3D12.cpp +++ b/src/dawn/native/d3d12/RenderPipelineD3D12.cpp @@ -389,7 +389,7 @@ MaybeError RenderPipeline::Initialize() { descriptorD3D12.RasterizerState.DepthBias = GetDepthBias(); descriptorD3D12.RasterizerState.DepthBiasClamp = GetDepthBiasClamp(); descriptorD3D12.RasterizerState.SlopeScaledDepthBias = GetDepthBiasSlopeScale(); - descriptorD3D12.RasterizerState.DepthClipEnable = TRUE; + descriptorD3D12.RasterizerState.DepthClipEnable = !HasUnclippedDepth(); descriptorD3D12.RasterizerState.MultisampleEnable = (GetSampleCount() > 1) ? TRUE : FALSE; descriptorD3D12.RasterizerState.AntialiasedLineEnable = FALSE; descriptorD3D12.RasterizerState.ForcedSampleCount = 0; diff --git a/src/dawn/native/metal/BackendMTL.mm b/src/dawn/native/metal/BackendMTL.mm index f9e7b53bef..ee480a6673 100644 --- a/src/dawn/native/metal/BackendMTL.mm +++ b/src/dawn/native/metal/BackendMTL.mm @@ -371,7 +371,7 @@ class Adapter : public AdapterBase { } if (@available(macOS 10.11, iOS 11.0, *)) { - mSupportedFeatures.EnableFeature(Feature::DepthClamping); + mSupportedFeatures.EnableFeature(Feature::DepthClipControl); } if (@available(macOS 10.11, iOS 9.0, *)) { diff --git a/src/dawn/native/metal/CommandBufferMTL.mm b/src/dawn/native/metal/CommandBufferMTL.mm index 04dab40699..d32f058911 100644 --- a/src/dawn/native/metal/CommandBufferMTL.mm +++ b/src/dawn/native/metal/CommandBufferMTL.mm @@ -1242,7 +1242,7 @@ MaybeError CommandBuffer::EncodeRenderPass(id encoder) slopeScale:newPipeline->GetDepthBiasSlopeScale() clamp:newPipeline->GetDepthBiasClamp()]; if (@available(macOS 10.11, iOS 11.0, *)) { - MTLDepthClipMode clipMode = newPipeline->ShouldClampDepth() + MTLDepthClipMode clipMode = newPipeline->HasUnclippedDepth() ? MTLDepthClipModeClamp : MTLDepthClipModeClip; [encoder setDepthClipMode:clipMode]; diff --git a/src/dawn/native/vulkan/AdapterVk.cpp b/src/dawn/native/vulkan/AdapterVk.cpp index 5e399ae6a6..9ccc4d6514 100644 --- a/src/dawn/native/vulkan/AdapterVk.cpp +++ b/src/dawn/native/vulkan/AdapterVk.cpp @@ -147,10 +147,6 @@ MaybeError Adapter::InitializeSupportedFeaturesImpl() { mSupportedFeatures.EnableFeature(Feature::PipelineStatisticsQuery); } - if (mDeviceInfo.features.depthClamp == VK_TRUE) { - mSupportedFeatures.EnableFeature(Feature::DepthClamping); - } - if (mDeviceInfo.properties.limits.timestampComputeAndGraphics == VK_TRUE) { mSupportedFeatures.EnableFeature(Feature::TimestampQuery); } @@ -171,6 +167,11 @@ MaybeError Adapter::InitializeSupportedFeaturesImpl() { mSupportedFeatures.EnableFeature(Feature::ChromiumExperimentalDp4a); } + if (mDeviceInfo.HasExt(DeviceExt::DepthClipEnable) && + mDeviceInfo.depthClipEnableFeatures.depthClipEnable == VK_TRUE) { + mSupportedFeatures.EnableFeature(Feature::DepthClipControl); + } + #if defined(DAWN_USE_SYNC_FDS) // TODO(chromium:1258986): Precisely enable the feature by querying the device's format // features. diff --git a/src/dawn/native/vulkan/CacheKeyVk.cpp b/src/dawn/native/vulkan/CacheKeyVk.cpp index d89649e746..3a8266783c 100644 --- a/src/dawn/native/vulkan/CacheKeyVk.cpp +++ b/src/dawn/native/vulkan/CacheKeyVk.cpp @@ -57,6 +57,13 @@ void CacheKeySerializer: key->Record(t.requiredSubgroupSize); } +template <> +void CacheKeySerializer::Serialize( + CacheKey* key, + const VkPipelineRasterizationDepthClipStateCreateInfoEXT& t) { + key->Record(t.depthClipEnable, t.flags); +} + template <> void CacheKeySerializer::Serialize(CacheKey* key, const VkSpecializationMapEntry& t) { @@ -170,7 +177,7 @@ void CacheKeySerializer::Serialize( key->Record(t.flags, t.depthClampEnable, t.rasterizerDiscardEnable, t.polygonMode, t.cullMode, t.frontFace, t.depthBiasEnable, t.depthBiasConstantFactor, t.depthBiasClamp, t.depthBiasSlopeFactor, t.lineWidth); - vulkan::SerializePnext<>(key, &t); + vulkan::SerializePnext(key, &t); } template <> diff --git a/src/dawn/native/vulkan/DeviceVk.cpp b/src/dawn/native/vulkan/DeviceVk.cpp index 3605dc027d..05f3a00b19 100644 --- a/src/dawn/native/vulkan/DeviceVk.cpp +++ b/src/dawn/native/vulkan/DeviceVk.cpp @@ -409,6 +409,16 @@ ResultOrError Device::CreateDevice(VkPhysicalDevice physicalD usedKnobs.features.pipelineStatisticsQuery = VK_TRUE; } + if (IsFeatureEnabled(Feature::DepthClipControl)) { + const VulkanDeviceInfo& deviceInfo = ToBackend(GetAdapter())->GetDeviceInfo(); + ASSERT(deviceInfo.HasExt(DeviceExt::DepthClipEnable) && + deviceInfo.depthClipEnableFeatures.depthClipEnable == VK_TRUE); + + usedKnobs.depthClipEnableFeatures.depthClipEnable = VK_TRUE; + featuresChain.Add(&usedKnobs.depthClipEnableFeatures, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT); + } + if (IsFeatureEnabled(Feature::ShaderFloat16)) { const VulkanDeviceInfo& deviceInfo = ToBackend(GetAdapter())->GetDeviceInfo(); ASSERT(deviceInfo.HasExt(DeviceExt::ShaderFloat16Int8) && @@ -427,11 +437,6 @@ ResultOrError Device::CreateDevice(VkPhysicalDevice physicalD VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES); } - if (IsFeatureEnabled(Feature::DepthClamping)) { - ASSERT(ToBackend(GetAdapter())->GetDeviceInfo().features.depthClamp == VK_TRUE); - usedKnobs.features.depthClamp = VK_TRUE; - } - // Find a universal queue family { // Note that GRAPHICS and COMPUTE imply TRANSFER so we don't need to check for it. diff --git a/src/dawn/native/vulkan/RenderPipelineVk.cpp b/src/dawn/native/vulkan/RenderPipelineVk.cpp index 8f30d58082..39a24b7627 100644 --- a/src/dawn/native/vulkan/RenderPipelineVk.cpp +++ b/src/dawn/native/vulkan/RenderPipelineVk.cpp @@ -430,7 +430,7 @@ MaybeError RenderPipeline::Initialize() { rasterization.sType = VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO; rasterization.pNext = nullptr; rasterization.flags = 0; - rasterization.depthClampEnable = ShouldClampDepth() ? VK_TRUE : VK_FALSE; + rasterization.depthClampEnable = VK_FALSE; rasterization.rasterizerDiscardEnable = VK_FALSE; rasterization.polygonMode = VK_POLYGON_MODE_FILL; rasterization.cullMode = VulkanCullMode(GetCullMode()); @@ -441,6 +441,18 @@ MaybeError RenderPipeline::Initialize() { rasterization.depthBiasSlopeFactor = GetDepthBiasSlopeScale(); rasterization.lineWidth = 1.0f; + PNextChainBuilder rasterizationChain(&rasterization); + VkPipelineRasterizationDepthClipStateCreateInfoEXT depthClipState; + if (HasUnclippedDepth()) { + ASSERT(device->IsFeatureEnabled(Feature::DepthClipControl)); + depthClipState.pNext = nullptr; + depthClipState.depthClipEnable = VK_FALSE; + depthClipState.flags = 0; + rasterizationChain.Add( + &depthClipState, + VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_DEPTH_CLIP_STATE_CREATE_INFO_EXT); + } + VkPipelineMultisampleStateCreateInfo multisample; multisample.sType = VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO; multisample.pNext = nullptr; diff --git a/src/dawn/native/vulkan/VulkanExtensions.cpp b/src/dawn/native/vulkan/VulkanExtensions.cpp index 439e95d129..aaf3e65830 100644 --- a/src/dawn/native/vulkan/VulkanExtensions.cpp +++ b/src/dawn/native/vulkan/VulkanExtensions.cpp @@ -162,6 +162,7 @@ static constexpr std::array sDeviceExtInfos{{ {DeviceExt::ExternalSemaphoreFD, "VK_KHR_external_semaphore_fd", NeverPromoted}, {DeviceExt::ExternalSemaphoreZirconHandle, "VK_FUCHSIA_external_semaphore", NeverPromoted}, + {DeviceExt::DepthClipEnable, "VK_EXT_depth_clip_enable", NeverPromoted}, {DeviceExt::ImageDrmFormatModifier, "VK_EXT_image_drm_format_modifier", NeverPromoted}, {DeviceExt::Swapchain, "VK_KHR_swapchain", NeverPromoted}, {DeviceExt::SubgroupSizeControl, "VK_EXT_subgroup_size_control", NeverPromoted}, @@ -283,6 +284,7 @@ DeviceExtSet EnsureDependencies(const DeviceExtSet& advertisedExts, hasDependencies = icdVersion >= VulkanVersion_1_1; break; + case DeviceExt::DepthClipEnable: case DeviceExt::ShaderIntegerDotProduct: case DeviceExt::ZeroInitializeWorkgroupMemory: hasDependencies = HasDep(DeviceExt::GetPhysicalDeviceProperties2); diff --git a/src/dawn/native/vulkan/VulkanExtensions.h b/src/dawn/native/vulkan/VulkanExtensions.h index 6912528404..eb6ef49a42 100644 --- a/src/dawn/native/vulkan/VulkanExtensions.h +++ b/src/dawn/native/vulkan/VulkanExtensions.h @@ -103,6 +103,7 @@ enum class DeviceExt { ExternalSemaphoreZirconHandle, // Others + DepthClipEnable, ImageDrmFormatModifier, Swapchain, SubgroupSizeControl, diff --git a/src/dawn/native/vulkan/VulkanInfo.cpp b/src/dawn/native/vulkan/VulkanInfo.cpp index 116fd7222d..d033e291ca 100644 --- a/src/dawn/native/vulkan/VulkanInfo.cpp +++ b/src/dawn/native/vulkan/VulkanInfo.cpp @@ -254,6 +254,11 @@ ResultOrError GatherDeviceInfo(const Adapter& adapter) { VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_DOT_PRODUCT_PROPERTIES_KHR); } + if (info.extensions[DeviceExt::DepthClipEnable]) { + featuresChain.Add(&info.depthClipEnableFeatures, + VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT); + } + // If we have DeviceExt::GetPhysicalDeviceProperties2, use features2 and properties2 so // that features no covered by VkPhysicalDevice{Features,Properties} can be queried. // diff --git a/src/dawn/native/vulkan/VulkanInfo.h b/src/dawn/native/vulkan/VulkanInfo.h index 39dd12d66c..5bb925736c 100644 --- a/src/dawn/native/vulkan/VulkanInfo.h +++ b/src/dawn/native/vulkan/VulkanInfo.h @@ -53,6 +53,7 @@ struct VulkanDeviceKnobs { VkPhysicalDeviceSubgroupSizeControlFeaturesEXT subgroupSizeControlFeatures; VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR zeroInitializeWorkgroupMemoryFeatures; VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR shaderIntegerDotProductFeatures; + VkPhysicalDeviceDepthClipEnableFeaturesEXT depthClipEnableFeatures; bool HasExt(DeviceExt ext) const; DeviceExtSet extensions; diff --git a/src/dawn/tests/end2end/PrimitiveStateTests.cpp b/src/dawn/tests/end2end/PrimitiveStateTests.cpp index fc6e5bde15..264c42f126 100644 --- a/src/dawn/tests/end2end/PrimitiveStateTests.cpp +++ b/src/dawn/tests/end2end/PrimitiveStateTests.cpp @@ -21,11 +21,11 @@ constexpr static unsigned int kRTSize = 1; -class DepthClampingTest : public DawnTest { +class DepthClippingTest : public DawnTest { protected: void SetUp() override { DawnTest::SetUp(); - DAWN_TEST_UNSUPPORTED_IF(!SupportsFeatures({wgpu::FeatureName::DepthClamping})); + DAWN_TEST_UNSUPPORTED_IF(!SupportsFeatures({wgpu::FeatureName::DepthClipControl})); wgpu::TextureDescriptor renderTargetDescriptor; renderTargetDescriptor.size = {kRTSize, kRTSize}; @@ -70,17 +70,16 @@ class DepthClampingTest : public DawnTest { std::vector GetRequiredFeatures() override { std::vector requiredFeatures = {}; - if (SupportsFeatures({wgpu::FeatureName::DepthClamping})) { - requiredFeatures.push_back(wgpu::FeatureName::DepthClamping); + if (SupportsFeatures({wgpu::FeatureName::DepthClipControl})) { + requiredFeatures.push_back(wgpu::FeatureName::DepthClipControl); } return requiredFeatures; } struct TestSpec { - wgpu::PrimitiveDepthClampingState* depthClampingState; + wgpu::PrimitiveDepthClipControl* depthClipControl; RGBA8 color; float depth; - wgpu::CompareFunction depthCompareFunction; }; // Each test param represents a pair of triangles with a color, depth, stencil value, and @@ -111,13 +110,12 @@ class DepthClampingTest : public DawnTest { // Create a pipeline for the triangles with the test spec's params. utils::ComboRenderPipelineDescriptor descriptor; - descriptor.primitive.nextInChain = test.depthClampingState; + descriptor.primitive.nextInChain = test.depthClipControl; descriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; descriptor.vertex.module = vsModule; descriptor.cFragment.module = fsModule; wgpu::DepthStencilState* depthStencil = descriptor.EnableDepthStencil(); depthStencil->depthWriteEnabled = true; - depthStencil->depthCompare = test.depthCompareFunction; depthStencil->format = wgpu::TextureFormat::Depth24PlusStencil8; wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor); @@ -146,150 +144,218 @@ class DepthClampingTest : public DawnTest { wgpu::ShaderModule fsModule; }; -// Test that fragments beyond the far plane are clamped to 1.0 if depth clamping is enabled. -TEST_P(DepthClampingTest, ClampOnBeyondFarPlane) { - wgpu::PrimitiveDepthClampingState clampingState; - clampingState.clampDepth = true; +// Test that fragments beyond the far plane are not clipped if unclippedDepth is true +TEST_P(DepthClippingTest, UnclippedBeyondFarPlane) { + wgpu::PrimitiveDepthClipControl depthClipControl; + depthClipControl.unclippedDepth = true; DoTest( { // Draw a red triangle at depth 1. { - nullptr, /* depthClampingState */ + nullptr, /* depthClipControl */ RGBA8(255, 0, 0, 255), /* color */ 1.f, /* depth */ - wgpu::CompareFunction::Always, }, - // Draw a green triangle at depth 2 which should get clamped to 1. + // Draw a green triangle at depth 2 which should not be clipped. { - &clampingState, + &depthClipControl, /* depthClipControl */ RGBA8(0, 255, 0, 255), /* color */ 2.f, /* depth */ - wgpu::CompareFunction::Equal, }, }, - // Since we draw the green triangle with an "equal" depth compare function, the resulting - // fragment should be green. + // The resulting fragment should be green even though the green triangle is + // outside the clip volume. RGBA8(0, 255, 0, 255)); } -// Test that fragments beyond the near plane are clamped to 0.0 if depth clamping is enabled. -TEST_P(DepthClampingTest, ClampOnBeyondNearPlane) { - wgpu::PrimitiveDepthClampingState clampingState; - clampingState.clampDepth = true; +// Test that fragments beyond the far plane are clipped if unclippedDepth is false +TEST_P(DepthClippingTest, ClippedBeyondFarPlane) { + wgpu::PrimitiveDepthClipControl depthClipControl; + depthClipControl.unclippedDepth = false; + + DoTest( + { + // Draw a red triangle at depth 1. + { + nullptr, /* depthClipControl */ + RGBA8(255, 0, 0, 255), /* color */ + 1.f, /* depth */ + }, + // Draw a green triangle at depth 2 which should be clipped. + { + &depthClipControl, /* depthClipControl */ + RGBA8(0, 255, 0, 255), /* color */ + 2.f, /* depth */ + }, + }, + // The resulting fragment should be red since the green triangle is + // outside the clip volume. + RGBA8(255, 0, 0, 255)); +} + +// Test that fragments beyond the far plane are clipped if unclippedDepth is not specified +TEST_P(DepthClippingTest, ClippedBeyondFarPlaneFeatureUnused) { + DoTest( + { + // Draw a red triangle at depth 1. + { + nullptr, /* depthClipControl */ + RGBA8(255, 0, 0, 255), /* color */ + 1.f, /* depth */ + }, + // Draw a green triangle at depth 2 which should be clipped. + { + nullptr, /* depthClipControl */ + RGBA8(0, 255, 0, 255), /* color */ + 2.f, /* depth */ + }, + }, + // The resulting fragment should be red since the green triangle is + // outside the clip volume. + RGBA8(255, 0, 0, 255)); +} + +// Test that fragments beyond the near plane are not clipped if unclippedDepth is true +TEST_P(DepthClippingTest, UnclippedBeyondNearPlane) { + wgpu::PrimitiveDepthClipControl depthClipControl; + depthClipControl.unclippedDepth = true; DoTest( { // Draw a red triangle at depth 0. { - nullptr, /* depthClampingState */ + nullptr, /* depthClipControl */ RGBA8(255, 0, 0, 255), /* color */ 0.f, /* depth */ - wgpu::CompareFunction::Always, }, - // Draw a green triangle at depth -1 which should get clamped to 0. + // Draw a green triangle at depth -1 which should not be clipped. { - &clampingState, + &depthClipControl, /* depthClipControl */ RGBA8(0, 255, 0, 255), /* color */ -1.f, /* depth */ - wgpu::CompareFunction::Equal, }, }, - // Since we draw the green triangle with an "equal" depth compare function, the resulting - // fragment should be green. + // The resulting fragment should be green even though the green triangle is + // outside the clip volume. RGBA8(0, 255, 0, 255)); } -// Test that fragments inside the view frustum are unaffected by depth clamping. -TEST_P(DepthClampingTest, ClampOnInsideViewFrustum) { - wgpu::PrimitiveDepthClampingState clampingState; - clampingState.clampDepth = true; +// Test that fragments beyond the near plane are clipped if unclippedDepth is false +TEST_P(DepthClippingTest, ClippedBeyondNearPlane) { + wgpu::PrimitiveDepthClipControl depthClipControl; + depthClipControl.unclippedDepth = false; DoTest( { + // Draw a red triangle at depth 0. { - &clampingState, - RGBA8(0, 255, 0, 255), /* color */ - 0.5f, /* depth */ - wgpu::CompareFunction::Always, + nullptr, /* depthClipControl */ + RGBA8(255, 0, 0, 255), /* color */ + 0.f, /* depth */ }, - }, - RGBA8(0, 255, 0, 255)); -} - -// Test that fragments outside the view frustum are clipped if depth clamping is disabled. -TEST_P(DepthClampingTest, ClampOffOutsideViewFrustum) { - wgpu::PrimitiveDepthClampingState clampingState; - clampingState.clampDepth = false; - - DoTest( - { + // Draw a green triangle at depth -1 which should be clipped. { - &clampingState, - RGBA8(0, 255, 0, 255), /* color */ - 2.f, /* depth */ - wgpu::CompareFunction::Always, - }, - { - &clampingState, + &depthClipControl, /* depthClipControl */ RGBA8(0, 255, 0, 255), /* color */ -1.f, /* depth */ - wgpu::CompareFunction::Always, }, }, - RGBA8(0, 0, 0, 0)); + // The resulting fragment should be red because the green triangle is + // outside the clip volume. + RGBA8(255, 0, 0, 255)); } -// Test that fragments outside the view frustum are clipped if clampDepth is left unspecified. -TEST_P(DepthClampingTest, ClampUnspecifiedOutsideViewFrustum) { +// Test that fragments beyond the near plane are clipped if unclippedDepth is not specified +TEST_P(DepthClippingTest, ClippedBeyondNearPlaneFeatureUnused) { DoTest( { + // Draw a red triangle at depth 0. { - nullptr, /* depthClampingState */ + nullptr, /* depthClipControl */ + RGBA8(255, 0, 0, 255), /* color */ + 0.f, /* depth */ + }, + // Draw a green triangle at depth -1 which should be clipped. + { + nullptr, /* depthClipControl */ RGBA8(0, 255, 0, 255), /* color */ -1.f, /* depth */ - wgpu::CompareFunction::Always, - }, - { - nullptr, /* depthClampingState */ - RGBA8(0, 255, 0, 255), /* color */ - 2.f, /* depth */ - wgpu::CompareFunction::Always, }, }, - RGBA8(0, 0, 0, 0)); + // The resulting fragment should be red because the green triangle is + // outside the clip volume. + RGBA8(255, 0, 0, 255)); } // Test that fragments are properly clipped or clamped if multiple render pipelines are used -// within the same render pass with differing clampDepth values. -TEST_P(DepthClampingTest, MultipleRenderPipelines) { - wgpu::PrimitiveDepthClampingState clampingState; - clampingState.clampDepth = true; +// within the same render pass with differing unclippedDepth values. +TEST_P(DepthClippingTest, MultipleRenderPipelines) { + wgpu::PrimitiveDepthClipControl depthClipControl1; + depthClipControl1.unclippedDepth = true; - wgpu::PrimitiveDepthClampingState clippingState; - clippingState.clampDepth = false; + wgpu::PrimitiveDepthClipControl depthClipControl2; + depthClipControl2.unclippedDepth = false; DoTest( { - // Draw green with clamping + // Draw green with no clipping { - &clampingState, - RGBA8(0, 255, 0, 255), /* color */ - 2.f, /* depth */ - wgpu::CompareFunction::Always, + &depthClipControl1, RGBA8(0, 255, 0, 255), /* color */ + 2.f, /* depth */ }, // Draw red with clipping { - &clippingState, - RGBA8(255, 0, 0, 255), /* color */ - 2.f, /* depth */ - wgpu::CompareFunction::Always, + &depthClipControl2, RGBA8(255, 0, 0, 255), /* color */ + 2.f, /* depth */ }, }, RGBA8(0, 255, 0, 255)); // Result should be green } -DAWN_INSTANTIATE_TEST(DepthClampingTest, +// Test that fragments are not clipped if unclippedDepth is true and that their +// depths are not being clamped instead. In the fragment shader, we should see +// depth values outside the viewport. +TEST_P(DepthClippingTest, UnclippedNotClamped) { + wgpu::PrimitiveDepthClipControl depthClipControl; + depthClipControl.unclippedDepth = true; + + // Create a pipeline to render a point. + utils::ComboRenderPipelineDescriptor descriptor; + descriptor.primitive.nextInChain = &depthClipControl; + descriptor.primitive.topology = wgpu::PrimitiveTopology::PointList; + // Draw the point at (0, 0) with depth 2.0. + descriptor.vertex.module = utils::CreateShaderModule(device, R"( + @vertex fn main() -> @builtin(position) vec4 { + return vec4(0.0, 0.0, 2.0, 1.0); + })"); + // Write frag_pos.z / 4.0 which should be about 0.5 to the red channel. + // This is the depth output from the vertex shader which is not clamped to the viewport. + descriptor.cFragment.module = utils::CreateShaderModule(device, R"( + @fragment fn main(@builtin(position) frag_pos: vec4) -> @location(0) vec4 { + return vec4(frag_pos.z / 4.0, 0.0, 0.0, 1.0); + })"); + wgpu::DepthStencilState* depthStencil = descriptor.EnableDepthStencil(); + depthStencil->depthWriteEnabled = true; + depthStencil->format = wgpu::TextureFormat::Depth24PlusStencil8; + + wgpu::RenderPipeline pipeline = device.CreateRenderPipeline(&descriptor); + + // Draw the point. + wgpu::CommandEncoder encoder = device.CreateCommandEncoder(); + utils::ComboRenderPassDescriptor renderPass({renderTargetView}, depthTextureView); + wgpu::RenderPassEncoder pass = encoder.BeginRenderPass(&renderPass); + pass.SetPipeline(pipeline); + pass.Draw(1); + pass.End(); + wgpu::CommandBuffer commands = encoder.Finish(); + queue.Submit(1, &commands); + + EXPECT_PIXEL_RGBA8_BETWEEN(RGBA8(127, 0, 0, 255), RGBA8(128, 0, 0, 255), renderTarget, 0, 0) + << "Pixel check failed"; +} + +DAWN_INSTANTIATE_TEST(DepthClippingTest, D3D12Backend(), MetalBackend(), OpenGLBackend(), diff --git a/src/dawn/tests/unittests/ChainUtilsTests.cpp b/src/dawn/tests/unittests/ChainUtilsTests.cpp index 87d7b46162..c1bea5b9d6 100644 --- a/src/dawn/tests/unittests/ChainUtilsTests.cpp +++ b/src/dawn/tests/unittests/ChainUtilsTests.cpp @@ -19,7 +19,7 @@ // Checks that we cannot find any structs in an empty chain TEST(ChainUtilsTests, FindEmptyChain) { - const dawn::native::PrimitiveDepthClampingState* info = nullptr; + const dawn::native::PrimitiveDepthClipControl* info = nullptr; dawn::native::FindInChain(nullptr, &info); ASSERT_EQ(nullptr, info); @@ -27,10 +27,10 @@ TEST(ChainUtilsTests, FindEmptyChain) { // Checks that searching a chain for a present struct returns that struct TEST(ChainUtilsTests, FindPresentInChain) { - dawn::native::PrimitiveDepthClampingState chain1; + dawn::native::PrimitiveDepthClipControl chain1; dawn::native::ShaderModuleSPIRVDescriptor chain2; chain1.nextInChain = &chain2; - const dawn::native::PrimitiveDepthClampingState* info1 = nullptr; + const dawn::native::PrimitiveDepthClipControl* info1 = nullptr; const dawn::native::ShaderModuleSPIRVDescriptor* info2 = nullptr; dawn::native::FindInChain(&chain1, &info1); dawn::native::FindInChain(&chain1, &info2); @@ -41,7 +41,7 @@ TEST(ChainUtilsTests, FindPresentInChain) { // Checks that searching a chain for a struct that doesn't exist returns a nullptr TEST(ChainUtilsTests, FindMissingInChain) { - dawn::native::PrimitiveDepthClampingState chain1; + dawn::native::PrimitiveDepthClipControl chain1; dawn::native::ShaderModuleSPIRVDescriptor chain2; chain1.nextInChain = &chain2; const dawn::native::SurfaceDescriptorFromMetalLayer* info = nullptr; @@ -52,9 +52,9 @@ TEST(ChainUtilsTests, FindMissingInChain) { // Checks that validation rejects chains with duplicate STypes TEST(ChainUtilsTests, ValidateDuplicateSTypes) { - dawn::native::PrimitiveDepthClampingState chain1; + dawn::native::PrimitiveDepthClipControl chain1; dawn::native::ShaderModuleSPIRVDescriptor chain2; - dawn::native::PrimitiveDepthClampingState chain3; + dawn::native::PrimitiveDepthClipControl chain3; chain1.nextInChain = &chain2; chain2.nextInChain = &chain3; @@ -65,7 +65,7 @@ TEST(ChainUtilsTests, ValidateDuplicateSTypes) { // Checks that validation rejects chains that contain unspecified STypes TEST(ChainUtilsTests, ValidateUnspecifiedSTypes) { - dawn::native::PrimitiveDepthClampingState chain1; + dawn::native::PrimitiveDepthClipControl chain1; dawn::native::ShaderModuleSPIRVDescriptor chain2; dawn::native::ShaderModuleWGSLDescriptor chain3; chain1.nextInChain = &chain2; @@ -73,7 +73,7 @@ TEST(ChainUtilsTests, ValidateUnspecifiedSTypes) { dawn::native::MaybeError result = dawn::native::ValidateSTypes(&chain1, { - {wgpu::SType::PrimitiveDepthClampingState}, + {wgpu::SType::PrimitiveDepthClipControl}, {wgpu::SType::ShaderModuleSPIRVDescriptor}, }); ASSERT_TRUE(result.IsError()); @@ -83,7 +83,7 @@ TEST(ChainUtilsTests, ValidateUnspecifiedSTypes) { // Checks that validation rejects chains that contain multiple STypes from the same oneof // constraint. TEST(ChainUtilsTests, ValidateOneOfFailure) { - dawn::native::PrimitiveDepthClampingState chain1; + dawn::native::PrimitiveDepthClipControl chain1; dawn::native::ShaderModuleSPIRVDescriptor chain2; dawn::native::ShaderModuleWGSLDescriptor chain3; chain1.nextInChain = &chain2; @@ -98,7 +98,7 @@ TEST(ChainUtilsTests, ValidateOneOfFailure) { // Checks that validation accepts chains that match the constraints. TEST(ChainUtilsTests, ValidateSuccess) { - dawn::native::PrimitiveDepthClampingState chain1; + dawn::native::PrimitiveDepthClipControl chain1; dawn::native::ShaderModuleSPIRVDescriptor chain2; chain1.nextInChain = &chain2; @@ -106,7 +106,7 @@ TEST(ChainUtilsTests, ValidateSuccess) { &chain1, { {wgpu::SType::ShaderModuleSPIRVDescriptor, wgpu::SType::ShaderModuleWGSLDescriptor}, - {wgpu::SType::PrimitiveDepthClampingState}, + {wgpu::SType::PrimitiveDepthClipControl}, {wgpu::SType::SurfaceDescriptorFromMetalLayer}, }); ASSERT_TRUE(result.IsSuccess()); @@ -117,7 +117,7 @@ TEST(ChainUtilsTests, ValidateEmptyChain) { dawn::native::MaybeError result = dawn::native::ValidateSTypes(nullptr, { {wgpu::SType::ShaderModuleSPIRVDescriptor}, - {wgpu::SType::PrimitiveDepthClampingState}, + {wgpu::SType::PrimitiveDepthClipControl}, }); ASSERT_TRUE(result.IsSuccess()); @@ -132,22 +132,22 @@ TEST(ChainUtilsTests, ValidateSingleEmptyChain) { ASSERT_TRUE(result.IsSuccess()); result = dawn::native::ValidateSingleSType(nullptr, wgpu::SType::ShaderModuleSPIRVDescriptor, - wgpu::SType::PrimitiveDepthClampingState); + wgpu::SType::PrimitiveDepthClipControl); ASSERT_TRUE(result.IsSuccess()); } // Checks that singleton validation always fails on chains with multiple children. TEST(ChainUtilsTests, ValidateSingleMultiChain) { - dawn::native::PrimitiveDepthClampingState chain1; + dawn::native::PrimitiveDepthClipControl chain1; dawn::native::ShaderModuleSPIRVDescriptor chain2; chain1.nextInChain = &chain2; dawn::native::MaybeError result = - dawn::native::ValidateSingleSType(&chain1, wgpu::SType::PrimitiveDepthClampingState); + dawn::native::ValidateSingleSType(&chain1, wgpu::SType::PrimitiveDepthClipControl); ASSERT_TRUE(result.IsError()); result.AcquireError(); - result = dawn::native::ValidateSingleSType(&chain1, wgpu::SType::PrimitiveDepthClampingState, + result = dawn::native::ValidateSingleSType(&chain1, wgpu::SType::PrimitiveDepthClipControl, wgpu::SType::ShaderModuleSPIRVDescriptor); ASSERT_TRUE(result.IsError()); result.AcquireError(); @@ -172,7 +172,7 @@ TEST(ChainUtilsTests, ValidateSingleSatisfied) { // Checks that singleton validation passes when the oneof constraint is not met. TEST(ChainUtilsTests, ValidateSingleUnsatisfied) { - dawn::native::PrimitiveDepthClampingState chain1; + dawn::native::PrimitiveDepthClipControl chain1; dawn::native::MaybeError result = dawn::native::ValidateSingleSType(&chain1, wgpu::SType::ShaderModuleWGSLDescriptor); diff --git a/src/dawn/tests/unittests/validation/DeviceValidationTests.cpp b/src/dawn/tests/unittests/validation/DeviceValidationTests.cpp index 2ed5916084..e1c9e0b781 100644 --- a/src/dawn/tests/unittests/validation/DeviceValidationTests.cpp +++ b/src/dawn/tests/unittests/validation/DeviceValidationTests.cpp @@ -201,9 +201,9 @@ TEST_F(RequestDeviceValidationTest, LowerIsBetter) { // Test that it is an error to request limits with an invalid chained struct TEST_F(RequestDeviceValidationTest, InvalidChainedStruct) { - wgpu::PrimitiveDepthClampingState depthClamp = {}; + wgpu::PrimitiveDepthClipControl depthClipControl = {}; wgpu::RequiredLimits limits = {}; - limits.nextInChain = &depthClamp; + limits.nextInChain = &depthClipControl; wgpu::DeviceDescriptor descriptor; descriptor.requiredLimits = &limits; diff --git a/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp b/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp index c1c36a8625..5271228122 100644 --- a/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp +++ b/src/dawn/tests/unittests/validation/RenderPipelineValidationTests.cpp @@ -975,15 +975,15 @@ TEST_F(RenderPipelineValidationTest, StripIndexFormatAllowed) { } } -// Test that specifying a clampDepth value is an error if the feature is not enabled. -TEST_F(RenderPipelineValidationTest, ClampDepthWithoutFeature) { +// Test that specifying a unclippedDepth value is an error if the feature is not enabled. +TEST_F(RenderPipelineValidationTest, UnclippedDepthWithoutFeature) { { utils::ComboRenderPipelineDescriptor descriptor; descriptor.vertex.module = vsModule; descriptor.cFragment.module = fsModule; - wgpu::PrimitiveDepthClampingState clampingState; - clampingState.clampDepth = true; - descriptor.primitive.nextInChain = &clampingState; + wgpu::PrimitiveDepthClipControl depthClipControl; + depthClipControl.unclippedDepth = true; + descriptor.primitive.nextInChain = &depthClipControl; ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor), testing::HasSubstr("not supported")); } @@ -991,9 +991,9 @@ TEST_F(RenderPipelineValidationTest, ClampDepthWithoutFeature) { utils::ComboRenderPipelineDescriptor descriptor; descriptor.vertex.module = vsModule; descriptor.cFragment.module = fsModule; - wgpu::PrimitiveDepthClampingState clampingState; - clampingState.clampDepth = false; - descriptor.primitive.nextInChain = &clampingState; + wgpu::PrimitiveDepthClipControl depthClipControl; + depthClipControl.unclippedDepth = false; + descriptor.primitive.nextInChain = &depthClipControl; ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor), testing::HasSubstr("not supported")); } @@ -1023,24 +1023,6 @@ TEST_F(RenderPipelineValidationTest, DepthClipControlWithoutFeature) { } } -// Test that using both DepthClipControl and DepthClamp features is invalid. -TEST_F(RenderPipelineValidationTest, DepthClipControlAndDepthClampInvalid) { - utils::ComboRenderPipelineDescriptor descriptor; - descriptor.vertex.module = vsModule; - descriptor.cFragment.module = fsModule; - - wgpu::PrimitiveDepthClipControl depthClipControl; - depthClipControl.unclippedDepth = false; - descriptor.primitive.nextInChain = &depthClipControl; - - wgpu::PrimitiveDepthClampingState clampingState; - clampingState.clampDepth = false; - depthClipControl.nextInChain = &clampingState; - - ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor), - testing::HasSubstr("only contain a single chained struct")); -} - // Test that depthStencil.depthCompare must not be undefiend. TEST_F(RenderPipelineValidationTest, DepthCompareUndefinedIsError) { utils::ComboRenderPipelineDescriptor descriptor; @@ -1359,35 +1341,35 @@ TEST_F(RenderPipelineValidationTest, BindingsFromCorrectEntryPoint) { ASSERT_DEVICE_ERROR(device.CreateRenderPipeline(&descriptor)); } -class DepthClampingValidationTest : public RenderPipelineValidationTest { +class DepthClipControlValidationTest : public RenderPipelineValidationTest { protected: WGPUDevice CreateTestDevice(dawn::native::Adapter dawnAdapter) override { wgpu::DeviceDescriptor descriptor; - wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::DepthClamping}; + wgpu::FeatureName requiredFeatures[1] = {wgpu::FeatureName::DepthClipControl}; descriptor.requiredFeatures = requiredFeatures; descriptor.requiredFeaturesCount = 1; return dawnAdapter.CreateDevice(&descriptor); } }; -// Tests that specifying a clampDepth value succeeds if the feature is enabled. -TEST_F(DepthClampingValidationTest, Success) { +// Tests that specifying a unclippedDepth value succeeds if the feature is enabled. +TEST_F(DepthClipControlValidationTest, Success) { { utils::ComboRenderPipelineDescriptor descriptor; descriptor.vertex.module = vsModule; descriptor.cFragment.module = fsModule; - wgpu::PrimitiveDepthClampingState clampingState; - clampingState.clampDepth = true; - descriptor.primitive.nextInChain = &clampingState; + wgpu::PrimitiveDepthClipControl depthClipControl; + depthClipControl.unclippedDepth = true; + descriptor.primitive.nextInChain = &depthClipControl; device.CreateRenderPipeline(&descriptor); } { utils::ComboRenderPipelineDescriptor descriptor; descriptor.vertex.module = vsModule; descriptor.cFragment.module = fsModule; - wgpu::PrimitiveDepthClampingState clampingState; - clampingState.clampDepth = false; - descriptor.primitive.nextInChain = &clampingState; + wgpu::PrimitiveDepthClipControl depthClipControl; + depthClipControl.unclippedDepth = false; + descriptor.primitive.nextInChain = &depthClipControl; device.CreateRenderPipeline(&descriptor); } } diff --git a/src/dawn/tests/unittests/wire/WireExtensionTests.cpp b/src/dawn/tests/unittests/wire/WireExtensionTests.cpp index 6060ce5d7b..b36e2447e4 100644 --- a/src/dawn/tests/unittests/wire/WireExtensionTests.cpp +++ b/src/dawn/tests/unittests/wire/WireExtensionTests.cpp @@ -36,10 +36,10 @@ TEST_F(WireExtensionTests, ChainedStruct) { EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiShaderModule)); FlushClient(); - WGPUPrimitiveDepthClampingState clientExt = {}; - clientExt.chain.sType = WGPUSType_PrimitiveDepthClampingState; + WGPUPrimitiveDepthClipControl clientExt = {}; + clientExt.chain.sType = WGPUSType_PrimitiveDepthClipControl; clientExt.chain.next = nullptr; - clientExt.clampDepth = true; + clientExt.unclippedDepth = true; WGPURenderPipelineDescriptor renderPipelineDesc = {}; renderPipelineDesc.vertex.module = shaderModule; @@ -50,10 +50,10 @@ TEST_F(WireExtensionTests, ChainedStruct) { EXPECT_CALL(api, DeviceCreateRenderPipeline(apiDevice, NotNull())) .WillOnce(Invoke( [&](Unused, const WGPURenderPipelineDescriptor* serverDesc) -> WGPURenderPipeline { - const auto* ext = reinterpret_cast( + const auto* ext = reinterpret_cast( serverDesc->primitive.nextInChain); EXPECT_EQ(ext->chain.sType, clientExt.chain.sType); - EXPECT_EQ(ext->clampDepth, true); + EXPECT_EQ(ext->unclippedDepth, true); EXPECT_EQ(ext->chain.next, nullptr); return api.GetNewRenderPipeline(); @@ -69,15 +69,15 @@ TEST_F(WireExtensionTests, MutlipleChainedStructs) { EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiShaderModule)); FlushClient(); - WGPUPrimitiveDepthClampingState clientExt2 = {}; - clientExt2.chain.sType = WGPUSType_PrimitiveDepthClampingState; + WGPUPrimitiveDepthClipControl clientExt2 = {}; + clientExt2.chain.sType = WGPUSType_PrimitiveDepthClipControl; clientExt2.chain.next = nullptr; - clientExt2.clampDepth = false; + clientExt2.unclippedDepth = false; - WGPUPrimitiveDepthClampingState clientExt1 = {}; - clientExt1.chain.sType = WGPUSType_PrimitiveDepthClampingState; + WGPUPrimitiveDepthClipControl clientExt1 = {}; + clientExt1.chain.sType = WGPUSType_PrimitiveDepthClipControl; clientExt1.chain.next = &clientExt2.chain; - clientExt1.clampDepth = true; + clientExt1.unclippedDepth = true; WGPURenderPipelineDescriptor renderPipelineDesc = {}; renderPipelineDesc.vertex.module = shaderModule; @@ -88,15 +88,15 @@ TEST_F(WireExtensionTests, MutlipleChainedStructs) { EXPECT_CALL(api, DeviceCreateRenderPipeline(apiDevice, NotNull())) .WillOnce(Invoke( [&](Unused, const WGPURenderPipelineDescriptor* serverDesc) -> WGPURenderPipeline { - const auto* ext1 = reinterpret_cast( + const auto* ext1 = reinterpret_cast( serverDesc->primitive.nextInChain); EXPECT_EQ(ext1->chain.sType, clientExt1.chain.sType); - EXPECT_EQ(ext1->clampDepth, true); + EXPECT_EQ(ext1->unclippedDepth, true); const auto* ext2 = - reinterpret_cast(ext1->chain.next); + reinterpret_cast(ext1->chain.next); EXPECT_EQ(ext2->chain.sType, clientExt2.chain.sType); - EXPECT_EQ(ext2->clampDepth, false); + EXPECT_EQ(ext2->unclippedDepth, false); EXPECT_EQ(ext2->chain.next, nullptr); return api.GetNewRenderPipeline(); @@ -112,15 +112,15 @@ TEST_F(WireExtensionTests, MutlipleChainedStructs) { EXPECT_CALL(api, DeviceCreateRenderPipeline(apiDevice, NotNull())) .WillOnce(Invoke( [&](Unused, const WGPURenderPipelineDescriptor* serverDesc) -> WGPURenderPipeline { - const auto* ext2 = reinterpret_cast( + const auto* ext2 = reinterpret_cast( serverDesc->primitive.nextInChain); EXPECT_EQ(ext2->chain.sType, clientExt2.chain.sType); - EXPECT_EQ(ext2->clampDepth, false); + EXPECT_EQ(ext2->unclippedDepth, false); const auto* ext1 = - reinterpret_cast(ext2->chain.next); + reinterpret_cast(ext2->chain.next); EXPECT_EQ(ext1->chain.sType, clientExt1.chain.sType); - EXPECT_EQ(ext1->clampDepth, true); + EXPECT_EQ(ext1->unclippedDepth, true); EXPECT_EQ(ext1->chain.next, nullptr); return api.GetNewRenderPipeline(); @@ -136,7 +136,7 @@ TEST_F(WireExtensionTests, InvalidSType) { EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiShaderModule)); FlushClient(); - WGPUPrimitiveDepthClampingState clientExt = {}; + WGPUPrimitiveDepthClipControl clientExt = {}; clientExt.chain.sType = WGPUSType_Invalid; clientExt.chain.next = nullptr; @@ -164,7 +164,7 @@ TEST_F(WireExtensionTests, UnknownSType) { EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiShaderModule)); FlushClient(); - WGPUPrimitiveDepthClampingState clientExt = {}; + WGPUPrimitiveDepthClipControl clientExt = {}; clientExt.chain.sType = static_cast(-1); clientExt.chain.next = nullptr; @@ -193,14 +193,14 @@ TEST_F(WireExtensionTests, ValidAndInvalidSTypeInChain) { EXPECT_CALL(api, DeviceCreateShaderModule(apiDevice, _)).WillOnce(Return(apiShaderModule)); FlushClient(); - WGPUPrimitiveDepthClampingState clientExt2 = {}; + WGPUPrimitiveDepthClipControl clientExt2 = {}; clientExt2.chain.sType = WGPUSType_Invalid; clientExt2.chain.next = nullptr; - WGPUPrimitiveDepthClampingState clientExt1 = {}; - clientExt1.chain.sType = WGPUSType_PrimitiveDepthClampingState; + WGPUPrimitiveDepthClipControl clientExt1 = {}; + clientExt1.chain.sType = WGPUSType_PrimitiveDepthClipControl; clientExt1.chain.next = &clientExt2.chain; - clientExt1.clampDepth = true; + clientExt1.unclippedDepth = true; WGPURenderPipelineDescriptor renderPipelineDesc = {}; renderPipelineDesc.vertex.module = shaderModule; @@ -211,10 +211,10 @@ TEST_F(WireExtensionTests, ValidAndInvalidSTypeInChain) { EXPECT_CALL(api, DeviceCreateRenderPipeline(apiDevice, NotNull())) .WillOnce(Invoke( [&](Unused, const WGPURenderPipelineDescriptor* serverDesc) -> WGPURenderPipeline { - const auto* ext = reinterpret_cast( + const auto* ext = reinterpret_cast( serverDesc->primitive.nextInChain); EXPECT_EQ(ext->chain.sType, clientExt1.chain.sType); - EXPECT_EQ(ext->clampDepth, true); + EXPECT_EQ(ext->unclippedDepth, true); EXPECT_EQ(ext->chain.next->sType, WGPUSType_Invalid); EXPECT_EQ(ext->chain.next->next, nullptr); @@ -233,10 +233,10 @@ TEST_F(WireExtensionTests, ValidAndInvalidSTypeInChain) { [&](Unused, const WGPURenderPipelineDescriptor* serverDesc) -> WGPURenderPipeline { EXPECT_EQ(serverDesc->primitive.nextInChain->sType, WGPUSType_Invalid); - const auto* ext = reinterpret_cast( + const auto* ext = reinterpret_cast( serverDesc->primitive.nextInChain->next); EXPECT_EQ(ext->chain.sType, clientExt1.chain.sType); - EXPECT_EQ(ext->clampDepth, true); + EXPECT_EQ(ext->unclippedDepth, true); EXPECT_EQ(ext->chain.next, nullptr); return api.GetNewRenderPipeline(); diff --git a/src/dawn/wire/SupportedFeatures.cpp b/src/dawn/wire/SupportedFeatures.cpp index 3deb1a7c05..aca064fa9c 100644 --- a/src/dawn/wire/SupportedFeatures.cpp +++ b/src/dawn/wire/SupportedFeatures.cpp @@ -32,7 +32,6 @@ bool IsFeatureSupported(WGPUFeatureName feature) { case WGPUFeatureName_TextureCompressionASTC: case WGPUFeatureName_IndirectFirstInstance: case WGPUFeatureName_DepthClipControl: - case WGPUFeatureName_DepthClamping: case WGPUFeatureName_DawnShaderFloat16: case WGPUFeatureName_DawnInternalUsages: case WGPUFeatureName_DawnMultiPlanarFormats: diff --git a/webgpu-cts/expectations.txt b/webgpu-cts/expectations.txt index cc2759c4b2..fc18769734 100644 --- a/webgpu-cts/expectations.txt +++ b/webgpu-cts/expectations.txt @@ -246,10 +246,9 @@ crbug.com/dawn/0000 webgpu:util,texture,texel_data:unorm_texel_data_in_shader:fo ################################################################################ # depth_clip_clamp failures -# KEEP ################################################################################ -crbug.com/dawn/0000 webgpu:api,operation,rendering,depth_clip_clamp:depth_clamp_and_clip:* [ Failure ] -crbug.com/dawn/0000 webgpu:api,operation,rendering,depth_clip_clamp:depth_test_input_clamped:* [ Failure ] +crbug.com/dawn/1125 [ linux ] webgpu:api,operation,rendering,depth_clip_clamp:depth_clamp_and_clip:* [ Failure ] +crbug.com/dawn/1125 [ linux ] webgpu:api,operation,rendering,depth_clip_clamp:depth_test_input_clamped:* [ Failure ] ################################################################################ # compilation_info failures