| // |
| // Copyright 2019 The ANGLE Project Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| // |
| // mtl_state_cache.mm: |
| // Implements StateCache, RenderPipelineCache and various |
| // C struct versions of Metal sampler, depth stencil, render pass, render pipeline descriptors. |
| // |
| |
| #include "libANGLE/renderer/metal/mtl_state_cache.h" |
| |
| #include <sstream> |
| |
| #include "common/debug.h" |
| #include "common/span.h" |
| #include "common/unsafe_buffers.h" |
| #include "libANGLE/renderer/metal/ContextMtl.h" |
| #include "libANGLE/renderer/metal/mtl_resources.h" |
| #include "libANGLE/renderer/metal/mtl_utils.h" |
| #include "platform/autogen/FeaturesMtl_autogen.h" |
| |
| namespace rx |
| { |
| namespace mtl |
| { |
| |
| namespace |
| { |
| |
| inline angle::ObjCPtr<MTLStencilDescriptor> ToObjC(const StencilDesc &desc) |
| { |
| auto objCDesc = angle::adoptObjCPtr([[MTLStencilDescriptor alloc] init]); |
| objCDesc.get().stencilFailureOperation = desc.getStencilFailureOperation(); |
| objCDesc.get().depthFailureOperation = desc.getDepthFailureOperation(); |
| objCDesc.get().depthStencilPassOperation = desc.getDepthStencilPassOperation(); |
| objCDesc.get().stencilCompareFunction = desc.getStencilCompareFunction(); |
| objCDesc.get().readMask = desc.readMask; |
| objCDesc.get().writeMask = desc.writeMask; |
| return objCDesc; |
| } |
| |
| inline angle::ObjCPtr<MTLDepthStencilDescriptor> ToObjC(const DepthStencilDesc &desc) |
| { |
| auto objCDesc = angle::adoptObjCPtr([[MTLDepthStencilDescriptor alloc] init]); |
| objCDesc.get().backFaceStencil = ToObjC(desc.backFaceStencil); |
| objCDesc.get().frontFaceStencil = ToObjC(desc.frontFaceStencil); |
| objCDesc.get().depthCompareFunction = desc.getDepthCompareFunction(); |
| objCDesc.get().depthWriteEnabled = desc.isDepthWriteEnabled(); |
| return objCDesc; |
| } |
| |
| inline angle::ObjCPtr<MTLSamplerDescriptor> ToObjC(const SamplerDesc &desc) |
| { |
| auto objCDesc = angle::adoptObjCPtr([[MTLSamplerDescriptor alloc] init]); |
| objCDesc.get().rAddressMode = desc.getRAddressMode(); |
| objCDesc.get().sAddressMode = desc.getSAddressMode(); |
| objCDesc.get().tAddressMode = desc.getTAddressMode(); |
| objCDesc.get().minFilter = desc.getMinFilter(); |
| objCDesc.get().magFilter = desc.getMagFilter(); |
| objCDesc.get().mipFilter = desc.getMipFilter(); |
| objCDesc.get().maxAnisotropy = desc.getMaxAnisotropy(); |
| objCDesc.get().compareFunction = desc.getCompareFunction(); |
| return objCDesc; |
| } |
| |
| inline angle::ObjCPtr<MTLVertexAttributeDescriptor> ToObjC(const VertexAttributeDesc &desc) |
| { |
| auto objCDesc = angle::adoptObjCPtr([[MTLVertexAttributeDescriptor alloc] init]); |
| objCDesc.get().format = desc.getFormat(); |
| objCDesc.get().offset = desc.getOffset(); |
| objCDesc.get().bufferIndex = desc.getBufferIndex(); |
| ASSERT(desc.getBufferIndex() >= kVboBindingIndexStart); |
| return objCDesc; |
| } |
| |
| inline angle::ObjCPtr<MTLVertexBufferLayoutDescriptor> ToObjC(const VertexBufferLayoutDesc &desc) |
| { |
| auto objCDesc = angle::adoptObjCPtr([[MTLVertexBufferLayoutDescriptor alloc] init]); |
| objCDesc.get().stepFunction = desc.getStepFunction(); |
| objCDesc.get().stepRate = desc.stepRate; |
| objCDesc.get().stride = desc.stride; |
| return objCDesc; |
| } |
| |
| inline angle::ObjCPtr<MTLVertexDescriptor> ToObjC(const VertexDesc &desc) |
| { |
| auto objCDesc = angle::adoptObjCPtr([[MTLVertexDescriptor alloc] init]); |
| [objCDesc reset]; |
| |
| for (uint8_t i = 0; i < desc.numAttribs; ++i) |
| { |
| [objCDesc.get().attributes setObject:ToObjC(ANGLE_UNSAFE_TODO(desc.attributes[i])) |
| atIndexedSubscript:i]; |
| } |
| |
| for (uint8_t i = 0; i < desc.numBufferLayouts; ++i) |
| { |
| // Ignore if stepFunction is kVertexStepFunctionInvalid. |
| // If we don't set this slot, it will apparently be disabled by metal runtime. |
| if (ANGLE_UNSAFE_TODO(desc.layouts[i].getStepFunction()) != kVertexStepFunctionInvalid) |
| { |
| [objCDesc.get().layouts setObject:ToObjC(ANGLE_UNSAFE_TODO(desc.layouts[i])) |
| atIndexedSubscript:i]; |
| } |
| } |
| |
| return objCDesc; |
| } |
| |
| inline angle::ObjCPtr<MTLRenderPipelineColorAttachmentDescriptor> ToObjC( |
| const RenderPipelineColorAttachmentDesc &desc) |
| { |
| auto objCDesc = angle::adoptObjCPtr([[MTLRenderPipelineColorAttachmentDescriptor alloc] init]); |
| objCDesc.get().pixelFormat = desc.getPixelFormat(); |
| objCDesc.get().writeMask = desc.getWriteMask(); |
| objCDesc.get().sourceRGBBlendFactor = desc.getSourceRgbBlendFactor(); |
| objCDesc.get().sourceAlphaBlendFactor = desc.getSourceAlphaBlendFactor(); |
| objCDesc.get().destinationRGBBlendFactor = desc.getDestinationRgbBlendFactor(); |
| objCDesc.get().destinationAlphaBlendFactor = desc.getDestinationAlphaBlendFactor(); |
| objCDesc.get().rgbBlendOperation = desc.getRgbBlendOperation(); |
| objCDesc.get().alphaBlendOperation = desc.getAlphaBlendOperation(); |
| objCDesc.get().blendingEnabled = desc.isBlendingEnabled(); |
| return objCDesc; |
| } |
| |
| id<MTLTexture> ToObjC(const TextureRef &texture) |
| { |
| auto textureRef = texture; |
| return textureRef ? textureRef->get() : nil; |
| } |
| |
| void BaseRenderPassAttachmentDescToObjC(const RenderPassAttachmentDesc &src, |
| MTLRenderPassAttachmentDescriptor *dst) |
| { |
| const TextureRef &implicitMsTexture = src.implicitMSTexture; |
| |
| if (implicitMsTexture) |
| { |
| dst.texture = ToObjC(implicitMsTexture); |
| dst.level = 0; |
| dst.slice = 0; |
| dst.depthPlane = 0; |
| dst.resolveTexture = ToObjC(src.texture); |
| dst.resolveLevel = src.level.get(); |
| if (dst.resolveTexture.textureType == MTLTextureType3D) |
| { |
| dst.resolveDepthPlane = src.sliceOrDepth; |
| dst.resolveSlice = 0; |
| } |
| else |
| { |
| dst.resolveSlice = src.sliceOrDepth; |
| dst.resolveDepthPlane = 0; |
| } |
| } |
| else |
| { |
| dst.texture = ToObjC(src.texture); |
| dst.level = src.level.get(); |
| if (dst.texture.textureType == MTLTextureType3D) |
| { |
| dst.depthPlane = src.sliceOrDepth; |
| dst.slice = 0; |
| } |
| else |
| { |
| dst.slice = src.sliceOrDepth; |
| dst.depthPlane = 0; |
| } |
| dst.resolveTexture = nil; |
| dst.resolveLevel = 0; |
| dst.resolveSlice = 0; |
| dst.resolveDepthPlane = 0; |
| } |
| |
| dst.loadAction = src.loadAction; |
| dst.storeAction = src.storeAction; |
| dst.storeActionOptions = src.storeActionOptions; |
| } |
| |
| void ToObjC(const RenderPassColorAttachmentDesc &desc, |
| MTLRenderPassColorAttachmentDescriptor *objCDesc) |
| { |
| BaseRenderPassAttachmentDescToObjC(desc, objCDesc); |
| objCDesc.clearColor = desc.clearColor; |
| } |
| |
| void ToObjC(const RenderPassDepthAttachmentDesc &desc, |
| MTLRenderPassDepthAttachmentDescriptor *objCDesc) |
| { |
| BaseRenderPassAttachmentDescToObjC(desc, objCDesc); |
| objCDesc.clearDepth = desc.clearDepth; |
| } |
| |
| void ToObjC(const RenderPassStencilAttachmentDesc &desc, |
| MTLRenderPassStencilAttachmentDescriptor *objCDesc) |
| { |
| BaseRenderPassAttachmentDescToObjC(desc, objCDesc); |
| objCDesc.clearStencil = desc.clearStencil; |
| } |
| |
| } // namespace |
| |
| void DepthStencilDesc::updateDepthTestEnabled(const gl::DepthStencilState &dsState) |
| { |
| if (!dsState.depthTest) |
| { |
| setDepthWriteDisabled(); |
| } |
| else |
| { |
| updateDepthCompareFunc(dsState); |
| updateDepthWriteEnabled(dsState); |
| } |
| } |
| |
| void DepthStencilDesc::updateDepthWriteEnabled(const gl::DepthStencilState &dsState) |
| { |
| mDepthWriteEnabled = dsState.depthTest && dsState.depthMask; |
| } |
| |
| void DepthStencilDesc::updateDepthCompareFunc(const gl::DepthStencilState &dsState) |
| { |
| if (!dsState.depthTest) |
| { |
| return; |
| } |
| mDepthCompareFunction = static_cast<uint32_t>(GetCompareFunc(dsState.depthFunc)); |
| } |
| |
| void DepthStencilDesc::updateStencilTestEnabled(const gl::DepthStencilState &dsState) |
| { |
| if (!dsState.stencilTest) |
| { |
| frontFaceStencil.setStencilCompareFunction(MTLCompareFunctionAlways); |
| frontFaceStencil.setDepthFailureOperation(MTLStencilOperationKeep); |
| frontFaceStencil.setDepthStencilPassOperation(MTLStencilOperationKeep); |
| frontFaceStencil.writeMask = 0; |
| |
| backFaceStencil.setStencilCompareFunction(MTLCompareFunctionAlways); |
| backFaceStencil.setDepthFailureOperation(MTLStencilOperationKeep); |
| backFaceStencil.setDepthStencilPassOperation(MTLStencilOperationKeep); |
| backFaceStencil.writeMask = 0; |
| } |
| else |
| { |
| updateStencilFrontFuncs(dsState); |
| updateStencilFrontOps(dsState); |
| updateStencilFrontWriteMask(dsState); |
| updateStencilBackFuncs(dsState); |
| updateStencilBackOps(dsState); |
| updateStencilBackWriteMask(dsState); |
| } |
| } |
| |
| void DepthStencilDesc::updateStencilFrontOps(const gl::DepthStencilState &dsState) |
| { |
| if (!dsState.stencilTest) |
| { |
| return; |
| } |
| frontFaceStencil.setStencilFailureOperation(GetStencilOp(dsState.stencilFail)); |
| frontFaceStencil.setDepthFailureOperation(GetStencilOp(dsState.stencilPassDepthFail)); |
| frontFaceStencil.setDepthStencilPassOperation(GetStencilOp(dsState.stencilPassDepthPass)); |
| } |
| |
| void DepthStencilDesc::updateStencilBackOps(const gl::DepthStencilState &dsState) |
| { |
| if (!dsState.stencilTest) |
| { |
| return; |
| } |
| backFaceStencil.setStencilFailureOperation(GetStencilOp(dsState.stencilBackFail)); |
| backFaceStencil.setDepthFailureOperation(GetStencilOp(dsState.stencilBackPassDepthFail)); |
| backFaceStencil.setDepthStencilPassOperation(GetStencilOp(dsState.stencilBackPassDepthPass)); |
| } |
| |
| void DepthStencilDesc::updateStencilFrontFuncs(const gl::DepthStencilState &dsState) |
| { |
| if (!dsState.stencilTest) |
| { |
| return; |
| } |
| frontFaceStencil.setStencilCompareFunction(GetCompareFunc(dsState.stencilFunc)); |
| frontFaceStencil.readMask = dsState.stencilMask & mtl::kStencilMaskAll; |
| } |
| |
| void DepthStencilDesc::updateStencilBackFuncs(const gl::DepthStencilState &dsState) |
| { |
| if (!dsState.stencilTest) |
| { |
| return; |
| } |
| backFaceStencil.setStencilCompareFunction(GetCompareFunc(dsState.stencilBackFunc)); |
| backFaceStencil.readMask = dsState.stencilBackMask & mtl::kStencilMaskAll; |
| } |
| |
| void DepthStencilDesc::updateStencilFrontWriteMask(const gl::DepthStencilState &dsState) |
| { |
| if (!dsState.stencilTest) |
| { |
| return; |
| } |
| frontFaceStencil.writeMask = dsState.stencilWritemask & mtl::kStencilMaskAll; |
| } |
| |
| void DepthStencilDesc::updateStencilBackWriteMask(const gl::DepthStencilState &dsState) |
| { |
| if (!dsState.stencilTest) |
| { |
| return; |
| } |
| backFaceStencil.writeMask = dsState.stencilBackWritemask & mtl::kStencilMaskAll; |
| } |
| |
| SamplerDesc::SamplerDesc(const gl::SamplerState &glState) |
| : mRAddressMode(static_cast<uint32_t>(GetSamplerAddressMode(glState.getWrapR()))), |
| mSAddressMode(static_cast<uint32_t>(GetSamplerAddressMode(glState.getWrapS()))), |
| mTAddressMode(static_cast<uint32_t>(GetSamplerAddressMode(glState.getWrapT()))), |
| mMinFilter(static_cast<uint32_t>(GetFilter(glState.getMinFilter()))), |
| mMagFilter(static_cast<uint32_t>(GetFilter(glState.getMagFilter()))), |
| mMipFilter(static_cast<uint32_t>(GetMipmapFilter(glState.getMinFilter()))), |
| mMaxAnisotropy(static_cast<uint32_t>(glState.getMaxAnisotropy())), |
| mCompareFunction(static_cast<uint32_t>(GetCompareFunc(glState.getCompareFunc()))) |
| { |
| } |
| |
| void BlendDesc::updateWriteMask(uint8_t angleMask) |
| { |
| ASSERT(angleMask == (angleMask & 0xF)); |
| |
| // ANGLE's packed color mask is abgr (matches Vulkan & D3D11), while Metal expects rgba. |
| #if defined(__aarch64__) |
| // ARM64 can reverse bits in a single instruction |
| mWriteMask = __builtin_bitreverse8(angleMask) >> 4; |
| #else |
| /* On other architectures, Clang generates a polyfill that uses more |
| instructions than the following expression optimized for a 4-bit value. |
| |
| (abgr * 0x41) & 0x14A: |
| .......abgr + |
| .abgr...... & |
| 00101001010 = |
| ..b.r..a.g. |
| |
| (b.r..a.g.) * 0x111: |
| b.r..a.g. + |
| b.r..a.g..... + |
| b.r..a.g......... = |
| b.r.bargbarg.a.g. |
| ^^^^ |
| */ |
| mWriteMask = ((((angleMask * 0x41) & 0x14A) * 0x111) >> 7) & 0xF; |
| #endif |
| } |
| |
| void RenderPipelineColorAttachmentDesc::reset(MTLPixelFormat format, MTLColorWriteMask writeMask) |
| { |
| // Reset the entire BlendDesc to defaults (blendingEnabled=false, default factors/operations), |
| // then set the specific values. |
| BlendDesc::operator=({}); |
| mWriteMask = static_cast<uint32_t>(writeMask); |
| mPixelFormat = static_cast<uint32_t>(format); |
| } |
| |
| void RenderPipelineColorAttachmentDesc::reset(MTLPixelFormat format, const BlendDesc &blendDesc) |
| { |
| BlendDesc::operator=(blendDesc); |
| mPixelFormat = static_cast<uint32_t>(format); |
| } |
| |
| bool RenderPipelineOutputDesc::operator==(const RenderPipelineOutputDesc &rhs) const |
| { |
| if (mNumColorAttachments != rhs.mNumColorAttachments) |
| { |
| return false; |
| } |
| |
| for (uint8_t i = 0; i < mNumColorAttachments; ++i) |
| { |
| if (colorAttachments[i] != rhs.colorAttachments[i]) |
| { |
| return false; |
| } |
| } |
| |
| return mDepthAttachmentPixelFormat == rhs.mDepthAttachmentPixelFormat && |
| mStencilAttachmentPixelFormat == rhs.mStencilAttachmentPixelFormat && |
| mRasterSampleCount == rhs.mRasterSampleCount; |
| } |
| |
| size_t RenderPipelineOutputDesc::hash() const |
| { |
| size_t hash = 0; |
| angle::HashCombine(hash, mNumColorAttachments); |
| for (uint8_t i = 0; i < mNumColorAttachments; ++i) |
| { |
| angle::HashCombine(hash, colorAttachments[i]); |
| } |
| angle::HashCombine(hash, mDepthAttachmentPixelFormat); |
| angle::HashCombine(hash, mStencilAttachmentPixelFormat); |
| angle::HashCombine(hash, mRasterSampleCount); |
| return hash; |
| } |
| |
| void RenderPipelineOutputDesc::updateEnabledDrawBuffers(gl::DrawBufferMask enabledBuffers) |
| { |
| for (uint32_t colorIndex = 0; colorIndex < mNumColorAttachments; ++colorIndex) |
| { |
| if (!enabledBuffers.test(colorIndex)) |
| { |
| colorAttachments[colorIndex].setWriteMask(MTLColorWriteMaskNone); |
| } |
| } |
| } |
| |
| bool RenderPipelineDesc::rasterizationEnabled() const |
| { |
| return mRasterizationType != static_cast<uint32_t>(RenderPipelineRasterization::Disabled); |
| } |
| |
| angle::ObjCPtr<MTLRenderPipelineDescriptor> RenderPipelineDesc::createMetalDesc( |
| id<MTLFunction> vertexShader, |
| id<MTLFunction> fragmentShader) const |
| { |
| auto objCDesc = angle::adoptObjCPtr([[MTLRenderPipelineDescriptor alloc] init]); |
| [objCDesc reset]; |
| |
| objCDesc.get().vertexDescriptor = ToObjC(vertexDescriptor); |
| |
| for (uint8_t i = 0; i < outputDescriptor.getNumColorAttachments(); ++i) |
| { |
| [objCDesc.get().colorAttachments setObject:ToObjC(outputDescriptor.colorAttachments[i]) |
| atIndexedSubscript:i]; |
| } |
| objCDesc.get().depthAttachmentPixelFormat = outputDescriptor.getDepthAttachmentPixelFormat(); |
| objCDesc.get().stencilAttachmentPixelFormat = |
| outputDescriptor.getStencilAttachmentPixelFormat(); |
| objCDesc.get().rasterSampleCount = outputDescriptor.getRasterSampleCount(); |
| objCDesc.get().inputPrimitiveTopology = getInputPrimitiveTopology(); |
| objCDesc.get().alphaToCoverageEnabled = getAlphaToCoverageEnabled(); |
| |
| // rasterizationEnabled will be true for both EmulatedDiscard & Enabled. |
| objCDesc.get().rasterizationEnabled = rasterizationEnabled(); |
| |
| objCDesc.get().vertexFunction = vertexShader; |
| objCDesc.get().fragmentFunction = objCDesc.get().rasterizationEnabled ? fragmentShader : nil; |
| |
| return objCDesc; |
| } |
| |
| bool RenderPassAttachmentDesc::equalIgnoreLoadStoreOptions( |
| const RenderPassAttachmentDesc &other) const |
| { |
| return texture == other.texture && implicitMSTexture == other.implicitMSTexture && |
| level == other.level && sliceOrDepth == other.sliceOrDepth && |
| blendable == other.blendable; |
| } |
| |
| bool RenderPassAttachmentDesc::operator==(const RenderPassAttachmentDesc &other) const |
| { |
| if (!equalIgnoreLoadStoreOptions(other)) |
| { |
| return false; |
| } |
| |
| return loadAction == other.loadAction && storeAction == other.storeAction && |
| storeActionOptions == other.storeActionOptions; |
| } |
| |
| void RenderPassDesc::populateRenderPipelineOutputDesc(RenderPipelineOutputDesc *outDesc) const |
| { |
| WriteMaskArray writeMaskArray; |
| writeMaskArray.fill(MTLColorWriteMaskAll); |
| populateRenderPipelineOutputDesc(writeMaskArray, outDesc); |
| } |
| |
| void RenderPassDesc::populateRenderPipelineOutputDesc(const WriteMaskArray &writeMaskArray, |
| RenderPipelineOutputDesc *outDesc) const |
| { |
| // Default blend state with replaced color write masks. |
| BlendDescArray blendDescArray; |
| for (size_t i = 0; i < blendDescArray.size(); i++) |
| { |
| blendDescArray[i].reset(writeMaskArray[i]); |
| } |
| populateRenderPipelineOutputDesc(blendDescArray, outDesc); |
| } |
| |
| void RenderPassDesc::populateRenderPipelineOutputDesc(const BlendDescArray &blendDescArray, |
| RenderPipelineOutputDesc *outDesc) const |
| { |
| outDesc->setNumColorAttachments(numColorAttachments); |
| outDesc->setRasterSampleCount(rasterSampleCount); |
| for (uint32_t i = 0; i < this->numColorAttachments; ++i) |
| { |
| auto &renderPassColorAttachment = colorAttachments[i]; |
| auto texture = renderPassColorAttachment.texture; |
| auto &outColorAttachment = outDesc->colorAttachments[i]; |
| if (texture) |
| { |
| if (renderPassColorAttachment.blendable && |
| blendDescArray[i].getWriteMask() != MTLColorWriteMaskNone) |
| { |
| // Copy parameters from blend state |
| outColorAttachment.reset(texture->pixelFormat(), blendDescArray[i]); |
| } |
| else |
| { |
| // Disable blending if the attachment's render target doesn't support blending |
| // or if all its color channels are masked out. The latter is needed because: |
| // |
| // * When blending is enabled and *Source1* blend factors are used, Metal |
| // requires a fragment shader to bind both primary and secondary outputs |
| // |
| // * ANGLE frontend validation allows draw calls on draw buffers without |
| // bound fragment outputs if all their color channels are masked out |
| // |
| // * When all color channels are masked out, blending has no effect anyway |
| // |
| // Besides disabling blending, use default values for factors and |
| // operations to reduce the number of unique pipeline states. |
| outColorAttachment.reset(texture->pixelFormat(), blendDescArray[i].getWriteMask()); |
| } |
| |
| // Combine the masks. This is useful when the texture is not supposed to have alpha |
| // channel such as GL_RGB8, however, Metal doesn't natively support 24 bit RGB, so |
| // we need to use RGBA texture, and then disable alpha write to this texture |
| outColorAttachment.setWriteMask(outColorAttachment.getWriteMask() & |
| texture->getColorWritableMask()); |
| } |
| else |
| { |
| |
| outColorAttachment.setBlendingDisabled(); |
| outColorAttachment.setPixelFormat(MTLPixelFormatInvalid); |
| } |
| } |
| |
| // Reset the unused output slots to ensure consistent hash value |
| for (uint32_t i = this->numColorAttachments; i < outDesc->colorAttachments.size(); ++i) |
| { |
| outDesc->colorAttachments[i] = {}; |
| } |
| |
| auto depthTexture = depthAttachment.texture; |
| outDesc->setDepthAttachmentPixelFormat(depthTexture ? depthTexture->pixelFormat() |
| : MTLPixelFormatInvalid); |
| |
| auto stencilTexture = stencilAttachment.texture; |
| outDesc->setStencilAttachmentPixelFormat(stencilTexture ? stencilTexture->pixelFormat() |
| : MTLPixelFormatInvalid); |
| } |
| |
| bool RenderPassDesc::equalIgnoreLoadStoreOptions(const RenderPassDesc &other) const |
| { |
| if (numColorAttachments != other.numColorAttachments) |
| { |
| return false; |
| } |
| |
| for (uint32_t i = 0; i < numColorAttachments; ++i) |
| { |
| auto &renderPassColorAttachment = colorAttachments[i]; |
| auto &otherRPAttachment = other.colorAttachments[i]; |
| if (!renderPassColorAttachment.equalIgnoreLoadStoreOptions(otherRPAttachment)) |
| { |
| return false; |
| } |
| } |
| |
| if (defaultWidth != other.defaultWidth || defaultHeight != other.defaultHeight) |
| { |
| return false; |
| } |
| |
| if (rasterSampleCount != other.rasterSampleCount) |
| { |
| return false; |
| } |
| |
| return depthAttachment.equalIgnoreLoadStoreOptions(other.depthAttachment) && |
| stencilAttachment.equalIgnoreLoadStoreOptions(other.stencilAttachment); |
| } |
| |
| bool RenderPassDesc::operator==(const RenderPassDesc &other) const |
| { |
| if (numColorAttachments != other.numColorAttachments) |
| { |
| return false; |
| } |
| |
| for (uint32_t i = 0; i < numColorAttachments; ++i) |
| { |
| if (colorAttachments[i] != other.colorAttachments[i]) |
| { |
| return false; |
| } |
| } |
| return depthAttachment == other.depthAttachment && |
| stencilAttachment == other.stencilAttachment && defaultWidth == other.defaultWidth && |
| defaultHeight == other.defaultHeight && rasterSampleCount == other.rasterSampleCount; |
| } |
| |
| // Convert to Metal object |
| void RenderPassDesc::convertToMetalDesc(MTLRenderPassDescriptor *objCDesc, |
| uint32_t deviceMaxRenderTargets) const |
| { |
| ASSERT(deviceMaxRenderTargets <= kMaxRenderTargets); |
| |
| for (uint32_t i = 0; i < numColorAttachments; ++i) |
| { |
| ToObjC(colorAttachments[i], objCDesc.colorAttachments[i]); |
| } |
| for (uint32_t i = numColorAttachments; i < deviceMaxRenderTargets; ++i) |
| { |
| // Inactive render target |
| objCDesc.colorAttachments[i].texture = nil; |
| objCDesc.colorAttachments[i].level = 0; |
| objCDesc.colorAttachments[i].slice = 0; |
| objCDesc.colorAttachments[i].depthPlane = 0; |
| objCDesc.colorAttachments[i].loadAction = MTLLoadActionDontCare; |
| objCDesc.colorAttachments[i].storeAction = MTLStoreActionDontCare; |
| } |
| |
| ToObjC(depthAttachment, objCDesc.depthAttachment); |
| ToObjC(stencilAttachment, objCDesc.stencilAttachment); |
| |
| if ((defaultWidth | defaultHeight) != 0) |
| { |
| objCDesc.renderTargetWidth = defaultWidth; |
| objCDesc.renderTargetHeight = defaultHeight; |
| objCDesc.defaultRasterSampleCount = 1; |
| } |
| else |
| { |
| objCDesc.renderTargetWidth = 0; |
| objCDesc.renderTargetHeight = 0; |
| // No need to reset defaultRasterSampleCount as it is only applied when no attachments are |
| // provided. |
| } |
| } |
| |
| // StateCache implementation |
| StateCache::StateCache(const angle::FeaturesMtl &features) : mFeatures(features) {} |
| |
| StateCache::~StateCache() {} |
| |
| angle::ObjCPtr<id<MTLDepthStencilState>> StateCache::getNullDepthStencilState( |
| const mtl::ContextDevice &device) |
| { |
| if (!mNullDepthStencilState) |
| { |
| DepthStencilDesc desc(MTLCompareFunctionAlways, false); |
| ASSERT(desc.frontFaceStencil.getStencilCompareFunction() == MTLCompareFunctionAlways); |
| mNullDepthStencilState = getDepthStencilState(device, desc); |
| } |
| return mNullDepthStencilState; |
| } |
| |
| angle::ObjCPtr<id<MTLDepthStencilState>> StateCache::getDepthStencilState( |
| const mtl::ContextDevice &device, |
| const DepthStencilDesc &desc) |
| { |
| auto ite = mDepthStencilStates.find(desc); |
| if (ite == mDepthStencilStates.end()) |
| { |
| auto re = mDepthStencilStates.insert( |
| std::make_pair(desc, device.newDepthStencilStateWithDescriptor(ToObjC(desc)))); |
| if (!re.second) |
| { |
| return nil; |
| } |
| |
| ite = re.first; |
| } |
| |
| return ite->second; |
| } |
| |
| angle::ObjCPtr<id<MTLSamplerState>> StateCache::getSamplerState(const mtl::ContextDevice &device, |
| const SamplerDesc &desc) |
| { |
| auto ite = mSamplerStates.find(desc); |
| if (ite == mSamplerStates.end()) |
| { |
| auto objCDesc = ToObjC(desc); |
| if (!mFeatures.allowRuntimeSamplerCompareMode.enabled) |
| { |
| // Runtime sampler compare mode is not supported, fallback to never. |
| objCDesc.get().compareFunction = MTLCompareFunctionNever; |
| } |
| auto re = mSamplerStates.insert( |
| std::make_pair(desc, device.newSamplerStateWithDescriptor(objCDesc))); |
| if (!re.second) |
| return nil; |
| |
| ite = re.first; |
| } |
| |
| return ite->second; |
| } |
| |
| angle::ObjCPtr<id<MTLSamplerState>> StateCache::getNullSamplerState(ContextMtl *context) |
| { |
| return getNullSamplerState(context->getMetalDevice()); |
| } |
| |
| angle::ObjCPtr<id<MTLSamplerState>> StateCache::getNullSamplerState( |
| const mtl::ContextDevice &device) |
| { |
| SamplerDesc desc; |
| return getSamplerState(device, desc); |
| } |
| |
| void StateCache::clear() |
| { |
| mNullDepthStencilState = nil; |
| mDepthStencilStates.clear(); |
| mSamplerStates.clear(); |
| } |
| |
| } // namespace mtl |
| } // namespace rx |
