objcjs-types 0.6.4 → 0.7.1

package/dist/Metal/MTL4ComputeCommandEncoder.d.ts

@@ -21,145 +21,145 @@ export interface _MTL4ComputeCommandEncoder extends _MTL4CommandEncoder {
     /**
      * Queries a bitmask representing the shader stages on which commands currently present in this command encoder operate. Metal dynamically updates this property based on the commands you encode into the command encoder, for example, it sets the bit ``MTLStages/MTLStageDispatch`` if this encoder contains any commands that dispatch a compute kernel. Similarly, it sets the bit ``MTLStages/MTLStageBlit`` if this encoder contains any commands to copy or modify buffers, textures, or indirect command buffers. Finally, Metal sets the bit ``MTLStages/MTLStageAccelerationStructure`` if this encoder contains any commands that build, copy, or refit acceleration structures. - Returns: a bitmask representing shader stages that commands currently present in this command encoder operate on.
      */
-    stages?(): MTLStages;
+    stages(): MTLStages;
     /**
      * Configures this encoder with a compute pipeline state that applies to your subsequent dispatch commands. - Parameter state: a non-`nil` ``MTLComputePipelineState``.
      */
-    setComputePipelineState$?(state: _MTLComputePipelineState): void;
+    setComputePipelineState$(state: _MTLComputePipelineState): void;
     /**
      * Configures the size of a threadgroup memory buffer for a threadgroup argument in the compute shader function. - Parameters: - length: The size of the threadgroup memory, in bytes. Use a multiple of `16` bytes. - index: An integer that corresponds to the index of the argument you annotate with attribute `[[threadgroup(index)]]` in the shader function.
      */
-    setThreadgroupMemoryLength$atIndex$?(length: number, index: number): void;
+    setThreadgroupMemoryLength$atIndex$(length: number, index: number): void;
     /**
      * Specifies the size, in pixels, of imageblock data in tile memory. - Parameters: - width: The width of the imageblock, in pixels. - height: The height of the imageblock, in pixels.
      */
-    setImageblockWidth$height$?(width: number, height: number): void;
+    setImageblockWidth$height$(width: number, height: number): void;
     /**
      * Encodes a compute dispatch command using an arbitrarily-sized grid. - Parameters: - threadsPerGrid: An ``MTLSize`` instance that represents the number of threads in the grid, in each dimension. - threadsPerThreadgroup: An ``MTLSize`` instance that represents the number of threads in one threadgroup, in each dimension.
      */
-    dispatchThreads$threadsPerThreadgroup$?(threadsPerGrid: MTLSize, threadsPerThreadgroup: MTLSize): void;
+    dispatchThreads$threadsPerThreadgroup$(threadsPerGrid: MTLSize, threadsPerThreadgroup: MTLSize): void;
     /**
      * Encodes a compute dispatch command with a grid that aligns to threadgroup boundaries. - Parameters: - threadgroupsPerGrid: An ``MTLSize`` instance that represents the number of threadgroups in the grid, in each dimension. - threadsPerThreadgroup: An ``MTLSize`` instance that represents the number of threads in one threadgroup, in each dimension.
      */
-    dispatchThreadgroups$threadsPerThreadgroup$?(threadgroupsPerGrid: MTLSize, threadsPerThreadgroup: MTLSize): void;
+    dispatchThreadgroups$threadsPerThreadgroup$(threadgroupsPerGrid: MTLSize, threadsPerThreadgroup: MTLSize): void;
     /**
      * Encodes a compute dispatch command with a grid that aligns to threadgroup boundaries, using an indirect buffer for arguments. This method allows you to supply the threadgroups-per-grid counts indirectly via an ``MTLBuffer`` index. This enables you to calculate this value in the GPU timeline from a shader function, enabling GPU-driven workflows. Metal assumes that the buffer contents correspond to the layout of struct ``MTLDispatchThreadgroupsIndirectArguments``. You are responsible for ensuring this address aligns to 4-bytes. Use an instance of ``MTLResidencySet`` to mark residency of the indirect buffer that the `indirectBuffer` parameter references. - Parameters: - indirectBuffer: GPUAddress of a ``MTLBuffer`` instance providing compute parameters. Lay out the data in this buffer as described in the ``MTLDispatchThreadgroupsIndirectArguments`` structure. This address requires 4-byte alignment. - threadsPerThreadgroup: A ``MTLSize`` instance that represents the number of threads in one threadgroup, in each dimension.
      */
-    dispatchThreadgroupsWithIndirectBuffer$threadsPerThreadgroup$?(indirectBuffer: number, threadsPerThreadgroup: MTLSize): void;
+    dispatchThreadgroupsWithIndirectBuffer$threadsPerThreadgroup$(indirectBuffer: number, threadsPerThreadgroup: MTLSize): void;
     /**
      * Encodes a compute dispatch command with an arbitrarily sized grid, using an indirect buffer for arguments. - Parameters: - indirectBuffer: GPUAddress of a ``MTLBuffer`` instance providing arguments. Lay out the data in this buffer as described in the ``MTLDispatchThreadsIndirectArguments`` structure. This address requires 4-byte alignment.
      */
-    dispatchThreadsWithIndirectBuffer$?(indirectBuffer: number): void;
+    dispatchThreadsWithIndirectBuffer$(indirectBuffer: number): void;
     /**
      * Encodes a command to execute a series of commands from an indirect command buffer. - Parameters: - indirectCommandBuffer: ``MTLIndirectCommandBuffer`` instance containing the commands to execute. - executionRange: The range of commands to execute.
      */
-    executeCommandsInBuffer$withRange$?(indirectCommandBuffer: _MTLIndirectCommandBuffer, executionRange: NSRange): void;
+    executeCommandsInBuffer$withRange$(indirectCommandBuffer: _MTLIndirectCommandBuffer, executionRange: NSRange): void;
     /**
      * Encodes an instruction to execute commands from an indirect command buffer, using an indirect buffer for arguments. Use an instance of ``MTLResidencySet`` to mark residency of the indirect buffer that the `indirectRangeBuffer` parameter references. - Parameters: - indirectCommandbuffer: ``MTLIndirectCommandBuffer`` instance containing the commands to execute. - indirectRangeBuffer: GPUAddress of a ``MTLBuffer`` containing the execution range. Lay out the data in this buffer as described in the ``MTLIndirectCommandBufferExecutionRange`` structure. This address requires 4-byte alignment.
      */
-    executeCommandsInBuffer$indirectBuffer$?(indirectCommandbuffer: _MTLIndirectCommandBuffer, indirectRangeBuffer: number): void;
+    executeCommandsInBuffer$indirectBuffer$(indirectCommandbuffer: _MTLIndirectCommandBuffer, indirectRangeBuffer: number): void;
     /**
      * Encodes a command that copies data from a texture to another. - Parameters: - sourceTexture: An ``MTLTexture`` instance the command copies data from. - destinationTexture: Another ``MTLTexture`` instance the command copies the data into that has the same ``MTLTexture/pixelFormat`` and ``MTLTexture/sampleCount`` as `sourceTexture`.
      */
-    copyFromTexture$toTexture$?(sourceTexture: _MTLTexture, destinationTexture: _MTLTexture): void;
+    copyFromTexture$toTexture$(sourceTexture: _MTLTexture, destinationTexture: _MTLTexture): void;
     /**
      * Encodes a command that copies slices of a texture to slices of another texture. - Parameters: - sourceTexture: A ``MTLTexture`` texture that the command copies data from. To read the source texture contents, you need to set its ``MTLTexture/framebufferOnly`` property to <doc ://com.apple.documentation/documentation/swift/false> prior to drawing into it. - sourceSlice: A slice within `sourceTexture` the command uses as a starting point to copy data from. Set this to `0` if `sourceTexture` isn’t a texture array or a cube texture. - sourceLevel: A mipmap level within `sourceTexture`. - destinationTexture: Another ``MTLTexture`` the command copies the data to that has the same ``MTLTexture/pixelFormat`` and ``MTLTexture/sampleCount`` as `sourceTexture`. To write the contents into this texture, you need to set its ``MTLTexture/framebufferOnly`` property to <doc ://com.apple.documentation/documentation/swift/false>. - destinationSlice: A slice within `destinationTexture` the command uses as its starting point for copying data to. Set this to `0` if `destinationTexture` isn’t a texture array or a cube texture. - destinationLevel: A mipmap level within `destinationTexture`. The mipmap level you reference needs to have the same size as the `sourceTexture` slice's mipmap at `sourceLevel`. - sliceCount: The number of slices the command copies so that it satisfies the conditions that the sum of `sourceSlice` and `sliceCount` doesn’t exceed the number of slices in `sourceTexture` and the sum of `destinationSlice` and `sliceCount` doesn’t exceed the number of slices in `destinationTexture`. - levelCount: The number of mipmap levels the command copies so that it satisfies the conditions that the sum of `sourceLevel` and `levelCount` doesn’t exceed the number of mipmap levels in `sourceTexture` and the sum of `destinationLevel` and `levelCount` doesn’t exceed the number of mipmap levels in `destinationTexture`.
      */
-    copyFromTexture$sourceSlice$sourceLevel$toTexture$destinationSlice$destinationLevel$sliceCount$levelCount$?(sourceTexture: _MTLTexture, sourceSlice: number, sourceLevel: number, destinationTexture: _MTLTexture, destinationSlice: number, destinationLevel: number, sliceCount: number, levelCount: number): void;
+    copyFromTexture$sourceSlice$sourceLevel$toTexture$destinationSlice$destinationLevel$sliceCount$levelCount$(sourceTexture: _MTLTexture, sourceSlice: number, sourceLevel: number, destinationTexture: _MTLTexture, destinationSlice: number, destinationLevel: number, sliceCount: number, levelCount: number): void;
     /**
      * Encodes a command that copies image data from a slice of a texture into a slice of another texture. - Parameters: - sourceTexture: An ``MTLTexture`` texture that the command copies data from. To read the source texture contents, you need to set its ``MTLTexture/framebufferOnly`` property to <doc ://com.apple.documentation/documentation/swift/false> prior to drawing into it. - sourceSlice: A slice within `sourceTexture` the command uses as a starting point to copy data from. Set this to `0` if `sourceTexture` isn’t a texture array or a cube texture. - sourceLevel: A mipmap level within `sourceTexture`. - sourceOrigin: An ``MTLOrigin`` instance that represents a location within `sourceTexture` that the command begins copying data from. Assign `0` to each dimension that’s not relevant to `sourceTexture`. - sourceSize: An ``MTLSize`` instance that represents the size of the region, in pixels, that the command copies from `sourceTexture`, starting at `sourceOrigin`. Assign `1` to each dimension that’s not relevant to `sourceTexture`. If sourceTexture uses a compressed pixel format, set `sourceSize` to a multiple of the pixel format’s block size. If the block extends outside the bounds of the texture, clamp `sourceSize` to the edge of the texture. - destinationTexture: Another ``MTLTexture`` the command copies the data to that has the same ``MTLTexture/pixelFormat`` and ``MTLTexture/sampleCount`` as `sourceTexture`. To write the contents into this texture, you need to set its ``MTLTexture/framebufferOnly`` property to <doc ://com.apple.documentation/documentation/swift/false>. - destinationSlice: A slice within `destinationTexture` the command uses as its starting point for copying data to. Set this to `0` if `destinationTexture` isn’t a texture array or a cube texture. - destinationLevel: A mipmap level within `destinationTexture`. The mipmap level you reference needs to have the same size as the `sourceTexture` slice's mipmap at `sourceLevel`. - destinationOrigin: An ``MTLOrigin`` instance that represents a location within `destinationTexture` that the command begins copying data to. Assign `0` to each dimension that’s not relevant to `destinationTexture`.
      */
-    copyFromTexture$sourceSlice$sourceLevel$sourceOrigin$sourceSize$toTexture$destinationSlice$destinationLevel$destinationOrigin$?(sourceTexture: _MTLTexture, sourceSlice: number, sourceLevel: number, sourceOrigin: MTLOrigin, sourceSize: MTLSize, destinationTexture: _MTLTexture, destinationSlice: number, destinationLevel: number, destinationOrigin: MTLOrigin): void;
+    copyFromTexture$sourceSlice$sourceLevel$sourceOrigin$sourceSize$toTexture$destinationSlice$destinationLevel$destinationOrigin$(sourceTexture: _MTLTexture, sourceSlice: number, sourceLevel: number, sourceOrigin: MTLOrigin, sourceSize: MTLSize, destinationTexture: _MTLTexture, destinationSlice: number, destinationLevel: number, destinationOrigin: MTLOrigin): void;
     /**
      * Encodes a command that copies image data from a slice of an ``MTLTexture`` instance to an ``MTLBuffer`` instance. - Parameters: - sourceTexture: An ``MTLTexture`` texture that the command copies data from. To read the source texture contents, you need to set its ``MTLTexture/framebufferOnly`` property to <doc ://com.apple.documentation/documentation/swift/false> prior to drawing into it. - sourceSlice: A slice within `sourceTexture` the command uses as a starting point to copy data from. Set this to `0` if `sourceTexture` isn’t a texture array or a cube texture. - sourceLevel: A mipmap level within `sourceTexture`. - sourceOrigin: An ``MTLOrigin`` instance that represents a location within `sourceTexture` that the command begins copying data from. Assign `0` to each dimension that’s not relevant to `sourceTexture`. - sourceSize: An ``MTLSize`` instance that represents the size of the region, in pixels, that the command copies from `sourceTexture`, starting at `sourceOrigin`. Assign `1` to each dimension that’s not relevant to `sourceTexture`. If `sourceTexture` uses a compressed pixel format, set `sourceSize` to a multiple of the `sourceTexture's` ``MTLTexture/pixelFormat`` block size. If the block extends outside the bounds of the texture, clamp `sourceSize` to the edge of the texture. - destinationBuffer: An ``MTLBuffer`` instance the command copies data to. - destinationOffset: A byte offset within `destinationBuffer` the command copies to. The value you provide as this argument needs to be a multiple of `sourceTexture's` pixel size, in bytes. - destinationBytesPerRow: The number of bytes between adjacent rows of pixels in `destinationBuffer`. This value must be a multiple of `sourceTexture's` pixel size, in bytes, and less than or equal to the product of `sourceTexture's` pixel size, in bytes, and the largest pixel width `sourceTexture’s` type allows. If `sourceTexture` uses a compressed pixel format, set `destinationBytesPerRow` to the number of bytes between the starts of two row blocks. - destinationBytesPerImage: The number of bytes between each 2D image of a 3D texture. This value must be a multiple of `sourceTexture's` pixel size, in bytes. Set this value to `0` if `sourceSize's` ``MTLSize/depth`` value is `1`.
      */
-    copyFromTexture$sourceSlice$sourceLevel$sourceOrigin$sourceSize$toBuffer$destinationOffset$destinationBytesPerRow$destinationBytesPerImage$?(sourceTexture: _MTLTexture, sourceSlice: number, sourceLevel: number, sourceOrigin: MTLOrigin, sourceSize: MTLSize, destinationBuffer: _MTLBuffer, destinationOffset: number, destinationBytesPerRow: number, destinationBytesPerImage: number): void;
+    copyFromTexture$sourceSlice$sourceLevel$sourceOrigin$sourceSize$toBuffer$destinationOffset$destinationBytesPerRow$destinationBytesPerImage$(sourceTexture: _MTLTexture, sourceSlice: number, sourceLevel: number, sourceOrigin: MTLOrigin, sourceSize: MTLSize, destinationBuffer: _MTLBuffer, destinationOffset: number, destinationBytesPerRow: number, destinationBytesPerImage: number): void;
     /**
      * Encodes a command that copies image data from a slice of a texture instance to a buffer, with options for special texture formats. - Parameters: - sourceTexture: An ``MTLTexture`` texture that the command copies data from. To read the source texture contents, you need to set its ``MTLTexture/framebufferOnly`` property to <doc ://com.apple.documentation/documentation/swift/false> prior to drawing into it. - sourceSlice: A slice within `sourceTexture` the command uses as a starting point to copy data from. Set this to `0` if `sourceTexture` isn’t a texture array or a cube texture. - sourceLevel: A mipmap level within `sourceTexture`. - sourceOrigin: An ``MTLOrigin`` instance that represents a location within `sourceTexture` that the command begins copying data from. Assign `0` to each dimension that’s not relevant to `sourceTexture`. - sourceSize: An ``MTLSize`` instance that represents the size of the region, in pixels, that the command copies from `sourceTexture`, starting at `sourceOrigin`. Assign `1` to each dimension that’s not relevant to `sourceTexture`. If `sourceTexture` uses a compressed pixel format, set `sourceSize` to a multiple of the `sourceTexture's` ``MTLTexture/pixelFormat`` block size. If the block extends outside the bounds of the texture, clamp `sourceSize` to the edge of the texture. - destinationBuffer: An ``MTLBuffer`` instance the command copies data to. - destinationOffset: A byte offset within `destinationBuffer` the command copies to. The value you provide as this argument needs to be a multiple of `sourceTexture's` pixel size, in bytes. - destinationBytesPerRow: The number of bytes between adjacent rows of pixels in `destinationBuffer`. This value must be a multiple of `sourceTexture's` pixel size, in bytes, and less than or equal to the product of `sourceTexture's` pixel size, in bytes, and the largest pixel width `sourceTexture’s` type allows. If `sourceTexture` uses a compressed pixel format, set `destinationBytesPerRow` to the number of bytes between the starts of two row blocks. - destinationBytesPerImage: The number of bytes between each 2D image of a 3D texture. This value must be a multiple of `sourceTexture's` pixel size, in bytes. Set this value to `0` if `sourceSize's` ``MTLSize/depth`` value is `1`. - options: A ``MTLBlitOption`` value that applies to textures with applicable pixel formats, such as combined depth/stencil or PVRTC formats. If `sourceTexture's` ``MTLTexture/pixelFormat`` is a combined depth/stencil format, set `options` to either ``MTLBlitOption/MTLBlitOptionDepthFromDepthStencil`` or ``MTLBlitOption/MTLBlitOptionStencilFromDepthStencil``, but not both. If `sourceTexture's` ``MTLTexture/pixelFormat`` is a PVRTC format, set `options` to ``MTLBlitOption/MTLBlitOptionRowLinearPVRTC``.
      */
-    copyFromTexture$sourceSlice$sourceLevel$sourceOrigin$sourceSize$toBuffer$destinationOffset$destinationBytesPerRow$destinationBytesPerImage$options$?(sourceTexture: _MTLTexture, sourceSlice: number, sourceLevel: number, sourceOrigin: MTLOrigin, sourceSize: MTLSize, destinationBuffer: _MTLBuffer, destinationOffset: number, destinationBytesPerRow: number, destinationBytesPerImage: number, options: MTLBlitOption): void;
+    copyFromTexture$sourceSlice$sourceLevel$sourceOrigin$sourceSize$toBuffer$destinationOffset$destinationBytesPerRow$destinationBytesPerImage$options$(sourceTexture: _MTLTexture, sourceSlice: number, sourceLevel: number, sourceOrigin: MTLOrigin, sourceSize: MTLSize, destinationBuffer: _MTLBuffer, destinationOffset: number, destinationBytesPerRow: number, destinationBytesPerImage: number, options: MTLBlitOption): void;
     /**
      * Encodes a command that copies data from a buffer instance into another. - Parameters: - sourceBuffer: An ``MTLBuffer`` instance the command copies data from. - sourceOffset: A byte offset within `sourceBuffer` the command copies from. - destinationBuffer: An ``MTLBuffer`` instance the command copies data to. - destinationOffset: A byte offset within `destinationBuffer` the command copies to. - size: The number of bytes the command copies from `sourceBuffer` to `destinationBuffer`.
      */
-    copyFromBuffer$sourceOffset$toBuffer$destinationOffset$size$?(sourceBuffer: _MTLBuffer, sourceOffset: number, destinationBuffer: _MTLBuffer, destinationOffset: number, size: number): void;
+    copyFromBuffer$sourceOffset$toBuffer$destinationOffset$size$(sourceBuffer: _MTLBuffer, sourceOffset: number, destinationBuffer: _MTLBuffer, destinationOffset: number, size: number): void;
     /**
      * Encodes a command to copy image data from a buffer instance into a texture. - Parameters: - sourceBuffer: A ``MTLBuffer`` instance the command copies data from. - sourceOffset: A byte offset within `sourceBuffer` the command copies from. Set this value to a multiple of `destinationTexture's` pixel size, in bytes. - sourceBytesPerRow: The number of bytes between adjacent rows of pixels in `sourceBuffer`. Set this value to a multiple of `destinationTexture's` pixel size, in bytes, and less than or equal to the product of `destinationTexture's` pixel size, in bytes, and the largest pixel width `destinationTexture's` type allows. If `destinationTexture` uses a compressed pixel format, set `sourceBytesPerRow` to the number of bytes between the starts of two row blocks. - sourceBytesPerImage: The number of bytes between each 2D image of a 3D texture. Set this value to a multiple of `destinationTexture's` pixel size, in bytes, or `0` if `sourceSize's` ``MTLSize/depth`` value is `1`. - sourceSize: A ``MTLSize`` instance that represents the size of the region in `destinationTexture`, in pixels, that the command copies data to, starting at `destinationOrigin`. Assign `1` to each dimension that’s not relevant to `destinationTexture`. If `destinationTexture` uses a compressed pixel format, set `sourceSize` to a multiple of `destinationTexture's` ``MTLTexture/pixelFormat`` block size. If the block extends outside the bounds of the texture, clamp `sourceSize` to the edge of the texture. - destinationTexture: An ``MTLTexture`` instance the command copies data to. In order to copy the contents into the destination texture, set its ``MTLTexture/framebufferOnly`` property to <doc ://com.apple.documentation/documentation/swift/false> and don't use a combined depth/stencil ``MTLTexture/pixelFormat``. - destinationSlice: A slice within `destinationTexture` the command uses as its starting point for copying data to. Set this to `0` if `destinationTexture` isn’t a texture array or a cube texture. - destinationLevel: A mipmap level within `destinationTexture` the command copies data to. - destinationOrigin: An ``MTLOrigin`` instance that represents a location within `destinationTexture` that the command begins copying data to. Assign `0` to each dimension that’s not relevant to `destinationTexture`.
      */
-    copyFromBuffer$sourceOffset$sourceBytesPerRow$sourceBytesPerImage$sourceSize$toTexture$destinationSlice$destinationLevel$destinationOrigin$?(sourceBuffer: _MTLBuffer, sourceOffset: number, sourceBytesPerRow: number, sourceBytesPerImage: number, sourceSize: MTLSize, destinationTexture: _MTLTexture, destinationSlice: number, destinationLevel: number, destinationOrigin: MTLOrigin): void;
+    copyFromBuffer$sourceOffset$sourceBytesPerRow$sourceBytesPerImage$sourceSize$toTexture$destinationSlice$destinationLevel$destinationOrigin$(sourceBuffer: _MTLBuffer, sourceOffset: number, sourceBytesPerRow: number, sourceBytesPerImage: number, sourceSize: MTLSize, destinationTexture: _MTLTexture, destinationSlice: number, destinationLevel: number, destinationOrigin: MTLOrigin): void;
     /**
      * Encodes a command to copy image data from a buffer into a texture with options for special texture formats. - Parameters: - sourceBuffer: An ``MTLBuffer`` instance the command copies data from. - sourceOffset: A byte offset within `sourceBuffer` the command copies from. Set this value to a multiple of `destinationTexture's` pixel size, in bytes. - sourceBytesPerRow: The number of bytes between adjacent rows of pixels in `sourceBuffer`. Set this value to a multiple of `destinationTexture's` pixel size, in bytes, and less than or equal to the product of `destinationTexture's` pixel size, in bytes, and the largest pixel width `destinationTexture's` type allows. If `destinationTexture` uses a compressed pixel format, set `sourceBytesPerRow` to the number of bytes between the starts of two row blocks. - sourceBytesPerImage: The number of bytes between each 2D image of a 3D texture. Set this value to a multiple of `destinationTexture's` pixel size, in bytes, or `0` if `sourceSize's` ``MTLSize/depth`` value is `1`. - sourceSize: An ``MTLSize`` instance that represents the size of the region in `destinationTexture`, in pixels, that the command copies data to, starting at `destinationOrigin`. Assign `1` to each dimension that’s not relevant to `destinationTexture`. If `destinationTexture` uses a compressed pixel format, set `sourceSize` to a multiple of `destinationTexture's` ``MTLTexture/pixelFormat`` block size. If the block extends outside the bounds of the texture, clamp `sourceSize` to the edge of the texture. - destinationTexture: An ``MTLTexture`` instance the command copies data to. In order to copy the contents into the destination texture, set its ``MTLTexture/framebufferOnly`` property to <doc ://com.apple.documentation/documentation/swift/false> and don't use a combined depth/stencil ``MTLTexture/pixelFormat``. - destinationSlice: A slice within `destinationTexture` the command uses as its starting point for copying data to. Set this to `0` if `destinationTexture` isn’t a texture array or a cube texture. - destinationLevel: A mipmap level within `destinationTexture` the command copies data to. - destinationOrigin: An ``MTLOrigin`` instance that represents a location within `destinationTexture` that the command begins copying data to. Assign `0` to each dimension that’s not relevant to `destinationTexture`. - options: An ``MTLBlitOption`` value that applies to textures with applicable pixel formats, such as combined depth/stencil or PVRTC formats. If `destinationTexture's` ``MTLTexture/pixelFormat`` is a combined depth/stencil format, set `options` to either ``MTLBlitOption/MTLBlitOptionDepthFromDepthStencil`` or ``MTLBlitOption/MTLBlitOptionStencilFromDepthStencil``, but not both. If `destinationTexture's` ``MTLTexture/pixelFormat`` is a PVRTC format, set `options` to ``MTLBlitOption/MTLBlitOptionRowLinearPVRTC``.
      */
-    copyFromBuffer$sourceOffset$sourceBytesPerRow$sourceBytesPerImage$sourceSize$toTexture$destinationSlice$destinationLevel$destinationOrigin$options$?(sourceBuffer: _MTLBuffer, sourceOffset: number, sourceBytesPerRow: number, sourceBytesPerImage: number, sourceSize: MTLSize, destinationTexture: _MTLTexture, destinationSlice: number, destinationLevel: number, destinationOrigin: MTLOrigin, options: MTLBlitOption): void;
+    copyFromBuffer$sourceOffset$sourceBytesPerRow$sourceBytesPerImage$sourceSize$toTexture$destinationSlice$destinationLevel$destinationOrigin$options$(sourceBuffer: _MTLBuffer, sourceOffset: number, sourceBytesPerRow: number, sourceBytesPerImage: number, sourceSize: MTLSize, destinationTexture: _MTLTexture, destinationSlice: number, destinationLevel: number, destinationOrigin: MTLOrigin, options: MTLBlitOption): void;
     /**
      * Encodes a command to copy data from a tensor instance into another. If the `sourceTensor` and `destinationTensor` instances are not aliasable, this command applies the correct reshapes to enable this operation. - Parameters: - sourceTensor: An ``MTLTensor`` instance the command copies data from. - sourceSlice: The slice of `sourceTensor` from which Metal copies data. - destinationTensor: An ``MTLTensor`` instance the command copies data to. - destinationSlice: The slice of `destinationTensor` to which Metal copies data.
      */
-    copyFromTensor$sourceOrigin$sourceDimensions$toTensor$destinationOrigin$destinationDimensions$?(sourceTensor: _MTLTensor, sourceOrigin: _MTLTensorExtents, sourceDimensions: _MTLTensorExtents, destinationTensor: _MTLTensor, destinationOrigin: _MTLTensorExtents, destinationDimensions: _MTLTensorExtents): void;
+    copyFromTensor$sourceOrigin$sourceDimensions$toTensor$destinationOrigin$destinationDimensions$(sourceTensor: _MTLTensor, sourceOrigin: _MTLTensorExtents, sourceDimensions: _MTLTensorExtents, destinationTensor: _MTLTensor, destinationOrigin: _MTLTensorExtents, destinationDimensions: _MTLTensorExtents): void;
     /**
      * Encodes a command that generates mipmaps for a texture instance from the base mipmap level up to the highest mipmap level. This method generates mipmaps for a mipmapped texture. The texture you provide needs to have a ``MTLTexture/mipmapLevelCount`` greater than `1`, and a color-renderable or color-filterable ``MTLTexture/pixelFormat``. - Parameter texture: A mipmapped, color-renderable or color-filterable ``MTLTexture`` instance the command generates mipmaps for.
      */
-    generateMipmapsForTexture$?(texture: _MTLTexture): void;
+    generateMipmapsForTexture$(texture: _MTLTexture): void;
     /**
      * Encodes a command that fills a buffer with a constant value for each byte. - Parameters: - buffer: A ``MTLBuffer`` instance for which this command assigns each byte in a range to a value. - range: A range of bytes within `buffer` the command assigns value to. When calling this method, pass in a range with a length greater than `0`. - value: The value to write to each byte.
      */
-    fillBuffer$range$value$?(buffer: _MTLBuffer, range: NSRange, value: number): void;
+    fillBuffer$range$value$(buffer: _MTLBuffer, range: NSRange, value: number): void;
     /**
      * Encodes a command that modifies the contents of a texture to improve the performance of GPU accesses to its contents. Optimizing a texture for GPU access may affect the performance of CPU accesses, however, the data the CPU retrieves from the texture remains consistent. You typically run this command for: * Textures the GPU accesses for an extended period of time. * Textures with a ``MTLTextureDescriptor/storageMode`` property that's ``MTLStorageMode/MTLStorageModeShared`` or ``MTLStorageMode/MTLStorageModeManaged``. - Parameter texture: A ``MTLTexture`` instance the command optimizes for GPU access.
      */
-    optimizeContentsForGPUAccess$?(texture: _MTLTexture): void;
+    optimizeContentsForGPUAccess$(texture: _MTLTexture): void;
     /**
      * Encodes a command that modifies the contents of a texture instance to improve the performance of GPU accesses to its contents in a specific region. Optimizing a texture for GPU access may affect the performance of CPU accesses, however, the data the CPU retrieves from the texture remains consistent. You typically run this command for: * Textures the GPU accesses for an extended period of time. * Textures with a ``MTLTextureDescriptor/storageMode`` property that's ``MTLStorageMode/MTLStorageModeShared`` or ``MTLStorageMode/MTLStorageModeManaged``. - Parameters: - texture: A ``MTLTexture`` the command optimizes for GPU access. - slice: A slice within `texture`. - level: A mipmap level within `texture`.
      */
-    optimizeContentsForGPUAccess$slice$level$?(texture: _MTLTexture, slice: number, level: number): void;
+    optimizeContentsForGPUAccess$slice$level$(texture: _MTLTexture, slice: number, level: number): void;
     /**
      * Encodes a command that modifies the contents of a texture to improve the performance of CPU accesses to its contents. Optimizing a texture for CPU access may affect the performance of GPU accesses, however, the data the GPU retrieves from the texture remains consistent. You typically use this command for: * Textures the CPU accesses for an extended period of time. * Textures with a ``MTLTextureDescriptor/storageMode`` property that's ``MTLStorageMode/MTLStorageModeShared`` or ``MTLStorageMode/MTLStorageModeManaged``. - Parameter texture: A ``MTLTexture`` instance the command optimizes for CPU access.
      */
-    optimizeContentsForCPUAccess$?(texture: _MTLTexture): void;
+    optimizeContentsForCPUAccess$(texture: _MTLTexture): void;
     /**
      * Encodes a command that modifies the contents of a texture to improve the performance of CPU accesses to its contents in a specific region. Optimizing a texture for CPU access may affect the performance of GPU accesses, however, the data the GPU retrieves from the texture remains consistent. You typically use this command for: * Textures the CPU accesses for an extended period of time. * Textures with a ``MTLTextureDescriptor/storageMode`` property that's ``MTLStorageMode/MTLStorageModeShared`` or ``MTLStorageMode/MTLStorageModeManaged``. - Parameters: - texture: A ``MTLTexture`` the command optimizes for CPU access. - slice: A slice within `texture`. - level: A mipmap level within `texture`.
      */
-    optimizeContentsForCPUAccess$slice$level$?(texture: _MTLTexture, slice: number, level: number): void;
+    optimizeContentsForCPUAccess$slice$level$(texture: _MTLTexture, slice: number, level: number): void;
     /**
      * Encodes a command that resets a range of commands in an indirect command buffer. - Parameters: - buffer: An ``MTLIndirectCommandBuffer`` the command resets. - range: A range of commands within `buffer`.
      */
-    resetCommandsInBuffer$withRange$?(buffer: _MTLIndirectCommandBuffer, range: NSRange): void;
+    resetCommandsInBuffer$withRange$(buffer: _MTLIndirectCommandBuffer, range: NSRange): void;
     /**
      * Encodes a command that copies commands from an indirect command buffer into another. - Parameters: - source: An ``MTLIndirectCommandBuffer`` instance from where the command copies. - sourceRange: The range of commands in `source` to copy. The copy operation requires that the source range starts at a valid execution point. - destination: Another ``MTLIndirectCommandBuffer`` instance into which the command copies. - destinationIndex: An index in `destination` into where the command copies content to. The copy operation requires that the destination index is a valid execution point with enough space left in `destination` to accommodate `sourceRange.count` commands.
      */
-    copyIndirectCommandBuffer$sourceRange$destination$destinationIndex$?(source: _MTLIndirectCommandBuffer, sourceRange: NSRange, destination: _MTLIndirectCommandBuffer, destinationIndex: number): void;
+    copyIndirectCommandBuffer$sourceRange$destination$destinationIndex$(source: _MTLIndirectCommandBuffer, sourceRange: NSRange, destination: _MTLIndirectCommandBuffer, destinationIndex: number): void;
     /**
      * Encode a command to attempt to improve the performance of a range of commands within an indirect command buffer. - Parameters: - indirectCommandBuffer: An ``MTLIndirectCommandBuffer`` instance that this command optimizes. - range: A range of commands within `indirectCommandBuffer`.
      */
-    optimizeIndirectCommandBuffer$withRange$?(indirectCommandBuffer: _MTLIndirectCommandBuffer, range: NSRange): void;
+    optimizeIndirectCommandBuffer$withRange$(indirectCommandBuffer: _MTLIndirectCommandBuffer, range: NSRange): void;
     /**
      * Sets an argument table for the compute shader stage of this pipeline. Metal takes a snapshot of the resources in the argument table when you make dispatch or execute calls on this encoder instance. Metal makes the snapshot contents available to the compute shader function of the current pipeline state. - Parameters: - argumentTable: A ``MTL4ArgumentTable`` to set on the command encoder.
      */
-    setArgumentTable$?(argumentTable: _MTL4ArgumentTable | null): void;
+    setArgumentTable$(argumentTable: _MTL4ArgumentTable | null): void;
     /**
      * Encodes an acceleration structure build into the command buffer. Before you build an instance acceleration structure, you are responsible for ensuring the build operations for all primitive acceleration structures is complete. The built acceleration structure doesn't retain any references to the input buffers of the descriptor, such as the vertex buffer or instance buffer, among others. The acceleration structure build process may continue as long as the command buffer is not completed. However, you can safely encode ray tracing work against the acceleration structure if you schedule and synchronize the command buffers that contain this ray tracing work such that the command buffer with the build command is complete by the time ray tracing starts. You are responsible for ensuring that the acceleration structure and scratch buffer are at least the size that the query ``MTLDevice/accelerationStructureSizesWithDescriptor:`` returns. Use an instance of ``MTLResidencySet`` to mark residency of the scratch buffer the `scratchBuffer` parameter references, as well as for all the primitive acceleration structures you directly and indirectly reference. - Parameters: - accelerationStructure: Acceleration structure storage to build into. - descriptor: A descriptor for the acceleration structure Metal builds. - scratchBuffer: Scratch buffer Metal can use while building the acceleration structure. Metal may overwrite the contents of this buffer, and you should consider them "undefined" after the refit operation starts and completes.
      */
-    buildAccelerationStructure$descriptor$scratchBuffer$?(accelerationStructure: _MTLAccelerationStructure, descriptor: _MTL4AccelerationStructureDescriptor, scratchBuffer: MTL4BufferRange): void;
+    buildAccelerationStructure$descriptor$scratchBuffer$(accelerationStructure: _MTLAccelerationStructure, descriptor: _MTL4AccelerationStructureDescriptor, scratchBuffer: MTL4BufferRange): void;
     /**
      * Encodes an acceleration structure refit into the command buffer. You refit an acceleration structure to update it when the geometry it references changes. This operation is typically much faster than rebuilding the acceleration structure from scratch. The trade off is that after you refit the acceleration structure, its quality, as well as the performance of any subsequent ray tracing operation degrades, depending on how much the geometry changes. After certain operations, refitting an acceleration structure may not be possible, for example, after adding or removing geometry. When you refit an acceleration structure, you can do so in place, by specifying the same source and destination acceleration structures, or by providing a `nil` destination acceleration structure. If the source and destination acceleration structures aren't the same, then you are responsible for ensuring they don't overlap in memory. Typically, the destination acceleration structure is at least as large as the source acceleration structure, except in cases where you compact the source acceleration structure. In this case, you need to allocate the destination acceleration to be at least as large as the compacted size of the source acceleration structure. The scratch buffer you provide for the refit operation needs to be at least as large as the size that the query ``MTLDevice/accelerationStructureSizesWithDescriptor:`` returns. If the size this query returns is zero, you can omit providing a scratch buffer by passing `0` as the address to the `scratchBuffer` parameter. Use an instance of ``MTLResidencySet`` to mark residency of the scratch buffer the `scratchBuffer` parameter references, as well as for all the instance and primitive acceleration structures you directly and indirectly reference. - Parameters: - sourceAccelerationStructure: Acceleration structure to refit. - descriptor: A descriptor for the acceleration structure to refit. - destinationAccelerationStructure: Acceleration structure to store the refit result into. If `destinationAccelerationStructure` is `nil`, Metal performs an in-place refit operation of the `sourceAccelerationStructure`. - scratchBuffer: Scratch buffer Metal can use while refitting the acceleration structure. Metal may overwrite the contents of this buffer, and you should consider them "undefined" after the refit operation starts and completes.
      */
-    refitAccelerationStructure$descriptor$destination$scratchBuffer$?(sourceAccelerationStructure: _MTLAccelerationStructure, descriptor: _MTL4AccelerationStructureDescriptor, destinationAccelerationStructure: _MTLAccelerationStructure | null, scratchBuffer: MTL4BufferRange): void;
+    refitAccelerationStructure$descriptor$destination$scratchBuffer$(sourceAccelerationStructure: _MTLAccelerationStructure, descriptor: _MTL4AccelerationStructureDescriptor, destinationAccelerationStructure: _MTLAccelerationStructure | null, scratchBuffer: MTL4BufferRange): void;
     /**
      * Encodes an acceleration structure refit operation into the command buffer, providing additional options. You refit an acceleration structure to update it when the geometry it references changes. This operation is typically much faster than rebuilding the acceleration structure from scratch. The trade off is that after you refit the acceleration structure, its quality, as well as the performance of any subsequent ray tracing operation degrades, depending on how much the geometry changes. After certain operations, refitting an acceleration structure may not be possible, for example, after adding or removing geometry. When you refit an acceleration structure, you can do so in place, by specifying the same source and destination acceleration structures, or by providing a `nil` destination acceleration structure. If the source and destination acceleration structures aren't the same, then you are responsible for ensuring they don't overlap in memory. Typically, the destination acceleration structure is at least as large as the source acceleration structure, except in cases where you compact the source acceleration structure. In this case, you need to allocate the destination acceleration to be at least as large as the compacted size of the source acceleration structure. The scratch buffer you provide for the refit operation needs to be at least as large as the size that the query ``MTLDevice/accelerationStructureSizesWithDescriptor:`` returns. If the size this query returns is zero, you can omit providing a scratch buffer by passing `0` as the address to the `scratchBuffer` parameter. Use an instance of ``MTLResidencySet`` to mark residency of the scratch buffer the `scratchBuffer` parameter references, as well as for all the instance and primitive acceleration structures you directly and indirectly reference. - Parameters: - sourceAccelerationStructure: Acceleration structure to refit. - descriptor: A descriptor for the acceleration structure to refit. - destinationAccelerationStructure: Acceleration structure to store the refit result into. If `destinationAccelerationStructure` is `nil`, Metal performs an in-place refit operation of the `sourceAccelerationStructure`. - scratchBuffer: Scratch buffer Metal can use while refitting the acceleration structure. Metal may overwrite the contents of this buffer, and you should consider them "undefined" after the refit operation starts and completes. - options: Options specifying the elements of the acceleration structure to refit.
      */
-    refitAccelerationStructure$descriptor$destination$scratchBuffer$options$?(sourceAccelerationStructure: _MTLAccelerationStructure, descriptor: _MTL4AccelerationStructureDescriptor, destinationAccelerationStructure: _MTLAccelerationStructure | null, scratchBuffer: MTL4BufferRange, options: MTLAccelerationStructureRefitOptions): void;
+    refitAccelerationStructure$descriptor$destination$scratchBuffer$options$(sourceAccelerationStructure: _MTLAccelerationStructure, descriptor: _MTL4AccelerationStructureDescriptor, destinationAccelerationStructure: _MTLAccelerationStructure | null, scratchBuffer: MTL4BufferRange, options: MTLAccelerationStructureRefitOptions): void;
     /**
      * Encodes an acceleration structure copy operation into the command buffer. You are responsible for ensuring the source and destination acceleration structures don't overlap in memory. If this is an instance acceleration structure, Metal preserves references to the primitive acceleration structures it references. Typically, the destination acceleration structure is at least as large as the source acceleration structure, except in cases where you compact the source acceleration structure. In this case, you need to allocate the destination acceleration to be at least as large as the compacted size of the source acceleration structure. - Parameters: - sourceAccelerationStructure: Acceleration structure to copy from. - destinationAccelerationStructure: Acceleration structure to copy to.
      */
-    copyAccelerationStructure$toAccelerationStructure$?(sourceAccelerationStructure: _MTLAccelerationStructure, destinationAccelerationStructure: _MTLAccelerationStructure): void;
+    copyAccelerationStructure$toAccelerationStructure$(sourceAccelerationStructure: _MTLAccelerationStructure, destinationAccelerationStructure: _MTLAccelerationStructure): void;
     /**
      * Encodes a command to compute the size an acceleration structure can compact into, writing the result into a buffer. This size is potentially smaller than the acceleration structure. To perform compaction, you typically read this size from the buffer once the command buffer completes. You then use it to allocate a new, potentially smaller acceleration structure. Finally, you call the ``copyAndCompactAccelerationStructure:toAccelerationStructure:`` method to perform the copy. - Parameters: - accelerationStructure: Source acceleration structure. - buffer: Destination size buffer. Metal writes the compacted size as a 64-bit unsigned integer value, representing the compacted size in bytes.
      */
-    writeCompactedAccelerationStructureSize$toBuffer$?(accelerationStructure: _MTLAccelerationStructure, buffer: MTL4BufferRange): void;
+    writeCompactedAccelerationStructureSize$toBuffer$(accelerationStructure: _MTLAccelerationStructure, buffer: MTL4BufferRange): void;
     /**
      * Encodes a command to copy and compact an acceleration structure. You are responsible for ensuring that the source and destination acceleration structures don't overlap in memory. If this is an instance acceleration structure, Metal preserves references to primitive acceleration structures it references. This operation requires that the destination acceleration structure is at least as large as the compacted size of the source acceleration structure. You can compute this size by calling the ``writeCompactedAccelerationStructureSize:toBuffer:`` method. - Parameters: - sourceAccelerationStructure: Acceleration structure to copy and compact. - destinationAccelerationStructure: Acceleration structure to copy to.
      */
-    copyAndCompactAccelerationStructure$toAccelerationStructure$?(sourceAccelerationStructure: _MTLAccelerationStructure, destinationAccelerationStructure: _MTLAccelerationStructure): void;
+    copyAndCompactAccelerationStructure$toAccelerationStructure$(sourceAccelerationStructure: _MTLAccelerationStructure, destinationAccelerationStructure: _MTLAccelerationStructure): void;
     /**
      * Writes a GPU timestamp into a heap. The method ensures that any prior work finishes, but doesn't delay any subsequent work. You can alter this command's behavior through the `granularity` parameter. - Pass ``MTL4TimestampGranularity/MTL4TimestampGranularityRelaxed`` to allow Metal to provide timestamps with minimal impact to runtime performance, but with less detail. For example, the command may group all timestamps for a pass together. - Pass ``MTL4TimestampGranularity/MTL4TimestampGranularityPrecise`` to request that Metal provides timestamps with the most detail. This can affect runtime performance. - Parameters: - granularity: ``MTL4TimestampGranularity`` hint to Metal about acceptable the level of precision. - counterHeap: ``MTL4CounterHeap`` to write timestamps into. - index: The index value into which Metal writes the timestamp.
      */
-    writeTimestampWithGranularity$intoHeap$atIndex$?(granularity: MTL4TimestampGranularity, counterHeap: _MTL4CounterHeap, index: number): void;
+    writeTimestampWithGranularity$intoHeap$atIndex$(granularity: MTL4TimestampGranularity, counterHeap: _MTL4CounterHeap, index: number): void;
 }

package/dist/Metal/MTL4CounterHeap.d.ts

@@ -6,16 +6,16 @@ export interface _MTL4CounterHeap {
     /**
      * Resolves heap data on the CPU timeline. This method resolves heap data in the CPU timeline. Your app needs to ensure the GPU work has completed in order to retrieve the data correctly. You can alternatively resolve the heap data in the GPU timeline by calling ``MTL4CommandBuffer/resolveCounterHeap:withRange:intoBuffer:waitFence:updateFence:``. - Note: When resolving counters in the CPU timeline, signaling an instance of ``MTLSharedEvent`` after any workloads write counters (and waiting on that signal on the CPU) is sufficient to ensure synchronization. - Parameter range: The range in the heap to resolve. - Returns a newly allocated autoreleased NSData containing tightly packed resolved heap counter values.
      */
-    resolveCounterRange$?(range: NSRange): _NSData | null;
+    resolveCounterRange$(range: NSRange): _NSData | null;
     /**
      * Invalidates a range of entries in this counter heap. The effect of this call is immediate on the CPU timeline. You are responsible for ensuring that this counter heap is not currently in use on the GPU. - Note: Invalidated entries produce 0 when resolved. - Parameters: - range: A heap index range to invalidate.
      */
-    invalidateCounterRange$?(range: NSRange): void;
+    invalidateCounterRange$(range: NSRange): void;
     /** Assigns a label for later inspection or visualization. */
-    label?(): _NSString | null;
-    setLabel$?(value: _NSString | null): void;
+    label(): _NSString | null;
+    setLabel$(value: _NSString | null): void;
     /** Queries the number of entries in the heap. */
-    count?(): number;
+    count(): number;
     /** Queries the type of the heap. */
-    type?(): MTL4CounterHeapType;
+    type(): MTL4CounterHeapType;
 }

package/dist/Metal/MTL4MachineLearningCommandEncoder.d.ts

@@ -6,13 +6,13 @@ export interface _MTL4MachineLearningCommandEncoder extends _MTL4CommandEncoder
     /**
      * Configures the encoder with a machine learning pipeline state instance. The pipeline state instance affects all subsequent Machine Learning commands. - Parameters: - pipelineState: A Machine Learning pipeline state instance.
      */
-    setPipelineState$?(pipelineState: _MTL4MachineLearningPipelineState): void;
+    setPipelineState$(pipelineState: _MTL4MachineLearningPipelineState): void;
     /**
      * Sets an argument table for the command encoder's machine learning shader stage. The argument table provides inputs to all subsequent Machine Learning dispatches. - Parameters: - argumentTable: An argument table to set on the command encoder's Machine Learning stage.
      */
-    setArgumentTable$?(argumentTable: _MTL4ArgumentTable): void;
+    setArgumentTable$(argumentTable: _MTL4ArgumentTable): void;
     /**
      * Dispatches a machine learning network using the current pipeline state and argument table. This method takes a parameter consisting of a `MTLHeap` that Metal can use to allocate intermediate tensors. You can query the minimum size Metal requires for this heap by calling ``MTL4MachineLearningPipelineState/intermediatesHeapSize``. - Parameters: - heap: a heap that Metal can use to allocate intermediate tensors.
      */
-    dispatchNetworkWithIntermediatesHeap$?(heap: _MTLHeap): void;
+    dispatchNetworkWithIntermediatesHeap$(heap: _MTLHeap): void;
 }

package/dist/Metal/MTL4MachineLearningPipelineState.d.ts

@@ -4,13 +4,13 @@ import type { _MTLAllocation } from "./MTLAllocation.js";
 import type { _MTLDevice } from "./MTLDevice.js";
 export interface _MTL4MachineLearningPipelineState extends _MTLAllocation {
     /** Queries the string that helps identify this object. */
-    label?(): _NSString | null;
+    label(): _NSString | null;
     /** Returns the device the pipeline state belongs to. */
-    device?(): _MTLDevice;
+    device(): _MTLDevice;
     /** Returns reflection information for this machine learning pipeline state. */
-    reflection?(): _MTL4MachineLearningPipelineReflection | null;
+    reflection(): _MTL4MachineLearningPipelineReflection | null;
     /**
      * Obtain the size of the heap, in bytes, this pipeline requires during the execution. Use this value to allocate a ``MTLHeap`` instance of sufficient size that you can then provide to ``MTL4MachineLearningCommandEncoder/dispatchNetworkWithIntermediatesHeap:``. Metal uses this heap to store intermediate data as it executes the pipeline. It is your responsibility to provide a heap at least as large as this property requests.
      */
-    intermediatesHeapSize?(): number;
+    intermediatesHeapSize(): number;
 }

package/dist/Metal/MTL4PipelineDataSetSerializer.d.ts

@@ -5,9 +5,9 @@ export interface _MTL4PipelineDataSetSerializer {
     /**
      * Serializes a pipeline data set to an archive. - Parameters: - url: the URL used to serialize the serializer data set as an archive to. - error: an optional parameter to store information in case of an error. - Returns: a boolean indicating whether the operation was successful.
      */
-    serializeAsArchiveAndFlushToURL$error$?(url: _NSURL, error: NobjcObject | null): boolean;
+    serializeAsArchiveAndFlushToURL$error$(url: _NSURL, error: NobjcObject | null): boolean;
     /**
      * Serializes a serializer data set to a pipeline script as raw data. - Parameters: - error: an optional parameter to store information in case of an error. - Returns: an `NSData` instance containing the pipeline script.
      */
-    serializeAsPipelinesScriptWithError$?(error: NobjcObject | null): _NSData | null;
+    serializeAsPipelinesScriptWithError$(error: NobjcObject | null): _NSData | null;
 }

package/dist/Metal/MTL4RenderCommandEncoder.d.ts

@@ -24,161 +24,161 @@ export interface _MTL4RenderCommandEncoder extends _MTL4CommandEncoder {
     /**
      * Sets the mapping from logical shader color output to physical render pass color attachments. Use this method to define how the physical color attachments you specify via ``MTL4RenderPassDescriptor/colorAttachments`` map to the logical color output the fragment shader writes to. To use this feature, make sure to set ``MTL4RenderPassDescriptor/supportColorAttachmentMapping`` to <doc ://com.apple.documentation/documentation/swift/true>. - Parameter mapping: Mapping from logical shader outputs to physical outputs.
      */
-    setColorAttachmentMap$?(mapping: _MTLLogicalToPhysicalColorAttachmentMap | null): void;
+    setColorAttachmentMap$(mapping: _MTLLogicalToPhysicalColorAttachmentMap | null): void;
     /**
      * Configures this encoder with a render pipeline state that applies to your subsequent draw commands. - Parameter pipelineState: a non-`nil` ``MTLRenderPipelineState`` instance.
      */
-    setRenderPipelineState$?(pipelineState: _MTLRenderPipelineState): void;
+    setRenderPipelineState$(pipelineState: _MTLRenderPipelineState): void;
     /**
      * Sets the viewport which that transforms vertices from normalized device coordinates to window coordinates. Metal clips fragments that lie outside this viewport, and optionally clamps fragments outside of z-near/z-far range depending on the value you assign to ``setDepthClipMode:``. - Parameter viewport: ``MTLViewport`` to set.
      */
-    setViewport$?(viewport: MTLViewport): void;
+    setViewport$(viewport: MTLViewport): void;
     /**
      * Sets an array of viewports to transform vertices from normalized device coordinates to window coordinates. Metal clips fragments that lie outside of the viewport, and optionally clamps fragments outside of z-near/z-far range, depending on the value you assign to ``setDepthClipMode:``. Metal selects the viewport to use from the `[[ viewport_array_index ]]` attribute you specify in the pipeline state's vertex shader function in the Metal Shading Language. - Parameters: - viewports: Array of ``MTLViewport`` instances. - count: Number of ``MTLViewport`` instances in the array.
      */
-    setViewports$count$?(viewports: NobjcObject, count: number): void;
+    setViewports$count$(viewports: NobjcObject, count: number): void;
     /**
      * Sets the vertex amplification count and its view mapping for each amplification ID. Each view mapping element describes how to route the corresponding amplification ID to a specific viewport and render target array index by using offsets from the base array index provided by the `[[ render_target_array_index ]]` and/or `[[ viewport_array_index ]]` output attributes in the vertex shader. This allows Metal to route each amplified vertex to a different `[[ render_target_array_index ]]` and `[[ viewport_array_index ]]`, even though you can't directly amplify these attributes. - Parameters: - count: The number of outputs to create. The maximum value is `2`. - viewMappings: Array of ``MTLVertexAmplificationViewMapping`` instances. Each instance provides per-output offsets to a specific render target and viewport.
      */
-    setVertexAmplificationCount$viewMappings$?(count: number, viewMappings: NobjcObject | null): void;
+    setVertexAmplificationCount$viewMappings$(count: number, viewMappings: NobjcObject | null): void;
     /**
      * Controls whether Metal culls front facing primitives, back facing primitives, or culls no primitives at all. - Parameter cullMode: ``MTLCullMode`` to set.
      */
-    setCullMode$?(cullMode: MTLCullMode): void;
+    setCullMode$(cullMode: MTLCullMode): void;
     /**
      * Controls the behavior for fragments outside of the near or far planes. - Parameter depthClipMode: ``MTLDepthClipMode`` to set.
      */
-    setDepthClipMode$?(depthClipMode: MTLDepthClipMode): void;
+    setDepthClipMode$(depthClipMode: MTLDepthClipMode): void;
     /**
      * Configures the adjustments a render pass applies to depth values from fragment shader functions by a scaling factor and bias. - Parameters: - depthBias: A constant bias the render pipeline applies to all fragments. - slopeScale: A bias coefficient that scales with the depth of the primitive relative to the camera. - clamp: A value that limits the bias value the render pipeline can apply to a fragment. Pass a positive or negative value to limit the largest magnitude of a positive or negative bias, respectively. Set this value to `0` to disable bias clamping.
      */
-    setDepthBias$slopeScale$clamp$?(depthBias: number, slopeScale: number, clamp: number): void;
+    setDepthBias$slopeScale$clamp$(depthBias: number, slopeScale: number, clamp: number): void;
     /**
      * Configures the minimum and maximum bounds for depth bounds testing. The render command encoder disables depth bounds testing by default. The render command encoder also disables depth bounds testing when all of the following properties equal a specific value: - The `minBound` property is equal to `0.0f`. - The `maxBound` property is equal to `1.0f`. Both `minBound` and `maxBound` need to be within `[0.0f, 1.0f]`, and `minBound` needs to be less than or equal to `maxBound`. - Parameters: - minBound: A minimum bound for depth testing, which discards fragments with a stored depth that is less than `minBound`. - maxBound: A maximum bound for depth testing, which discards fragments with a stored depth that is greater than `maxBound`.
      */
-    setDepthTestMinBound$maxBound$?(minBound: number, maxBound: number): void;
+    setDepthTestMinBound$maxBound$(minBound: number, maxBound: number): void;
     /**
      * Sets a scissor rectangle to discard fragments outside a specific area. Metal performs a scissor test and discards all fragments outside of the scissor rect. - Parameter rect: ``MTLScissorRect`` rectangle to specify. This rectangle needs to lie completely within the current render attachment.
      */
-    setScissorRect$?(rect: MTLScissorRect): void;
+    setScissorRect$(rect: MTLScissorRect): void;
     /**
      * Sets an array of scissor rectangles for a fragment scissor test. Metal uses the specific scissor rectangle corresponding to the index you specify via the `[[ viewport_array_index ]]` output attribute of the vertex shader function in the Metal Shading Language, discarding all fragments outside of the scissor rect. - Parameters: - scissorRects: Array of ``MTLScissorRect`` structures. - count: Number of ``MTLScissorRect`` structures in the array.
      */
-    setScissorRects$count$?(scissorRects: NobjcObject, count: number): void;
+    setScissorRects$count$(scissorRects: NobjcObject, count: number): void;
     /**
      * Configures how subsequent draw commands rasterize triangle and triangle strip primitives. - Parameter fillMode:``MTLTriangleFillMode`` the render pass applies to draw commands that rasterize triangles or triangle strips.
      */
-    setTriangleFillMode$?(fillMode: MTLTriangleFillMode): void;
+    setTriangleFillMode$(fillMode: MTLTriangleFillMode): void;
     /**
      * Configures each pixel component value, including alpha, for the render pipeline’s constant blend color. - Parameters: - red: A value for the red component for the blend color constant. - green: A value for the green component for the blend color constant. - blue: A value for the blue component for the blend color constant. - alpha: A value for the alpha component for the blend color constant.
      */
-    setBlendColorRed$green$blue$alpha$?(red: number, green: number, blue: number, alpha: number): void;
+    setBlendColorRed$green$blue$alpha$(red: number, green: number, blue: number, alpha: number): void;
     /**
      * Configures this encoder with a depth stencil state that applies to your subsequent draw commands. - Parameter depthStencilState: the ``MTLDepthStencilState`` instance to set.
      */
-    setDepthStencilState$?(depthStencilState: _MTLDepthStencilState | null): void;
+    setDepthStencilState$(depthStencilState: _MTLDepthStencilState | null): void;
     /**
      * Configures this encoder with a reference value for stencil testing. The render pipeline applies this reference value to both front-facing and back-facing primitives. - Parameter referenceValue: A stencil test comparison value.
      */
-    setStencilReferenceValue$?(referenceValue: number): void;
+    setStencilReferenceValue$(referenceValue: number): void;
     /**
      * Configures the encoder with different stencil test reference values for front-facing and back-facing primitives. The render pipeline applies `frontReferenceValue` to front-facing primitives and `backReferenceValue` to back-facing primitives. - Parameters: - frontReferenceValue: A stencil test comparison value the render pipeline applies to front-facing primitives. - backReferenceValue: A stencil test comparison value the render pipeline applies to back-facing primitives.
      */
-    setStencilFrontReferenceValue$backReferenceValue$?(frontReferenceValue: number, backReferenceValue: number): void;
+    setStencilFrontReferenceValue$backReferenceValue$(frontReferenceValue: number, backReferenceValue: number): void;
     /**
      * Configures a visibility test for Metal to run, and the destination for any results it generates. You use the `mode` parameter to enable or disable the visibility test, and determine if it produces a boolean response for passing fragments, or if it counts the number of fragments. - Parameters: - mode: A ``MTLVisibilityResultMode`` that configures which visibility test results the render pass saves to a buffer, or disables visibility testing. - offset: A location, in bytes, relative to the start of ``MTL4RenderPassDescriptor/visibilityResultBuffer`` The GPU stores the result of a visibility test at `offset`, which needs to be a multiple of `8`.
      */
-    setVisibilityResultMode$offset$?(mode: MTLVisibilityResultMode, offset: number): void;
+    setVisibilityResultMode$offset$(mode: MTLVisibilityResultMode, offset: number): void;
     /**
      * Configures the store action for a color attachment. - Parameters: - storeAction: A store action for the color attachment that can’t be ``MTLStoreAction/MTLStoreActionUnknown``. - colorAttachmentIndex: The index of a color attachment.
      */
-    setColorStoreAction$atIndex$?(storeAction: MTLStoreAction, colorAttachmentIndex: number): void;
+    setColorStoreAction$atIndex$(storeAction: MTLStoreAction, colorAttachmentIndex: number): void;
     /**
      * Configures the store action for the depth attachment. - Parameter storeAction: A store action for the depth attachment that can’t be ``MTLStoreAction/MTLStoreActionUnknown``.
      */
-    setDepthStoreAction$?(storeAction: MTLStoreAction): void;
+    setDepthStoreAction$(storeAction: MTLStoreAction): void;
     /**
      * Configures the store action for the stencil attachment. - Parameter storeAction: A store action for the stencil attachment that can’t be ``MTLStoreAction/MTLStoreActionUnknown``.
      */
-    setStencilStoreAction$?(storeAction: MTLStoreAction): void;
+    setStencilStoreAction$(storeAction: MTLStoreAction): void;
     /**
      * Encodes a draw command that renders an instance of a geometric primitive. This command assigns each vertex a unique `vertex_id` value that increases from `vertexStart` through `(vertexStart + vertexCount - 1)`. Your vertex shader function can use this value to uniquely identify each vertex. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - vertexStart: The lowest value the command passes to your vertex shader function’s parameter with the `[[vertex_id]]` attribute. - vertexCount: An integer that represents the number of vertices of `primitiveType` the command draws.
      */
-    drawPrimitives$vertexStart$vertexCount$?(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number): void;
+    drawPrimitives$vertexStart$vertexCount$(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive. The command assigns each vertex a unique `vertex_id` value within its drawing instance that increases from `vertexStart` through `(vertexStart + vertexCount - 1)`. Additionally, the command assigns each drawing instance a unique `instance_id` value that increases from `0` through `(instanceCount - 1)`. Your vertex shader can use the `vertex_id` value to uniquely identify each vertex in each drawing instance, and the `instance_id` value to identify which instance that vertex belongs to. - Parameters: - primitiveType: A ``MTLPrimitiveType`` represents how the command interprets vertex argument data. - vertexStart: The lowest value the command passes to your vertex shader function’s parameter with the `vertex_id` attribute. - vertexCount: An integer that represents the number of vertices of `primitiveType` the command draws. - instanceCount: An integer that represents the number of times the command draws `primitiveType` primitives with `vertexCount` vertices.
      */
-    drawPrimitives$vertexStart$vertexCount$instanceCount$?(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number, instanceCount: number): void;
+    drawPrimitives$vertexStart$vertexCount$instanceCount$(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number, instanceCount: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive, starting with a custom instance identification number. The command assigns each vertex a unique `vertex_id` value within its drawing instance that increases from `vertexStart` through `(vertexStart + vertexCount - 1)`. Additionally, the command assigns each drawing instance a unique `instance_id` value that increases from `baseInstance` through `(baseInstance + instanceCount - 1)`. Your vertex shader can use the `vertex_id` value to uniquely identify each vertex in each drawing instance, and the `instance_id` value to identify which instance that vertex belongs to. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - vertexStart: The lowest value the command passes to your vertex shader function’s parameter with the `vertex_id` attribute. - vertexCount: An integer that represents the number of vertices of `primitiveType` the command draws. - instanceCount: An integer that represents the number of times the command draws `primitiveType` with `vertexCount` vertices. - baseInstance: The lowest value the command passes to your vertex shader function’s parameter with the `instance_id` attribute.
      */
-    drawPrimitives$vertexStart$vertexCount$instanceCount$baseInstance$?(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number, instanceCount: number, baseInstance: number): void;
+    drawPrimitives$vertexStart$vertexCount$instanceCount$baseInstance$(primitiveType: MTLPrimitiveType, vertexStart: number, vertexCount: number, instanceCount: number, baseInstance: number): void;
     /**
      * Encodes a draw command that renders an instance of a geometric primitive with indexed vertices. Use this method to perform indexed drawing, where an index buffer determines how Metal assembles primitives. Metal imposes some restrictions on the index buffer's address, which needs to be 2- or 4-byte aligned, and its length in bytes, which needs to be a multiple of 2 or 4, depending on whether the format of the index is ``MTLIndexType/MTLIndexTypeUInt16`` or ``MTLIndexType/MTLIndexTypeUInt32``. Use an instance of ``MTLResidencySet`` to mark residency of the index buffer the `indexBuffer` parameter references. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - indexCount: An integer that represents the number of vertices the command reads from `indexBuffer`. - indexType: A ``MTLIndexType`` instance that represents the index format. - indexBuffer: GPUAddress of a ``MTLBuffer`` instance that contains `indexCount` indices of `indexType` format. You are responsible for ensuring this address is aligned to 2 bytes if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and aligned to 4 bytes if the format is ``MTLIndexType/MTLIndexTypeUInt32``. - indexBufferLength: An integer that represents the length of `indexBuffer`, in bytes. You are responsible for ensuring this this size is a multiple of 2 if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and a multiple of 4 if the format is ``MTLIndexType/MTLIndexTypeUInt32``. If this draw call causes Metal to read indices at or beyond the `indexBufferLength`, Metal continues to execute them assigning a value of `0` to the `vertex_id` attribute.
      */
-    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$?(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number): void;
+    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive with indexed vertices. Use this method to perform instanced indexed drawing, where an index buffer determines how Metal assembles primitives. The command assigns each drawing instance a unique `instance_id` value that increases from `0` through `(instanceCount - 1)`. Your shader can use this value to identify which instance the vertex belongs to. Metal imposes some restrictions on the index buffer's address, which needs to be 2- or 4-byte aligned, and its length in bytes, which needs to be a multiple of 2 or 4, depending on whether the format of the index is ``MTLIndexType/MTLIndexTypeUInt16`` or ``MTLIndexType/MTLIndexTypeUInt32``. Use an instance of ``MTLResidencySet`` to mark residency of the index buffer the `indexBuffer` parameter references. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - indexCount: An integer that represents the number of vertices the command reads from `indexBuffer`. - indexType: A ``MTLIndexType`` instance that represents the index format. - indexBuffer: GPUAddress of a ``MTLBuffer`` instance that contains `indexCount` indices of `indexType` format. You are responsible for ensuring this address is aligned to 2 bytes if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and aligned to 4 bytes if the format is ``MTLIndexType/MTLIndexTypeUInt32``. - indexBufferLength: An integer that represents the length of `indexBuffer`, in bytes. You are responsible for ensuring this this size is a multiple of 2 if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and a multiple of 4 if the format is ``MTLIndexType/MTLIndexTypeUInt32``. Metal disregards this value and assigns `0` to the `vertex_id` attribute for all primitives that require loading indices at a byte offset of `indexBufferLength` or greater. - instanceCount: An integer that represents the number of times the command draws `primitiveType` with `indexCount` vertices.
      */
-    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$instanceCount$?(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, instanceCount: number): void;
+    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$instanceCount$(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, instanceCount: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive with indexed vertices, starting with a custom vertex and instance. Use this method to perform instanced indexed drawing, where an index buffer determines how Metal assembles primitives whilst customizing the base vertex and base instance value Metal passes to the vertex shader function. The command assigns each drawing instance a unique `instance_id` value that increases from `baseInstance` through `(baseInstance + instanceCount - 1)`. Your shader can use this value to identify which instance the vertex belongs to. Metal imposes some restrictions on the index buffer's address, which needs to be 2- or 4-byte aligned, and its length in bytes, which needs to be a multiple of 2 or 4, depending on whether the format of the index is ``MTLIndexType/MTLIndexTypeUInt16`` or ``MTLIndexType/MTLIndexTypeUInt32``. Use an instance of ``MTLResidencySet`` to mark residency of the index buffer the `indexBuffer` parameter references. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - indexCount: An integer that represents the number of vertices the command reads from `indexBuffer`. - indexType: A ``MTLIndexType`` instance that represents the index format. - indexBuffer: GPUAddress of a ``MTLBuffer`` instance that contains `indexCount` indices of `indexType` format. You are responsible for ensuring this address is aligned to 2 bytes if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and aligned to 4 bytes if the format is ``MTLIndexType/MTLIndexTypeUInt32``. - indexBufferLength: An integer that represents the length of `indexBuffer`, in bytes. You are responsible for ensuring this this size is a multiple of 2 if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and a multiple of 4 if the format is ``MTLIndexType/MTLIndexTypeUInt32``. If this draw call causes Metal to read indices at or beyond the `indexBufferLength`, Metal continues to execute them assigning a value of `0` to the `vertex_id` attribute. - instanceCount: An integer that represents the number of times the command draws `primitiveType` with `indexCount` vertices. - baseVertex: The lowest value the command passes to your vertex shader functions’s parameter with the `vertex_id` attribute. Metal disregards this value and assigns `0` to the `vertex_id` attribute for all primitives that require loading indices at a byte offset of `indexBufferLength` or greater. - baseInstance: The lowest value the command passes to your vertex shader’s parameter with the `instance_id` attribute.
      */
-    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$instanceCount$baseVertex$baseInstance$?(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, instanceCount: number, baseVertex: number, baseInstance: number): void;
+    drawIndexedPrimitives$indexCount$indexType$indexBuffer$indexBufferLength$instanceCount$baseVertex$baseInstance$(primitiveType: MTLPrimitiveType, indexCount: number, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, instanceCount: number, baseVertex: number, baseInstance: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive with indirect arguments. When you use this function, Metal reads the parameters to the draw command from an ``MTLBuffer`` instance, allowing you to implement a GPU-driven workflow where a compute pipeline state determines the draw arguments. You are responsible for ensuring that the address of the indirect buffer you provide to this method has 4-byte alignment. Because this is a non-indexed draw call, Metal interprets the contents of the indirect buffer to match the layout of struct ``MTLDrawPrimitivesIndirectArguments``. Use an instance of ``MTLResidencySet`` to mark residency of the indirect buffer that the `indirectBuffer` parameter references. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - indirectBuffer: GPUAddress of a ``MTLBuffer`` instance with data that matches the layout of the ``MTLDrawPrimitivesIndirectArguments`` structure. You are responsible for ensuring that the alignment of this address is 4 bytes.
      */
-    drawPrimitives$indirectBuffer$?(primitiveType: MTLPrimitiveType, indirectBuffer: number): void;
+    drawPrimitives$indirectBuffer$(primitiveType: MTLPrimitiveType, indirectBuffer: number): void;
     /**
      * Encodes a draw command that renders multiple instances of a geometric primitive with indexed vertices and indirect arguments. When you use this function, Metal reads the parameters to the draw command from an ``MTLBuffer`` instance, allowing you to implement a GPU-driven workflow where a compute pipeline state determines the draw arguments. Because this is an indexed draw call, Metal interprets the contents of the indirect buffer to match the layout of struct ``MTLDrawIndexedPrimitivesIndirectArguments``, which includes `indexStart` and `indexCount` members, denoting a range within the index buffer you provide in the `indexBuffer` parameter. The range of indices within the `indexBuffer` form the primitives Metal draws. Metal imposes some restrictions on the index buffer's address, which needs to be 2- or 4-byte aligned, and its length in bytes, which needs to be a multiple of 2 or 4, depending on whether the format of the index is ``MTLIndexType/MTLIndexTypeUInt16`` or ``MTLIndexType/MTLIndexTypeUInt32``. Similarly, you are responsible for ensuring the indirect buffer's address has 4-byte alignment. Use an instance of ``MTLResidencySet`` to mark residency of the indirect buffer that the `indirectBuffer` parameter references, and of the index buffer the `indexBuffer` parameter references. - Parameters: - primitiveType: A ``MTLPrimitiveType`` representing how the command interprets vertex argument data. - indexType: A ``MTLIndexType`` instance that represents the index format. - indexBuffer: GPUAddress of a ``MTLBuffer`` instance that contains `indexCount` indices of `indexType` format. You are responsible for ensuring this address is aligned to 2 bytes if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and aligned to 4 bytes if the format is ``MTLIndexType/MTLIndexTypeUInt32``. - indexBufferLength: An integer that represents the length of `indexBuffer`, in bytes. You are responsible for ensuring this this size is a multiple of 2 if the `indexType` format is ``MTLIndexType/MTLIndexTypeUInt16``, and a multiple of 4 if the format is ``MTLIndexType/MTLIndexTypeUInt32``. If this draw call causes Metal to read indices at or beyond the `indexBufferLength`, Metal continues to execute them assigning a value of `0` to the `vertex_id` attribute. - indirectBuffer: GPUAddress of an ``MTLBuffer`` instance with data that matches the layout of the ``MTLDrawIndexedPrimitivesIndirectArguments`` structure. This address requires 4-byte alignment.
      */
-    drawIndexedPrimitives$indexType$indexBuffer$indexBufferLength$indirectBuffer$?(primitiveType: MTLPrimitiveType, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, indirectBuffer: number): void;
+    drawIndexedPrimitives$indexType$indexBuffer$indexBufferLength$indirectBuffer$(primitiveType: MTLPrimitiveType, indexType: MTLIndexType, indexBuffer: number, indexBufferLength: number, indirectBuffer: number): void;
     /**
      * Encodes a command that runs a range of commands from an indirect command buffer. - Parameters: - indirectCommandBuffer: A ``MTLIndirectCommandBuffer`` instance containing other commands that the current command runs. - executionRange: A span of integers that represent the command entries in the buffer that the current command runs.
      */
-    executeCommandsInBuffer$withRange$?(indirectCommandBuffer: _MTLIndirectCommandBuffer, executionRange: NSRange): void;
+    executeCommandsInBuffer$withRange$(indirectCommandBuffer: _MTLIndirectCommandBuffer, executionRange: NSRange): void;
     /**
      * Encodes a command that runs an indirect range of commands from an indirect command buffer. Use this method to indicate to Metal the span of indices in the command buffer to execute indirectly via an ``MTLBuffer`` instance you provide in the `indirectRangeBuffer` parameter. This allows you to calculate the span of commands Metal executes in the GPU timeline, enabling GPU-driven workflows. Metal requires that the contents of this buffer match the layout of struct ``MTLIndirectCommandBufferExecutionRange``, which specifies a location and a length within the indirect command buffer. You are responsible for ensuring the address of this buffer has 4-byte alignment. Use an instance of ``MTLResidencySet`` to mark residency of the indirect buffer that the `indirectRangeBuffer` parameter references. - Parameters: - indirectCommandBuffer: A ``MTLIndirectCommandBuffer`` instance that contains other commands the current command runs. - indirectRangeBuffer: GPUAddress of a ``MTLBuffer`` instance with data that matches the layout of the ``MTLIndirectCommandBufferExecutionRange`` structure. This address requires 4-byte alignment.
      */
-    executeCommandsInBuffer$indirectBuffer$?(indirectCommandBuffer: _MTLIndirectCommandBuffer, indirectRangeBuffer: number): void;
+    executeCommandsInBuffer$indirectBuffer$(indirectCommandBuffer: _MTLIndirectCommandBuffer, indirectRangeBuffer: number): void;
     /**
      * Configures the size of a threadgroup memory buffer for a threadgroup argument in the object shader function. - Parameters: - length: The size of the threadgroup memory, in bytes. - index: An integer that corresponds to the index of the argument you annotate with attribute `[[threadgroup(index)]]` in the shader function.
      */
-    setObjectThreadgroupMemoryLength$atIndex$?(length: number, index: number): void;
+    setObjectThreadgroupMemoryLength$atIndex$(length: number, index: number): void;
     /**
      * Encodes a draw command that invokes a mesh shader and, optionally, an object shader with a grid of threadgroups. - Parameters: - threadgroupsPerGrid: A ``MTLSize`` instance that represents the number of threadgroups for each grid dimension. - threadsPerObjectThreadgroup: A ``MTLSize`` instance that represents the number of threads in an object shader threadgroup, if applicable. - threadsPerMeshThreadgroup: A ``MTLSize`` instance that represents the number of threads in a mesh shader threadgroup.
      */
-    drawMeshThreadgroups$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$?(threadgroupsPerGrid: MTLSize, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
+    drawMeshThreadgroups$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$(threadgroupsPerGrid: MTLSize, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
     /**
      * Encodes a draw command that invokes a mesh shader and, optionally, an object shader with a grid of threads. - Parameters: - threadsPerGrid: A ``MTLSize`` instance that represents the number of threads for each grid dimension. For mesh shaders, the command rounds the value down to the nearest multiple of `threadsPerMeshThreadgroup` for each dimension. For object shaders, the value doesn’t need to be a multiple of `threadsPerObjectThreadgroup`. - threadsPerObjectThreadgroup: A ``MTLSize`` instance that represents the number of threads in an object shader threadgroup, if applicable. - threadsPerMeshThreadgroup: A ``MTLSize`` instance that represents the number of threads in a mesh shader threadgroup.
      */
-    drawMeshThreads$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$?(threadsPerGrid: MTLSize, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
+    drawMeshThreads$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$(threadsPerGrid: MTLSize, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
     /**
      * Encodes a draw command that invokes a mesh shader and, optionally, an object shader with indirect arguments. This method enables you to determine the number of threadgroups per grid indirectly, in the GPU timeline. Metal expects this buffer's contents to match the layout of structure ``MTLDispatchThreadgroupsIndirectArguments``. You are responsible for ensuring the address of this buffer has 4-byte alignment. Use an instance of ``MTLResidencySet`` to mark residency of the indirect buffer that the `indirectBuffer` parameter references. - Parameters: - indirectBuffer: GPUAddress of an ``MTLBuffer`` instance with data that matches the layout of the ``MTLDispatchThreadgroupsIndirectArguments`` structure. This address requires 4-byte alignment. - threadsPerObjectThreadgroup: A ``MTLSize`` instance that represents the number of threads in an object shader threadgroup, if applicable. - threadsPerMeshThreadgroup: A ``MTLSize`` instance that represents the number of threads in a mesh shader threadgroup.
      */
-    drawMeshThreadgroupsWithIndirectBuffer$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$?(indirectBuffer: number, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
+    drawMeshThreadgroupsWithIndirectBuffer$threadsPerObjectThreadgroup$threadsPerMeshThreadgroup$(indirectBuffer: number, threadsPerObjectThreadgroup: MTLSize, threadsPerMeshThreadgroup: MTLSize): void;
     /**
      * Encodes a command that invokes a tile shader function from the encoder’s current tile render pipeline state. - Parameter threadsPerTile: A ``MTLSize`` instance that represents the number of threads the render pass uses per tile. Set the size’s ``MTLSize/width`` and ``MTLSize/height`` properties to values that are less than or equal to ``tileWidth`` and ``tileHeight``, respectively. Some GPU families only support square tile dispatches and require the same value for width and height. Set ``MTLSize/depth`` to `1`.
      */
-    dispatchThreadsPerTile$?(threadsPerTile: MTLSize): void;
+    dispatchThreadsPerTile$(threadsPerTile: MTLSize): void;
     /**
      * Configures the size of a threadgroup memory buffer for a threadgroup argument in the fragment and tile shader functions. - Parameters: - length: The size of the threadgroup memory, in bytes. - offset: An integer that represents the location, in bytes, from the start of the threadgroup memory buffer at `index` where the threadgroup memory begins. - index: An integer that corresponds to the index of the argument you annotate with attribute `[[threadgroup(index)]]` in the shader function.
      */
-    setThreadgroupMemoryLength$offset$atIndex$?(length: number, offset: number, index: number): void;
+    setThreadgroupMemoryLength$offset$atIndex$(length: number, offset: number, index: number): void;
     /**
      * Associates an argument table with a set of render stages. Metal takes a snapshot of the resources in the argument table when you encode a draw, dispatch, or execute command. This snapshot becomes available to the `stages` you specify to this method. - Parameters: - argumentTable: ``MTL4ArgumentTable`` to set. - stages: A ``MTLRenderStages`` bitmask that specifies the shader stages with visibility over the table.
      */
-    setArgumentTable$atStages$?(argumentTable: _MTL4ArgumentTable, stages: MTLRenderStages): void;
+    setArgumentTable$atStages$(argumentTable: _MTL4ArgumentTable, stages: MTLRenderStages): void;
     /**
      * Configures the vertex winding order that determines which face of a geometric primitive is the front one. - Parameter frontFacingWinding: A ``MTLWinding`` value that determines which side of a primitive the render pipeline interprets as front facing.
      */
-    setFrontFacingWinding$?(frontFacingWinding: MTLWinding): void;
+    setFrontFacingWinding$(frontFacingWinding: MTLWinding): void;
     /**
      * Writes a GPU timestamp into the given ``MTL4CounterHeap`` at `index` after `stage` completes. This command only guarantees all draws prior to this command are complete when Metal writes the timestamp into the counter heap you provide in the `counterHeap` parameter. The timestamp may also include subsequent operations. If you call this method before any draw calls, Metal writes a timestamp before the stage you specify in the `stage` parameter begins. - Parameters: - granularity: a ``MTL4TimestampGranularity`` hint. - stage: ``MTLRenderStages`` that need to complete before Metal writes the timestamp. This may also include later stages that are related, for example ``MTLRenderStages/MTLRenderStageMesh`` may include ``MTLRenderStages/MTLRenderStageVertex``. - counterHeap: ``MTL4CounterHeap`` into which Metal writes timestamps. - index: The index value into which Metal writes this timestamp.
      */
-    writeTimestampWithGranularity$afterStage$intoHeap$atIndex$?(granularity: MTL4TimestampGranularity, stage: MTLRenderStages, counterHeap: _MTL4CounterHeap, index: number): void;
+    writeTimestampWithGranularity$afterStage$intoHeap$atIndex$(granularity: MTL4TimestampGranularity, stage: MTLRenderStages, counterHeap: _MTL4CounterHeap, index: number): void;
     /** Sets the width of a tile for this render pass. */
-    tileWidth?(): number;
+    tileWidth(): number;
     /** Sets the height of a tile for this render pass. */
-    tileHeight?(): number;
+    tileHeight(): number;
 }

package/dist/Metal/MTLAccelerationStructure.d.ts

@@ -1,9 +1,9 @@
 import type { _MTLResource } from "./MTLResource.js";
 import type { MTLResourceID } from "../structs/MTLResourceID.js";
 export interface _MTLAccelerationStructure extends _MTLResource {
-    size?(): number;
+    size(): number;
     /**
      * @property gpuResourceID @abstract Handle of the GPU resource suitable for storing in an Argument Buffer
      */
-    gpuResourceID?(): MTLResourceID;
+    gpuResourceID(): MTLResourceID;
 }