Why does the default Metal VisionOS implementation of the Renderer use 0.0 as the default depth buffer and greater as the depthCompareFunction?

Question

Question

As the head states, it seems from what I'm reading, most places seems to be standard to use "less" as the comparator function and using 1.0 as the depth buffer.

Does it make a difference which one I use, or can I just arbitrarily set one, and as long as I stay consistent, it should be okay?

Code

Renderer Initialization

init(_ layerRenderer: LayerRenderer) {
    self.layerRenderer = layerRenderer
    self.device = layerRenderer.device
    self.commandQueue = self.device.makeCommandQueue()!

    let uniformBufferSize = alignedUniformsSize * maxBuffersInFlight

    self.dynamicUniformBuffer = self.device.makeBuffer(length:uniformBufferSize,
                                                       options:[MTLResourceOptions.storageModeShared])!

    self.dynamicUniformBuffer.label = "UniformBuffer"

    uniforms = UnsafeMutableRawPointer(dynamicUniformBuffer.contents()).bindMemory(to:UniformsArray.self, capacity:1)

    let mtlVertexDescriptor = Renderer.buildMetalVertexDescriptor()

    do {
        pipelineState = try Renderer.buildRenderPipelineWithDevice(device: device,
                                                                   layerRenderer: layerRenderer,
                                                                   mtlVertexDescriptor: mtlVertexDescriptor)
    } catch {
        fatalError("Unable to compile render pipeline state.  Error info: \(error)")
    }

    let depthStateDescriptor = MTLDepthStencilDescriptor()
    depthStateDescriptor.depthCompareFunction = MTLCompareFunction.greater
    depthStateDescriptor.isDepthWriteEnabled = true
    self.depthState = device.makeDepthStencilState(descriptor:depthStateDescriptor)!

    do {
        mesh = try Renderer.buildMesh(device: device, mtlVertexDescriptor: mtlVertexDescriptor)
    } catch {
        fatalError("Unable to build MetalKit Mesh. Error info: \(error)")
    }

    do {
        colorMap = try Renderer.loadTexture(device: device, textureName: "ColorMap")
    } catch {
        fatalError("Unable to load texture. Error info: \(error)")
    }
    
    worldTracking = WorldTrackingProvider()
    arSession = ARKitSession()
}

---

Render Pass Descriptor

    let renderPassDescriptor = MTLRenderPassDescriptor()
    renderPassDescriptor.colorAttachments[0].texture = drawable.colorTextures[0]
    renderPassDescriptor.colorAttachments[0].loadAction = .clear
    renderPassDescriptor.colorAttachments[0].storeAction = .store
    renderPassDescriptor.colorAttachments[0].clearColor = MTLClearColor(red: 0.0, green: 0.0, blue: 0.0, alpha: 0.0)
    renderPassDescriptor.depthAttachment.texture = drawable.depthTextures[0]
    renderPassDescriptor.depthAttachment.loadAction = .clear
    renderPassDescriptor.depthAttachment.storeAction = .store
    renderPassDescriptor.depthAttachment.clearDepth = 0.0
    renderPassDescriptor.rasterizationRateMap = drawable.rasterizationRateMaps.first
    if layerRenderer.configuration.layout == .layered {
        renderPassDescriptor.renderTargetArrayLength = drawable.views.count
    }