All Superinterfaces:

MTLCommandEncoder
```
public interface MTLComputeCommandEncoder
extends MTLCommandEncoder
```
[@protocol] MTLComputeCommandEncoder A command encoder that writes data parallel compute commands. API-Since: 8.0

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method	Description
`void`	`dispatchThreadgroupsThreadsPerThreadgroup(MTLSize threadgroupsPerGrid, MTLSize threadsPerThreadgroup)`	dispatchThreadgroups:threadsPerThreadgroup: Enqueue a compute function dispatch as a multiple of the threadgroup size.
`void`	`dispatchThreadgroupsWithIndirectBufferIndirectBufferOffsetThreadsPerThreadgroup(@NotNull MTLBuffer indirectBuffer, long indirectBufferOffset, MTLSize threadsPerThreadgroup)`	dispatchThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerThreadgroup: Enqueue a compute function dispatch using an indirect buffer for threadgroupsPerGrid see MTLDispatchThreadgroupsIndirectArguments.
`void`	`dispatchThreadsThreadsPerThreadgroup(MTLSize threadsPerGrid, MTLSize threadsPerThreadgroup)`	dispatchThreads:threadsPerThreadgroup: Enqueue a compute function dispatch using an arbitrarily-sized grid.
`long`	`dispatchType()`	[@property] dispatchType The dispatch type of the compute command encoder.
`void`	`executeCommandsInBufferIndirectBufferIndirectBufferOffset(@NotNull MTLIndirectCommandBuffer indirectCommandbuffer, @NotNull MTLBuffer indirectRangeBuffer, long indirectBufferOffset)`	executeCommandsInBuffer:indirectBuffer:indirectBufferOffset: Execute commands in the buffer within the range specified by the indirect range buffer.
`void`	`executeCommandsInBufferWithRange(@NotNull MTLIndirectCommandBuffer indirectCommandBuffer, NSRange executionRange)`	executeCommandsInBuffer:withRange: Execute commands in the buffer within the range specified.
`void`	`memoryBarrierWithResourcesCount(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> resources, long count)`	memoryBarrierWithResources Encodes a barrier between currently dispatched kernels in a concurrent compute command encoder and any subsequent ones on an array of resources.
`void`	`memoryBarrierWithScope(long scope)`	memoryBarrierWithScope Encodes a barrier between currently dispatched kernels in a concurrent compute command encoder and any subsequent ones on a specified resource group This API ensures that all dispatches in the encoder have completed execution and their side effects are visible to subsequent dispatches in that encoder.
`void`	`sampleCountersInBufferAtSampleIndexWithBarrier(@NotNull MTLCounterSampleBuffer sampleBuffer, long sampleIndex, boolean barrier)`	sampleCountersInBuffer:atSampleIndex:withBarrier: Sample hardware counters at this point in the compute encoder and store the counter sample into the sample buffer at the specified index.
`void`	`setAccelerationStructureAtBufferIndex(@Nullable MTLAccelerationStructure accelerationStructure, long bufferIndex)`	setAccelerationStructure:atBufferIndex: Set a global raytracing acceleration structure for all compute kernels at the given buffer bind point index.
`void`	`setBufferOffsetAtIndex(long offset, long index)`	setBufferOffset:atIndex: Set the offset within the current global buffer for all compute kernels at the given bind point index.
`void`	`setBufferOffsetAtIndex(@Nullable MTLBuffer buffer, long offset, long index)`	setBuffer:offset:atIndex: Set a global buffer for all compute kernels at the given bind point index.
`void`	`setBufferOffsetAttributeStrideAtIndex(long offset, long stride, long index)`	only call this when the buffer-index is part of the stageInputDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic` API-Since: 17.0
`void`	`setBufferOffsetAttributeStrideAtIndex(@NotNull MTLBuffer buffer, long offset, long stride, long index)`	sets kernel buffer at specified index with provided offset and stride.
`void`	`setBuffersOffsetsAttributeStridesWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers, @NotNull org.moe.natj.general.ptr.ConstNUIntPtr offsets, @NotNull org.moe.natj.general.ptr.ConstNUIntPtr strides, NSRange range)`	sets an array of kernel buffers with provided offsets and strides with the given bind point range.
`void`	`setBuffersOffsetsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers, @NotNull org.moe.natj.general.ptr.ConstNUIntPtr offsets, NSRange range)`	setBuffers:offsets:withRange: Set an array of global buffers for all compute kernels with the given bind point range.
`void`	`setBytesLengthAtIndex(@NotNull org.moe.natj.general.ptr.ConstVoidPtr bytes, long length, long index)`	setBytes:length:atIndex: Set the data (by copy) for a given buffer binding point.
`void`	`setBytesLengthAttributeStrideAtIndex(@NotNull org.moe.natj.general.ptr.ConstVoidPtr bytes, long length, long stride, long index)`	only call this when the buffer-index is part of the stageInputDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic` API-Since: 17.0
`void`	`setComputePipelineState(@NotNull MTLComputePipelineState state)`	setComputePipelineState: Set the compute pipeline state that will be used.
`void`	`setImageblockWidthHeight(long width, long height)`	setImageblockWidth:height: Set imageblock sizes.
`void`	`setIntersectionFunctionTableAtBufferIndex(@Nullable MTLIntersectionFunctionTable intersectionFunctionTable, long bufferIndex)`	setIntersectionFunctionTable:atBufferIndex: Set a visible function table at the given buffer index API-Since: 14.0
`void`	`setIntersectionFunctionTablesWithBufferRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> intersectionFunctionTables, NSRange range)`	setIntersectionFunctionTables:withBufferRange: Set visible function tables at the given buffer index range API-Since: 14.0
`void`	`setSamplerStateAtIndex(@Nullable MTLSamplerState sampler, long index)`	setSamplerState:atIndex: Set a global sampler for all compute kernels at the given bind point index.
`void`	`setSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable MTLSamplerState sampler, float lodMinClamp, float lodMaxClamp, long index)`	setSamplerState:lodMinClamp:lodMaxClamp:atIndex: Set a global sampler for all compute kernels at the given bind point index.
`void`	`setSamplerStatesLodMinClampsLodMaxClampsWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps, @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMaxClamps, NSRange range)`	setSamplers:lodMinClamps:lodMaxClamps:withRange: Set an array of global samplers for all compute kernels with the given bind point range.
`void`	`setSamplerStatesWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers, NSRange range)`	setSamplers:withRange: Set an array of global samplers for all compute kernels with the given bind point range.
`void`	`setStageInRegion(MTLRegion region)`	setStageInRegion:region: Set the region of the stage_in attributes to apply the compute kernel.
`void`	`setStageInRegionWithIndirectBufferIndirectBufferOffset(@NotNull MTLBuffer indirectBuffer, long indirectBufferOffset)`	setStageInRegionWithIndirectBuffer:indirectBufferOffset: sets the stage in region indirectly for the following indirect dispatch calls.
`void`	`setTextureAtIndex(@Nullable MTLTexture texture, long index)`	setTexture:atIndex: Set a global texture for all compute kernels at the given bind point index.
`void`	`setTexturesWithRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> textures, NSRange range)`	setTextures:withRange: Set an array of global textures for all compute kernels with the given bind point range.
`void`	`setThreadgroupMemoryLengthAtIndex(long length, long index)`	setThreadgroupMemoryLength:atIndex: Set the threadgroup memory byte length at the binding point specified by the index.
`void`	`setVisibleFunctionTableAtBufferIndex(@Nullable MTLVisibleFunctionTable visibleFunctionTable, long bufferIndex)`	setVisibleFunctionTable:atBufferIndex: Set a visible function table at the given buffer index API-Since: 14.0
`void`	`setVisibleFunctionTablesWithBufferRange(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> visibleFunctionTables, NSRange range)`	setVisibleFunctionTables:withBufferRange: Set visible function tables at the given buffer index range API-Since: 14.0
`void`	`updateFence(@NotNull MTLFence fence)`	updateFence: Update the fence to capture all GPU work so far enqueued by this encoder.
`void`	`useHeap(@NotNull MTLHeap heap)`	useHeap: Declare that the resources allocated from a heap may be accessed as readonly by the render pass through an argument buffer For tracked MTLHeaps, this method protects against data hazards.
`void`	`useHeapsCount(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> heaps, long count)`	useHeaps:count: Declare that the resources allocated from an array of heaps may be accessed as readonly by the render pass through an argument buffer For tracked MTLHeaps, this method protects against data hazards.
`void`	`useResourcesCountUsage(@NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> resources, long count, long usage)`	useResources:count:usage: Declare that an array of resources may be accessed through an argument buffer by the command encoder For tracked MTL Resources, this method protects against data hazards.
`void`	`useResourceUsage(@NotNull MTLResource resource, long usage)`	useResource:usage: Declare that a resource may be accessed by the command encoder through an argument buffer For tracked MTLResources, this method protects against data hazards.
`void`	`waitForFence(@NotNull MTLFence fence)`	waitForFence: Prevent further GPU work until the fence is reached.

Methods inherited from interface apple.metal.protocol.MTLCommandEncoder
device, endEncoding, insertDebugSignpost, label, popDebugGroup, pushDebugGroup, setLabel

- Method Detail
  - dispatchThreadgroupsThreadsPerThreadgroup
```
void dispatchThreadgroupsThreadsPerThreadgroup(MTLSize threadgroupsPerGrid,
                                               MTLSize threadsPerThreadgroup)
```
    dispatchThreadgroups:threadsPerThreadgroup: Enqueue a compute function dispatch as a multiple of the threadgroup size.
  - dispatchThreadgroupsWithIndirectBufferIndirectBufferOffsetThreadsPerThreadgroup
```
void dispatchThreadgroupsWithIndirectBufferIndirectBufferOffsetThreadsPerThreadgroup(@NotNull
                                                                                     @NotNull MTLBuffer indirectBuffer,
                                                                                     long indirectBufferOffset,
                                                                                     MTLSize threadsPerThreadgroup)
```
    dispatchThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerThreadgroup: Enqueue a compute function dispatch using an indirect buffer for threadgroupsPerGrid see MTLDispatchThreadgroupsIndirectArguments.
    
    Parameters:
    
    indirectBuffer - A buffer object that the device will read dispatchThreadgroups arguments from, see MTLDispatchThreadgroupsIndirectArguments.
    
    indirectBufferOffset - Byte offset within @a indirectBuffer to read arguments from. @a indirectBufferOffset must be a multiple of 4. API-Since: 9.0
  - setBufferOffsetAtIndex
```
void setBufferOffsetAtIndex(@Nullable
                            @Nullable MTLBuffer buffer,
                            long offset,
                            long index)
```
    setBuffer:offset:atIndex: Set a global buffer for all compute kernels at the given bind point index.
  - setBufferOffsetAtIndex
```
void setBufferOffsetAtIndex(long offset,
                            long index)
```
    setBufferOffset:atIndex: Set the offset within the current global buffer for all compute kernels at the given bind point index. API-Since: 8.3
  - setBuffersOffsetsWithRange
```
void setBuffersOffsetsWithRange(@NotNull
                                @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers,
                                @NotNull
                                @NotNull org.moe.natj.general.ptr.ConstNUIntPtr offsets,
                                NSRange range)
```
    setBuffers:offsets:withRange: Set an array of global buffers for all compute kernels with the given bind point range.
  - setBytesLengthAtIndex
```
void setBytesLengthAtIndex(@NotNull
                           @NotNull org.moe.natj.general.ptr.ConstVoidPtr bytes,
                           long length,
                           long index)
```
    setBytes:length:atIndex: Set the data (by copy) for a given buffer binding point. This will remove any existing MTLBuffer from the binding point. API-Since: 8.3
  - setComputePipelineState
```
void setComputePipelineState(@NotNull
                             @NotNull MTLComputePipelineState state)
```
    setComputePipelineState: Set the compute pipeline state that will be used.
  - setSamplerStateAtIndex
```
void setSamplerStateAtIndex(@Nullable
                            @Nullable MTLSamplerState sampler,
                            long index)
```
    setSamplerState:atIndex: Set a global sampler for all compute kernels at the given bind point index.
  - setSamplerStateLodMinClampLodMaxClampAtIndex
```
void setSamplerStateLodMinClampLodMaxClampAtIndex(@Nullable
                                                  @Nullable MTLSamplerState sampler,
                                                  float lodMinClamp,
                                                  float lodMaxClamp,
                                                  long index)
```
    setSamplerState:lodMinClamp:lodMaxClamp:atIndex: Set a global sampler for all compute kernels at the given bind point index.
  - setSamplerStatesLodMinClampsLodMaxClampsWithRange
```
void setSamplerStatesLodMinClampsLodMaxClampsWithRange(@NotNull
                                                       @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers,
                                                       @NotNull
                                                       @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMinClamps,
                                                       @NotNull
                                                       @NotNull org.moe.natj.general.ptr.ConstFloatPtr lodMaxClamps,
                                                       NSRange range)
```
    setSamplers:lodMinClamps:lodMaxClamps:withRange: Set an array of global samplers for all compute kernels with the given bind point range.
  - setSamplerStatesWithRange
```
void setSamplerStatesWithRange(@NotNull
                               @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> samplers,
                               NSRange range)
```
    setSamplers:withRange: Set an array of global samplers for all compute kernels with the given bind point range.
  - setStageInRegion
```
void setStageInRegion(MTLRegion region)
```
    setStageInRegion:region: Set the region of the stage_in attributes to apply the compute kernel. API-Since: 10.0
  - setTextureAtIndex
```
void setTextureAtIndex(@Nullable
                       @Nullable MTLTexture texture,
                       long index)
```
    setTexture:atIndex: Set a global texture for all compute kernels at the given bind point index.
  - setTexturesWithRange
```
void setTexturesWithRange(@NotNull
                          @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> textures,
                          NSRange range)
```
    setTextures:withRange: Set an array of global textures for all compute kernels with the given bind point range.
  - setThreadgroupMemoryLengthAtIndex
```
void setThreadgroupMemoryLengthAtIndex(long length,
                                       long index)
```
    setThreadgroupMemoryLength:atIndex: Set the threadgroup memory byte length at the binding point specified by the index. This applies to all compute kernels.
  - updateFence
```
void updateFence(@NotNull
                 @NotNull MTLFence fence)
```
    updateFence: Update the fence to capture all GPU work so far enqueued by this encoder. The fence is updated at kernel submission to maintain global order and prevent deadlock. Drivers may delay fence updates until the end of the encoder. Drivers may also wait on fences at the beginning of an encoder. It is therefore illegal to wait on a fence after it has been updated in the same encoder. API-Since: 10.0
  - waitForFence
```
void waitForFence(@NotNull
                  @NotNull MTLFence fence)
```
    waitForFence: Prevent further GPU work until the fence is reached. The fence is evaluated at kernel submission to maintain global order and prevent deadlock. Drivers may delay fence updates until the end of the encoder. Drivers may also wait on fences at the beginning of an encoder. It is therefore illegal to wait on a fence after it has been updated in the same encoder. API-Since: 10.0
  - dispatchThreadsThreadsPerThreadgroup
```
void dispatchThreadsThreadsPerThreadgroup(MTLSize threadsPerGrid,
                                          MTLSize threadsPerThreadgroup)
```
    dispatchThreads:threadsPerThreadgroup: Enqueue a compute function dispatch using an arbitrarily-sized grid. threadsPerGrid does not have to be a multiple of the threadGroup size API-Since: 11.0
  - setImageblockWidthHeight
```
void setImageblockWidthHeight(long width,
                              long height)
```
    setImageblockWidth:height: Set imageblock sizes. API-Since: 11.0
  - useHeap
```
void useHeap(@NotNull
             @NotNull MTLHeap heap)
```
    useHeap: Declare that the resources allocated from a heap may be accessed as readonly by the render pass through an argument buffer For tracked MTLHeaps, this method protects against data hazards. This method must be called before encoding any dispatch commands which may access the resources allocated from the heap through an argument buffer. This method may cause all of the color attachments allocated from the heap to become decompressed. Therefore, it is recommended that the useResource:usage: or useResources:count:usage: methods be used for color attachments instead, with a minimal (i.e. read-only) usage. [@warning] Prior to iOS 13, macOS 10.15, this method does not protect against data hazards. If you are deploying to older versions of macOS or iOS, use fences to ensure data hazards are resolved. API-Since: 11.0
  - useHeapsCount
```
void useHeapsCount(@NotNull
                   @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> heaps,
                   long count)
```
    useHeaps:count: Declare that the resources allocated from an array of heaps may be accessed as readonly by the render pass through an argument buffer For tracked MTLHeaps, this method protects against data hazards. This method must be called before encoding any dispatch commands which may access the resources allocated from the heaps through an argument buffer. This method may cause all of the color attachments allocated from the heaps to become decompressed. Therefore, it is recommended that the useResource:usage: or useResources:count:usage: methods be used for color attachments instead, with a minimal (i.e. read-only) usage. [@warning] Prior to iOS 13, macOS 10.15, this method does not protect against data hazards. If you are deploying to older versions of macOS or iOS, use fences to ensure data hazards are resolved. API-Since: 11.0
  - useResourceUsage
```
void useResourceUsage(@NotNull
                      @NotNull MTLResource resource,
                      long usage)
```
    useResource:usage: Declare that a resource may be accessed by the command encoder through an argument buffer For tracked MTLResources, this method protects against data hazards. This method must be called before encoding any dispatch commands which may access the resource through an argument buffer. [@warning] Prior to iOS 13, macOS 10.15, this method does not protect against data hazards. If you are deploying to older versions of macOS or iOS, use fences to ensure data hazards are resolved. API-Since: 11.0
  - useResourcesCountUsage
```
void useResourcesCountUsage(@NotNull
                            @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> resources,
                            long count,
                            long usage)
```
    useResources:count:usage: Declare that an array of resources may be accessed through an argument buffer by the command encoder For tracked MTL Resources, this method protects against data hazards. This method must be called before encoding any dispatch commands which may access the resources through an argument buffer. [@warning] Prior to iOS 13, macOS 10.15, this method does not protect against data hazards. If you are deploying to older versions of macOS or iOS, use fences to ensure data hazards are resolved. API-Since: 11.0
  - dispatchType
```
long dispatchType()
```
    [@property] dispatchType The dispatch type of the compute command encoder. API-Since: 12.0
  - executeCommandsInBufferIndirectBufferIndirectBufferOffset
```
void executeCommandsInBufferIndirectBufferIndirectBufferOffset(@NotNull
                                                               @NotNull MTLIndirectCommandBuffer indirectCommandbuffer,
                                                               @NotNull
                                                               @NotNull MTLBuffer indirectRangeBuffer,
                                                               long indirectBufferOffset)
```
    executeCommandsInBuffer:indirectBuffer:indirectBufferOffset: Execute commands in the buffer within the range specified by the indirect range buffer. The same indirect command buffer may be executed any number of times within the same encoder. API-Since: 13.0
    
    Parameters:
    
    indirectRangeBuffer - An indirect buffer from which the device reads the execution range parameter, as laid out in the MTLIndirectCommandBufferExecutionRange structure.
    
    indirectBufferOffset - The byte offset within indirectBuffer where the execution range parameter is located. Must be a multiple of 4 bytes.
  - executeCommandsInBufferWithRange
```
void executeCommandsInBufferWithRange(@NotNull
                                      @NotNull MTLIndirectCommandBuffer indirectCommandBuffer,
                                      NSRange executionRange)
```
    executeCommandsInBuffer:withRange: Execute commands in the buffer within the range specified. The same indirect command buffer may be executed any number of times within the same encoder. API-Since: 13.0
  - memoryBarrierWithResourcesCount
```
void memoryBarrierWithResourcesCount(@NotNull
                                     @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> resources,
                                     long count)
```
    memoryBarrierWithResources Encodes a barrier between currently dispatched kernels in a concurrent compute command encoder and any subsequent ones on an array of resources. This API ensures that all dispatches in the encoder have completed execution and side effects on the specified resources are visible to subsequent dispatches in that encoder. Calling barrier on a serial encoder is allowed, but ignored. API-Since: 12.0
  - memoryBarrierWithScope
```
void memoryBarrierWithScope(long scope)
```
    memoryBarrierWithScope Encodes a barrier between currently dispatched kernels in a concurrent compute command encoder and any subsequent ones on a specified resource group This API ensures that all dispatches in the encoder have completed execution and their side effects are visible to subsequent dispatches in that encoder. Calling barrier on a serial encoder is allowed, but ignored. API-Since: 12.0
  - setStageInRegionWithIndirectBufferIndirectBufferOffset
```
void setStageInRegionWithIndirectBufferIndirectBufferOffset(@NotNull
                                                            @NotNull MTLBuffer indirectBuffer,
                                                            long indirectBufferOffset)
```
    setStageInRegionWithIndirectBuffer:indirectBufferOffset: sets the stage in region indirectly for the following indirect dispatch calls.
    
    Parameters:
    
    indirectBuffer - A buffer object that the device will read the stageIn region arguments from, see MTLStageInRegionIndirectArguments.
    
    indirectBufferOffset - Byte offset within indirectBuffer to read arguments from. indirectBufferOffset must be a multiple of 4. API-Since: 12.0
  - sampleCountersInBufferAtSampleIndexWithBarrier
```
void sampleCountersInBufferAtSampleIndexWithBarrier(@NotNull
                                                    @NotNull MTLCounterSampleBuffer sampleBuffer,
                                                    long sampleIndex,
                                                    boolean barrier)
```
    sampleCountersInBuffer:atSampleIndex:withBarrier: Sample hardware counters at this point in the compute encoder and store the counter sample into the sample buffer at the specified index. On devices where MTLCounterSamplingPointAtDispatchBoundary is unsupported, this method is not available and will generate an error if called. API-Since: 14.0
    
    Parameters:
    
    sampleBuffer - The sample buffer to sample into
    
    sampleIndex - The index into the counter buffer to write the sample
    
    barrier - Insert a barrier before taking the sample. Passing YES will ensure that all work encoded before this operation in the encoder is complete but does not isolate the work with respect to other encoders. Passing NO will allow the sample to be taken concurrently with other operations in this encoder. In general, passing YES will lead to more repeatable counter results but may negatively impact performance. Passing NO will generally be higher performance but counter results may not be repeatable.
  - setAccelerationStructureAtBufferIndex
```
void setAccelerationStructureAtBufferIndex(@Nullable
                                           @Nullable MTLAccelerationStructure accelerationStructure,
                                           long bufferIndex)
```
    setAccelerationStructure:atBufferIndex: Set a global raytracing acceleration structure for all compute kernels at the given buffer bind point index. API-Since: 14.0
  - setIntersectionFunctionTableAtBufferIndex
```
void setIntersectionFunctionTableAtBufferIndex(@Nullable
                                               @Nullable MTLIntersectionFunctionTable intersectionFunctionTable,
                                               long bufferIndex)
```
    setIntersectionFunctionTable:atBufferIndex: Set a visible function table at the given buffer index API-Since: 14.0
  - setIntersectionFunctionTablesWithBufferRange
```
void setIntersectionFunctionTablesWithBufferRange(@NotNull
                                                  @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> intersectionFunctionTables,
                                                  NSRange range)
```
    setIntersectionFunctionTables:withBufferRange: Set visible function tables at the given buffer index range API-Since: 14.0
  - setVisibleFunctionTableAtBufferIndex
```
void setVisibleFunctionTableAtBufferIndex(@Nullable
                                          @Nullable MTLVisibleFunctionTable visibleFunctionTable,
                                          long bufferIndex)
```
    setVisibleFunctionTable:atBufferIndex: Set a visible function table at the given buffer index API-Since: 14.0
  - setVisibleFunctionTablesWithBufferRange
```
void setVisibleFunctionTablesWithBufferRange(@NotNull
                                             @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> visibleFunctionTables,
                                             NSRange range)
```
    setVisibleFunctionTables:withBufferRange: Set visible function tables at the given buffer index range API-Since: 14.0
  - setBufferOffsetAttributeStrideAtIndex
```
void setBufferOffsetAttributeStrideAtIndex(@NotNull
                                           @NotNull MTLBuffer buffer,
                                           long offset,
                                           long stride,
                                           long index)
```
    sets kernel buffer at specified index with provided offset and stride. only call this when the kernel-buffer is part of the stageInputDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic` API-Since: 17.0
  - setBufferOffsetAttributeStrideAtIndex
```
void setBufferOffsetAttributeStrideAtIndex(long offset,
                                           long stride,
                                           long index)
```
    only call this when the buffer-index is part of the stageInputDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic` API-Since: 17.0
  - setBuffersOffsetsAttributeStridesWithRange
```
void setBuffersOffsetsAttributeStridesWithRange(@NotNull
                                                @NotNull org.moe.natj.general.ptr.Ptr<org.moe.natj.objc.ObjCObject> buffers,
                                                @NotNull
                                                @NotNull org.moe.natj.general.ptr.ConstNUIntPtr offsets,
                                                @NotNull
                                                @NotNull org.moe.natj.general.ptr.ConstNUIntPtr strides,
                                                NSRange range)
```
    sets an array of kernel buffers with provided offsets and strides with the given bind point range. Only call this when at least one buffer is part of the vertexDescriptor, other buffers must set `MTLAttributeStrideStatic` API-Since: 17.0
  - setBytesLengthAttributeStrideAtIndex
```
void setBytesLengthAttributeStrideAtIndex(@NotNull
                                          @NotNull org.moe.natj.general.ptr.ConstVoidPtr bytes,
                                          long length,
                                          long stride,
                                          long index)
```
    only call this when the buffer-index is part of the stageInputDescriptor and has set its stride to `MTLBufferLayoutStrideDynamic` API-Since: 17.0

Interface MTLComputeCommandEncoder

Method Summary

Methods inherited from interface apple.metal.protocol.MTLCommandEncoder

Method Detail

dispatchThreadgroupsThreadsPerThreadgroup

dispatchThreadgroupsWithIndirectBufferIndirectBufferOffsetThreadsPerThreadgroup

setBufferOffsetAtIndex

setBufferOffsetAtIndex

setBuffersOffsetsWithRange

setBytesLengthAtIndex

setComputePipelineState

setSamplerStateAtIndex

setSamplerStateLodMinClampLodMaxClampAtIndex

setSamplerStatesLodMinClampsLodMaxClampsWithRange

setSamplerStatesWithRange

setStageInRegion

setTextureAtIndex

setTexturesWithRange

setThreadgroupMemoryLengthAtIndex

updateFence

waitForFence

dispatchThreadsThreadsPerThreadgroup

setImageblockWidthHeight

useHeap

useHeapsCount

useResourceUsage

useResourcesCountUsage

dispatchType

executeCommandsInBufferIndirectBufferIndirectBufferOffset

executeCommandsInBufferWithRange

memoryBarrierWithResourcesCount

memoryBarrierWithScope

setStageInRegionWithIndirectBufferIndirectBufferOffset

sampleCountersInBufferAtSampleIndexWithBarrier

setAccelerationStructureAtBufferIndex

setIntersectionFunctionTableAtBufferIndex

setIntersectionFunctionTablesWithBufferRange

setVisibleFunctionTableAtBufferIndex

setVisibleFunctionTablesWithBufferRange

setBufferOffsetAttributeStrideAtIndex

setBufferOffsetAttributeStrideAtIndex

setBuffersOffsetsAttributeStridesWithRange

setBytesLengthAttributeStrideAtIndex