CoCalc -- MTL4AccelerationStructure.hpp

GitHub Repository: godotengine/godot
Path: blob/master/thirdparty/metal-cpp/Metal/MTL4AccelerationStructure.hpp
²¹⁰⁶⁶ views
1
//-------------------------------------------------------------------------------------------------------------------------------------------------------------
2
//
3
// Metal/MTL4AccelerationStructure.hpp
4
//
5
// Copyright 2020-2025 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 "../Foundation/Foundation.hpp"
24
#include "MTLAccelerationStructure.hpp"
25
#include "MTLAccelerationStructureTypes.hpp"
26
#include "MTLArgument.hpp"
27
#include "MTLDefines.hpp"
28
#include "MTLHeaderBridge.hpp"
29
#include "MTLPrivate.hpp"
30
#include "MTLStageInputOutputDescriptor.hpp"
31

32
namespace MTL4
33
{
34
class AccelerationStructureBoundingBoxGeometryDescriptor;
35
class AccelerationStructureCurveGeometryDescriptor;
36
class AccelerationStructureDescriptor;
37
class AccelerationStructureGeometryDescriptor;
38
class AccelerationStructureMotionBoundingBoxGeometryDescriptor;
39
class AccelerationStructureMotionCurveGeometryDescriptor;
40
class AccelerationStructureMotionTriangleGeometryDescriptor;
41
class AccelerationStructureTriangleGeometryDescriptor;
42
class IndirectInstanceAccelerationStructureDescriptor;
43
class InstanceAccelerationStructureDescriptor;
44
class PrimitiveAccelerationStructureDescriptor;
45

46
class AccelerationStructureDescriptor : public NS::Copying<AccelerationStructureDescriptor, MTL::AccelerationStructureDescriptor>
47
{
48
public:
49
    static AccelerationStructureDescriptor* alloc();
50

51
    AccelerationStructureDescriptor*        init();
52
};
53
class AccelerationStructureGeometryDescriptor : public NS::Copying<AccelerationStructureGeometryDescriptor>
54
{
55
public:
56
    static AccelerationStructureGeometryDescriptor* alloc();
57

58
    bool                                            allowDuplicateIntersectionFunctionInvocation() const;
59

60
    AccelerationStructureGeometryDescriptor*        init();
61

62
    NS::UInteger                                    intersectionFunctionTableOffset() const;
63

64
    NS::String*                                     label() const;
65

66
    bool                                            opaque() const;
67

68
    BufferRange                                     primitiveDataBuffer() const;
69

70
    NS::UInteger                                    primitiveDataElementSize() const;
71

72
    NS::UInteger                                    primitiveDataStride() const;
73

74
    void                                            setAllowDuplicateIntersectionFunctionInvocation(bool allowDuplicateIntersectionFunctionInvocation);
75

76
    void                                            setIntersectionFunctionTableOffset(NS::UInteger intersectionFunctionTableOffset);
77

78
    void                                            setLabel(const NS::String* label);
79

80
    void                                            setOpaque(bool opaque);
81

82
    void                                            setPrimitiveDataBuffer(const MTL4::BufferRange primitiveDataBuffer);
83

84
    void                                            setPrimitiveDataElementSize(NS::UInteger primitiveDataElementSize);
85

86
    void                                            setPrimitiveDataStride(NS::UInteger primitiveDataStride);
87
};
88
class PrimitiveAccelerationStructureDescriptor : public NS::Copying<PrimitiveAccelerationStructureDescriptor, AccelerationStructureDescriptor>
89
{
90
public:
91
    static PrimitiveAccelerationStructureDescriptor* alloc();
92

93
    NS::Array*                                       geometryDescriptors() const;
94

95
    PrimitiveAccelerationStructureDescriptor*        init();
96

97
    MTL::MotionBorderMode                            motionEndBorderMode() const;
98

99
    float                                            motionEndTime() const;
100

101
    NS::UInteger                                     motionKeyframeCount() const;
102

103
    MTL::MotionBorderMode                            motionStartBorderMode() const;
104

105
    float                                            motionStartTime() const;
106

107
    void                                             setGeometryDescriptors(const NS::Array* geometryDescriptors);
108

109
    void                                             setMotionEndBorderMode(MTL::MotionBorderMode motionEndBorderMode);
110

111
    void                                             setMotionEndTime(float motionEndTime);
112

113
    void                                             setMotionKeyframeCount(NS::UInteger motionKeyframeCount);
114

115
    void                                             setMotionStartBorderMode(MTL::MotionBorderMode motionStartBorderMode);
116

117
    void                                             setMotionStartTime(float motionStartTime);
118
};
119
class AccelerationStructureTriangleGeometryDescriptor : public NS::Copying<AccelerationStructureTriangleGeometryDescriptor, AccelerationStructureGeometryDescriptor>
120
{
121
public:
122
    static AccelerationStructureTriangleGeometryDescriptor* alloc();
123

124
    BufferRange                                             indexBuffer() const;
125

126
    MTL::IndexType                                          indexType() const;
127

128
    AccelerationStructureTriangleGeometryDescriptor*        init();
129

130
    void                                                    setIndexBuffer(const MTL4::BufferRange indexBuffer);
131

132
    void                                                    setIndexType(MTL::IndexType indexType);
133

134
    void                                                    setTransformationMatrixBuffer(const MTL4::BufferRange transformationMatrixBuffer);
135

136
    void                                                    setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout);
137

138
    void                                                    setTriangleCount(NS::UInteger triangleCount);
139

140
    void                                                    setVertexBuffer(const MTL4::BufferRange vertexBuffer);
141

142
    void                                                    setVertexFormat(MTL::AttributeFormat vertexFormat);
143

144
    void                                                    setVertexStride(NS::UInteger vertexStride);
145

146
    BufferRange                                             transformationMatrixBuffer() const;
147

148
    MTL::MatrixLayout                                       transformationMatrixLayout() const;
149

150
    NS::UInteger                                            triangleCount() const;
151

152
    BufferRange                                             vertexBuffer() const;
153

154
    MTL::AttributeFormat                                    vertexFormat() const;
155

156
    NS::UInteger                                            vertexStride() const;
157
};
158
class AccelerationStructureBoundingBoxGeometryDescriptor : public NS::Copying<AccelerationStructureBoundingBoxGeometryDescriptor, AccelerationStructureGeometryDescriptor>
159
{
160
public:
161
    static AccelerationStructureBoundingBoxGeometryDescriptor* alloc();
162

163
    BufferRange                                                boundingBoxBuffer() const;
164

165
    NS::UInteger                                               boundingBoxCount() const;
166

167
    NS::UInteger                                               boundingBoxStride() const;
168

169
    AccelerationStructureBoundingBoxGeometryDescriptor*        init();
170

171
    void                                                       setBoundingBoxBuffer(const MTL4::BufferRange boundingBoxBuffer);
172

173
    void                                                       setBoundingBoxCount(NS::UInteger boundingBoxCount);
174

175
    void                                                       setBoundingBoxStride(NS::UInteger boundingBoxStride);
176
};
177
class AccelerationStructureMotionTriangleGeometryDescriptor : public NS::Copying<AccelerationStructureMotionTriangleGeometryDescriptor, AccelerationStructureGeometryDescriptor>
178
{
179
public:
180
    static AccelerationStructureMotionTriangleGeometryDescriptor* alloc();
181

182
    BufferRange                                                   indexBuffer() const;
183

184
    MTL::IndexType                                                indexType() const;
185

186
    AccelerationStructureMotionTriangleGeometryDescriptor*        init();
187

188
    void                                                          setIndexBuffer(const MTL4::BufferRange indexBuffer);
189

190
    void                                                          setIndexType(MTL::IndexType indexType);
191

192
    void                                                          setTransformationMatrixBuffer(const MTL4::BufferRange transformationMatrixBuffer);
193

194
    void                                                          setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout);
195

196
    void                                                          setTriangleCount(NS::UInteger triangleCount);
197

198
    void                                                          setVertexBuffers(const MTL4::BufferRange vertexBuffers);
199

200
    void                                                          setVertexFormat(MTL::AttributeFormat vertexFormat);
201

202
    void                                                          setVertexStride(NS::UInteger vertexStride);
203

204
    BufferRange                                                   transformationMatrixBuffer() const;
205

206
    MTL::MatrixLayout                                             transformationMatrixLayout() const;
207

208
    NS::UInteger                                                  triangleCount() const;
209

210
    BufferRange                                                   vertexBuffers() const;
211

212
    MTL::AttributeFormat                                          vertexFormat() const;
213

214
    NS::UInteger                                                  vertexStride() const;
215
};
216
class AccelerationStructureMotionBoundingBoxGeometryDescriptor : public NS::Copying<AccelerationStructureMotionBoundingBoxGeometryDescriptor, AccelerationStructureGeometryDescriptor>
217
{
218
public:
219
    static AccelerationStructureMotionBoundingBoxGeometryDescriptor* alloc();
220

221
    BufferRange                                                      boundingBoxBuffers() const;
222

223
    NS::UInteger                                                     boundingBoxCount() const;
224

225
    NS::UInteger                                                     boundingBoxStride() const;
226

227
    AccelerationStructureMotionBoundingBoxGeometryDescriptor*        init();
228

229
    void                                                             setBoundingBoxBuffers(const MTL4::BufferRange boundingBoxBuffers);
230

231
    void                                                             setBoundingBoxCount(NS::UInteger boundingBoxCount);
232

233
    void                                                             setBoundingBoxStride(NS::UInteger boundingBoxStride);
234
};
235
class AccelerationStructureCurveGeometryDescriptor : public NS::Copying<AccelerationStructureCurveGeometryDescriptor, AccelerationStructureGeometryDescriptor>
236
{
237
public:
238
    static AccelerationStructureCurveGeometryDescriptor* alloc();
239

240
    BufferRange                                          controlPointBuffer() const;
241

242
    NS::UInteger                                         controlPointCount() const;
243

244
    MTL::AttributeFormat                                 controlPointFormat() const;
245

246
    NS::UInteger                                         controlPointStride() const;
247

248
    MTL::CurveBasis                                      curveBasis() const;
249

250
    MTL::CurveEndCaps                                    curveEndCaps() const;
251

252
    MTL::CurveType                                       curveType() const;
253

254
    BufferRange                                          indexBuffer() const;
255

256
    MTL::IndexType                                       indexType() const;
257

258
    AccelerationStructureCurveGeometryDescriptor*        init();
259

260
    BufferRange                                          radiusBuffer() const;
261

262
    MTL::AttributeFormat                                 radiusFormat() const;
263

264
    NS::UInteger                                         radiusStride() const;
265

266
    NS::UInteger                                         segmentControlPointCount() const;
267

268
    NS::UInteger                                         segmentCount() const;
269

270
    void                                                 setControlPointBuffer(const MTL4::BufferRange controlPointBuffer);
271

272
    void                                                 setControlPointCount(NS::UInteger controlPointCount);
273

274
    void                                                 setControlPointFormat(MTL::AttributeFormat controlPointFormat);
275

276
    void                                                 setControlPointStride(NS::UInteger controlPointStride);
277

278
    void                                                 setCurveBasis(MTL::CurveBasis curveBasis);
279

280
    void                                                 setCurveEndCaps(MTL::CurveEndCaps curveEndCaps);
281

282
    void                                                 setCurveType(MTL::CurveType curveType);
283

284
    void                                                 setIndexBuffer(const MTL4::BufferRange indexBuffer);
285

286
    void                                                 setIndexType(MTL::IndexType indexType);
287

288
    void                                                 setRadiusBuffer(const MTL4::BufferRange radiusBuffer);
289

290
    void                                                 setRadiusFormat(MTL::AttributeFormat radiusFormat);
291

292
    void                                                 setRadiusStride(NS::UInteger radiusStride);
293

294
    void                                                 setSegmentControlPointCount(NS::UInteger segmentControlPointCount);
295

296
    void                                                 setSegmentCount(NS::UInteger segmentCount);
297
};
298
class AccelerationStructureMotionCurveGeometryDescriptor : public NS::Copying<AccelerationStructureMotionCurveGeometryDescriptor, AccelerationStructureGeometryDescriptor>
299
{
300
public:
301
    static AccelerationStructureMotionCurveGeometryDescriptor* alloc();
302

303
    BufferRange                                                controlPointBuffers() const;
304

305
    NS::UInteger                                               controlPointCount() const;
306

307
    MTL::AttributeFormat                                       controlPointFormat() const;
308

309
    NS::UInteger                                               controlPointStride() const;
310

311
    MTL::CurveBasis                                            curveBasis() const;
312

313
    MTL::CurveEndCaps                                          curveEndCaps() const;
314

315
    MTL::CurveType                                             curveType() const;
316

317
    BufferRange                                                indexBuffer() const;
318

319
    MTL::IndexType                                             indexType() const;
320

321
    AccelerationStructureMotionCurveGeometryDescriptor*        init();
322

323
    BufferRange                                                radiusBuffers() const;
324

325
    MTL::AttributeFormat                                       radiusFormat() const;
326

327
    NS::UInteger                                               radiusStride() const;
328

329
    NS::UInteger                                               segmentControlPointCount() const;
330

331
    NS::UInteger                                               segmentCount() const;
332

333
    void                                                       setControlPointBuffers(const MTL4::BufferRange controlPointBuffers);
334

335
    void                                                       setControlPointCount(NS::UInteger controlPointCount);
336

337
    void                                                       setControlPointFormat(MTL::AttributeFormat controlPointFormat);
338

339
    void                                                       setControlPointStride(NS::UInteger controlPointStride);
340

341
    void                                                       setCurveBasis(MTL::CurveBasis curveBasis);
342

343
    void                                                       setCurveEndCaps(MTL::CurveEndCaps curveEndCaps);
344

345
    void                                                       setCurveType(MTL::CurveType curveType);
346

347
    void                                                       setIndexBuffer(const MTL4::BufferRange indexBuffer);
348

349
    void                                                       setIndexType(MTL::IndexType indexType);
350

351
    void                                                       setRadiusBuffers(const MTL4::BufferRange radiusBuffers);
352

353
    void                                                       setRadiusFormat(MTL::AttributeFormat radiusFormat);
354

355
    void                                                       setRadiusStride(NS::UInteger radiusStride);
356

357
    void                                                       setSegmentControlPointCount(NS::UInteger segmentControlPointCount);
358

359
    void                                                       setSegmentCount(NS::UInteger segmentCount);
360
};
361
class InstanceAccelerationStructureDescriptor : public NS::Copying<InstanceAccelerationStructureDescriptor, AccelerationStructureDescriptor>
362
{
363
public:
364
    static InstanceAccelerationStructureDescriptor*  alloc();
365

366
    InstanceAccelerationStructureDescriptor*         init();
367

368
    NS::UInteger                                     instanceCount() const;
369

370
    BufferRange                                      instanceDescriptorBuffer() const;
371

372
    NS::UInteger                                     instanceDescriptorStride() const;
373

374
    MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType() const;
375

376
    MTL::MatrixLayout                                instanceTransformationMatrixLayout() const;
377

378
    BufferRange                                      motionTransformBuffer() const;
379

380
    NS::UInteger                                     motionTransformCount() const;
381

382
    NS::UInteger                                     motionTransformStride() const;
383

384
    MTL::TransformType                               motionTransformType() const;
385

386
    void                                             setInstanceCount(NS::UInteger instanceCount);
387

388
    void                                             setInstanceDescriptorBuffer(const MTL4::BufferRange instanceDescriptorBuffer);
389

390
    void                                             setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride);
391

392
    void                                             setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType);
393

394
    void                                             setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout);
395

396
    void                                             setMotionTransformBuffer(const MTL4::BufferRange motionTransformBuffer);
397

398
    void                                             setMotionTransformCount(NS::UInteger motionTransformCount);
399

400
    void                                             setMotionTransformStride(NS::UInteger motionTransformStride);
401

402
    void                                             setMotionTransformType(MTL::TransformType motionTransformType);
403
};
404
class IndirectInstanceAccelerationStructureDescriptor : public NS::Copying<IndirectInstanceAccelerationStructureDescriptor, AccelerationStructureDescriptor>
405
{
406
public:
407
    static IndirectInstanceAccelerationStructureDescriptor* alloc();
408

409
    IndirectInstanceAccelerationStructureDescriptor*        init();
410

411
    BufferRange                                             instanceCountBuffer() const;
412

413
    BufferRange                                             instanceDescriptorBuffer() const;
414

415
    NS::UInteger                                            instanceDescriptorStride() const;
416

417
    MTL::AccelerationStructureInstanceDescriptorType        instanceDescriptorType() const;
418

419
    MTL::MatrixLayout                                       instanceTransformationMatrixLayout() const;
420

421
    NS::UInteger                                            maxInstanceCount() const;
422

423
    NS::UInteger                                            maxMotionTransformCount() const;
424

425
    BufferRange                                             motionTransformBuffer() const;
426

427
    BufferRange                                             motionTransformCountBuffer() const;
428

429
    NS::UInteger                                            motionTransformStride() const;
430

431
    MTL::TransformType                                      motionTransformType() const;
432

433
    void                                                    setInstanceCountBuffer(const MTL4::BufferRange instanceCountBuffer);
434

435
    void                                                    setInstanceDescriptorBuffer(const MTL4::BufferRange instanceDescriptorBuffer);
436

437
    void                                                    setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride);
438

439
    void                                                    setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType);
440

441
    void                                                    setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout);
442

443
    void                                                    setMaxInstanceCount(NS::UInteger maxInstanceCount);
444

445
    void                                                    setMaxMotionTransformCount(NS::UInteger maxMotionTransformCount);
446

447
    void                                                    setMotionTransformBuffer(const MTL4::BufferRange motionTransformBuffer);
448

449
    void                                                    setMotionTransformCountBuffer(const MTL4::BufferRange motionTransformCountBuffer);
450

451
    void                                                    setMotionTransformStride(NS::UInteger motionTransformStride);
452

453
    void                                                    setMotionTransformType(MTL::TransformType motionTransformType);
454
};
455

456
}
457
_MTL_INLINE MTL4::AccelerationStructureDescriptor* MTL4::AccelerationStructureDescriptor::alloc()
458
{
459
    return NS::Object::alloc<MTL4::AccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTL4AccelerationStructureDescriptor));
460
}
461

462
_MTL_INLINE MTL4::AccelerationStructureDescriptor* MTL4::AccelerationStructureDescriptor::init()
463
{
464
    return NS::Object::init<MTL4::AccelerationStructureDescriptor>();
465
}
466

467
_MTL_INLINE MTL4::AccelerationStructureGeometryDescriptor* MTL4::AccelerationStructureGeometryDescriptor::alloc()
468
{
469
    return NS::Object::alloc<MTL4::AccelerationStructureGeometryDescriptor>(_MTL_PRIVATE_CLS(MTL4AccelerationStructureGeometryDescriptor));
470
}
471

472
_MTL_INLINE bool MTL4::AccelerationStructureGeometryDescriptor::allowDuplicateIntersectionFunctionInvocation() const
473
{
474
    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(allowDuplicateIntersectionFunctionInvocation));
475
}
476

477
_MTL_INLINE MTL4::AccelerationStructureGeometryDescriptor* MTL4::AccelerationStructureGeometryDescriptor::init()
478
{
479
    return NS::Object::init<MTL4::AccelerationStructureGeometryDescriptor>();
480
}
481

482
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureGeometryDescriptor::intersectionFunctionTableOffset() const
483
{
484
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(intersectionFunctionTableOffset));
485
}
486

487
_MTL_INLINE NS::String* MTL4::AccelerationStructureGeometryDescriptor::label() const
488
{
489
    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
490
}
491

492
_MTL_INLINE bool MTL4::AccelerationStructureGeometryDescriptor::opaque() const
493
{
494
    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(opaque));
495
}
496

497
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureGeometryDescriptor::primitiveDataBuffer() const
498
{
499
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(primitiveDataBuffer));
500
}
501

502
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureGeometryDescriptor::primitiveDataElementSize() const
503
{
504
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(primitiveDataElementSize));
505
}
506

507
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureGeometryDescriptor::primitiveDataStride() const
508
{
509
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(primitiveDataStride));
510
}
511

512
_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setAllowDuplicateIntersectionFunctionInvocation(bool allowDuplicateIntersectionFunctionInvocation)
513
{
514
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAllowDuplicateIntersectionFunctionInvocation_), allowDuplicateIntersectionFunctionInvocation);
515
}
516

517
_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setIntersectionFunctionTableOffset(NS::UInteger intersectionFunctionTableOffset)
518
{
519
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIntersectionFunctionTableOffset_), intersectionFunctionTableOffset);
520
}
521

522
_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setLabel(const NS::String* label)
523
{
524
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
525
}
526

527
_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setOpaque(bool opaque)
528
{
529
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setOpaque_), opaque);
530
}
531

532
_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setPrimitiveDataBuffer(const MTL4::BufferRange primitiveDataBuffer)
533
{
534
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrimitiveDataBuffer_), primitiveDataBuffer);
535
}
536

537
_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setPrimitiveDataElementSize(NS::UInteger primitiveDataElementSize)
538
{
539
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrimitiveDataElementSize_), primitiveDataElementSize);
540
}
541

542
_MTL_INLINE void MTL4::AccelerationStructureGeometryDescriptor::setPrimitiveDataStride(NS::UInteger primitiveDataStride)
543
{
544
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPrimitiveDataStride_), primitiveDataStride);
545
}
546

547
_MTL_INLINE MTL4::PrimitiveAccelerationStructureDescriptor* MTL4::PrimitiveAccelerationStructureDescriptor::alloc()
548
{
549
    return NS::Object::alloc<MTL4::PrimitiveAccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTL4PrimitiveAccelerationStructureDescriptor));
550
}
551

552
_MTL_INLINE NS::Array* MTL4::PrimitiveAccelerationStructureDescriptor::geometryDescriptors() const
553
{
554
    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(geometryDescriptors));
555
}
556

557
_MTL_INLINE MTL4::PrimitiveAccelerationStructureDescriptor* MTL4::PrimitiveAccelerationStructureDescriptor::init()
558
{
559
    return NS::Object::init<MTL4::PrimitiveAccelerationStructureDescriptor>();
560
}
561

562
_MTL_INLINE MTL::MotionBorderMode MTL4::PrimitiveAccelerationStructureDescriptor::motionEndBorderMode() const
563
{
564
    return Object::sendMessage<MTL::MotionBorderMode>(this, _MTL_PRIVATE_SEL(motionEndBorderMode));
565
}
566

567
_MTL_INLINE float MTL4::PrimitiveAccelerationStructureDescriptor::motionEndTime() const
568
{
569
    return Object::sendMessage<float>(this, _MTL_PRIVATE_SEL(motionEndTime));
570
}
571

572
_MTL_INLINE NS::UInteger MTL4::PrimitiveAccelerationStructureDescriptor::motionKeyframeCount() const
573
{
574
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionKeyframeCount));
575
}
576

577
_MTL_INLINE MTL::MotionBorderMode MTL4::PrimitiveAccelerationStructureDescriptor::motionStartBorderMode() const
578
{
579
    return Object::sendMessage<MTL::MotionBorderMode>(this, _MTL_PRIVATE_SEL(motionStartBorderMode));
580
}
581

582
_MTL_INLINE float MTL4::PrimitiveAccelerationStructureDescriptor::motionStartTime() const
583
{
584
    return Object::sendMessage<float>(this, _MTL_PRIVATE_SEL(motionStartTime));
585
}
586

587
_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setGeometryDescriptors(const NS::Array* geometryDescriptors)
588
{
589
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setGeometryDescriptors_), geometryDescriptors);
590
}
591

592
_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setMotionEndBorderMode(MTL::MotionBorderMode motionEndBorderMode)
593
{
594
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionEndBorderMode_), motionEndBorderMode);
595
}
596

597
_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setMotionEndTime(float motionEndTime)
598
{
599
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionEndTime_), motionEndTime);
600
}
601

602
_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setMotionKeyframeCount(NS::UInteger motionKeyframeCount)
603
{
604
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionKeyframeCount_), motionKeyframeCount);
605
}
606

607
_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setMotionStartBorderMode(MTL::MotionBorderMode motionStartBorderMode)
608
{
609
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionStartBorderMode_), motionStartBorderMode);
610
}
611

612
_MTL_INLINE void MTL4::PrimitiveAccelerationStructureDescriptor::setMotionStartTime(float motionStartTime)
613
{
614
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionStartTime_), motionStartTime);
615
}
616

617
_MTL_INLINE MTL4::AccelerationStructureTriangleGeometryDescriptor* MTL4::AccelerationStructureTriangleGeometryDescriptor::alloc()
618
{
619
    return NS::Object::alloc<MTL4::AccelerationStructureTriangleGeometryDescriptor>(_MTL_PRIVATE_CLS(MTL4AccelerationStructureTriangleGeometryDescriptor));
620
}
621

622
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureTriangleGeometryDescriptor::indexBuffer() const
623
{
624
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(indexBuffer));
625
}
626

627
_MTL_INLINE MTL::IndexType MTL4::AccelerationStructureTriangleGeometryDescriptor::indexType() const
628
{
629
    return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
630
}
631

632
_MTL_INLINE MTL4::AccelerationStructureTriangleGeometryDescriptor* MTL4::AccelerationStructureTriangleGeometryDescriptor::init()
633
{
634
    return NS::Object::init<MTL4::AccelerationStructureTriangleGeometryDescriptor>();
635
}
636

637
_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setIndexBuffer(const MTL4::BufferRange indexBuffer)
638
{
639
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
640
}
641

642
_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setIndexType(MTL::IndexType indexType)
643
{
644
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
645
}
646

647
_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixBuffer(const MTL4::BufferRange transformationMatrixBuffer)
648
{
649
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixBuffer_), transformationMatrixBuffer);
650
}
651

652
_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout)
653
{
654
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixLayout_), transformationMatrixLayout);
655
}
656

657
_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setTriangleCount(NS::UInteger triangleCount)
658
{
659
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTriangleCount_), triangleCount);
660
}
661

662
_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setVertexBuffer(const MTL4::BufferRange vertexBuffer)
663
{
664
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffer_), vertexBuffer);
665
}
666

667
_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setVertexFormat(MTL::AttributeFormat vertexFormat)
668
{
669
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexFormat_), vertexFormat);
670
}
671

672
_MTL_INLINE void MTL4::AccelerationStructureTriangleGeometryDescriptor::setVertexStride(NS::UInteger vertexStride)
673
{
674
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexStride_), vertexStride);
675
}
676

677
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixBuffer() const
678
{
679
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(transformationMatrixBuffer));
680
}
681

682
_MTL_INLINE MTL::MatrixLayout MTL4::AccelerationStructureTriangleGeometryDescriptor::transformationMatrixLayout() const
683
{
684
    return Object::sendMessage<MTL::MatrixLayout>(this, _MTL_PRIVATE_SEL(transformationMatrixLayout));
685
}
686

687
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureTriangleGeometryDescriptor::triangleCount() const
688
{
689
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(triangleCount));
690
}
691

692
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureTriangleGeometryDescriptor::vertexBuffer() const
693
{
694
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(vertexBuffer));
695
}
696

697
_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureTriangleGeometryDescriptor::vertexFormat() const
698
{
699
    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(vertexFormat));
700
}
701

702
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureTriangleGeometryDescriptor::vertexStride() const
703
{
704
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(vertexStride));
705
}
706

707
_MTL_INLINE MTL4::AccelerationStructureBoundingBoxGeometryDescriptor* MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::alloc()
708
{
709
    return NS::Object::alloc<MTL4::AccelerationStructureBoundingBoxGeometryDescriptor>(_MTL_PRIVATE_CLS(MTL4AccelerationStructureBoundingBoxGeometryDescriptor));
710
}
711

712
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxBuffer() const
713
{
714
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(boundingBoxBuffer));
715
}
716

717
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxCount() const
718
{
719
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxCount));
720
}
721

722
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::boundingBoxStride() const
723
{
724
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxStride));
725
}
726

727
_MTL_INLINE MTL4::AccelerationStructureBoundingBoxGeometryDescriptor* MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::init()
728
{
729
    return NS::Object::init<MTL4::AccelerationStructureBoundingBoxGeometryDescriptor>();
730
}
731

732
_MTL_INLINE void MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxBuffer(const MTL4::BufferRange boundingBoxBuffer)
733
{
734
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxBuffer_), boundingBoxBuffer);
735
}
736

737
_MTL_INLINE void MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxCount(NS::UInteger boundingBoxCount)
738
{
739
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxCount_), boundingBoxCount);
740
}
741

742
_MTL_INLINE void MTL4::AccelerationStructureBoundingBoxGeometryDescriptor::setBoundingBoxStride(NS::UInteger boundingBoxStride)
743
{
744
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxStride_), boundingBoxStride);
745
}
746

747
_MTL_INLINE MTL4::AccelerationStructureMotionTriangleGeometryDescriptor* MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::alloc()
748
{
749
    return NS::Object::alloc<MTL4::AccelerationStructureMotionTriangleGeometryDescriptor>(_MTL_PRIVATE_CLS(MTL4AccelerationStructureMotionTriangleGeometryDescriptor));
750
}
751

752
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::indexBuffer() const
753
{
754
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(indexBuffer));
755
}
756

757
_MTL_INLINE MTL::IndexType MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::indexType() const
758
{
759
    return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
760
}
761

762
_MTL_INLINE MTL4::AccelerationStructureMotionTriangleGeometryDescriptor* MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::init()
763
{
764
    return NS::Object::init<MTL4::AccelerationStructureMotionTriangleGeometryDescriptor>();
765
}
766

767
_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexBuffer(const MTL4::BufferRange indexBuffer)
768
{
769
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
770
}
771

772
_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setIndexType(MTL::IndexType indexType)
773
{
774
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
775
}
776

777
_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixBuffer(const MTL4::BufferRange transformationMatrixBuffer)
778
{
779
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixBuffer_), transformationMatrixBuffer);
780
}
781

782
_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setTransformationMatrixLayout(MTL::MatrixLayout transformationMatrixLayout)
783
{
784
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTransformationMatrixLayout_), transformationMatrixLayout);
785
}
786

787
_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setTriangleCount(NS::UInteger triangleCount)
788
{
789
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTriangleCount_), triangleCount);
790
}
791

792
_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexBuffers(const MTL4::BufferRange vertexBuffers)
793
{
794
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexBuffers_), vertexBuffers);
795
}
796

797
_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexFormat(MTL::AttributeFormat vertexFormat)
798
{
799
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexFormat_), vertexFormat);
800
}
801

802
_MTL_INLINE void MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::setVertexStride(NS::UInteger vertexStride)
803
{
804
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexStride_), vertexStride);
805
}
806

807
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixBuffer() const
808
{
809
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(transformationMatrixBuffer));
810
}
811

812
_MTL_INLINE MTL::MatrixLayout MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::transformationMatrixLayout() const
813
{
814
    return Object::sendMessage<MTL::MatrixLayout>(this, _MTL_PRIVATE_SEL(transformationMatrixLayout));
815
}
816

817
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::triangleCount() const
818
{
819
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(triangleCount));
820
}
821

822
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::vertexBuffers() const
823
{
824
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(vertexBuffers));
825
}
826

827
_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::vertexFormat() const
828
{
829
    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(vertexFormat));
830
}
831

832
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionTriangleGeometryDescriptor::vertexStride() const
833
{
834
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(vertexStride));
835
}
836

837
_MTL_INLINE MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::alloc()
838
{
839
    return NS::Object::alloc<MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor>(_MTL_PRIVATE_CLS(MTL4AccelerationStructureMotionBoundingBoxGeometryDescriptor));
840
}
841

842
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxBuffers() const
843
{
844
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(boundingBoxBuffers));
845
}
846

847
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxCount() const
848
{
849
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxCount));
850
}
851

852
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::boundingBoxStride() const
853
{
854
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(boundingBoxStride));
855
}
856

857
_MTL_INLINE MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor* MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::init()
858
{
859
    return NS::Object::init<MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor>();
860
}
861

862
_MTL_INLINE void MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxBuffers(const MTL4::BufferRange boundingBoxBuffers)
863
{
864
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxBuffers_), boundingBoxBuffers);
865
}
866

867
_MTL_INLINE void MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxCount(NS::UInteger boundingBoxCount)
868
{
869
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxCount_), boundingBoxCount);
870
}
871

872
_MTL_INLINE void MTL4::AccelerationStructureMotionBoundingBoxGeometryDescriptor::setBoundingBoxStride(NS::UInteger boundingBoxStride)
873
{
874
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBoundingBoxStride_), boundingBoxStride);
875
}
876

877
_MTL_INLINE MTL4::AccelerationStructureCurveGeometryDescriptor* MTL4::AccelerationStructureCurveGeometryDescriptor::alloc()
878
{
879
    return NS::Object::alloc<MTL4::AccelerationStructureCurveGeometryDescriptor>(_MTL_PRIVATE_CLS(MTL4AccelerationStructureCurveGeometryDescriptor));
880
}
881

882
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureCurveGeometryDescriptor::controlPointBuffer() const
883
{
884
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(controlPointBuffer));
885
}
886

887
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureCurveGeometryDescriptor::controlPointCount() const
888
{
889
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointCount));
890
}
891

892
_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureCurveGeometryDescriptor::controlPointFormat() const
893
{
894
    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(controlPointFormat));
895
}
896

897
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureCurveGeometryDescriptor::controlPointStride() const
898
{
899
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointStride));
900
}
901

902
_MTL_INLINE MTL::CurveBasis MTL4::AccelerationStructureCurveGeometryDescriptor::curveBasis() const
903
{
904
    return Object::sendMessage<MTL::CurveBasis>(this, _MTL_PRIVATE_SEL(curveBasis));
905
}
906

907
_MTL_INLINE MTL::CurveEndCaps MTL4::AccelerationStructureCurveGeometryDescriptor::curveEndCaps() const
908
{
909
    return Object::sendMessage<MTL::CurveEndCaps>(this, _MTL_PRIVATE_SEL(curveEndCaps));
910
}
911

912
_MTL_INLINE MTL::CurveType MTL4::AccelerationStructureCurveGeometryDescriptor::curveType() const
913
{
914
    return Object::sendMessage<MTL::CurveType>(this, _MTL_PRIVATE_SEL(curveType));
915
}
916

917
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureCurveGeometryDescriptor::indexBuffer() const
918
{
919
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(indexBuffer));
920
}
921

922
_MTL_INLINE MTL::IndexType MTL4::AccelerationStructureCurveGeometryDescriptor::indexType() const
923
{
924
    return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
925
}
926

927
_MTL_INLINE MTL4::AccelerationStructureCurveGeometryDescriptor* MTL4::AccelerationStructureCurveGeometryDescriptor::init()
928
{
929
    return NS::Object::init<MTL4::AccelerationStructureCurveGeometryDescriptor>();
930
}
931

932
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureCurveGeometryDescriptor::radiusBuffer() const
933
{
934
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(radiusBuffer));
935
}
936

937
_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureCurveGeometryDescriptor::radiusFormat() const
938
{
939
    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(radiusFormat));
940
}
941

942
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureCurveGeometryDescriptor::radiusStride() const
943
{
944
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(radiusStride));
945
}
946

947
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureCurveGeometryDescriptor::segmentControlPointCount() const
948
{
949
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentControlPointCount));
950
}
951

952
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureCurveGeometryDescriptor::segmentCount() const
953
{
954
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentCount));
955
}
956

957
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setControlPointBuffer(const MTL4::BufferRange controlPointBuffer)
958
{
959
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointBuffer_), controlPointBuffer);
960
}
961

962
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setControlPointCount(NS::UInteger controlPointCount)
963
{
964
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointCount_), controlPointCount);
965
}
966

967
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setControlPointFormat(MTL::AttributeFormat controlPointFormat)
968
{
969
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointFormat_), controlPointFormat);
970
}
971

972
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setControlPointStride(NS::UInteger controlPointStride)
973
{
974
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointStride_), controlPointStride);
975
}
976

977
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setCurveBasis(MTL::CurveBasis curveBasis)
978
{
979
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveBasis_), curveBasis);
980
}
981

982
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setCurveEndCaps(MTL::CurveEndCaps curveEndCaps)
983
{
984
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveEndCaps_), curveEndCaps);
985
}
986

987
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setCurveType(MTL::CurveType curveType)
988
{
989
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveType_), curveType);
990
}
991

992
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setIndexBuffer(const MTL4::BufferRange indexBuffer)
993
{
994
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
995
}
996

997
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setIndexType(MTL::IndexType indexType)
998
{
999
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
1000
}
1001

1002
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setRadiusBuffer(const MTL4::BufferRange radiusBuffer)
1003
{
1004
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusBuffer_), radiusBuffer);
1005
}
1006

1007
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setRadiusFormat(MTL::AttributeFormat radiusFormat)
1008
{
1009
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusFormat_), radiusFormat);
1010
}
1011

1012
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setRadiusStride(NS::UInteger radiusStride)
1013
{
1014
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusStride_), radiusStride);
1015
}
1016

1017
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setSegmentControlPointCount(NS::UInteger segmentControlPointCount)
1018
{
1019
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentControlPointCount_), segmentControlPointCount);
1020
}
1021

1022
_MTL_INLINE void MTL4::AccelerationStructureCurveGeometryDescriptor::setSegmentCount(NS::UInteger segmentCount)
1023
{
1024
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentCount_), segmentCount);
1025
}
1026

1027
_MTL_INLINE MTL4::AccelerationStructureMotionCurveGeometryDescriptor* MTL4::AccelerationStructureMotionCurveGeometryDescriptor::alloc()
1028
{
1029
    return NS::Object::alloc<MTL4::AccelerationStructureMotionCurveGeometryDescriptor>(_MTL_PRIVATE_CLS(MTL4AccelerationStructureMotionCurveGeometryDescriptor));
1030
}
1031

1032
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionCurveGeometryDescriptor::controlPointBuffers() const
1033
{
1034
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(controlPointBuffers));
1035
}
1036

1037
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionCurveGeometryDescriptor::controlPointCount() const
1038
{
1039
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointCount));
1040
}
1041

1042
_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureMotionCurveGeometryDescriptor::controlPointFormat() const
1043
{
1044
    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(controlPointFormat));
1045
}
1046

1047
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionCurveGeometryDescriptor::controlPointStride() const
1048
{
1049
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(controlPointStride));
1050
}
1051

1052
_MTL_INLINE MTL::CurveBasis MTL4::AccelerationStructureMotionCurveGeometryDescriptor::curveBasis() const
1053
{
1054
    return Object::sendMessage<MTL::CurveBasis>(this, _MTL_PRIVATE_SEL(curveBasis));
1055
}
1056

1057
_MTL_INLINE MTL::CurveEndCaps MTL4::AccelerationStructureMotionCurveGeometryDescriptor::curveEndCaps() const
1058
{
1059
    return Object::sendMessage<MTL::CurveEndCaps>(this, _MTL_PRIVATE_SEL(curveEndCaps));
1060
}
1061

1062
_MTL_INLINE MTL::CurveType MTL4::AccelerationStructureMotionCurveGeometryDescriptor::curveType() const
1063
{
1064
    return Object::sendMessage<MTL::CurveType>(this, _MTL_PRIVATE_SEL(curveType));
1065
}
1066

1067
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionCurveGeometryDescriptor::indexBuffer() const
1068
{
1069
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(indexBuffer));
1070
}
1071

1072
_MTL_INLINE MTL::IndexType MTL4::AccelerationStructureMotionCurveGeometryDescriptor::indexType() const
1073
{
1074
    return Object::sendMessage<MTL::IndexType>(this, _MTL_PRIVATE_SEL(indexType));
1075
}
1076

1077
_MTL_INLINE MTL4::AccelerationStructureMotionCurveGeometryDescriptor* MTL4::AccelerationStructureMotionCurveGeometryDescriptor::init()
1078
{
1079
    return NS::Object::init<MTL4::AccelerationStructureMotionCurveGeometryDescriptor>();
1080
}
1081

1082
_MTL_INLINE MTL4::BufferRange MTL4::AccelerationStructureMotionCurveGeometryDescriptor::radiusBuffers() const
1083
{
1084
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(radiusBuffers));
1085
}
1086

1087
_MTL_INLINE MTL::AttributeFormat MTL4::AccelerationStructureMotionCurveGeometryDescriptor::radiusFormat() const
1088
{
1089
    return Object::sendMessage<MTL::AttributeFormat>(this, _MTL_PRIVATE_SEL(radiusFormat));
1090
}
1091

1092
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionCurveGeometryDescriptor::radiusStride() const
1093
{
1094
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(radiusStride));
1095
}
1096

1097
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionCurveGeometryDescriptor::segmentControlPointCount() const
1098
{
1099
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentControlPointCount));
1100
}
1101

1102
_MTL_INLINE NS::UInteger MTL4::AccelerationStructureMotionCurveGeometryDescriptor::segmentCount() const
1103
{
1104
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(segmentCount));
1105
}
1106

1107
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointBuffers(const MTL4::BufferRange controlPointBuffers)
1108
{
1109
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointBuffers_), controlPointBuffers);
1110
}
1111

1112
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointCount(NS::UInteger controlPointCount)
1113
{
1114
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointCount_), controlPointCount);
1115
}
1116

1117
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointFormat(MTL::AttributeFormat controlPointFormat)
1118
{
1119
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointFormat_), controlPointFormat);
1120
}
1121

1122
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setControlPointStride(NS::UInteger controlPointStride)
1123
{
1124
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setControlPointStride_), controlPointStride);
1125
}
1126

1127
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setCurveBasis(MTL::CurveBasis curveBasis)
1128
{
1129
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveBasis_), curveBasis);
1130
}
1131

1132
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setCurveEndCaps(MTL::CurveEndCaps curveEndCaps)
1133
{
1134
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveEndCaps_), curveEndCaps);
1135
}
1136

1137
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setCurveType(MTL::CurveType curveType)
1138
{
1139
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setCurveType_), curveType);
1140
}
1141

1142
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setIndexBuffer(const MTL4::BufferRange indexBuffer)
1143
{
1144
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexBuffer_), indexBuffer);
1145
}
1146

1147
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setIndexType(MTL::IndexType indexType)
1148
{
1149
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setIndexType_), indexType);
1150
}
1151

1152
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusBuffers(const MTL4::BufferRange radiusBuffers)
1153
{
1154
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusBuffers_), radiusBuffers);
1155
}
1156

1157
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusFormat(MTL::AttributeFormat radiusFormat)
1158
{
1159
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusFormat_), radiusFormat);
1160
}
1161

1162
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setRadiusStride(NS::UInteger radiusStride)
1163
{
1164
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRadiusStride_), radiusStride);
1165
}
1166

1167
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setSegmentControlPointCount(NS::UInteger segmentControlPointCount)
1168
{
1169
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentControlPointCount_), segmentControlPointCount);
1170
}
1171

1172
_MTL_INLINE void MTL4::AccelerationStructureMotionCurveGeometryDescriptor::setSegmentCount(NS::UInteger segmentCount)
1173
{
1174
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSegmentCount_), segmentCount);
1175
}
1176

1177
_MTL_INLINE MTL4::InstanceAccelerationStructureDescriptor* MTL4::InstanceAccelerationStructureDescriptor::alloc()
1178
{
1179
    return NS::Object::alloc<MTL4::InstanceAccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTL4InstanceAccelerationStructureDescriptor));
1180
}
1181

1182
_MTL_INLINE MTL4::InstanceAccelerationStructureDescriptor* MTL4::InstanceAccelerationStructureDescriptor::init()
1183
{
1184
    return NS::Object::init<MTL4::InstanceAccelerationStructureDescriptor>();
1185
}
1186

1187
_MTL_INLINE NS::UInteger MTL4::InstanceAccelerationStructureDescriptor::instanceCount() const
1188
{
1189
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceCount));
1190
}
1191

1192
_MTL_INLINE MTL4::BufferRange MTL4::InstanceAccelerationStructureDescriptor::instanceDescriptorBuffer() const
1193
{
1194
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(instanceDescriptorBuffer));
1195
}
1196

1197
_MTL_INLINE NS::UInteger MTL4::InstanceAccelerationStructureDescriptor::instanceDescriptorStride() const
1198
{
1199
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceDescriptorStride));
1200
}
1201

1202
_MTL_INLINE MTL::AccelerationStructureInstanceDescriptorType MTL4::InstanceAccelerationStructureDescriptor::instanceDescriptorType() const
1203
{
1204
    return Object::sendMessage<MTL::AccelerationStructureInstanceDescriptorType>(this, _MTL_PRIVATE_SEL(instanceDescriptorType));
1205
}
1206

1207
_MTL_INLINE MTL::MatrixLayout MTL4::InstanceAccelerationStructureDescriptor::instanceTransformationMatrixLayout() const
1208
{
1209
    return Object::sendMessage<MTL::MatrixLayout>(this, _MTL_PRIVATE_SEL(instanceTransformationMatrixLayout));
1210
}
1211

1212
_MTL_INLINE MTL4::BufferRange MTL4::InstanceAccelerationStructureDescriptor::motionTransformBuffer() const
1213
{
1214
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(motionTransformBuffer));
1215
}
1216

1217
_MTL_INLINE NS::UInteger MTL4::InstanceAccelerationStructureDescriptor::motionTransformCount() const
1218
{
1219
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformCount));
1220
}
1221

1222
_MTL_INLINE NS::UInteger MTL4::InstanceAccelerationStructureDescriptor::motionTransformStride() const
1223
{
1224
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformStride));
1225
}
1226

1227
_MTL_INLINE MTL::TransformType MTL4::InstanceAccelerationStructureDescriptor::motionTransformType() const
1228
{
1229
    return Object::sendMessage<MTL::TransformType>(this, _MTL_PRIVATE_SEL(motionTransformType));
1230
}
1231

1232
_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setInstanceCount(NS::UInteger instanceCount)
1233
{
1234
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceCount_), instanceCount);
1235
}
1236

1237
_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setInstanceDescriptorBuffer(const MTL4::BufferRange instanceDescriptorBuffer)
1238
{
1239
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBuffer_), instanceDescriptorBuffer);
1240
}
1241

1242
_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride)
1243
{
1244
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorStride_), instanceDescriptorStride);
1245
}
1246

1247
_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType)
1248
{
1249
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorType_), instanceDescriptorType);
1250
}
1251

1252
_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout)
1253
{
1254
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceTransformationMatrixLayout_), instanceTransformationMatrixLayout);
1255
}
1256

1257
_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setMotionTransformBuffer(const MTL4::BufferRange motionTransformBuffer)
1258
{
1259
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformBuffer_), motionTransformBuffer);
1260
}
1261

1262
_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setMotionTransformCount(NS::UInteger motionTransformCount)
1263
{
1264
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformCount_), motionTransformCount);
1265
}
1266

1267
_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setMotionTransformStride(NS::UInteger motionTransformStride)
1268
{
1269
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformStride_), motionTransformStride);
1270
}
1271

1272
_MTL_INLINE void MTL4::InstanceAccelerationStructureDescriptor::setMotionTransformType(MTL::TransformType motionTransformType)
1273
{
1274
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformType_), motionTransformType);
1275
}
1276

1277
_MTL_INLINE MTL4::IndirectInstanceAccelerationStructureDescriptor* MTL4::IndirectInstanceAccelerationStructureDescriptor::alloc()
1278
{
1279
    return NS::Object::alloc<MTL4::IndirectInstanceAccelerationStructureDescriptor>(_MTL_PRIVATE_CLS(MTL4IndirectInstanceAccelerationStructureDescriptor));
1280
}
1281

1282
_MTL_INLINE MTL4::IndirectInstanceAccelerationStructureDescriptor* MTL4::IndirectInstanceAccelerationStructureDescriptor::init()
1283
{
1284
    return NS::Object::init<MTL4::IndirectInstanceAccelerationStructureDescriptor>();
1285
}
1286

1287
_MTL_INLINE MTL4::BufferRange MTL4::IndirectInstanceAccelerationStructureDescriptor::instanceCountBuffer() const
1288
{
1289
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(instanceCountBuffer));
1290
}
1291

1292
_MTL_INLINE MTL4::BufferRange MTL4::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorBuffer() const
1293
{
1294
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(instanceDescriptorBuffer));
1295
}
1296

1297
_MTL_INLINE NS::UInteger MTL4::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorStride() const
1298
{
1299
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(instanceDescriptorStride));
1300
}
1301

1302
_MTL_INLINE MTL::AccelerationStructureInstanceDescriptorType MTL4::IndirectInstanceAccelerationStructureDescriptor::instanceDescriptorType() const
1303
{
1304
    return Object::sendMessage<MTL::AccelerationStructureInstanceDescriptorType>(this, _MTL_PRIVATE_SEL(instanceDescriptorType));
1305
}
1306

1307
_MTL_INLINE MTL::MatrixLayout MTL4::IndirectInstanceAccelerationStructureDescriptor::instanceTransformationMatrixLayout() const
1308
{
1309
    return Object::sendMessage<MTL::MatrixLayout>(this, _MTL_PRIVATE_SEL(instanceTransformationMatrixLayout));
1310
}
1311

1312
_MTL_INLINE NS::UInteger MTL4::IndirectInstanceAccelerationStructureDescriptor::maxInstanceCount() const
1313
{
1314
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxInstanceCount));
1315
}
1316

1317
_MTL_INLINE NS::UInteger MTL4::IndirectInstanceAccelerationStructureDescriptor::maxMotionTransformCount() const
1318
{
1319
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxMotionTransformCount));
1320
}
1321

1322
_MTL_INLINE MTL4::BufferRange MTL4::IndirectInstanceAccelerationStructureDescriptor::motionTransformBuffer() const
1323
{
1324
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(motionTransformBuffer));
1325
}
1326

1327
_MTL_INLINE MTL4::BufferRange MTL4::IndirectInstanceAccelerationStructureDescriptor::motionTransformCountBuffer() const
1328
{
1329
    return Object::sendMessage<MTL4::BufferRange>(this, _MTL_PRIVATE_SEL(motionTransformCountBuffer));
1330
}
1331

1332
_MTL_INLINE NS::UInteger MTL4::IndirectInstanceAccelerationStructureDescriptor::motionTransformStride() const
1333
{
1334
    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(motionTransformStride));
1335
}
1336

1337
_MTL_INLINE MTL::TransformType MTL4::IndirectInstanceAccelerationStructureDescriptor::motionTransformType() const
1338
{
1339
    return Object::sendMessage<MTL::TransformType>(this, _MTL_PRIVATE_SEL(motionTransformType));
1340
}
1341

1342
_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setInstanceCountBuffer(const MTL4::BufferRange instanceCountBuffer)
1343
{
1344
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceCountBuffer_), instanceCountBuffer);
1345
}
1346

1347
_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorBuffer(const MTL4::BufferRange instanceDescriptorBuffer)
1348
{
1349
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorBuffer_), instanceDescriptorBuffer);
1350
}
1351

1352
_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorStride(NS::UInteger instanceDescriptorStride)
1353
{
1354
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorStride_), instanceDescriptorStride);
1355
}
1356

1357
_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setInstanceDescriptorType(MTL::AccelerationStructureInstanceDescriptorType instanceDescriptorType)
1358
{
1359
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceDescriptorType_), instanceDescriptorType);
1360
}
1361

1362
_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setInstanceTransformationMatrixLayout(MTL::MatrixLayout instanceTransformationMatrixLayout)
1363
{
1364
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInstanceTransformationMatrixLayout_), instanceTransformationMatrixLayout);
1365
}
1366

1367
_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMaxInstanceCount(NS::UInteger maxInstanceCount)
1368
{
1369
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxInstanceCount_), maxInstanceCount);
1370
}
1371

1372
_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMaxMotionTransformCount(NS::UInteger maxMotionTransformCount)
1373
{
1374
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxMotionTransformCount_), maxMotionTransformCount);
1375
}
1376

1377
_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformBuffer(const MTL4::BufferRange motionTransformBuffer)
1378
{
1379
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformBuffer_), motionTransformBuffer);
1380
}
1381

1382
_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformCountBuffer(const MTL4::BufferRange motionTransformCountBuffer)
1383
{
1384
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformCountBuffer_), motionTransformCountBuffer);
1385
}
1386

1387
_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformStride(NS::UInteger motionTransformStride)
1388
{
1389
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformStride_), motionTransformStride);
1390
}
1391

1392
_MTL_INLINE void MTL4::IndirectInstanceAccelerationStructureDescriptor::setMotionTransformType(MTL::TransformType motionTransformType)
1393
{
1394
    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMotionTransformType_), motionTransformType);
1395
}
1396

1397
Product

Resources

Company
