1  //-------------------------------------------------------------------------------------------------------------------------------------------------------------
   2  //
   3  // Metal/MTLAccelerationStructure.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 "MTLAccelerationStructure.hpp"
  30  #include "MTLAccelerationStructureTypes.hpp"
  31  #include "MTLResource.hpp"
  32  #include "MTLStageInputOutputDescriptor.hpp"
  33  #include "MTLTypes.hpp"
  34  
  35  namespace MTL
  36  {
  37  _MTL_OPTIONS(NS::UInteger, AccelerationStructureUsage) {
  38      AccelerationStructureUsageNone = 0,
  39      AccelerationStructureUsageRefit = 1,
  40      AccelerationStructureUsagePreferFastBuild = 2,
  41      AccelerationStructureUsageExtendedLimits = 4,
  42  };
  43  
  44  _MTL_OPTIONS(uint32_t, AccelerationStructureInstanceOptions) {
  45      AccelerationStructureInstanceOptionNone = 0,
  46      AccelerationStructureInstanceOptionDisableTriangleCulling = 1,
  47      AccelerationStructureInstanceOptionTriangleFrontFacingWindingCounterClockwise = 2,
  48      AccelerationStructureInstanceOptionOpaque = 4,
  49      AccelerationStructureInstanceOptionNonOpaque = 8,
  50  };
  51  
  52  _MTL_ENUM(NS::Integer, MatrixLayout) {
  53      MatrixLayoutColumnMajor = 0,
  54      MatrixLayoutRowMajor = 1,
  55  };
  56  
  57  class AccelerationStructureDescriptor : public NS::Copying<AccelerationStructureDescriptor>
  58  {
  59  public:
  60      static class AccelerationStructureDescriptor* alloc();
  61  
  62      class AccelerationStructureDescriptor*        init();
  63  
  64      MTL::AccelerationStructureUsage               usage() const;
  65      void                                          setUsage(MTL::AccelerationStructureUsage usage);
  66  };
  67  
  68  class AccelerationStructureGeometryDescriptor : public NS::Copying<AccelerationStructureGeometryDescriptor>
  69  {
  70  public:
  71      static class AccelerationStructureGeometryDescriptor* alloc();
  72  
  73      class AccelerationStructureGeometryDescriptor*        init();
  74  
  75      NS::UInteger                                          intersectionFunctionTableOffset() const;
  76      void                                                  setIntersectionFunctionTableOffset(NS::UInteger intersectionFunctionTableOffset);
  77  
  78      bool                                                  opaque() const;
  79      void                                                  setOpaque(bool opaque);
  80  
  81      bool                                                  allowDuplicateIntersectionFunctionInvocation() const;
  82      void                                                  setAllowDuplicateIntersectionFunctionInvocation(bool allowDuplicateIntersectionFunctionInvocation);
  83  
  84      NS::String*                                           label() const;
  85      void                                                  setLabel(const NS::String* label);
  86  
  87      class Buffer*                                         primitiveDataBuffer() const;
  88      void                                                  setPrimitiveDataBuffer(const class Buffer* primitiveDataBuffer);
  89  
  90      NS::UInteger                                          primitiveDataBufferOffset() const;
  91      void                                                  setPrimitiveDataBufferOffset(NS::UInteger primitiveDataBufferOffset);
  92  
  93      NS::UInteger                                          primitiveDataStride() const;
  94      void                                                  setPrimitiveDataStride(NS::UInteger primitiveDataStride);
  95  
  96      NS::UInteger                                          primitiveDataElementSize() const;
  97      void                                                  setPrimitiveDataElementSize(NS::UInteger primitiveDataElementSize);
  98  };
  99  
 100  _MTL_ENUM(uint32_t, MotionBorderMode) {
 101      MotionBorderModeClamp = 0,
 102      MotionBorderModeVanish = 1,
 103  };
 104  
 105  class PrimitiveAccelerationStructureDescriptor : public NS::Copying<PrimitiveAccelerationStructureDescriptor, MTL::AccelerationStructureDescriptor>
 106  {
 107  public:
 108      static class PrimitiveAccelerationStructureDescriptor* alloc();
 109  
 110      class PrimitiveAccelerationStructureDescriptor*        init();
 111  
 112      NS::Array*                                             geometryDescriptors() const;
 113      void                                                   setGeometryDescriptors(const NS::Array* geometryDescriptors);
 114  
 115      MTL::MotionBorderMode                                  motionStartBorderMode() const;
 116      void                                                   setMotionStartBorderMode(MTL::MotionBorderMode motionStartBorderMode);
 117  
 118      MTL::MotionBorderMode                                  motionEndBorderMode() const;
 119      void                                                   setMotionEndBorderMode(MTL::MotionBorderMode motionEndBorderMode);
 120  
 121      float                                                  motionStartTime() const;
 122      void                                                   setMotionStartTime(float motionStartTime);
 123  
 124      float                                                  motionEndTime() const;
 125      void                                                   setMotionEndTime(float motionEndTime);
 126  
 127      NS::UInteger                                           motionKeyframeCount() const;
 128      void                                                   setMotionKeyframeCount(NS::UInteger motionKeyframeCount);
 129  
 130      static MTL::PrimitiveAccelerationStructureDescriptor*  descriptor();
 131  };
 132  
 133  class AccelerationStructureTriangleGeometryDescriptor : public NS::Copying<AccelerationStructureTriangleGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
 134  {
 135  public:
 136      static class AccelerationStructureTriangleGeometryDescriptor* alloc();
 137  
 138      class AccelerationStructureTriangleGeometryDescriptor*        init();
 139  
 140      class Buffer*                                                 vertexBuffer() const;
 141      void                                                          setVertexBuffer(const class Buffer* vertexBuffer);
 142  
 143      NS::UInteger                                                  vertexBufferOffset() const;
 144      void                                                          setVertexBufferOffset(NS::UInteger vertexBufferOffset);
 145  
 146      MTL::AttributeFormat                                          vertexFormat() const;
 147      void                                                          setVertexFormat(MTL::AttributeFormat vertexFormat);
 148  
 149      NS::UInteger                                                  vertexStride() const;
 150      void                                                          setVertexStride(NS::UInteger vertexStride);
 151  
 152      class Buffer*                                                 indexBuffer() const;
 153      void                                                          setIndexBuffer(const class Buffer* indexBuffer);
 154  
 155      NS::UInteger                                                  indexBufferOffset() const;
 156      void                                                          setIndexBufferOffset(NS::UInteger indexBufferOffset);
 157  
 158      MTL::IndexType                                                indexType() const;
 159      void                                                          setIndexType(MTL::IndexType indexType);
 160  
 161      NS::UInteger                                                  triangleCount() const;
 162      void                                                          setTriangleCount(NS::UInteger triangleCount);
 163  
 164      class Buffer*                                                 transformationMatrixBuffer() const;
 165      void                                                          setTransformationMatrixBuffer(const class Buffer* transformationMatrixBuffer);
 166  
 167      NS::UInteger                                                  transformationMatrixBufferOffset() const;
 168      void                                                          setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset);
 169  
 170      MTL::MatrixLayout                                             transformationMatrixLayout() const;
 171      void                                                          setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout);
 172  
 173      static MTL::AccelerationStructureTriangleGeometryDescriptor*  descriptor();
 174  };
 175  
 176  class AccelerationStructureBoundingBoxGeometryDescriptor : public NS::Copying<AccelerationStructureBoundingBoxGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
 177  {
 178  public:
 179      static class AccelerationStructureBoundingBoxGeometryDescriptor* alloc();
 180  
 181      class AccelerationStructureBoundingBoxGeometryDescriptor*        init();
 182  
 183      class Buffer*                                                    boundingBoxBuffer() const;
 184      void                                                             setBoundingBoxBuffer(const class Buffer* boundingBoxBuffer);
 185  
 186      NS::UInteger                                                     boundingBoxBufferOffset() const;
 187      void                                                             setBoundingBoxBufferOffset(NS::UInteger boundingBoxBufferOffset);
 188  
 189      NS::UInteger                                                     boundingBoxStride() const;
 190      void                                                             setBoundingBoxStride(NS::UInteger boundingBoxStride);
 191  
 192      NS::UInteger                                                     boundingBoxCount() const;
 193      void                                                             setBoundingBoxCount(NS::UInteger boundingBoxCount);
 194  
 195      static MTL::AccelerationStructureBoundingBoxGeometryDescriptor*  descriptor();
 196  };
 197  
 198  class MotionKeyframeData : public NS::Referencing<MotionKeyframeData>
 199  {
 200  public:
 201      static class MotionKeyframeData* alloc();
 202  
 203      class MotionKeyframeData*        init();
 204  
 205      class Buffer*                    buffer() const;
 206      void                             setBuffer(const class Buffer* buffer);
 207  
 208      NS::UInteger                     offset() const;
 209      void                             setOffset(NS::UInteger offset);
 210  
 211      static MTL::MotionKeyframeData*  data();
 212  };
 213  
 214  class AccelerationStructureMotionTriangleGeometryDescriptor : public NS::Copying<AccelerationStructureMotionTriangleGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
 215  {
 216  public:
 217      static class AccelerationStructureMotionTriangleGeometryDescriptor* alloc();
 218  
 219      class AccelerationStructureMotionTriangleGeometryDescriptor*        init();
 220  
 221      NS::Array*                                                          vertexBuffers() const;
 222      void                                                                setVertexBuffers(const NS::Array* vertexBuffers);
 223  
 224      MTL::AttributeFormat                                                vertexFormat() const;
 225      void                                                                setVertexFormat(MTL::AttributeFormat vertexFormat);
 226  
 227      NS::UInteger                                                        vertexStride() const;
 228      void                                                                setVertexStride(NS::UInteger vertexStride);
 229  
 230      class Buffer*                                                       indexBuffer() const;
 231      void                                                                setIndexBuffer(const class Buffer* indexBuffer);
 232  
 233      NS::UInteger                                                        indexBufferOffset() const;
 234      void                                                                setIndexBufferOffset(NS::UInteger indexBufferOffset);
 235  
 236      MTL::IndexType                                                      indexType() const;
 237      void                                                                setIndexType(MTL::IndexType indexType);
 238  
 239      NS::UInteger                                                        triangleCount() const;
 240      void                                                                setTriangleCount(NS::UInteger triangleCount);
 241  
 242      class Buffer*                                                       transformationMatrixBuffer() const;
 243      void                                                                setTransformationMatrixBuffer(const class Buffer* transformationMatrixBuffer);
 244  
 245      NS::UInteger                                                        transformationMatrixBufferOffset() const;
 246      void                                                                setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset);
 247  
 248      MTL::MatrixLayout                                                   transformationMatrixLayout() const;
 249      void                                                                setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout);
 250  
 251      static MTL::AccelerationStructureMotionTriangleGeometryDescriptor*  descriptor();
 252  };
 253  
 254  class AccelerationStructureMotionBoundingBoxGeometryDescriptor : public NS::Copying<AccelerationStructureMotionBoundingBoxGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
 255  {
 256  public:
 257      static class AccelerationStructureMotionBoundingBoxGeometryDescriptor* alloc();
 258  
 259      class AccelerationStructureMotionBoundingBoxGeometryDescriptor*        init();
 260  
 261      NS::Array*                                                             boundingBoxBuffers() const;
 262      void                                                                   setBoundingBoxBuffers(const NS::Array* boundingBoxBuffers);
 263  
 264      NS::UInteger                                                           boundingBoxStride() const;
 265      void                                                                   setBoundingBoxStride(NS::UInteger boundingBoxStride);
 266  
 267      NS::UInteger                                                           boundingBoxCount() const;
 268      void                                                                   setBoundingBoxCount(NS::UInteger boundingBoxCount);
 269  
 270      static MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor*  descriptor();
 271  };
 272  
 273  _MTL_ENUM(NS::Integer, CurveType) {
 274      CurveTypeRound = 0,
 275      CurveTypeFlat = 1,
 276  };
 277  
 278  _MTL_ENUM(NS::Integer, CurveBasis) {
 279      CurveBasisBSpline = 0,
 280      CurveBasisCatmullRom = 1,
 281      CurveBasisLinear = 2,
 282      CurveBasisBezier = 3,
 283  };
 284  
 285  _MTL_ENUM(NS::Integer, CurveEndCaps) {
 286      CurveEndCapsNone = 0,
 287      CurveEndCapsDisk = 1,
 288      CurveEndCapsSphere = 2,
 289  };
 290  
 291  class AccelerationStructureCurveGeometryDescriptor : public NS::Copying<AccelerationStructureCurveGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
 292  {
 293  public:
 294      static class AccelerationStructureCurveGeometryDescriptor* alloc();
 295  
 296      class AccelerationStructureCurveGeometryDescriptor*        init();
 297  
 298      class Buffer*                                              controlPointBuffer() const;
 299      void                                                       setControlPointBuffer(const class Buffer* controlPointBuffer);
 300  
 301      NS::UInteger                                               controlPointBufferOffset() const;
 302      void                                                       setControlPointBufferOffset(NS::UInteger controlPointBufferOffset);
 303  
 304      NS::UInteger                                               controlPointCount() const;
 305      void                                                       setControlPointCount(NS::UInteger controlPointCount);
 306  
 307      NS::UInteger                                               controlPointStride() const;
 308      void                                                       setControlPointStride(NS::UInteger controlPointStride);
 309  
 310      MTL::AttributeFormat                                       controlPointFormat() const;
 311      void                                                       setControlPointFormat(MTL::AttributeFormat controlPointFormat);
 312  
 313      class Buffer*                                              radiusBuffer() const;
 314      void                                                       setRadiusBuffer(const class Buffer* radiusBuffer);
 315  
 316      NS::UInteger                                               radiusBufferOffset() const;
 317      void                                                       setRadiusBufferOffset(NS::UInteger radiusBufferOffset);
 318  
 319      MTL::AttributeFormat                                       radiusFormat() const;
 320      void                                                       setRadiusFormat(MTL::AttributeFormat radiusFormat);
 321  
 322      NS::UInteger                                               radiusStride() const;
 323      void                                                       setRadiusStride(NS::UInteger radiusStride);
 324  
 325      class Buffer*                                              indexBuffer() const;
 326      void                                                       setIndexBuffer(const class Buffer* indexBuffer);
 327  
 328      NS::UInteger                                               indexBufferOffset() const;
 329      void                                                       setIndexBufferOffset(NS::UInteger indexBufferOffset);
 330  
 331      MTL::IndexType                                             indexType() const;
 332      void                                                       setIndexType(MTL::IndexType indexType);
 333  
 334      NS::UInteger                                               segmentCount() const;
 335      void                                                       setSegmentCount(NS::UInteger segmentCount);
 336  
 337      NS::UInteger                                               segmentControlPointCount() const;
 338      void                                                       setSegmentControlPointCount(NS::UInteger segmentControlPointCount);
 339  
 340      MTL::CurveType                                             curveType() const;
 341      void                                                       setCurveType(MTL::CurveType curveType);
 342  
 343      MTL::CurveBasis                                            curveBasis() const;
 344      void                                                       setCurveBasis(MTL::CurveBasis curveBasis);
 345  
 346      MTL::CurveEndCaps                                          curveEndCaps() const;
 347      void                                                       setCurveEndCaps(MTL::CurveEndCaps curveEndCaps);
 348  
 349      static MTL::AccelerationStructureCurveGeometryDescriptor*  descriptor();
 350  };
 351  
 352  class AccelerationStructureMotionCurveGeometryDescriptor : public NS::Copying<AccelerationStructureMotionCurveGeometryDescriptor, MTL::AccelerationStructureGeometryDescriptor>
 353  {
 354  public:
 355      static class AccelerationStructureMotionCurveGeometryDescriptor* alloc();
 356  
 357      class AccelerationStructureMotionCurveGeometryDescriptor*        init();
 358  
 359      NS::Array*                                                       controlPointBuffers() const;
 360      void                                                             setControlPointBuffers(const NS::Array* controlPointBuffers);
 361  
 362      NS::UInteger                                                     controlPointCount() const;
 363      void                                                             setControlPointCount(NS::UInteger controlPointCount);
 364  
 365      NS::UInteger                                                     controlPointStride() const;
 366      void                                                             setControlPointStride(NS::UInteger controlPointStride);
 367  
 368      MTL::AttributeFormat                                             controlPointFormat() const;
 369      void                                                             setControlPointFormat(MTL::AttributeFormat controlPointFormat);
 370  
 371      NS::Array*                                                       radiusBuffers() const;
 372      void                                                             setRadiusBuffers(const NS::Array* radiusBuffers);
 373  
 374      MTL::AttributeFormat                                             radiusFormat() const;
 375      void                                                             setRadiusFormat(MTL::AttributeFormat radiusFormat);
 376  
 377      NS::UInteger                                                     radiusStride() const;
 378      void                                                             setRadiusStride(NS::UInteger radiusStride);
 379  
 380      class Buffer*                                                    indexBuffer() const;
 381      void                                                             setIndexBuffer(const class Buffer* indexBuffer);
 382  
 383      NS::UInteger                                                     indexBufferOffset() const;
 384      void                                                             setIndexBufferOffset(NS::UInteger indexBufferOffset);
 385  
 386      MTL::IndexType                                                   indexType() const;
 387      void                                                             setIndexType(MTL::IndexType indexType);
 388  
 389      NS::UInteger                                                     segmentCount() const;
 390      void                                                             setSegmentCount(NS::UInteger segmentCount);
 391  
 392      NS::UInteger                                                     segmentControlPointCount() const;
 393      void                                                             setSegmentControlPointCount(NS::UInteger segmentControlPointCount);
 394  
 395      MTL::CurveType                                                   curveType() const;
 396      void                                                             setCurveType(MTL::CurveType curveType);
 397  
 398      MTL::CurveBasis                                                  curveBasis() const;
 399      void                                                             setCurveBasis(MTL::CurveBasis curveBasis);
 400  
 401      MTL::CurveEndCaps                                                curveEndCaps() const;
 402      void                                                             setCurveEndCaps(MTL::CurveEndCaps curveEndCaps);
 403  
 404      static MTL::AccelerationStructureMotionCurveGeometryDescriptor*  descriptor();
 405  };
 406  
 407  struct AccelerationStructureInstanceDescriptor
 408  {
 409      MTL::PackedFloat4x3                       transformationMatrix;
 410      MTL::AccelerationStructureInstanceOptions options;
 411      uint32_t                                  mask;
 412      uint32_t                                  intersectionFunctionTableOffset;
 413      uint32_t                                  accelerationStructureIndex;
 414  } _MTL_PACKED;
 415  
 416  struct AccelerationStructureUserIDInstanceDescriptor
 417  {
 418      MTL::PackedFloat4x3                       transformationMatrix;
 419      MTL::AccelerationStructureInstanceOptions options;
 420      uint32_t                                  mask;
 421      uint32_t                                  intersectionFunctionTableOffset;
 422      uint32_t                                  accelerationStructureIndex;
 423      uint32_t                                  userID;
 424  } _MTL_PACKED;
 425  
 426  _MTL_ENUM(NS::UInteger, AccelerationStructureInstanceDescriptorType) {
 427      AccelerationStructureInstanceDescriptorTypeDefault = 0,
 428      AccelerationStructureInstanceDescriptorTypeUserID = 1,
 429      AccelerationStructureInstanceDescriptorTypeMotion = 2,
 430      AccelerationStructureInstanceDescriptorTypeIndirect = 3,
 431      AccelerationStructureInstanceDescriptorTypeIndirectMotion = 4,
 432  };
 433  
 434  struct AccelerationStructureMotionInstanceDescriptor
 435  {
 436      MTL::AccelerationStructureInstanceOptions options;
 437      uint32_t                                  mask;
 438      uint32_t                                  intersectionFunctionTableOffset;
 439      uint32_t                                  accelerationStructureIndex;
 440      uint32_t                                  userID;
 441      uint32_t                                  motionTransformsStartIndex;
 442      uint32_t                                  motionTransformsCount;
 443      MTL::MotionBorderMode                     motionStartBorderMode;
 444      MTL::MotionBorderMode                     motionEndBorderMode;
 445      float                                     motionStartTime;
 446      float                                     motionEndTime;
 447  } _MTL_PACKED;
 448  
 449  struct IndirectAccelerationStructureInstanceDescriptor
 450  {
 451      MTL::PackedFloat4x3                       transformationMatrix;
 452      MTL::AccelerationStructureInstanceOptions options;
 453      uint32_t                                  mask;
 454      uint32_t                                  intersectionFunctionTableOffset;
 455      uint32_t                                  userID;
 456      MTL::ResourceID                           accelerationStructureID;
 457  } _MTL_PACKED;
 458  
 459  struct IndirectAccelerationStructureMotionInstanceDescriptor
 460  {
 461      MTL::AccelerationStructureInstanceOptions options;
 462      uint32_t                                  mask;
 463      uint32_t                                  intersectionFunctionTableOffset;
 464      uint32_t                                  userID;
 465      MTL::ResourceID                           accelerationStructureID;
 466      uint32_t                                  motionTransformsStartIndex;
 467      uint32_t                                  motionTransformsCount;
 468      MTL::MotionBorderMode                     motionStartBorderMode;
 469      MTL::MotionBorderMode                     motionEndBorderMode;
 470      float                                     motionStartTime;
 471      float                                     motionEndTime;
 472  } _MTL_PACKED;
 473  
 474  _MTL_ENUM(NS::Integer, TransformType) {
 475      TransformTypePackedFloat4x3 = 0,
 476      TransformTypeComponent = 1,
 477  };
 478  
 479  class InstanceAccelerationStructureDescriptor : public NS::Copying<InstanceAccelerationStructureDescriptor, MTL::AccelerationStructureDescriptor>
 480  {
 481  public:
 482      static class InstanceAccelerationStructureDescriptor* alloc();
 483  
 484      class InstanceAccelerationStructureDescriptor*        init();
 485  
 486      class Buffer*                                         instanceDescriptorBuffer() const;
 487      void                                                  setInstanceDescriptorBuffer(const class Buffer* instanceDescriptorBuffer);
 488  
 489      NS::UInteger                                          instanceDescriptorBufferOffset() const;
 490      void                                                  setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset);
 491  
 492      NS::UInteger                                          instanceDescriptorStride() const;
 493      void                                                  setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride);
 494  
 495      NS::UInteger                                          instanceCount() const;
 496      void                                                  setInstanceCount(NS::UInteger instanceCount);
 497  
 498      NS::Array*                                            instancedAccelerationStructures() const;
 499      void                                                  setInstancedAccelerationStructures(const NS::Array* instancedAccelerationStructures);
 500  
 501      MTL::AccelerationStructureInstanceDescriptorType      instanceDescriptorType() const;
 502      void                                                  setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType);
 503  
 504      class Buffer*                                         motionTransformBuffer() const;
 505      void                                                  setMotionTransformBuffer(const class Buffer* motionTransformBuffer);
 506  
 507      NS::UInteger                                          motionTransformBufferOffset() const;
 508      void                                                  setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset);
 509  
 510      NS::UInteger                                          motionTransformCount() const;
 511      void                                                  setMotionTransformCount(NS::UInteger motionTransformCount);
 512  
 513      MTL::MatrixLayout                                     instanceTransformationMatrixLayout() const;
 514      void                                                  setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout);
 515  
 516      MTL::TransformType                                    motionTransformType() const;
 517      void                                                  setMotionTransformType(MTL::TransformType motionTransformType);
 518  
 519      NS::UInteger                                          motionTransformStride() const;
 520      void                                                  setMotionTransformStride(NS::UInteger motionTransformStride);
 521  
 522      static MTL::InstanceAccelerationStructureDescriptor*  descriptor();
 523  };
 524  
 525  class IndirectInstanceAccelerationStructureDescriptor : public NS::Copying<IndirectInstanceAccelerationStructureDescriptor, MTL::AccelerationStructureDescriptor>
 526  {
 527  public:
 528      static class IndirectInstanceAccelerationStructureDescriptor* alloc();
 529  
 530      class IndirectInstanceAccelerationStructureDescriptor*        init();
 531  
 532      class Buffer*                                                 instanceDescriptorBuffer() const;
 533      void                                                          setInstanceDescriptorBuffer(const class Buffer* instanceDescriptorBuffer);
 534  
 535      NS::UInteger                                                  instanceDescriptorBufferOffset() const;
 536      void                                                          setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset);
 537  
 538      NS::UInteger                                                  instanceDescriptorStride() const;
 539      void                                                          setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride);
 540  
 541      NS::UInteger                                                  maxInstanceCount() const;
 542      void                                                          setMaxInstanceCount(NS::UInteger maxInstanceCount);
 543  
 544      class Buffer*                                                 instanceCountBuffer() const;
 545      void                                                          setInstanceCountBuffer(const class Buffer* instanceCountBuffer);
 546  
 547      NS::UInteger                                                  instanceCountBufferOffset() const;
 548      void                                                          setInstanceCountBufferOffset(NS::UInteger instanceCountBufferOffset);
 549  
 550      MTL::AccelerationStructureInstanceDescriptorType              instanceDescriptorType() const;
 551      void                                                          setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType);
 552  
 553      class Buffer*                                                 motionTransformBuffer() const;
 554      void                                                          setMotionTransformBuffer(const class Buffer* motionTransformBuffer);
 555  
 556      NS::UInteger                                                  motionTransformBufferOffset() const;
 557      void                                                          setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset);
 558  
 559      NS::UInteger                                                  maxMotionTransformCount() const;
 560      void                                                          setMaxMotionTransformCount(NS::UInteger maxMotionTransformCount);
 561  
 562      class Buffer*                                                 motionTransformCountBuffer() const;
 563      void                                                          setMotionTransformCountBuffer(const class Buffer* motionTransformCountBuffer);
 564  
 565      NS::UInteger                                                  motionTransformCountBufferOffset() const;
 566      void                                                          setMotionTransformCountBufferOffset(NS::UInteger motionTransformCountBufferOffset);
 567  
 568      MTL::MatrixLayout                                             instanceTransformationMatrixLayout() const;
 569      void                                                          setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout);
 570  
 571      MTL::TransformType                                            motionTransformType() const;
 572      void                                                          setMotionTransformType(MTL::TransformType motionTransformType);
 573  
 574      NS::UInteger                                                  motionTransformStride() const;
 575      void                                                          setMotionTransformStride(NS::UInteger motionTransformStride);
 576  
 577      static MTL::IndirectInstanceAccelerationStructureDescriptor*  descriptor();
 578  };
 579  
 580  class AccelerationStructure : public NS::Referencing<AccelerationStructure, Resource>
 581  {
 582  public:
 583      NS::UInteger    size() const;
 584  
 585      MTL::ResourceID gpuResourceID() const;
 586  };
 587  
 588  }
 589  
 590  // static method: alloc
 591  _MTL_INLINE MTL::AccelerationStructureDescriptor* MTL::AccelerationStructureDescriptor::alloc()
 592  {
 593      return NS::Object::alloc<MTL::AccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureDescriptor));
 594  }
 595  
 596  // method: init
 597  _MTL_INLINE MTL::AccelerationStructureDescriptor* MTL::AccelerationStructureDescriptor::init()
 598  {
 599      return NS::Object::init<MTL::AccelerationStructureDescriptor>();
 600  }
 601  
 602  // property: usage
 603  _MTL_INLINE MTL::AccelerationStructureUsage MTL::AccelerationStructureDescriptor::usage() const
 604  {
 605      return Object::sendMessage<MTL::AccelerationStructureUsage>(this, _MTL_PRIVATE_SEL(usage));
 606  }
 607  
 608  _MTL_INLINE void MTL::AccelerationStructureDescriptor::setUsage(MTL::AccelerationStructureUsage usage)
 609  {
 610      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setUsage_), usage);
 611  }
 612  
 613  // static method: alloc
 614  _MTL_INLINE MTL::AccelerationStructureGeometryDescriptor* MTL::AccelerationStructureGeometryDescriptor::alloc()
 615  {
 616      return NS::Object::alloc<MTL::AccelerationStructureGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureGeometryDescriptor));
 617  }
 618  
 619  // method: init
 620  _MTL_INLINE MTL::AccelerationStructureGeometryDescriptor* MTL::AccelerationStructureGeometryDescriptor::init()
 621  {
 622      return NS::Object::init<MTL::AccelerationStructureGeometryDescriptor>();
 623  }
 624  
 625  // property: intersectionFunctionTableOffset
 626  _MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::intersectionFunctionTableOffset() const
 627  {
 628      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(intersectionFunctionTableOffset));
 629  }
 630  
 631  _MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setIntersectionFunctionTableOffset(NS::UInteger intersectionFunctionTableOffset)
 632  {
 633      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTableOffset_), intersectionFunctionTableOffset);
 634  }
 635  
 636  // property: opaque
 637  _MTL_INLINE bool MTL::AccelerationStructureGeometryDescriptor::opaque() const
 638  {
 639      return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(opaque));
 640  }
 641  
 642  _MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setOpaque(bool opaque)
 643  {
 644      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOpaque_), opaque);
 645  }
 646  
 647  // property: allowDuplicateIntersectionFunctionInvocation
 648  _MTL_INLINE bool MTL::AccelerationStructureGeometryDescriptor::allowDuplicateIntersectionFunctionInvocation() const
 649  {
 650      return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(allowDuplicateIntersectionFunctionInvocation));
 651  }
 652  
 653  _MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setAllowDuplicateIntersectionFunctionInvocation(bool allowDuplicateIntersectionFunctionInvocation)
 654  {
 655      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAllowDuplicateIntersectionFunctionInvocation_), allowDuplicateIntersectionFunctionInvocation);
 656  }
 657  
 658  // property: label
 659  _MTL_INLINE NS::String* MTL::AccelerationStructureGeometryDescriptor::label() const
 660  {
 661      return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
 662  }
 663  
 664  _MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setLabel(const NS::String* label)
 665  {
 666      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
 667  }
 668  
 669  // property: primitiveDataBuffer
 670  _MTL_INLINE MTL::Buffer* MTL::AccelerationStructureGeometryDescriptor::primitiveDataBuffer() const
 671  {
 672      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(primitiveDataBuffer));
 673  }
 674  
 675  _MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataBuffer(const MTL::Buffer* primitiveDataBuffer)
 676  {
 677      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrimitiveDataBuffer_), primitiveDataBuffer);
 678  }
 679  
 680  // property: primitiveDataBufferOffset
 681  _MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::primitiveDataBufferOffset() const
 682  {
 683      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(primitiveDataBufferOffset));
 684  }
 685  
 686  _MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataBufferOffset(NS::UInteger primitiveDataBufferOffset)
 687  {
 688      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrimitiveDataBufferOffset_), primitiveDataBufferOffset);
 689  }
 690  
 691  // property: primitiveDataStride
 692  _MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::primitiveDataStride() const
 693  {
 694      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(primitiveDataStride));
 695  }
 696  
 697  _MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataStride(NS::UInteger primitiveDataStride)
 698  {
 699      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrimitiveDataStride_), primitiveDataStride);
 700  }
 701  
 702  // property: primitiveDataElementSize
 703  _MTL_INLINE NS::UInteger MTL::AccelerationStructureGeometryDescriptor::primitiveDataElementSize() const
 704  {
 705      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(primitiveDataElementSize));
 706  }
 707  
 708  _MTL_INLINE void MTL::AccelerationStructureGeometryDescriptor::setPrimitiveDataElementSize(NS::UInteger primitiveDataElementSize)
 709  {
 710      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrimitiveDataElementSize_), primitiveDataElementSize);
 711  }
 712  
 713  // static method: alloc
 714  _MTL_INLINE MTL::PrimitiveAccelerationStructureDescriptor* MTL::PrimitiveAccelerationStructureDescriptor::alloc()
 715  {
 716      return NS::Object::alloc<MTL::PrimitiveAccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTLPrimitiveAccelerationStructureDescriptor));
 717  }
 718  
 719  // method: init
 720  _MTL_INLINE MTL::PrimitiveAccelerationStructureDescriptor* MTL::PrimitiveAccelerationStructureDescriptor::init()
 721  {
 722      return NS::Object::init<MTL::PrimitiveAccelerationStructureDescriptor>();
 723  }
 724  
 725  // property: geometryDescriptors
 726  _MTL_INLINE NS::Array* MTL::PrimitiveAccelerationStructureDescriptor::geometryDescriptors() const
 727  {
 728      return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(geometryDescriptors));
 729  }
 730  
 731  _MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setGeometryDescriptors(const NS::Array* geometryDescriptors)
 732  {
 733      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setGeometryDescriptors_), geometryDescriptors);
 734  }
 735  
 736  // property: motionStartBorderMode
 737  _MTL_INLINE MTL::MotionBorderMode MTL::PrimitiveAccelerationStructureDescriptor::motionStartBorderMode() const
 738  {
 739      return Object::sendMessage<MTL::MotionBorderMode>(this, _MTL_PRIVATE_SEL(motionStartBorderMode));
 740  }
 741  
 742  _MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionStartBorderMode(MTL::MotionBorderMode motionStartBorderMode)
 743  {
 744      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionStartBorderMode_), motionStartBorderMode);
 745  }
 746  
 747  // property: motionEndBorderMode
 748  _MTL_INLINE MTL::MotionBorderMode MTL::PrimitiveAccelerationStructureDescriptor::motionEndBorderMode() const
 749  {
 750      return Object::sendMessage<MTL::MotionBorderMode>(this, _MTL_PRIVATE_SEL(motionEndBorderMode));
 751  }
 752  
 753  _MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionEndBorderMode(MTL::MotionBorderMode motionEndBorderMode)
 754  {
 755      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionEndBorderMode_), motionEndBorderMode);
 756  }
 757  
 758  // property: motionStartTime
 759  _MTL_INLINE float MTL::PrimitiveAccelerationStructureDescriptor::motionStartTime() const
 760  {
 761      return Object::sendMessage<float>(this, _MTL_PRIVATE_SEL(motionStartTime));
 762  }
 763  
 764  _MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionStartTime(float motionStartTime)
 765  {
 766      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionStartTime_), motionStartTime);
 767  }
 768  
 769  // property: motionEndTime
 770  _MTL_INLINE float MTL::PrimitiveAccelerationStructureDescriptor::motionEndTime() const
 771  {
 772      return Object::sendMessage<float>(this, _MTL_PRIVATE_SEL(motionEndTime));
 773  }
 774  
 775  _MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionEndTime(float motionEndTime)
 776  {
 777      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionEndTime_), motionEndTime);
 778  }
 779  
 780  // property: motionKeyframeCount
 781  _MTL_INLINE NS::UInteger MTL::PrimitiveAccelerationStructureDescriptor::motionKeyframeCount() const
 782  {
 783      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionKeyframeCount));
 784  }
 785  
 786  _MTL_INLINE void MTL::PrimitiveAccelerationStructureDescriptor::setMotionKeyframeCount(NS::UInteger motionKeyframeCount)
 787  {
 788      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionKeyframeCount_), motionKeyframeCount);
 789  }
 790  
 791  // static method: descriptor
 792  _MTL_INLINE MTL::PrimitiveAccelerationStructureDescriptor* MTL::PrimitiveAccelerationStructureDescriptor::descriptor()
 793  {
 794      return Object::sendMessage<MTL::PrimitiveAccelerationStructureDescriptor*>(_MTL_PRIVATE_CLS(MTLPrimitiveAccelerationStructureDescriptor), _MTL_PRIVATE_SEL(descriptor));
 795  }
 796  
 797  // static method: alloc
 798  _MTL_INLINE MTL::AccelerationStructureTriangleGeometryDescriptor* MTL::AccelerationStructureTriangleGeometryDescriptor::alloc()
 799  {
 800      return NS::Object::alloc<MTL::AccelerationStructureTriangleGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureTriangleGeometryDescriptor));
 801  }
 802  
 803  // method: init
 804  _MTL_INLINE MTL::AccelerationStructureTriangleGeometryDescriptor* MTL::AccelerationStructureTriangleGeometryDescriptor::init()
 805  {
 806      return NS::Object::init<MTL::AccelerationStructureTriangleGeometryDescriptor>();
 807  }
 808  
 809  // property: vertexBuffer
 810  _MTL_INLINE MTL::Buffer* MTL::AccelerationStructureTriangleGeometryDescriptor::vertexBuffer() const
 811  {
 812      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(vertexBuffer));
 813  }
 814  
 815  _MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexBuffer(const MTL::Buffer* vertexBuffer)
 816  {
 817      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffer_), vertexBuffer);
 818  }
 819  
 820  // property: vertexBufferOffset
 821  _MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::vertexBufferOffset() const
 822  {
 823      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(vertexBufferOffset));
 824  }
 825  
 826  _MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexBufferOffset(NS::UInteger vertexBufferOffset)
 827  {
 828      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBufferOffset_), vertexBufferOffset);
 829  }
 830  
 831  // property: vertexFormat
 832  _MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureTriangleGeometryDescriptor::vertexFormat() const
 833  {
 834      return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(vertexFormat));
 835  }
 836  
 837  _MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexFormat(MTL::AttributeFormat vertexFormat)
 838  {
 839      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexFormat_), vertexFormat);
 840  }
 841  
 842  // property: vertexStride
 843  _MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::vertexStride() const
 844  {
 845      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(vertexStride));
 846  }
 847  
 848  _MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setVertexStride(NS::UInteger vertexStride)
 849  {
 850      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexStride_), vertexStride);
 851  }
 852  
 853  // property: indexBuffer
 854  _MTL_INLINE MTL::Buffer* MTL::AccelerationStructureTriangleGeometryDescriptor::indexBuffer() const
 855  {
 856      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(indexBuffer));
 857  }
 858  
 859  _MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer)
 860  {
 861      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
 862  }
 863  
 864  // property: indexBufferOffset
 865  _MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::indexBufferOffset() const
 866  {
 867      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(indexBufferOffset));
 868  }
 869  
 870  _MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset)
 871  {
 872      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset);
 873  }
 874  
 875  // property: indexType
 876  _MTL_INLINE MTL::IndexType MTL::AccelerationStructureTriangleGeometryDescriptor::indexType() const
 877  {
 878      return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
 879  }
 880  
 881  _MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setIndexType(MTL::IndexType indexType)
 882  {
 883      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
 884  }
 885  
 886  // property: triangleCount
 887  _MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::triangleCount() const
 888  {
 889      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(triangleCount));
 890  }
 891  
 892  _MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setTriangleCount(NS::UInteger triangleCount)
 893  {
 894      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTriangleCount_), triangleCount);
 895  }
 896  
 897  // property: transformationMatrixBuffer
 898  _MTL_INLINE MTL::Buffer* MTL::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixBuffer() const
 899  {
 900      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(transformationMatrixBuffer));
 901  }
 902  
 903  _MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixBuffer(const MTL::Buffer* transformationMatrixBuffer)
 904  {
 905      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixBuffer_), transformationMatrixBuffer);
 906  }
 907  
 908  // property: transformationMatrixBufferOffset
 909  _MTL_INLINE NS::UInteger MTL::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixBufferOffset() const
 910  {
 911      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(transformationMatrixBufferOffset));
 912  }
 913  
 914  _MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset)
 915  {
 916      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixBufferOffset_), transformationMatrixBufferOffset);
 917  }
 918  
 919  // property: transformationMatrixLayout
 920  _MTL_INLINE MTL::MatrixLayout MTL::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixLayout() const
 921  {
 922      return Object::sendMessage<MTL::MatrixLayout>(this, _MTL_PRIVATE_SEL(transformationMatrixLayout));
 923  }
 924  
 925  _MTL_INLINE void MTL::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout)
 926  {
 927      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixLayout_), transformationMatrixLayout);
 928  }
 929  
 930  // static method: descriptor
 931  _MTL_INLINE MTL::AccelerationStructureTriangleGeometryDescriptor* MTL::AccelerationStructureTriangleGeometryDescriptor::descriptor()
 932  {
 933      return Object::sendMessage<MTL::AccelerationStructureTriangleGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureTriangleGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
 934  }
 935  
 936  // static method: alloc
 937  _MTL_INLINE MTL::AccelerationStructureBoundingBoxGeometryDescriptor* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::alloc()
 938  {
 939      return NS::Object::alloc<MTL::AccelerationStructureBoundingBoxGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureBoundingBoxGeometryDescriptor));
 940  }
 941  
 942  // method: init
 943  _MTL_INLINE MTL::AccelerationStructureBoundingBoxGeometryDescriptor* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::init()
 944  {
 945      return NS::Object::init<MTL::AccelerationStructureBoundingBoxGeometryDescriptor>();
 946  }
 947  
 948  // property: boundingBoxBuffer
 949  _MTL_INLINE MTL::Buffer* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxBuffer() const
 950  {
 951      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(boundingBoxBuffer));
 952  }
 953  
 954  _MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxBuffer(const MTL::Buffer* boundingBoxBuffer)
 955  {
 956      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxBuffer_), boundingBoxBuffer);
 957  }
 958  
 959  // property: boundingBoxBufferOffset
 960  _MTL_INLINE NS::UInteger MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxBufferOffset() const
 961  {
 962      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxBufferOffset));
 963  }
 964  
 965  _MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxBufferOffset(NS::UInteger boundingBoxBufferOffset)
 966  {
 967      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxBufferOffset_), boundingBoxBufferOffset);
 968  }
 969  
 970  // property: boundingBoxStride
 971  _MTL_INLINE NS::UInteger MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxStride() const
 972  {
 973      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxStride));
 974  }
 975  
 976  _MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxStride(NS::UInteger boundingBoxStride)
 977  {
 978      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxStride_), boundingBoxStride);
 979  }
 980  
 981  // property: boundingBoxCount
 982  _MTL_INLINE NS::UInteger MTL::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxCount() const
 983  {
 984      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxCount));
 985  }
 986  
 987  _MTL_INLINE void MTL::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxCount(NS::UInteger boundingBoxCount)
 988  {
 989      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxCount_), boundingBoxCount);
 990  }
 991  
 992  // static method: descriptor
 993  _MTL_INLINE MTL::AccelerationStructureBoundingBoxGeometryDescriptor* MTL::AccelerationStructureBoundingBoxGeometryDescriptor::descriptor()
 994  {
 995      return Object::sendMessage<MTL::AccelerationStructureBoundingBoxGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureBoundingBoxGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
 996  }
 997  
 998  // static method: alloc
 999  _MTL_INLINE MTL::MotionKeyframeData* MTL::MotionKeyframeData::alloc()
1000  {
1001      return NS::Object::alloc<MTL::MotionKeyframeData>(_MTL_PRIVATE_CLS(MTLMotionKeyframeData));
1002  }
1003  
1004  // method: init
1005  _MTL_INLINE MTL::MotionKeyframeData* MTL::MotionKeyframeData::init()
1006  {
1007      return NS::Object::init<MTL::MotionKeyframeData>();
1008  }
1009  
1010  // property: buffer
1011  _MTL_INLINE MTL::Buffer* MTL::MotionKeyframeData::buffer() const
1012  {
1013      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(buffer));
1014  }
1015  
1016  _MTL_INLINE void MTL::MotionKeyframeData::setBuffer(const MTL::Buffer* buffer)
1017  {
1018      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBuffer_), buffer);
1019  }
1020  
1021  // property: offset
1022  _MTL_INLINE NS::UInteger MTL::MotionKeyframeData::offset() const
1023  {
1024      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(offset));
1025  }
1026  
1027  _MTL_INLINE void MTL::MotionKeyframeData::setOffset(NS::UInteger offset)
1028  {
1029      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOffset_), offset);
1030  }
1031  
1032  // static method: data
1033  _MTL_INLINE MTL::MotionKeyframeData* MTL::MotionKeyframeData::data()
1034  {
1035      return Object::sendMessage<MTL::MotionKeyframeData*>(_MTL_PRIVATE_CLS(MTLMotionKeyframeData), _MTL_PRIVATE_SEL(data));
1036  }
1037  
1038  // static method: alloc
1039  _MTL_INLINE MTL::AccelerationStructureMotionTriangleGeometryDescriptor* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::alloc()
1040  {
1041      return NS::Object::alloc<MTL::AccelerationStructureMotionTriangleGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionTriangleGeometryDescriptor));
1042  }
1043  
1044  // method: init
1045  _MTL_INLINE MTL::AccelerationStructureMotionTriangleGeometryDescriptor* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::init()
1046  {
1047      return NS::Object::init<MTL::AccelerationStructureMotionTriangleGeometryDescriptor>();
1048  }
1049  
1050  // property: vertexBuffers
1051  _MTL_INLINE NS::Array* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::vertexBuffers() const
1052  {
1053      return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexBuffers));
1054  }
1055  
1056  _MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexBuffers(const NS::Array* vertexBuffers)
1057  {
1058      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffers_), vertexBuffers);
1059  }
1060  
1061  // property: vertexFormat
1062  _MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureMotionTriangleGeometryDescriptor::vertexFormat() const
1063  {
1064      return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(vertexFormat));
1065  }
1066  
1067  _MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexFormat(MTL::AttributeFormat vertexFormat)
1068  {
1069      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexFormat_), vertexFormat);
1070  }
1071  
1072  // property: vertexStride
1073  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::vertexStride() const
1074  {
1075      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(vertexStride));
1076  }
1077  
1078  _MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexStride(NS::UInteger vertexStride)
1079  {
1080      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexStride_), vertexStride);
1081  }
1082  
1083  // property: indexBuffer
1084  _MTL_INLINE MTL::Buffer* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::indexBuffer() const
1085  {
1086      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(indexBuffer));
1087  }
1088  
1089  _MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer)
1090  {
1091      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
1092  }
1093  
1094  // property: indexBufferOffset
1095  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::indexBufferOffset() const
1096  {
1097      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(indexBufferOffset));
1098  }
1099  
1100  _MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset)
1101  {
1102      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset);
1103  }
1104  
1105  // property: indexType
1106  _MTL_INLINE MTL::IndexType MTL::AccelerationStructureMotionTriangleGeometryDescriptor::indexType() const
1107  {
1108      return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
1109  }
1110  
1111  _MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexType(MTL::IndexType indexType)
1112  {
1113      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
1114  }
1115  
1116  // property: triangleCount
1117  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::triangleCount() const
1118  {
1119      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(triangleCount));
1120  }
1121  
1122  _MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setTriangleCount(NS::UInteger triangleCount)
1123  {
1124      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTriangleCount_), triangleCount);
1125  }
1126  
1127  // property: transformationMatrixBuffer
1128  _MTL_INLINE MTL::Buffer* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixBuffer() const
1129  {
1130      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(transformationMatrixBuffer));
1131  }
1132  
1133  _MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixBuffer(const MTL::Buffer* transformationMatrixBuffer)
1134  {
1135      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixBuffer_), transformationMatrixBuffer);
1136  }
1137  
1138  // property: transformationMatrixBufferOffset
1139  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixBufferOffset() const
1140  {
1141      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(transformationMatrixBufferOffset));
1142  }
1143  
1144  _MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixBufferOffset(NS::UInteger transformationMatrixBufferOffset)
1145  {
1146      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixBufferOffset_), transformationMatrixBufferOffset);
1147  }
1148  
1149  // property: transformationMatrixLayout
1150  _MTL_INLINE MTL::MatrixLayout MTL::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixLayout() const
1151  {
1152      return Object::sendMessage<MTL::MatrixLayout>(this, _MTL_PRIVATE_SEL(transformationMatrixLayout));
1153  }
1154  
1155  _MTL_INLINE void MTL::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout)
1156  {
1157      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixLayout_), transformationMatrixLayout);
1158  }
1159  
1160  // static method: descriptor
1161  _MTL_INLINE MTL::AccelerationStructureMotionTriangleGeometryDescriptor* MTL::AccelerationStructureMotionTriangleGeometryDescriptor::descriptor()
1162  {
1163      return Object::sendMessage<MTL::AccelerationStructureMotionTriangleGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionTriangleGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
1164  }
1165  
1166  // static method: alloc
1167  _MTL_INLINE MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::alloc()
1168  {
1169      return NS::Object::alloc<MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionBoundingBoxGeometryDescriptor));
1170  }
1171  
1172  // method: init
1173  _MTL_INLINE MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::init()
1174  {
1175      return NS::Object::init<MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor>();
1176  }
1177  
1178  // property: boundingBoxBuffers
1179  _MTL_INLINE NS::Array* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxBuffers() const
1180  {
1181      return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(boundingBoxBuffers));
1182  }
1183  
1184  _MTL_INLINE void MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxBuffers(const NS::Array* boundingBoxBuffers)
1185  {
1186      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxBuffers_), boundingBoxBuffers);
1187  }
1188  
1189  // property: boundingBoxStride
1190  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxStride() const
1191  {
1192      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxStride));
1193  }
1194  
1195  _MTL_INLINE void MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxStride(NS::UInteger boundingBoxStride)
1196  {
1197      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxStride_), boundingBoxStride);
1198  }
1199  
1200  // property: boundingBoxCount
1201  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxCount() const
1202  {
1203      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxCount));
1204  }
1205  
1206  _MTL_INLINE void MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxCount(NS::UInteger boundingBoxCount)
1207  {
1208      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxCount_), boundingBoxCount);
1209  }
1210  
1211  // static method: descriptor
1212  _MTL_INLINE MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor::descriptor()
1213  {
1214      return Object::sendMessage<MTL::AccelerationStructureMotionBoundingBoxGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionBoundingBoxGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
1215  }
1216  
1217  // static method: alloc
1218  _MTL_INLINE MTL::AccelerationStructureCurveGeometryDescriptor* MTL::AccelerationStructureCurveGeometryDescriptor::alloc()
1219  {
1220      return NS::Object::alloc<MTL::AccelerationStructureCurveGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureCurveGeometryDescriptor));
1221  }
1222  
1223  // method: init
1224  _MTL_INLINE MTL::AccelerationStructureCurveGeometryDescriptor* MTL::AccelerationStructureCurveGeometryDescriptor::init()
1225  {
1226      return NS::Object::init<MTL::AccelerationStructureCurveGeometryDescriptor>();
1227  }
1228  
1229  // property: controlPointBuffer
1230  _MTL_INLINE MTL::Buffer* MTL::AccelerationStructureCurveGeometryDescriptor::controlPointBuffer() const
1231  {
1232      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(controlPointBuffer));
1233  }
1234  
1235  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointBuffer(const MTL::Buffer* controlPointBuffer)
1236  {
1237      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointBuffer_), controlPointBuffer);
1238  }
1239  
1240  // property: controlPointBufferOffset
1241  _MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::controlPointBufferOffset() const
1242  {
1243      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointBufferOffset));
1244  }
1245  
1246  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointBufferOffset(NS::UInteger controlPointBufferOffset)
1247  {
1248      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointBufferOffset_), controlPointBufferOffset);
1249  }
1250  
1251  // property: controlPointCount
1252  _MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::controlPointCount() const
1253  {
1254      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointCount));
1255  }
1256  
1257  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointCount(NS::UInteger controlPointCount)
1258  {
1259      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointCount_), controlPointCount);
1260  }
1261  
1262  // property: controlPointStride
1263  _MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::controlPointStride() const
1264  {
1265      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointStride));
1266  }
1267  
1268  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointStride(NS::UInteger controlPointStride)
1269  {
1270      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointStride_), controlPointStride);
1271  }
1272  
1273  // property: controlPointFormat
1274  _MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureCurveGeometryDescriptor::controlPointFormat() const
1275  {
1276      return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(controlPointFormat));
1277  }
1278  
1279  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setControlPointFormat(MTL::AttributeFormat controlPointFormat)
1280  {
1281      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointFormat_), controlPointFormat);
1282  }
1283  
1284  // property: radiusBuffer
1285  _MTL_INLINE MTL::Buffer* MTL::AccelerationStructureCurveGeometryDescriptor::radiusBuffer() const
1286  {
1287      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(radiusBuffer));
1288  }
1289  
1290  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusBuffer(const MTL::Buffer* radiusBuffer)
1291  {
1292      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusBuffer_), radiusBuffer);
1293  }
1294  
1295  // property: radiusBufferOffset
1296  _MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::radiusBufferOffset() const
1297  {
1298      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(radiusBufferOffset));
1299  }
1300  
1301  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusBufferOffset(NS::UInteger radiusBufferOffset)
1302  {
1303      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusBufferOffset_), radiusBufferOffset);
1304  }
1305  
1306  // property: radiusFormat
1307  _MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureCurveGeometryDescriptor::radiusFormat() const
1308  {
1309      return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(radiusFormat));
1310  }
1311  
1312  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusFormat(MTL::AttributeFormat radiusFormat)
1313  {
1314      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusFormat_), radiusFormat);
1315  }
1316  
1317  // property: radiusStride
1318  _MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::radiusStride() const
1319  {
1320      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(radiusStride));
1321  }
1322  
1323  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setRadiusStride(NS::UInteger radiusStride)
1324  {
1325      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusStride_), radiusStride);
1326  }
1327  
1328  // property: indexBuffer
1329  _MTL_INLINE MTL::Buffer* MTL::AccelerationStructureCurveGeometryDescriptor::indexBuffer() const
1330  {
1331      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(indexBuffer));
1332  }
1333  
1334  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer)
1335  {
1336      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
1337  }
1338  
1339  // property: indexBufferOffset
1340  _MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::indexBufferOffset() const
1341  {
1342      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(indexBufferOffset));
1343  }
1344  
1345  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset)
1346  {
1347      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset);
1348  }
1349  
1350  // property: indexType
1351  _MTL_INLINE MTL::IndexType MTL::AccelerationStructureCurveGeometryDescriptor::indexType() const
1352  {
1353      return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
1354  }
1355  
1356  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setIndexType(MTL::IndexType indexType)
1357  {
1358      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
1359  }
1360  
1361  // property: segmentCount
1362  _MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::segmentCount() const
1363  {
1364      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentCount));
1365  }
1366  
1367  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setSegmentCount(NS::UInteger segmentCount)
1368  {
1369      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentCount_), segmentCount);
1370  }
1371  
1372  // property: segmentControlPointCount
1373  _MTL_INLINE NS::UInteger MTL::AccelerationStructureCurveGeometryDescriptor::segmentControlPointCount() const
1374  {
1375      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentControlPointCount));
1376  }
1377  
1378  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setSegmentControlPointCount(NS::UInteger segmentControlPointCount)
1379  {
1380      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentControlPointCount_), segmentControlPointCount);
1381  }
1382  
1383  // property: curveType
1384  _MTL_INLINE MTL::CurveType MTL::AccelerationStructureCurveGeometryDescriptor::curveType() const
1385  {
1386      return Object::sendMessage<MTL::CurveType>(this, _MTL_PRIVATE_SEL(curveType));
1387  }
1388  
1389  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setCurveType(MTL::CurveType curveType)
1390  {
1391      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveType_), curveType);
1392  }
1393  
1394  // property: curveBasis
1395  _MTL_INLINE MTL::CurveBasis MTL::AccelerationStructureCurveGeometryDescriptor::curveBasis() const
1396  {
1397      return Object::sendMessage<MTL::CurveBasis>(this, _MTL_PRIVATE_SEL(curveBasis));
1398  }
1399  
1400  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setCurveBasis(MTL::CurveBasis curveBasis)
1401  {
1402      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveBasis_), curveBasis);
1403  }
1404  
1405  // property: curveEndCaps
1406  _MTL_INLINE MTL::CurveEndCaps MTL::AccelerationStructureCurveGeometryDescriptor::curveEndCaps() const
1407  {
1408      return Object::sendMessage<MTL::CurveEndCaps>(this, _MTL_PRIVATE_SEL(curveEndCaps));
1409  }
1410  
1411  _MTL_INLINE void MTL::AccelerationStructureCurveGeometryDescriptor::setCurveEndCaps(MTL::CurveEndCaps curveEndCaps)
1412  {
1413      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveEndCaps_), curveEndCaps);
1414  }
1415  
1416  // static method: descriptor
1417  _MTL_INLINE MTL::AccelerationStructureCurveGeometryDescriptor* MTL::AccelerationStructureCurveGeometryDescriptor::descriptor()
1418  {
1419      return Object::sendMessage<MTL::AccelerationStructureCurveGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureCurveGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
1420  }
1421  
1422  // static method: alloc
1423  _MTL_INLINE MTL::AccelerationStructureMotionCurveGeometryDescriptor* MTL::AccelerationStructureMotionCurveGeometryDescriptor::alloc()
1424  {
1425      return NS::Object::alloc<MTL::AccelerationStructureMotionCurveGeometryDescriptor>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionCurveGeometryDescriptor));
1426  }
1427  
1428  // method: init
1429  _MTL_INLINE MTL::AccelerationStructureMotionCurveGeometryDescriptor* MTL::AccelerationStructureMotionCurveGeometryDescriptor::init()
1430  {
1431      return NS::Object::init<MTL::AccelerationStructureMotionCurveGeometryDescriptor>();
1432  }
1433  
1434  // property: controlPointBuffers
1435  _MTL_INLINE NS::Array* MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointBuffers() const
1436  {
1437      return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(controlPointBuffers));
1438  }
1439  
1440  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointBuffers(const NS::Array* controlPointBuffers)
1441  {
1442      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointBuffers_), controlPointBuffers);
1443  }
1444  
1445  // property: controlPointCount
1446  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointCount() const
1447  {
1448      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointCount));
1449  }
1450  
1451  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointCount(NS::UInteger controlPointCount)
1452  {
1453      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointCount_), controlPointCount);
1454  }
1455  
1456  // property: controlPointStride
1457  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointStride() const
1458  {
1459      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointStride));
1460  }
1461  
1462  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointStride(NS::UInteger controlPointStride)
1463  {
1464      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointStride_), controlPointStride);
1465  }
1466  
1467  // property: controlPointFormat
1468  _MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureMotionCurveGeometryDescriptor::controlPointFormat() const
1469  {
1470      return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(controlPointFormat));
1471  }
1472  
1473  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointFormat(MTL::AttributeFormat controlPointFormat)
1474  {
1475      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointFormat_), controlPointFormat);
1476  }
1477  
1478  // property: radiusBuffers
1479  _MTL_INLINE NS::Array* MTL::AccelerationStructureMotionCurveGeometryDescriptor::radiusBuffers() const
1480  {
1481      return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(radiusBuffers));
1482  }
1483  
1484  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusBuffers(const NS::Array* radiusBuffers)
1485  {
1486      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusBuffers_), radiusBuffers);
1487  }
1488  
1489  // property: radiusFormat
1490  _MTL_INLINE MTL::AttributeFormat MTL::AccelerationStructureMotionCurveGeometryDescriptor::radiusFormat() const
1491  {
1492      return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(radiusFormat));
1493  }
1494  
1495  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusFormat(MTL::AttributeFormat radiusFormat)
1496  {
1497      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusFormat_), radiusFormat);
1498  }
1499  
1500  // property: radiusStride
1501  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::radiusStride() const
1502  {
1503      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(radiusStride));
1504  }
1505  
1506  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusStride(NS::UInteger radiusStride)
1507  {
1508      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusStride_), radiusStride);
1509  }
1510  
1511  // property: indexBuffer
1512  _MTL_INLINE MTL::Buffer* MTL::AccelerationStructureMotionCurveGeometryDescriptor::indexBuffer() const
1513  {
1514      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(indexBuffer));
1515  }
1516  
1517  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setIndexBuffer(const MTL::Buffer* indexBuffer)
1518  {
1519      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
1520  }
1521  
1522  // property: indexBufferOffset
1523  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::indexBufferOffset() const
1524  {
1525      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(indexBufferOffset));
1526  }
1527  
1528  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setIndexBufferOffset(NS::UInteger indexBufferOffset)
1529  {
1530      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBufferOffset_), indexBufferOffset);
1531  }
1532  
1533  // property: indexType
1534  _MTL_INLINE MTL::IndexType MTL::AccelerationStructureMotionCurveGeometryDescriptor::indexType() const
1535  {
1536      return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
1537  }
1538  
1539  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setIndexType(MTL::IndexType indexType)
1540  {
1541      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
1542  }
1543  
1544  // property: segmentCount
1545  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::segmentCount() const
1546  {
1547      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentCount));
1548  }
1549  
1550  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setSegmentCount(NS::UInteger segmentCount)
1551  {
1552      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentCount_), segmentCount);
1553  }
1554  
1555  // property: segmentControlPointCount
1556  _MTL_INLINE NS::UInteger MTL::AccelerationStructureMotionCurveGeometryDescriptor::segmentControlPointCount() const
1557  {
1558      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentControlPointCount));
1559  }
1560  
1561  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setSegmentControlPointCount(NS::UInteger segmentControlPointCount)
1562  {
1563      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentControlPointCount_), segmentControlPointCount);
1564  }
1565  
1566  // property: curveType
1567  _MTL_INLINE MTL::CurveType MTL::AccelerationStructureMotionCurveGeometryDescriptor::curveType() const
1568  {
1569      return Object::sendMessage<MTL::CurveType>(this, _MTL_PRIVATE_SEL(curveType));
1570  }
1571  
1572  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setCurveType(MTL::CurveType curveType)
1573  {
1574      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveType_), curveType);
1575  }
1576  
1577  // property: curveBasis
1578  _MTL_INLINE MTL::CurveBasis MTL::AccelerationStructureMotionCurveGeometryDescriptor::curveBasis() const
1579  {
1580      return Object::sendMessage<MTL::CurveBasis>(this, _MTL_PRIVATE_SEL(curveBasis));
1581  }
1582  
1583  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setCurveBasis(MTL::CurveBasis curveBasis)
1584  {
1585      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveBasis_), curveBasis);
1586  }
1587  
1588  // property: curveEndCaps
1589  _MTL_INLINE MTL::CurveEndCaps MTL::AccelerationStructureMotionCurveGeometryDescriptor::curveEndCaps() const
1590  {
1591      return Object::sendMessage<MTL::CurveEndCaps>(this, _MTL_PRIVATE_SEL(curveEndCaps));
1592  }
1593  
1594  _MTL_INLINE void MTL::AccelerationStructureMotionCurveGeometryDescriptor::setCurveEndCaps(MTL::CurveEndCaps curveEndCaps)
1595  {
1596      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveEndCaps_), curveEndCaps);
1597  }
1598  
1599  // static method: descriptor
1600  _MTL_INLINE MTL::AccelerationStructureMotionCurveGeometryDescriptor* MTL::AccelerationStructureMotionCurveGeometryDescriptor::descriptor()
1601  {
1602      return Object::sendMessage<MTL::AccelerationStructureMotionCurveGeometryDescriptor*>(_MTL_PRIVATE_CLS(MTLAccelerationStructureMotionCurveGeometryDescriptor), _MTL_PRIVATE_SEL(descriptor));
1603  }
1604  
1605  // static method: alloc
1606  _MTL_INLINE MTL::InstanceAccelerationStructureDescriptor* MTL::InstanceAccelerationStructureDescriptor::alloc()
1607  {
1608      return NS::Object::alloc<MTL::InstanceAccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTLInstanceAccelerationStructureDescriptor));
1609  }
1610  
1611  // method: init
1612  _MTL_INLINE MTL::InstanceAccelerationStructureDescriptor* MTL::InstanceAccelerationStructureDescriptor::init()
1613  {
1614      return NS::Object::init<MTL::InstanceAccelerationStructureDescriptor>();
1615  }
1616  
1617  // property: instanceDescriptorBuffer
1618  _MTL_INLINE MTL::Buffer* MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorBuffer() const
1619  {
1620      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(instanceDescriptorBuffer));
1621  }
1622  
1623  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorBuffer(const MTL::Buffer* instanceDescriptorBuffer)
1624  {
1625      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBuffer_), instanceDescriptorBuffer);
1626  }
1627  
1628  // property: instanceDescriptorBufferOffset
1629  _MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorBufferOffset() const
1630  {
1631      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceDescriptorBufferOffset));
1632  }
1633  
1634  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset)
1635  {
1636      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBufferOffset_), instanceDescriptorBufferOffset);
1637  }
1638  
1639  // property: instanceDescriptorStride
1640  _MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorStride() const
1641  {
1642      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceDescriptorStride));
1643  }
1644  
1645  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride)
1646  {
1647      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorStride_), instanceDescriptorStride);
1648  }
1649  
1650  // property: instanceCount
1651  _MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::instanceCount() const
1652  {
1653      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceCount));
1654  }
1655  
1656  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceCount(NS::UInteger instanceCount)
1657  {
1658      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceCount_), instanceCount);
1659  }
1660  
1661  // property: instancedAccelerationStructures
1662  _MTL_INLINE NS::Array* MTL::InstanceAccelerationStructureDescriptor::instancedAccelerationStructures() const
1663  {
1664      return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(instancedAccelerationStructures));
1665  }
1666  
1667  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstancedAccelerationStructures(const NS::Array* instancedAccelerationStructures)
1668  {
1669      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstancedAccelerationStructures_), instancedAccelerationStructures);
1670  }
1671  
1672  // property: instanceDescriptorType
1673  _MTL_INLINE MTL::AccelerationStructureInstanceDescriptorType MTL::InstanceAccelerationStructureDescriptor::instanceDescriptorType() const
1674  {
1675      return Object::sendMessage<MTL::AccelerationStructureInstanceDescriptorType>(this, _MTL_PRIVATE_SEL(instanceDescriptorType));
1676  }
1677  
1678  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType)
1679  {
1680      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorType_), instanceDescriptorType);
1681  }
1682  
1683  // property: motionTransformBuffer
1684  _MTL_INLINE MTL::Buffer* MTL::InstanceAccelerationStructureDescriptor::motionTransformBuffer() const
1685  {
1686      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(motionTransformBuffer));
1687  }
1688  
1689  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformBuffer(const MTL::Buffer* motionTransformBuffer)
1690  {
1691      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformBuffer_), motionTransformBuffer);
1692  }
1693  
1694  // property: motionTransformBufferOffset
1695  _MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::motionTransformBufferOffset() const
1696  {
1697      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformBufferOffset));
1698  }
1699  
1700  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset)
1701  {
1702      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformBufferOffset_), motionTransformBufferOffset);
1703  }
1704  
1705  // property: motionTransformCount
1706  _MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::motionTransformCount() const
1707  {
1708      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformCount));
1709  }
1710  
1711  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformCount(NS::UInteger motionTransformCount)
1712  {
1713      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformCount_), motionTransformCount);
1714  }
1715  
1716  // property: instanceTransformationMatrixLayout
1717  _MTL_INLINE MTL::MatrixLayout MTL::InstanceAccelerationStructureDescriptor::instanceTransformationMatrixLayout() const
1718  {
1719      return Object::sendMessage<MTL::MatrixLayout>(this, _MTL_PRIVATE_SEL(instanceTransformationMatrixLayout));
1720  }
1721  
1722  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout)
1723  {
1724      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceTransformationMatrixLayout_), instanceTransformationMatrixLayout);
1725  }
1726  
1727  // property: motionTransformType
1728  _MTL_INLINE MTL::TransformType MTL::InstanceAccelerationStructureDescriptor::motionTransformType() const
1729  {
1730      return Object::sendMessage<MTL::TransformType>(this, _MTL_PRIVATE_SEL(motionTransformType));
1731  }
1732  
1733  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformType(MTL::TransformType motionTransformType)
1734  {
1735      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformType_), motionTransformType);
1736  }
1737  
1738  // property: motionTransformStride
1739  _MTL_INLINE NS::UInteger MTL::InstanceAccelerationStructureDescriptor::motionTransformStride() const
1740  {
1741      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformStride));
1742  }
1743  
1744  _MTL_INLINE void MTL::InstanceAccelerationStructureDescriptor::setMotionTransformStride(NS::UInteger motionTransformStride)
1745  {
1746      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformStride_), motionTransformStride);
1747  }
1748  
1749  // static method: descriptor
1750  _MTL_INLINE MTL::InstanceAccelerationStructureDescriptor* MTL::InstanceAccelerationStructureDescriptor::descriptor()
1751  {
1752      return Object::sendMessage<MTL::InstanceAccelerationStructureDescriptor*>(_MTL_PRIVATE_CLS(MTLInstanceAccelerationStructureDescriptor), _MTL_PRIVATE_SEL(descriptor));
1753  }
1754  
1755  // static method: alloc
1756  _MTL_INLINE MTL::IndirectInstanceAccelerationStructureDescriptor* MTL::IndirectInstanceAccelerationStructureDescriptor::alloc()
1757  {
1758      return NS::Object::alloc<MTL::IndirectInstanceAccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTLIndirectInstanceAccelerationStructureDescriptor));
1759  }
1760  
1761  // method: init
1762  _MTL_INLINE MTL::IndirectInstanceAccelerationStructureDescriptor* MTL::IndirectInstanceAccelerationStructureDescriptor::init()
1763  {
1764      return NS::Object::init<MTL::IndirectInstanceAccelerationStructureDescriptor>();
1765  }
1766  
1767  // property: instanceDescriptorBuffer
1768  _MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorBuffer() const
1769  {
1770      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(instanceDescriptorBuffer));
1771  }
1772  
1773  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorBuffer(const MTL::Buffer* instanceDescriptorBuffer)
1774  {
1775      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBuffer_), instanceDescriptorBuffer);
1776  }
1777  
1778  // property: instanceDescriptorBufferOffset
1779  _MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorBufferOffset() const
1780  {
1781      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceDescriptorBufferOffset));
1782  }
1783  
1784  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorBufferOffset(NS::UInteger instanceDescriptorBufferOffset)
1785  {
1786      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBufferOffset_), instanceDescriptorBufferOffset);
1787  }
1788  
1789  // property: instanceDescriptorStride
1790  _MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorStride() const
1791  {
1792      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceDescriptorStride));
1793  }
1794  
1795  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride)
1796  {
1797      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorStride_), instanceDescriptorStride);
1798  }
1799  
1800  // property: maxInstanceCount
1801  _MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::maxInstanceCount() const
1802  {
1803      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxInstanceCount));
1804  }
1805  
1806  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMaxInstanceCount(NS::UInteger maxInstanceCount)
1807  {
1808      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxInstanceCount_), maxInstanceCount);
1809  }
1810  
1811  // property: instanceCountBuffer
1812  _MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::instanceCountBuffer() const
1813  {
1814      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(instanceCountBuffer));
1815  }
1816  
1817  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceCountBuffer(const MTL::Buffer* instanceCountBuffer)
1818  {
1819      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceCountBuffer_), instanceCountBuffer);
1820  }
1821  
1822  // property: instanceCountBufferOffset
1823  _MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::instanceCountBufferOffset() const
1824  {
1825      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceCountBufferOffset));
1826  }
1827  
1828  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceCountBufferOffset(NS::UInteger instanceCountBufferOffset)
1829  {
1830      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceCountBufferOffset_), instanceCountBufferOffset);
1831  }
1832  
1833  // property: instanceDescriptorType
1834  _MTL_INLINE MTL::AccelerationStructureInstanceDescriptorType MTL::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorType() const
1835  {
1836      return Object::sendMessage<MTL::AccelerationStructureInstanceDescriptorType>(this, _MTL_PRIVATE_SEL(instanceDescriptorType));
1837  }
1838  
1839  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType)
1840  {
1841      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorType_), instanceDescriptorType);
1842  }
1843  
1844  // property: motionTransformBuffer
1845  _MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformBuffer() const
1846  {
1847      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(motionTransformBuffer));
1848  }
1849  
1850  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformBuffer(const MTL::Buffer* motionTransformBuffer)
1851  {
1852      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformBuffer_), motionTransformBuffer);
1853  }
1854  
1855  // property: motionTransformBufferOffset
1856  _MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformBufferOffset() const
1857  {
1858      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformBufferOffset));
1859  }
1860  
1861  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformBufferOffset(NS::UInteger motionTransformBufferOffset)
1862  {
1863      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformBufferOffset_), motionTransformBufferOffset);
1864  }
1865  
1866  // property: maxMotionTransformCount
1867  _MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::maxMotionTransformCount() const
1868  {
1869      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxMotionTransformCount));
1870  }
1871  
1872  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMaxMotionTransformCount(NS::UInteger maxMotionTransformCount)
1873  {
1874      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxMotionTransformCount_), maxMotionTransformCount);
1875  }
1876  
1877  // property: motionTransformCountBuffer
1878  _MTL_INLINE MTL::Buffer* MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformCountBuffer() const
1879  {
1880      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(motionTransformCountBuffer));
1881  }
1882  
1883  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformCountBuffer(const MTL::Buffer* motionTransformCountBuffer)
1884  {
1885      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformCountBuffer_), motionTransformCountBuffer);
1886  }
1887  
1888  // property: motionTransformCountBufferOffset
1889  _MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformCountBufferOffset() const
1890  {
1891      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformCountBufferOffset));
1892  }
1893  
1894  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformCountBufferOffset(NS::UInteger motionTransformCountBufferOffset)
1895  {
1896      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformCountBufferOffset_), motionTransformCountBufferOffset);
1897  }
1898  
1899  // property: instanceTransformationMatrixLayout
1900  _MTL_INLINE MTL::MatrixLayout MTL::IndirectInstanceAccelerationStructureDescriptor::instanceTransformationMatrixLayout() const
1901  {
1902      return Object::sendMessage<MTL::MatrixLayout>(this, _MTL_PRIVATE_SEL(instanceTransformationMatrixLayout));
1903  }
1904  
1905  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout)
1906  {
1907      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceTransformationMatrixLayout_), instanceTransformationMatrixLayout);
1908  }
1909  
1910  // property: motionTransformType
1911  _MTL_INLINE MTL::TransformType MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformType() const
1912  {
1913      return Object::sendMessage<MTL::TransformType>(this, _MTL_PRIVATE_SEL(motionTransformType));
1914  }
1915  
1916  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformType(MTL::TransformType motionTransformType)
1917  {
1918      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformType_), motionTransformType);
1919  }
1920  
1921  // property: motionTransformStride
1922  _MTL_INLINE NS::UInteger MTL::IndirectInstanceAccelerationStructureDescriptor::motionTransformStride() const
1923  {
1924      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformStride));
1925  }
1926  
1927  _MTL_INLINE void MTL::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformStride(NS::UInteger motionTransformStride)
1928  {
1929      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformStride_), motionTransformStride);
1930  }
1931  
1932  // static method: descriptor
1933  _MTL_INLINE MTL::IndirectInstanceAccelerationStructureDescriptor* MTL::IndirectInstanceAccelerationStructureDescriptor::descriptor()
1934  {
1935      return Object::sendMessage<MTL::IndirectInstanceAccelerationStructureDescriptor*>(_MTL_PRIVATE_CLS(MTLIndirectInstanceAccelerationStructureDescriptor), _MTL_PRIVATE_SEL(descriptor));
1936  }
1937  
1938  // property: size
1939  _MTL_INLINE NS::UInteger MTL::AccelerationStructure::size() const
1940  {
1941      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(size));
1942  }
1943  
1944  // property: gpuResourceID
1945  _MTL_INLINE MTL::ResourceID MTL::AccelerationStructure::gpuResourceID() const
1946  {
1947      return Object::sendMessage<MTL::ResourceID>(this, _MTL_PRIVATE_SEL(gpuResourceID));
1948  }