1  //-------------------------------------------------------------------------------------------------------------------------------------------------------------
   2  //
   3  // Metal/MTLRenderCommandEncoder.hpp
   4  //
   5  // Copyright 2020-2024 Apple Inc.
   6  //
   7  // Licensed under the Apache License, Version 2.0 (the "License");
   8  // you may not use this file except in compliance with the License.
   9  // You may obtain a copy of the License at
  10  //
  11  //     http://www.apache.org/licenses/LICENSE-2.0
  12  //
  13  // Unless required by applicable law or agreed to in writing, software
  14  // distributed under the License is distributed on an "AS IS" BASIS,
  15  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  // See the License for the specific language governing permissions and
  17  // limitations under the License.
  18  //
  19  //-------------------------------------------------------------------------------------------------------------------------------------------------------------
  20  
  21  #pragma once
  22  
  23  #include "MTLDefines.hpp"
  24  #include "MTLHeaderBridge.hpp"
  25  #include "MTLPrivate.hpp"
  26  
  27  #include <Foundation/Foundation.hpp>
  28  
  29  #include "MTLCommandEncoder.hpp"
  30  #include "MTLRenderCommandEncoder.hpp"
  31  #include "MTLRenderPass.hpp"
  32  #include "MTLStageInputOutputDescriptor.hpp"
  33  #include "MTLTypes.hpp"
  34  
  35  namespace MTL
  36  {
  37  _MTL_ENUM(NS::UInteger, PrimitiveType) {
  38      PrimitiveTypePoint = 0,
  39      PrimitiveTypeLine = 1,
  40      PrimitiveTypeLineStrip = 2,
  41      PrimitiveTypeTriangle = 3,
  42      PrimitiveTypeTriangleStrip = 4,
  43  };
  44  
  45  _MTL_ENUM(NS::UInteger, VisibilityResultMode) {
  46      VisibilityResultModeDisabled = 0,
  47      VisibilityResultModeBoolean = 1,
  48      VisibilityResultModeCounting = 2,
  49  };
  50  
  51  struct ScissorRect
  52  {
  53      NS::UInteger x;
  54      NS::UInteger y;
  55      NS::UInteger width;
  56      NS::UInteger height;
  57  } _MTL_PACKED;
  58  
  59  struct Viewport
  60  {
  61      double originX;
  62      double originY;
  63      double width;
  64      double height;
  65      double znear;
  66      double zfar;
  67  } _MTL_PACKED;
  68  
  69  _MTL_ENUM(NS::UInteger, CullMode) {
  70      CullModeNone = 0,
  71      CullModeFront = 1,
  72      CullModeBack = 2,
  73  };
  74  
  75  _MTL_ENUM(NS::UInteger, Winding) {
  76      WindingClockwise = 0,
  77      WindingCounterClockwise = 1,
  78  };
  79  
  80  _MTL_ENUM(NS::UInteger, DepthClipMode) {
  81      DepthClipModeClip = 0,
  82      DepthClipModeClamp = 1,
  83  };
  84  
  85  _MTL_ENUM(NS::UInteger, TriangleFillMode) {
  86      TriangleFillModeFill = 0,
  87      TriangleFillModeLines = 1,
  88  };
  89  
  90  struct DrawPrimitivesIndirectArguments
  91  {
  92      uint32_t vertexCount;
  93      uint32_t instanceCount;
  94      uint32_t vertexStart;
  95      uint32_t baseInstance;
  96  } _MTL_PACKED;
  97  
  98  struct DrawIndexedPrimitivesIndirectArguments
  99  {
 100      uint32_t indexCount;
 101      uint32_t instanceCount;
 102      uint32_t indexStart;
 103      int32_t  baseVertex;
 104      uint32_t baseInstance;
 105  } _MTL_PACKED;
 106  
 107  struct VertexAmplificationViewMapping
 108  {
 109      uint32_t viewportArrayIndexOffset;
 110      uint32_t renderTargetArrayIndexOffset;
 111  } _MTL_PACKED;
 112  
 113  struct DrawPatchIndirectArguments
 114  {
 115      uint32_t patchCount;
 116      uint32_t instanceCount;
 117      uint32_t patchStart;
 118      uint32_t baseInstance;
 119  } _MTL_PACKED;
 120  
 121  struct QuadTessellationFactorsHalf
 122  {
 123      uint16_t edgeTessellationFactor[4];
 124      uint16_t insideTessellationFactor[2];
 125  } _MTL_PACKED;
 126  
 127  struct TriangleTessellationFactorsHalf
 128  {
 129      uint16_t edgeTessellationFactor[3];
 130      uint16_t insideTessellationFactor;
 131  } _MTL_PACKED;
 132  
 133  _MTL_OPTIONS(NS::UInteger, RenderStages) {
 134      RenderStageVertex = 1,
 135      RenderStageFragment = 2,
 136      RenderStageTile = 4,
 137      RenderStageObject = 8,
 138      RenderStageMesh = 16,
 139  };
 140  
 141  class RenderCommandEncoder : public NS::Referencing<RenderCommandEncoder, CommandEncoder>
 142  {
 143  public:
 144      void         setRenderPipelineState(const class RenderPipelineState* pipelineState);
 145  
 146      void         setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
 147  
 148      void         setVertexBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
 149  
 150      void         setVertexBufferOffset(NS::UInteger offset, NS::UInteger index);
 151  
 152      void         setVertexBuffers(const class Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range);
 153  
 154      void         setVertexBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
 155  
 156      void         setVertexBuffers(const class Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range);
 157  
 158      void         setVertexBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index);
 159  
 160      void         setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index);
 161  
 162      void         setVertexTexture(const class Texture* texture, NS::UInteger index);
 163  
 164      void         setVertexTextures(const class Texture* const textures[], NS::Range range);
 165  
 166      void         setVertexSamplerState(const class SamplerState* sampler, NS::UInteger index);
 167  
 168      void         setVertexSamplerStates(const class SamplerState* const samplers[], NS::Range range);
 169  
 170      void         setVertexSamplerState(const class SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
 171  
 172      void         setVertexSamplerStates(const class SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range);
 173  
 174      void         setVertexVisibleFunctionTable(const class VisibleFunctionTable* functionTable, NS::UInteger bufferIndex);
 175  
 176      void         setVertexVisibleFunctionTables(const class VisibleFunctionTable* const functionTables[], NS::Range range);
 177  
 178      void         setVertexIntersectionFunctionTable(const class IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex);
 179  
 180      void         setVertexIntersectionFunctionTables(const class IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range);
 181  
 182      void         setVertexAccelerationStructure(const class AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex);
 183  
 184      void         setViewport(MTL::Viewport viewport);
 185  
 186      void         setViewports(const MTL::Viewport* viewports, NS::UInteger count);
 187  
 188      void         setFrontFacingWinding(MTL::Winding frontFacingWinding);
 189  
 190      void         setVertexAmplificationCount(NS::UInteger count, const MTL::VertexAmplificationViewMapping* viewMappings);
 191  
 192      void         setCullMode(MTL::CullMode cullMode);
 193  
 194      void         setDepthClipMode(MTL::DepthClipMode depthClipMode);
 195  
 196      void         setDepthBias(float depthBias, float slopeScale, float clamp);
 197  
 198      void         setScissorRect(MTL::ScissorRect rect);
 199  
 200      void         setScissorRects(const MTL::ScissorRect* scissorRects, NS::UInteger count);
 201  
 202      void         setTriangleFillMode(MTL::TriangleFillMode fillMode);
 203  
 204      void         setFragmentBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
 205  
 206      void         setFragmentBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
 207  
 208      void         setFragmentBufferOffset(NS::UInteger offset, NS::UInteger index);
 209  
 210      void         setFragmentBuffers(const class Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range);
 211  
 212      void         setFragmentTexture(const class Texture* texture, NS::UInteger index);
 213  
 214      void         setFragmentTextures(const class Texture* const textures[], NS::Range range);
 215  
 216      void         setFragmentSamplerState(const class SamplerState* sampler, NS::UInteger index);
 217  
 218      void         setFragmentSamplerStates(const class SamplerState* const samplers[], NS::Range range);
 219  
 220      void         setFragmentSamplerState(const class SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
 221  
 222      void         setFragmentSamplerStates(const class SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range);
 223  
 224      void         setFragmentVisibleFunctionTable(const class VisibleFunctionTable* functionTable, NS::UInteger bufferIndex);
 225  
 226      void         setFragmentVisibleFunctionTables(const class VisibleFunctionTable* const functionTables[], NS::Range range);
 227  
 228      void         setFragmentIntersectionFunctionTable(const class IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex);
 229  
 230      void         setFragmentIntersectionFunctionTables(const class IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range);
 231  
 232      void         setFragmentAccelerationStructure(const class AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex);
 233  
 234      void         setBlendColor(float red, float green, float blue, float alpha);
 235  
 236      void         setDepthStencilState(const class DepthStencilState* depthStencilState);
 237  
 238      void         setStencilReferenceValue(uint32_t referenceValue);
 239  
 240      void         setStencilReferenceValues(uint32_t frontReferenceValue, uint32_t backReferenceValue);
 241  
 242      void         setVisibilityResultMode(MTL::VisibilityResultMode mode, NS::UInteger offset);
 243  
 244      void         setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex);
 245  
 246      void         setDepthStoreAction(MTL::StoreAction storeAction);
 247  
 248      void         setStencilStoreAction(MTL::StoreAction storeAction);
 249  
 250      void         setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex);
 251  
 252      void         setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions);
 253  
 254      void         setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions);
 255  
 256      void         setObjectBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
 257  
 258      void         setObjectBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
 259  
 260      void         setObjectBufferOffset(NS::UInteger offset, NS::UInteger index);
 261  
 262      void         setObjectBuffers(const class Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range);
 263  
 264      void         setObjectTexture(const class Texture* texture, NS::UInteger index);
 265  
 266      void         setObjectTextures(const class Texture* const textures[], NS::Range range);
 267  
 268      void         setObjectSamplerState(const class SamplerState* sampler, NS::UInteger index);
 269  
 270      void         setObjectSamplerStates(const class SamplerState* const samplers[], NS::Range range);
 271  
 272      void         setObjectSamplerState(const class SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
 273  
 274      void         setObjectSamplerStates(const class SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range);
 275  
 276      void         setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index);
 277  
 278      void         setMeshBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
 279  
 280      void         setMeshBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
 281  
 282      void         setMeshBufferOffset(NS::UInteger offset, NS::UInteger index);
 283  
 284      void         setMeshBuffers(const class Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range);
 285  
 286      void         setMeshTexture(const class Texture* texture, NS::UInteger index);
 287  
 288      void         setMeshTextures(const class Texture* const textures[], NS::Range range);
 289  
 290      void         setMeshSamplerState(const class SamplerState* sampler, NS::UInteger index);
 291  
 292      void         setMeshSamplerStates(const class SamplerState* const samplers[], NS::Range range);
 293  
 294      void         setMeshSamplerState(const class SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
 295  
 296      void         setMeshSamplerStates(const class SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range);
 297  
 298      void         drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup);
 299  
 300      void         drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup);
 301  
 302      void         drawMeshThreadgroups(const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup);
 303  
 304      void         drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount);
 305  
 306      void         drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount);
 307  
 308      void         drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const class Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount);
 309  
 310      void         drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const class Buffer* indexBuffer, NS::UInteger indexBufferOffset);
 311  
 312      void         drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance);
 313  
 314      void         drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const class Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance);
 315  
 316      void         drawPrimitives(MTL::PrimitiveType primitiveType, const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset);
 317  
 318      void         drawIndexedPrimitives(MTL::PrimitiveType primitiveType, MTL::IndexType indexType, const class Buffer* indexBuffer, NS::UInteger indexBufferOffset, const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset);
 319  
 320      void         textureBarrier();
 321  
 322      void         updateFence(const class Fence* fence, MTL::RenderStages stages);
 323  
 324      void         waitForFence(const class Fence* fence, MTL::RenderStages stages);
 325  
 326      void         setTessellationFactorBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride);
 327  
 328      void         setTessellationFactorScale(float scale);
 329  
 330      void         drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const class Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance);
 331  
 332      void         drawPatches(NS::UInteger numberOfPatchControlPoints, const class Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset);
 333  
 334      void         drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const class Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const class Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance);
 335  
 336      void         drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, const class Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const class Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, const class Buffer* indirectBuffer, NS::UInteger indirectBufferOffset);
 337  
 338      NS::UInteger tileWidth() const;
 339  
 340      NS::UInteger tileHeight() const;
 341  
 342      void         setTileBytes(const void* bytes, NS::UInteger length, NS::UInteger index);
 343  
 344      void         setTileBuffer(const class Buffer* buffer, NS::UInteger offset, NS::UInteger index);
 345  
 346      void         setTileBufferOffset(NS::UInteger offset, NS::UInteger index);
 347  
 348      void         setTileBuffers(const class Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range);
 349  
 350      void         setTileTexture(const class Texture* texture, NS::UInteger index);
 351  
 352      void         setTileTextures(const class Texture* const textures[], NS::Range range);
 353  
 354      void         setTileSamplerState(const class SamplerState* sampler, NS::UInteger index);
 355  
 356      void         setTileSamplerStates(const class SamplerState* const samplers[], NS::Range range);
 357  
 358      void         setTileSamplerState(const class SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index);
 359  
 360      void         setTileSamplerStates(const class SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range);
 361  
 362      void         setTileVisibleFunctionTable(const class VisibleFunctionTable* functionTable, NS::UInteger bufferIndex);
 363  
 364      void         setTileVisibleFunctionTables(const class VisibleFunctionTable* const functionTables[], NS::Range range);
 365  
 366      void         setTileIntersectionFunctionTable(const class IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex);
 367  
 368      void         setTileIntersectionFunctionTables(const class IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range);
 369  
 370      void         setTileAccelerationStructure(const class AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex);
 371  
 372      void         dispatchThreadsPerTile(MTL::Size threadsPerTile);
 373  
 374      void         setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger offset, NS::UInteger index);
 375  
 376      void         useResource(const class Resource* resource, MTL::ResourceUsage usage);
 377  
 378      void         useResources(const class Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage);
 379  
 380      void         useResource(const class Resource* resource, MTL::ResourceUsage usage, MTL::RenderStages stages);
 381  
 382      void         useResources(const class Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage, MTL::RenderStages stages);
 383  
 384      void         useHeap(const class Heap* heap);
 385  
 386      void         useHeaps(const class Heap* const heaps[], NS::UInteger count);
 387  
 388      void         useHeap(const class Heap* heap, MTL::RenderStages stages);
 389  
 390      void         useHeaps(const class Heap* const heaps[], NS::UInteger count, MTL::RenderStages stages);
 391  
 392      void         executeCommandsInBuffer(const class IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange);
 393  
 394      void         executeCommandsInBuffer(const class IndirectCommandBuffer* indirectCommandbuffer, const class Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset);
 395  
 396      void         memoryBarrier(MTL::BarrierScope scope, MTL::RenderStages after, MTL::RenderStages before);
 397  
 398      void         memoryBarrier(const class Resource* const resources[], NS::UInteger count, MTL::RenderStages after, MTL::RenderStages before);
 399  
 400      void         sampleCountersInBuffer(const class CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier);
 401  };
 402  
 403  }
 404  
 405  // method: setRenderPipelineState:
 406  _MTL_INLINE void MTL::RenderCommandEncoder::setRenderPipelineState(const MTL::RenderPipelineState* pipelineState)
 407  {
 408      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderPipelineState_), pipelineState);
 409  }
 410  
 411  // method: setVertexBytes:length:atIndex:
 412  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
 413  {
 414      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBytes_length_atIndex_), bytes, length, index);
 415  }
 416  
 417  // method: setVertexBuffer:offset:atIndex:
 418  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
 419  {
 420      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_atIndex_), buffer, offset, index);
 421  }
 422  
 423  // method: setVertexBufferOffset:atIndex:
 424  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexBufferOffset(NS::UInteger offset, NS::UInteger index)
 425  {
 426      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBufferOffset_atIndex_), offset, index);
 427  }
 428  
 429  // method: setVertexBuffers:offsets:withRange:
 430  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range)
 431  {
 432      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffers_offsets_withRange_), buffers, offsets, range);
 433  }
 434  
 435  // method: setVertexBuffer:offset:attributeStride:atIndex:
 436  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
 437  {
 438      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffer_offset_attributeStride_atIndex_), buffer, offset, stride, index);
 439  }
 440  
 441  // method: setVertexBuffers:offsets:attributeStrides:withRange:
 442  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, const NS::UInteger* strides, NS::Range range)
 443  {
 444      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffers_offsets_attributeStrides_withRange_), buffers, offsets, strides, range);
 445  }
 446  
 447  // method: setVertexBufferOffset:attributeStride:atIndex:
 448  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexBufferOffset(NS::UInteger offset, NS::UInteger stride, NS::UInteger index)
 449  {
 450      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBufferOffset_attributeStride_atIndex_), offset, stride, index);
 451  }
 452  
 453  // method: setVertexBytes:length:attributeStride:atIndex:
 454  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexBytes(const void* bytes, NS::UInteger length, NS::UInteger stride, NS::UInteger index)
 455  {
 456      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBytes_length_attributeStride_atIndex_), bytes, length, stride, index);
 457  }
 458  
 459  // method: setVertexTexture:atIndex:
 460  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexTexture(const MTL::Texture* texture, NS::UInteger index)
 461  {
 462      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexTexture_atIndex_), texture, index);
 463  }
 464  
 465  // method: setVertexTextures:withRange:
 466  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexTextures(const MTL::Texture* const textures[], NS::Range range)
 467  {
 468      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexTextures_withRange_), textures, range);
 469  }
 470  
 471  // method: setVertexSamplerState:atIndex:
 472  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
 473  {
 474      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexSamplerState_atIndex_), sampler, index);
 475  }
 476  
 477  // method: setVertexSamplerStates:withRange:
 478  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
 479  {
 480      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexSamplerStates_withRange_), samplers, range);
 481  }
 482  
 483  // method: setVertexSamplerState:lodMinClamp:lodMaxClamp:atIndex:
 484  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
 485  {
 486      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
 487  }
 488  
 489  // method: setVertexSamplerStates:lodMinClamps:lodMaxClamps:withRange:
 490  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range)
 491  {
 492      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
 493  }
 494  
 495  // method: setVertexVisibleFunctionTable:atBufferIndex:
 496  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex)
 497  {
 498      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex);
 499  }
 500  
 501  // method: setVertexVisibleFunctionTables:withBufferRange:
 502  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range)
 503  {
 504      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexVisibleFunctionTables_withBufferRange_), functionTables, range);
 505  }
 506  
 507  // method: setVertexIntersectionFunctionTable:atBufferIndex:
 508  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex)
 509  {
 510      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex);
 511  }
 512  
 513  // method: setVertexIntersectionFunctionTables:withBufferRange:
 514  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range)
 515  {
 516      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range);
 517  }
 518  
 519  // method: setVertexAccelerationStructure:atBufferIndex:
 520  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex)
 521  {
 522      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex);
 523  }
 524  
 525  // method: setViewport:
 526  _MTL_INLINE void MTL::RenderCommandEncoder::setViewport(MTL::Viewport viewport)
 527  {
 528      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setViewport_), viewport);
 529  }
 530  
 531  // method: setViewports:count:
 532  _MTL_INLINE void MTL::RenderCommandEncoder::setViewports(const MTL::Viewport* viewports, NS::UInteger count)
 533  {
 534      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setViewports_count_), viewports, count);
 535  }
 536  
 537  // method: setFrontFacingWinding:
 538  _MTL_INLINE void MTL::RenderCommandEncoder::setFrontFacingWinding(MTL::Winding frontFacingWinding)
 539  {
 540      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFrontFacingWinding_), frontFacingWinding);
 541  }
 542  
 543  // method: setVertexAmplificationCount:viewMappings:
 544  _MTL_INLINE void MTL::RenderCommandEncoder::setVertexAmplificationCount(NS::UInteger count, const MTL::VertexAmplificationViewMapping* viewMappings)
 545  {
 546      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexAmplificationCount_viewMappings_), count, viewMappings);
 547  }
 548  
 549  // method: setCullMode:
 550  _MTL_INLINE void MTL::RenderCommandEncoder::setCullMode(MTL::CullMode cullMode)
 551  {
 552      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCullMode_), cullMode);
 553  }
 554  
 555  // method: setDepthClipMode:
 556  _MTL_INLINE void MTL::RenderCommandEncoder::setDepthClipMode(MTL::DepthClipMode depthClipMode)
 557  {
 558      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthClipMode_), depthClipMode);
 559  }
 560  
 561  // method: setDepthBias:slopeScale:clamp:
 562  _MTL_INLINE void MTL::RenderCommandEncoder::setDepthBias(float depthBias, float slopeScale, float clamp)
 563  {
 564      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthBias_slopeScale_clamp_), depthBias, slopeScale, clamp);
 565  }
 566  
 567  // method: setScissorRect:
 568  _MTL_INLINE void MTL::RenderCommandEncoder::setScissorRect(MTL::ScissorRect rect)
 569  {
 570      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setScissorRect_), rect);
 571  }
 572  
 573  // method: setScissorRects:count:
 574  _MTL_INLINE void MTL::RenderCommandEncoder::setScissorRects(const MTL::ScissorRect* scissorRects, NS::UInteger count)
 575  {
 576      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setScissorRects_count_), scissorRects, count);
 577  }
 578  
 579  // method: setTriangleFillMode:
 580  _MTL_INLINE void MTL::RenderCommandEncoder::setTriangleFillMode(MTL::TriangleFillMode fillMode)
 581  {
 582      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTriangleFillMode_), fillMode);
 583  }
 584  
 585  // method: setFragmentBytes:length:atIndex:
 586  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
 587  {
 588      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentBytes_length_atIndex_), bytes, length, index);
 589  }
 590  
 591  // method: setFragmentBuffer:offset:atIndex:
 592  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
 593  {
 594      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentBuffer_offset_atIndex_), buffer, offset, index);
 595  }
 596  
 597  // method: setFragmentBufferOffset:atIndex:
 598  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBufferOffset(NS::UInteger offset, NS::UInteger index)
 599  {
 600      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentBufferOffset_atIndex_), offset, index);
 601  }
 602  
 603  // method: setFragmentBuffers:offsets:withRange:
 604  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentBuffers(const MTL::Buffer* const buffers[], const NS::UInteger offsets[], NS::Range range)
 605  {
 606      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentBuffers_offsets_withRange_), buffers, offsets, range);
 607  }
 608  
 609  // method: setFragmentTexture:atIndex:
 610  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentTexture(const MTL::Texture* texture, NS::UInteger index)
 611  {
 612      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentTexture_atIndex_), texture, index);
 613  }
 614  
 615  // method: setFragmentTextures:withRange:
 616  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentTextures(const MTL::Texture* const textures[], NS::Range range)
 617  {
 618      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentTextures_withRange_), textures, range);
 619  }
 620  
 621  // method: setFragmentSamplerState:atIndex:
 622  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
 623  {
 624      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentSamplerState_atIndex_), sampler, index);
 625  }
 626  
 627  // method: setFragmentSamplerStates:withRange:
 628  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
 629  {
 630      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentSamplerStates_withRange_), samplers, range);
 631  }
 632  
 633  // method: setFragmentSamplerState:lodMinClamp:lodMaxClamp:atIndex:
 634  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
 635  {
 636      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
 637  }
 638  
 639  // method: setFragmentSamplerStates:lodMinClamps:lodMaxClamps:withRange:
 640  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range)
 641  {
 642      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
 643  }
 644  
 645  // method: setFragmentVisibleFunctionTable:atBufferIndex:
 646  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex)
 647  {
 648      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex);
 649  }
 650  
 651  // method: setFragmentVisibleFunctionTables:withBufferRange:
 652  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range)
 653  {
 654      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentVisibleFunctionTables_withBufferRange_), functionTables, range);
 655  }
 656  
 657  // method: setFragmentIntersectionFunctionTable:atBufferIndex:
 658  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex)
 659  {
 660      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex);
 661  }
 662  
 663  // method: setFragmentIntersectionFunctionTables:withBufferRange:
 664  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range)
 665  {
 666      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range);
 667  }
 668  
 669  // method: setFragmentAccelerationStructure:atBufferIndex:
 670  _MTL_INLINE void MTL::RenderCommandEncoder::setFragmentAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex)
 671  {
 672      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex);
 673  }
 674  
 675  // method: setBlendColorRed:green:blue:alpha:
 676  _MTL_INLINE void MTL::RenderCommandEncoder::setBlendColor(float red, float green, float blue, float alpha)
 677  {
 678      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBlendColorRed_green_blue_alpha_), red, green, blue, alpha);
 679  }
 680  
 681  // method: setDepthStencilState:
 682  _MTL_INLINE void MTL::RenderCommandEncoder::setDepthStencilState(const MTL::DepthStencilState* depthStencilState)
 683  {
 684      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStencilState_), depthStencilState);
 685  }
 686  
 687  // method: setStencilReferenceValue:
 688  _MTL_INLINE void MTL::RenderCommandEncoder::setStencilReferenceValue(uint32_t referenceValue)
 689  {
 690      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilReferenceValue_), referenceValue);
 691  }
 692  
 693  // method: setStencilFrontReferenceValue:backReferenceValue:
 694  _MTL_INLINE void MTL::RenderCommandEncoder::setStencilReferenceValues(uint32_t frontReferenceValue, uint32_t backReferenceValue)
 695  {
 696      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilFrontReferenceValue_backReferenceValue_), frontReferenceValue, backReferenceValue);
 697  }
 698  
 699  // method: setVisibilityResultMode:offset:
 700  _MTL_INLINE void MTL::RenderCommandEncoder::setVisibilityResultMode(MTL::VisibilityResultMode mode, NS::UInteger offset)
 701  {
 702      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibilityResultMode_offset_), mode, offset);
 703  }
 704  
 705  // method: setColorStoreAction:atIndex:
 706  _MTL_INLINE void MTL::RenderCommandEncoder::setColorStoreAction(MTL::StoreAction storeAction, NS::UInteger colorAttachmentIndex)
 707  {
 708      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorStoreAction_atIndex_), storeAction, colorAttachmentIndex);
 709  }
 710  
 711  // method: setDepthStoreAction:
 712  _MTL_INLINE void MTL::RenderCommandEncoder::setDepthStoreAction(MTL::StoreAction storeAction)
 713  {
 714      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStoreAction_), storeAction);
 715  }
 716  
 717  // method: setStencilStoreAction:
 718  _MTL_INLINE void MTL::RenderCommandEncoder::setStencilStoreAction(MTL::StoreAction storeAction)
 719  {
 720      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilStoreAction_), storeAction);
 721  }
 722  
 723  // method: setColorStoreActionOptions:atIndex:
 724  _MTL_INLINE void MTL::RenderCommandEncoder::setColorStoreActionOptions(MTL::StoreActionOptions storeActionOptions, NS::UInteger colorAttachmentIndex)
 725  {
 726      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setColorStoreActionOptions_atIndex_), storeActionOptions, colorAttachmentIndex);
 727  }
 728  
 729  // method: setDepthStoreActionOptions:
 730  _MTL_INLINE void MTL::RenderCommandEncoder::setDepthStoreActionOptions(MTL::StoreActionOptions storeActionOptions)
 731  {
 732      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStoreActionOptions_), storeActionOptions);
 733  }
 734  
 735  // method: setStencilStoreActionOptions:
 736  _MTL_INLINE void MTL::RenderCommandEncoder::setStencilStoreActionOptions(MTL::StoreActionOptions storeActionOptions)
 737  {
 738      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilStoreActionOptions_), storeActionOptions);
 739  }
 740  
 741  // method: setObjectBytes:length:atIndex:
 742  _MTL_INLINE void MTL::RenderCommandEncoder::setObjectBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
 743  {
 744      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectBytes_length_atIndex_), bytes, length, index);
 745  }
 746  
 747  // method: setObjectBuffer:offset:atIndex:
 748  _MTL_INLINE void MTL::RenderCommandEncoder::setObjectBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
 749  {
 750      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectBuffer_offset_atIndex_), buffer, offset, index);
 751  }
 752  
 753  // method: setObjectBufferOffset:atIndex:
 754  _MTL_INLINE void MTL::RenderCommandEncoder::setObjectBufferOffset(NS::UInteger offset, NS::UInteger index)
 755  {
 756      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectBufferOffset_atIndex_), offset, index);
 757  }
 758  
 759  // method: setObjectBuffers:offsets:withRange:
 760  _MTL_INLINE void MTL::RenderCommandEncoder::setObjectBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range)
 761  {
 762      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectBuffers_offsets_withRange_), buffers, offsets, range);
 763  }
 764  
 765  // method: setObjectTexture:atIndex:
 766  _MTL_INLINE void MTL::RenderCommandEncoder::setObjectTexture(const MTL::Texture* texture, NS::UInteger index)
 767  {
 768      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectTexture_atIndex_), texture, index);
 769  }
 770  
 771  // method: setObjectTextures:withRange:
 772  _MTL_INLINE void MTL::RenderCommandEncoder::setObjectTextures(const MTL::Texture* const textures[], NS::Range range)
 773  {
 774      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectTextures_withRange_), textures, range);
 775  }
 776  
 777  // method: setObjectSamplerState:atIndex:
 778  _MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
 779  {
 780      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectSamplerState_atIndex_), sampler, index);
 781  }
 782  
 783  // method: setObjectSamplerStates:withRange:
 784  _MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
 785  {
 786      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectSamplerStates_withRange_), samplers, range);
 787  }
 788  
 789  // method: setObjectSamplerState:lodMinClamp:lodMaxClamp:atIndex:
 790  _MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
 791  {
 792      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
 793  }
 794  
 795  // method: setObjectSamplerStates:lodMinClamps:lodMaxClamps:withRange:
 796  _MTL_INLINE void MTL::RenderCommandEncoder::setObjectSamplerStates(const MTL::SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range)
 797  {
 798      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
 799  }
 800  
 801  // method: setObjectThreadgroupMemoryLength:atIndex:
 802  _MTL_INLINE void MTL::RenderCommandEncoder::setObjectThreadgroupMemoryLength(NS::UInteger length, NS::UInteger index)
 803  {
 804      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObjectThreadgroupMemoryLength_atIndex_), length, index);
 805  }
 806  
 807  // method: setMeshBytes:length:atIndex:
 808  _MTL_INLINE void MTL::RenderCommandEncoder::setMeshBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
 809  {
 810      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshBytes_length_atIndex_), bytes, length, index);
 811  }
 812  
 813  // method: setMeshBuffer:offset:atIndex:
 814  _MTL_INLINE void MTL::RenderCommandEncoder::setMeshBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
 815  {
 816      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshBuffer_offset_atIndex_), buffer, offset, index);
 817  }
 818  
 819  // method: setMeshBufferOffset:atIndex:
 820  _MTL_INLINE void MTL::RenderCommandEncoder::setMeshBufferOffset(NS::UInteger offset, NS::UInteger index)
 821  {
 822      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshBufferOffset_atIndex_), offset, index);
 823  }
 824  
 825  // method: setMeshBuffers:offsets:withRange:
 826  _MTL_INLINE void MTL::RenderCommandEncoder::setMeshBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range)
 827  {
 828      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshBuffers_offsets_withRange_), buffers, offsets, range);
 829  }
 830  
 831  // method: setMeshTexture:atIndex:
 832  _MTL_INLINE void MTL::RenderCommandEncoder::setMeshTexture(const MTL::Texture* texture, NS::UInteger index)
 833  {
 834      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshTexture_atIndex_), texture, index);
 835  }
 836  
 837  // method: setMeshTextures:withRange:
 838  _MTL_INLINE void MTL::RenderCommandEncoder::setMeshTextures(const MTL::Texture* const textures[], NS::Range range)
 839  {
 840      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshTextures_withRange_), textures, range);
 841  }
 842  
 843  // method: setMeshSamplerState:atIndex:
 844  _MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
 845  {
 846      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshSamplerState_atIndex_), sampler, index);
 847  }
 848  
 849  // method: setMeshSamplerStates:withRange:
 850  _MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
 851  {
 852      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshSamplerStates_withRange_), samplers, range);
 853  }
 854  
 855  // method: setMeshSamplerState:lodMinClamp:lodMaxClamp:atIndex:
 856  _MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
 857  {
 858      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
 859  }
 860  
 861  // method: setMeshSamplerStates:lodMinClamps:lodMaxClamps:withRange:
 862  _MTL_INLINE void MTL::RenderCommandEncoder::setMeshSamplerStates(const MTL::SamplerState* const samplers[], const float* lodMinClamps, const float* lodMaxClamps, NS::Range range)
 863  {
 864      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMeshSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
 865  }
 866  
 867  // method: drawMeshThreadgroups:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:
 868  _MTL_INLINE void MTL::RenderCommandEncoder::drawMeshThreadgroups(MTL::Size threadgroupsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup)
 869  {
 870      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawMeshThreadgroups_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadgroupsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup);
 871  }
 872  
 873  // method: drawMeshThreads:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:
 874  _MTL_INLINE void MTL::RenderCommandEncoder::drawMeshThreads(MTL::Size threadsPerGrid, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup)
 875  {
 876      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawMeshThreads_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), threadsPerGrid, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup);
 877  }
 878  
 879  // method: drawMeshThreadgroupsWithIndirectBuffer:indirectBufferOffset:threadsPerObjectThreadgroup:threadsPerMeshThreadgroup:
 880  _MTL_INLINE void MTL::RenderCommandEncoder::drawMeshThreadgroups(const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset, MTL::Size threadsPerObjectThreadgroup, MTL::Size threadsPerMeshThreadgroup)
 881  {
 882      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawMeshThreadgroupsWithIndirectBuffer_indirectBufferOffset_threadsPerObjectThreadgroup_threadsPerMeshThreadgroup_), indirectBuffer, indirectBufferOffset, threadsPerObjectThreadgroup, threadsPerMeshThreadgroup);
 883  }
 884  
 885  // method: drawPrimitives:vertexStart:vertexCount:instanceCount:
 886  _MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount)
 887  {
 888      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_), primitiveType, vertexStart, vertexCount, instanceCount);
 889  }
 890  
 891  // method: drawPrimitives:vertexStart:vertexCount:
 892  _MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount)
 893  {
 894      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_), primitiveType, vertexStart, vertexCount);
 895  }
 896  
 897  // method: drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:
 898  _MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount)
 899  {
 900      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount);
 901  }
 902  
 903  // method: drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:
 904  _MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset)
 905  {
 906      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset);
 907  }
 908  
 909  // method: drawPrimitives:vertexStart:vertexCount:instanceCount:baseInstance:
 910  _MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger vertexStart, NS::UInteger vertexCount, NS::UInteger instanceCount, NS::UInteger baseInstance)
 911  {
 912      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_vertexStart_vertexCount_instanceCount_baseInstance_), primitiveType, vertexStart, vertexCount, instanceCount, baseInstance);
 913  }
 914  
 915  // method: drawIndexedPrimitives:indexCount:indexType:indexBuffer:indexBufferOffset:instanceCount:baseVertex:baseInstance:
 916  _MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, NS::UInteger indexCount, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, NS::UInteger instanceCount, NS::Integer baseVertex, NS::UInteger baseInstance)
 917  {
 918      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexCount_indexType_indexBuffer_indexBufferOffset_instanceCount_baseVertex_baseInstance_), primitiveType, indexCount, indexType, indexBuffer, indexBufferOffset, instanceCount, baseVertex, baseInstance);
 919  }
 920  
 921  // method: drawPrimitives:indirectBuffer:indirectBufferOffset:
 922  _MTL_INLINE void MTL::RenderCommandEncoder::drawPrimitives(MTL::PrimitiveType primitiveType, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset)
 923  {
 924      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPrimitives_indirectBuffer_indirectBufferOffset_), primitiveType, indirectBuffer, indirectBufferOffset);
 925  }
 926  
 927  // method: drawIndexedPrimitives:indexType:indexBuffer:indexBufferOffset:indirectBuffer:indirectBufferOffset:
 928  _MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPrimitives(MTL::PrimitiveType primitiveType, MTL::IndexType indexType, const MTL::Buffer* indexBuffer, NS::UInteger indexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset)
 929  {
 930      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPrimitives_indexType_indexBuffer_indexBufferOffset_indirectBuffer_indirectBufferOffset_), primitiveType, indexType, indexBuffer, indexBufferOffset, indirectBuffer, indirectBufferOffset);
 931  }
 932  
 933  // method: textureBarrier
 934  _MTL_INLINE void MTL::RenderCommandEncoder::textureBarrier()
 935  {
 936      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(textureBarrier));
 937  }
 938  
 939  // method: updateFence:afterStages:
 940  _MTL_INLINE void MTL::RenderCommandEncoder::updateFence(const MTL::Fence* fence, MTL::RenderStages stages)
 941  {
 942      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(updateFence_afterStages_), fence, stages);
 943  }
 944  
 945  // method: waitForFence:beforeStages:
 946  _MTL_INLINE void MTL::RenderCommandEncoder::waitForFence(const MTL::Fence* fence, MTL::RenderStages stages)
 947  {
 948      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(waitForFence_beforeStages_), fence, stages);
 949  }
 950  
 951  // method: setTessellationFactorBuffer:offset:instanceStride:
 952  _MTL_INLINE void MTL::RenderCommandEncoder::setTessellationFactorBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger instanceStride)
 953  {
 954      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationFactorBuffer_offset_instanceStride_), buffer, offset, instanceStride);
 955  }
 956  
 957  // method: setTessellationFactorScale:
 958  _MTL_INLINE void MTL::RenderCommandEncoder::setTessellationFactorScale(float scale)
 959  {
 960      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationFactorScale_), scale);
 961  }
 962  
 963  // method: drawPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:instanceCount:baseInstance:
 964  _MTL_INLINE void MTL::RenderCommandEncoder::drawPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance)
 965  {
 966      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_instanceCount_baseInstance_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, instanceCount, baseInstance);
 967  }
 968  
 969  // method: drawPatches:patchIndexBuffer:patchIndexBufferOffset:indirectBuffer:indirectBufferOffset:
 970  _MTL_INLINE void MTL::RenderCommandEncoder::drawPatches(NS::UInteger numberOfPatchControlPoints, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset)
 971  {
 972      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawPatches_patchIndexBuffer_patchIndexBufferOffset_indirectBuffer_indirectBufferOffset_), numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, indirectBuffer, indirectBufferOffset);
 973  }
 974  
 975  // method: drawIndexedPatches:patchStart:patchCount:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:instanceCount:baseInstance:
 976  _MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, NS::UInteger patchStart, NS::UInteger patchCount, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, NS::UInteger instanceCount, NS::UInteger baseInstance)
 977  {
 978      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPatches_patchStart_patchCount_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_instanceCount_baseInstance_), numberOfPatchControlPoints, patchStart, patchCount, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, instanceCount, baseInstance);
 979  }
 980  
 981  // method: drawIndexedPatches:patchIndexBuffer:patchIndexBufferOffset:controlPointIndexBuffer:controlPointIndexBufferOffset:indirectBuffer:indirectBufferOffset:
 982  _MTL_INLINE void MTL::RenderCommandEncoder::drawIndexedPatches(NS::UInteger numberOfPatchControlPoints, const MTL::Buffer* patchIndexBuffer, NS::UInteger patchIndexBufferOffset, const MTL::Buffer* controlPointIndexBuffer, NS::UInteger controlPointIndexBufferOffset, const MTL::Buffer* indirectBuffer, NS::UInteger indirectBufferOffset)
 983  {
 984      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(drawIndexedPatches_patchIndexBuffer_patchIndexBufferOffset_controlPointIndexBuffer_controlPointIndexBufferOffset_indirectBuffer_indirectBufferOffset_), numberOfPatchControlPoints, patchIndexBuffer, patchIndexBufferOffset, controlPointIndexBuffer, controlPointIndexBufferOffset, indirectBuffer, indirectBufferOffset);
 985  }
 986  
 987  // property: tileWidth
 988  _MTL_INLINE NS::UInteger MTL::RenderCommandEncoder::tileWidth() const
 989  {
 990      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileWidth));
 991  }
 992  
 993  // property: tileHeight
 994  _MTL_INLINE NS::UInteger MTL::RenderCommandEncoder::tileHeight() const
 995  {
 996      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileHeight));
 997  }
 998  
 999  // method: setTileBytes:length:atIndex:
1000  _MTL_INLINE void MTL::RenderCommandEncoder::setTileBytes(const void* bytes, NS::UInteger length, NS::UInteger index)
1001  {
1002      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileBytes_length_atIndex_), bytes, length, index);
1003  }
1004  
1005  // method: setTileBuffer:offset:atIndex:
1006  _MTL_INLINE void MTL::RenderCommandEncoder::setTileBuffer(const MTL::Buffer* buffer, NS::UInteger offset, NS::UInteger index)
1007  {
1008      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileBuffer_offset_atIndex_), buffer, offset, index);
1009  }
1010  
1011  // method: setTileBufferOffset:atIndex:
1012  _MTL_INLINE void MTL::RenderCommandEncoder::setTileBufferOffset(NS::UInteger offset, NS::UInteger index)
1013  {
1014      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileBufferOffset_atIndex_), offset, index);
1015  }
1016  
1017  // method: setTileBuffers:offsets:withRange:
1018  _MTL_INLINE void MTL::RenderCommandEncoder::setTileBuffers(const MTL::Buffer* const buffers[], const NS::UInteger* offsets, NS::Range range)
1019  {
1020      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileBuffers_offsets_withRange_), buffers, offsets, range);
1021  }
1022  
1023  // method: setTileTexture:atIndex:
1024  _MTL_INLINE void MTL::RenderCommandEncoder::setTileTexture(const MTL::Texture* texture, NS::UInteger index)
1025  {
1026      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileTexture_atIndex_), texture, index);
1027  }
1028  
1029  // method: setTileTextures:withRange:
1030  _MTL_INLINE void MTL::RenderCommandEncoder::setTileTextures(const MTL::Texture* const textures[], NS::Range range)
1031  {
1032      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileTextures_withRange_), textures, range);
1033  }
1034  
1035  // method: setTileSamplerState:atIndex:
1036  _MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerState(const MTL::SamplerState* sampler, NS::UInteger index)
1037  {
1038      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileSamplerState_atIndex_), sampler, index);
1039  }
1040  
1041  // method: setTileSamplerStates:withRange:
1042  _MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerStates(const MTL::SamplerState* const samplers[], NS::Range range)
1043  {
1044      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileSamplerStates_withRange_), samplers, range);
1045  }
1046  
1047  // method: setTileSamplerState:lodMinClamp:lodMaxClamp:atIndex:
1048  _MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerState(const MTL::SamplerState* sampler, float lodMinClamp, float lodMaxClamp, NS::UInteger index)
1049  {
1050      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileSamplerState_lodMinClamp_lodMaxClamp_atIndex_), sampler, lodMinClamp, lodMaxClamp, index);
1051  }
1052  
1053  // method: setTileSamplerStates:lodMinClamps:lodMaxClamps:withRange:
1054  _MTL_INLINE void MTL::RenderCommandEncoder::setTileSamplerStates(const MTL::SamplerState* const samplers[], const float lodMinClamps[], const float lodMaxClamps[], NS::Range range)
1055  {
1056      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileSamplerStates_lodMinClamps_lodMaxClamps_withRange_), samplers, lodMinClamps, lodMaxClamps, range);
1057  }
1058  
1059  // method: setTileVisibleFunctionTable:atBufferIndex:
1060  _MTL_INLINE void MTL::RenderCommandEncoder::setTileVisibleFunctionTable(const MTL::VisibleFunctionTable* functionTable, NS::UInteger bufferIndex)
1061  {
1062      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileVisibleFunctionTable_atBufferIndex_), functionTable, bufferIndex);
1063  }
1064  
1065  // method: setTileVisibleFunctionTables:withBufferRange:
1066  _MTL_INLINE void MTL::RenderCommandEncoder::setTileVisibleFunctionTables(const MTL::VisibleFunctionTable* const functionTables[], NS::Range range)
1067  {
1068      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileVisibleFunctionTables_withBufferRange_), functionTables, range);
1069  }
1070  
1071  // method: setTileIntersectionFunctionTable:atBufferIndex:
1072  _MTL_INLINE void MTL::RenderCommandEncoder::setTileIntersectionFunctionTable(const MTL::IntersectionFunctionTable* intersectionFunctionTable, NS::UInteger bufferIndex)
1073  {
1074      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileIntersectionFunctionTable_atBufferIndex_), intersectionFunctionTable, bufferIndex);
1075  }
1076  
1077  // method: setTileIntersectionFunctionTables:withBufferRange:
1078  _MTL_INLINE void MTL::RenderCommandEncoder::setTileIntersectionFunctionTables(const MTL::IntersectionFunctionTable* const intersectionFunctionTables[], NS::Range range)
1079  {
1080      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileIntersectionFunctionTables_withBufferRange_), intersectionFunctionTables, range);
1081  }
1082  
1083  // method: setTileAccelerationStructure:atBufferIndex:
1084  _MTL_INLINE void MTL::RenderCommandEncoder::setTileAccelerationStructure(const MTL::AccelerationStructure* accelerationStructure, NS::UInteger bufferIndex)
1085  {
1086      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileAccelerationStructure_atBufferIndex_), accelerationStructure, bufferIndex);
1087  }
1088  
1089  // method: dispatchThreadsPerTile:
1090  _MTL_INLINE void MTL::RenderCommandEncoder::dispatchThreadsPerTile(MTL::Size threadsPerTile)
1091  {
1092      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(dispatchThreadsPerTile_), threadsPerTile);
1093  }
1094  
1095  // method: setThreadgroupMemoryLength:offset:atIndex:
1096  _MTL_INLINE void MTL::RenderCommandEncoder::setThreadgroupMemoryLength(NS::UInteger length, NS::UInteger offset, NS::UInteger index)
1097  {
1098      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_offset_atIndex_), length, offset, index);
1099  }
1100  
1101  // method: useResource:usage:
1102  _MTL_INLINE void MTL::RenderCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage)
1103  {
1104      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResource_usage_), resource, usage);
1105  }
1106  
1107  // method: useResources:count:usage:
1108  _MTL_INLINE void MTL::RenderCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage)
1109  {
1110      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResources_count_usage_), resources, count, usage);
1111  }
1112  
1113  // method: useResource:usage:stages:
1114  _MTL_INLINE void MTL::RenderCommandEncoder::useResource(const MTL::Resource* resource, MTL::ResourceUsage usage, MTL::RenderStages stages)
1115  {
1116      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResource_usage_stages_), resource, usage, stages);
1117  }
1118  
1119  // method: useResources:count:usage:stages:
1120  _MTL_INLINE void MTL::RenderCommandEncoder::useResources(const MTL::Resource* const resources[], NS::UInteger count, MTL::ResourceUsage usage, MTL::RenderStages stages)
1121  {
1122      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useResources_count_usage_stages_), resources, count, usage, stages);
1123  }
1124  
1125  // method: useHeap:
1126  _MTL_INLINE void MTL::RenderCommandEncoder::useHeap(const MTL::Heap* heap)
1127  {
1128      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeap_), heap);
1129  }
1130  
1131  // method: useHeaps:count:
1132  _MTL_INLINE void MTL::RenderCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count)
1133  {
1134      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeaps_count_), heaps, count);
1135  }
1136  
1137  // method: useHeap:stages:
1138  _MTL_INLINE void MTL::RenderCommandEncoder::useHeap(const MTL::Heap* heap, MTL::RenderStages stages)
1139  {
1140      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeap_stages_), heap, stages);
1141  }
1142  
1143  // method: useHeaps:count:stages:
1144  _MTL_INLINE void MTL::RenderCommandEncoder::useHeaps(const MTL::Heap* const heaps[], NS::UInteger count, MTL::RenderStages stages)
1145  {
1146      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(useHeaps_count_stages_), heaps, count, stages);
1147  }
1148  
1149  // method: executeCommandsInBuffer:withRange:
1150  _MTL_INLINE void MTL::RenderCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandBuffer, NS::Range executionRange)
1151  {
1152      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_withRange_), indirectCommandBuffer, executionRange);
1153  }
1154  
1155  // method: executeCommandsInBuffer:indirectBuffer:indirectBufferOffset:
1156  _MTL_INLINE void MTL::RenderCommandEncoder::executeCommandsInBuffer(const MTL::IndirectCommandBuffer* indirectCommandbuffer, const MTL::Buffer* indirectRangeBuffer, NS::UInteger indirectBufferOffset)
1157  {
1158      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(executeCommandsInBuffer_indirectBuffer_indirectBufferOffset_), indirectCommandbuffer, indirectRangeBuffer, indirectBufferOffset);
1159  }
1160  
1161  // method: memoryBarrierWithScope:afterStages:beforeStages:
1162  _MTL_INLINE void MTL::RenderCommandEncoder::memoryBarrier(MTL::BarrierScope scope, MTL::RenderStages after, MTL::RenderStages before)
1163  {
1164      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(memoryBarrierWithScope_afterStages_beforeStages_), scope, after, before);
1165  }
1166  
1167  // method: memoryBarrierWithResources:count:afterStages:beforeStages:
1168  _MTL_INLINE void MTL::RenderCommandEncoder::memoryBarrier(const MTL::Resource* const resources[], NS::UInteger count, MTL::RenderStages after, MTL::RenderStages before)
1169  {
1170      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(memoryBarrierWithResources_count_afterStages_beforeStages_), resources, count, after, before);
1171  }
1172  
1173  // method: sampleCountersInBuffer:atSampleIndex:withBarrier:
1174  _MTL_INLINE void MTL::RenderCommandEncoder::sampleCountersInBuffer(const MTL::CounterSampleBuffer* sampleBuffer, NS::UInteger sampleIndex, bool barrier)
1175  {
1176      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(sampleCountersInBuffer_atSampleIndex_withBarrier_), sampleBuffer, sampleIndex, barrier);
1177  }