yum-mirror/VkFFT

git clone https://git.yummers.dev/yum-mirror/VkFFT

Tolmachev DmitriiMetal support in VkFFTba7001c

master
branchesdevelopmasterall refs →
52.5 KiB1212 linesraw
1//-------------------------------------------------------------------------------------------------------------------------------------------------------------
2//
3// Metal/MTLRenderPipeline.hpp
4//
5// Copyright 2020-2021 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 "MTLPixelFormat.hpp"
30#include "MTLRenderCommandEncoder.hpp"
31#include "MTLRenderPipeline.hpp"
32#include "MTLTypes.hpp"
33
34namespace MTL
35{
36_MTL_ENUM(NS::UInteger, BlendFactor) {
37    BlendFactorZero = 0,
38    BlendFactorOne = 1,
39    BlendFactorSourceColor = 2,
40    BlendFactorOneMinusSourceColor = 3,
41    BlendFactorSourceAlpha = 4,
42    BlendFactorOneMinusSourceAlpha = 5,
43    BlendFactorDestinationColor = 6,
44    BlendFactorOneMinusDestinationColor = 7,
45    BlendFactorDestinationAlpha = 8,
46    BlendFactorOneMinusDestinationAlpha = 9,
47    BlendFactorSourceAlphaSaturated = 10,
48    BlendFactorBlendColor = 11,
49    BlendFactorOneMinusBlendColor = 12,
50    BlendFactorBlendAlpha = 13,
51    BlendFactorOneMinusBlendAlpha = 14,
52    BlendFactorSource1Color = 15,
53    BlendFactorOneMinusSource1Color = 16,
54    BlendFactorSource1Alpha = 17,
55    BlendFactorOneMinusSource1Alpha = 18,
56};
57
58_MTL_ENUM(NS::UInteger, BlendOperation) {
59    BlendOperationAdd = 0,
60    BlendOperationSubtract = 1,
61    BlendOperationReverseSubtract = 2,
62    BlendOperationMin = 3,
63    BlendOperationMax = 4,
64};
65
66_MTL_OPTIONS(NS::UInteger, ColorWriteMask) {
67    ColorWriteMaskNone = 0,
68    ColorWriteMaskAlpha = 1,
69    ColorWriteMaskBlue = 2,
70    ColorWriteMaskGreen = 4,
71    ColorWriteMaskRed = 8,
72    ColorWriteMaskAll = 15,
73};
74
75_MTL_ENUM(NS::UInteger, PrimitiveTopologyClass) {
76    PrimitiveTopologyClassUnspecified = 0,
77    PrimitiveTopologyClassPoint = 1,
78    PrimitiveTopologyClassLine = 2,
79    PrimitiveTopologyClassTriangle = 3,
80};
81
82_MTL_ENUM(NS::UInteger, TessellationPartitionMode) {
83    TessellationPartitionModePow2 = 0,
84    TessellationPartitionModeInteger = 1,
85    TessellationPartitionModeFractionalOdd = 2,
86    TessellationPartitionModeFractionalEven = 3,
87};
88
89_MTL_ENUM(NS::UInteger, TessellationFactorStepFunction) {
90    TessellationFactorStepFunctionConstant = 0,
91    TessellationFactorStepFunctionPerPatch = 1,
92    TessellationFactorStepFunctionPerInstance = 2,
93    TessellationFactorStepFunctionPerPatchAndPerInstance = 3,
94};
95
96_MTL_ENUM(NS::UInteger, TessellationFactorFormat) {
97    TessellationFactorFormatHalf = 0,
98};
99
100_MTL_ENUM(NS::UInteger, TessellationControlPointIndexType) {
101    TessellationControlPointIndexTypeNone = 0,
102    TessellationControlPointIndexTypeUInt16 = 1,
103    TessellationControlPointIndexTypeUInt32 = 2,
104};
105
106class RenderPipelineColorAttachmentDescriptor : public NS::Copying<RenderPipelineColorAttachmentDescriptor>
107{
108public:
109    static class RenderPipelineColorAttachmentDescriptor* alloc();
110
111    class RenderPipelineColorAttachmentDescriptor*        init();
112
113    MTL::PixelFormat                                      pixelFormat() const;
114    void                                                  setPixelFormat(MTL::PixelFormat pixelFormat);
115
116    bool                                                  blendingEnabled() const;
117    void                                                  setBlendingEnabled(bool blendingEnabled);
118
119    MTL::BlendFactor                                      sourceRGBBlendFactor() const;
120    void                                                  setSourceRGBBlendFactor(MTL::BlendFactor sourceRGBBlendFactor);
121
122    MTL::BlendFactor                                      destinationRGBBlendFactor() const;
123    void                                                  setDestinationRGBBlendFactor(MTL::BlendFactor destinationRGBBlendFactor);
124
125    MTL::BlendOperation                                   rgbBlendOperation() const;
126    void                                                  setRgbBlendOperation(MTL::BlendOperation rgbBlendOperation);
127
128    MTL::BlendFactor                                      sourceAlphaBlendFactor() const;
129    void                                                  setSourceAlphaBlendFactor(MTL::BlendFactor sourceAlphaBlendFactor);
130
131    MTL::BlendFactor                                      destinationAlphaBlendFactor() const;
132    void                                                  setDestinationAlphaBlendFactor(MTL::BlendFactor destinationAlphaBlendFactor);
133
134    MTL::BlendOperation                                   alphaBlendOperation() const;
135    void                                                  setAlphaBlendOperation(MTL::BlendOperation alphaBlendOperation);
136
137    MTL::ColorWriteMask                                   writeMask() const;
138    void                                                  setWriteMask(MTL::ColorWriteMask writeMask);
139};
140
141class RenderPipelineReflection : public NS::Referencing<RenderPipelineReflection>
142{
143public:
144    static class RenderPipelineReflection* alloc();
145
146    class RenderPipelineReflection*        init();
147
148    NS::Array*                             vertexArguments() const;
149
150    NS::Array*                             fragmentArguments() const;
151
152    NS::Array*                             tileArguments() const;
153};
154
155class RenderPipelineDescriptor : public NS::Copying<RenderPipelineDescriptor>
156{
157public:
158    static class RenderPipelineDescriptor*              alloc();
159
160    class RenderPipelineDescriptor*                     init();
161
162    NS::String*                                         label() const;
163    void                                                setLabel(const NS::String* label);
164
165    class Function*                                     vertexFunction() const;
166    void                                                setVertexFunction(const class Function* vertexFunction);
167
168    class Function*                                     fragmentFunction() const;
169    void                                                setFragmentFunction(const class Function* fragmentFunction);
170
171    class VertexDescriptor*                             vertexDescriptor() const;
172    void                                                setVertexDescriptor(const class VertexDescriptor* vertexDescriptor);
173
174    NS::UInteger                                        sampleCount() const;
175    void                                                setSampleCount(NS::UInteger sampleCount);
176
177    NS::UInteger                                        rasterSampleCount() const;
178    void                                                setRasterSampleCount(NS::UInteger rasterSampleCount);
179
180    bool                                                alphaToCoverageEnabled() const;
181    void                                                setAlphaToCoverageEnabled(bool alphaToCoverageEnabled);
182
183    bool                                                alphaToOneEnabled() const;
184    void                                                setAlphaToOneEnabled(bool alphaToOneEnabled);
185
186    bool                                                rasterizationEnabled() const;
187    void                                                setRasterizationEnabled(bool rasterizationEnabled);
188
189    NS::UInteger                                        maxVertexAmplificationCount() const;
190    void                                                setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount);
191
192    class RenderPipelineColorAttachmentDescriptorArray* colorAttachments() const;
193
194    MTL::PixelFormat                                    depthAttachmentPixelFormat() const;
195    void                                                setDepthAttachmentPixelFormat(MTL::PixelFormat depthAttachmentPixelFormat);
196
197    MTL::PixelFormat                                    stencilAttachmentPixelFormat() const;
198    void                                                setStencilAttachmentPixelFormat(MTL::PixelFormat stencilAttachmentPixelFormat);
199
200    MTL::PrimitiveTopologyClass                         inputPrimitiveTopology() const;
201    void                                                setInputPrimitiveTopology(MTL::PrimitiveTopologyClass inputPrimitiveTopology);
202
203    MTL::TessellationPartitionMode                      tessellationPartitionMode() const;
204    void                                                setTessellationPartitionMode(MTL::TessellationPartitionMode tessellationPartitionMode);
205
206    NS::UInteger                                        maxTessellationFactor() const;
207    void                                                setMaxTessellationFactor(NS::UInteger maxTessellationFactor);
208
209    bool                                                tessellationFactorScaleEnabled() const;
210    void                                                setTessellationFactorScaleEnabled(bool tessellationFactorScaleEnabled);
211
212    MTL::TessellationFactorFormat                       tessellationFactorFormat() const;
213    void                                                setTessellationFactorFormat(MTL::TessellationFactorFormat tessellationFactorFormat);
214
215    MTL::TessellationControlPointIndexType              tessellationControlPointIndexType() const;
216    void                                                setTessellationControlPointIndexType(MTL::TessellationControlPointIndexType tessellationControlPointIndexType);
217
218    MTL::TessellationFactorStepFunction                 tessellationFactorStepFunction() const;
219    void                                                setTessellationFactorStepFunction(MTL::TessellationFactorStepFunction tessellationFactorStepFunction);
220
221    MTL::Winding                                        tessellationOutputWindingOrder() const;
222    void                                                setTessellationOutputWindingOrder(MTL::Winding tessellationOutputWindingOrder);
223
224    class PipelineBufferDescriptorArray*                vertexBuffers() const;
225
226    class PipelineBufferDescriptorArray*                fragmentBuffers() const;
227
228    bool                                                supportIndirectCommandBuffers() const;
229    void                                                setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers);
230
231    NS::Array*                                          binaryArchives() const;
232    void                                                setBinaryArchives(const NS::Array* binaryArchives);
233
234    NS::Array*                                          vertexPreloadedLibraries() const;
235    void                                                setVertexPreloadedLibraries(const NS::Array* vertexPreloadedLibraries);
236
237    NS::Array*                                          fragmentPreloadedLibraries() const;
238    void                                                setFragmentPreloadedLibraries(const NS::Array* fragmentPreloadedLibraries);
239
240    class LinkedFunctions*                              vertexLinkedFunctions() const;
241    void                                                setVertexLinkedFunctions(const class LinkedFunctions* vertexLinkedFunctions);
242
243    class LinkedFunctions*                              fragmentLinkedFunctions() const;
244    void                                                setFragmentLinkedFunctions(const class LinkedFunctions* fragmentLinkedFunctions);
245
246    bool                                                supportAddingVertexBinaryFunctions() const;
247    void                                                setSupportAddingVertexBinaryFunctions(bool supportAddingVertexBinaryFunctions);
248
249    bool                                                supportAddingFragmentBinaryFunctions() const;
250    void                                                setSupportAddingFragmentBinaryFunctions(bool supportAddingFragmentBinaryFunctions);
251
252    NS::UInteger                                        maxVertexCallStackDepth() const;
253    void                                                setMaxVertexCallStackDepth(NS::UInteger maxVertexCallStackDepth);
254
255    NS::UInteger                                        maxFragmentCallStackDepth() const;
256    void                                                setMaxFragmentCallStackDepth(NS::UInteger maxFragmentCallStackDepth);
257
258    void                                                reset();
259};
260
261class RenderPipelineFunctionsDescriptor : public NS::Copying<RenderPipelineFunctionsDescriptor>
262{
263public:
264    static class RenderPipelineFunctionsDescriptor* alloc();
265
266    class RenderPipelineFunctionsDescriptor*        init();
267
268    NS::Array*                                      vertexAdditionalBinaryFunctions() const;
269    void                                            setVertexAdditionalBinaryFunctions(const NS::Array* vertexAdditionalBinaryFunctions);
270
271    NS::Array*                                      fragmentAdditionalBinaryFunctions() const;
272    void                                            setFragmentAdditionalBinaryFunctions(const NS::Array* fragmentAdditionalBinaryFunctions);
273
274    NS::Array*                                      tileAdditionalBinaryFunctions() const;
275    void                                            setTileAdditionalBinaryFunctions(const NS::Array* tileAdditionalBinaryFunctions);
276};
277
278class RenderPipelineState : public NS::Referencing<RenderPipelineState>
279{
280public:
281    NS::String*                      label() const;
282
283    class Device*                    device() const;
284
285    NS::UInteger                     maxTotalThreadsPerThreadgroup() const;
286
287    bool                             threadgroupSizeMatchesTileSize() const;
288
289    NS::UInteger                     imageblockSampleLength() const;
290
291    NS::UInteger                     imageblockMemoryLength(MTL::Size imageblockDimensions);
292
293    bool                             supportIndirectCommandBuffers() const;
294
295    class FunctionHandle*            functionHandle(const class Function* function, MTL::RenderStages stage);
296
297    class VisibleFunctionTable*      newVisibleFunctionTable(const class VisibleFunctionTableDescriptor* descriptor, MTL::RenderStages stage);
298
299    class IntersectionFunctionTable* newIntersectionFunctionTable(const class IntersectionFunctionTableDescriptor* descriptor, MTL::RenderStages stage);
300
301    class RenderPipelineState*       newRenderPipelineState(const class RenderPipelineFunctionsDescriptor* additionalBinaryFunctions, NS::Error** error);
302};
303
304class RenderPipelineColorAttachmentDescriptorArray : public NS::Referencing<RenderPipelineColorAttachmentDescriptorArray>
305{
306public:
307    static class RenderPipelineColorAttachmentDescriptorArray* alloc();
308
309    class RenderPipelineColorAttachmentDescriptorArray*        init();
310
311    class RenderPipelineColorAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
312
313    void                                                       setObject(const class RenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
314};
315
316class TileRenderPipelineColorAttachmentDescriptor : public NS::Copying<TileRenderPipelineColorAttachmentDescriptor>
317{
318public:
319    static class TileRenderPipelineColorAttachmentDescriptor* alloc();
320
321    class TileRenderPipelineColorAttachmentDescriptor*        init();
322
323    MTL::PixelFormat                                          pixelFormat() const;
324    void                                                      setPixelFormat(MTL::PixelFormat pixelFormat);
325};
326
327class TileRenderPipelineColorAttachmentDescriptorArray : public NS::Referencing<TileRenderPipelineColorAttachmentDescriptorArray>
328{
329public:
330    static class TileRenderPipelineColorAttachmentDescriptorArray* alloc();
331
332    class TileRenderPipelineColorAttachmentDescriptorArray*        init();
333
334    class TileRenderPipelineColorAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
335
336    void                                                           setObject(const class TileRenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
337};
338
339class TileRenderPipelineDescriptor : public NS::Copying<TileRenderPipelineDescriptor>
340{
341public:
342    static class TileRenderPipelineDescriptor*              alloc();
343
344    class TileRenderPipelineDescriptor*                     init();
345
346    NS::String*                                             label() const;
347    void                                                    setLabel(const NS::String* label);
348
349    class Function*                                         tileFunction() const;
350    void                                                    setTileFunction(const class Function* tileFunction);
351
352    NS::UInteger                                            rasterSampleCount() const;
353    void                                                    setRasterSampleCount(NS::UInteger rasterSampleCount);
354
355    class TileRenderPipelineColorAttachmentDescriptorArray* colorAttachments() const;
356
357    bool                                                    threadgroupSizeMatchesTileSize() const;
358    void                                                    setThreadgroupSizeMatchesTileSize(bool threadgroupSizeMatchesTileSize);
359
360    class PipelineBufferDescriptorArray*                    tileBuffers() const;
361
362    NS::UInteger                                            maxTotalThreadsPerThreadgroup() const;
363    void                                                    setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup);
364
365    NS::Array*                                              binaryArchives() const;
366    void                                                    setBinaryArchives(const NS::Array* binaryArchives);
367
368    NS::Array*                                              preloadedLibraries() const;
369    void                                                    setPreloadedLibraries(const NS::Array* preloadedLibraries);
370
371    class LinkedFunctions*                                  linkedFunctions() const;
372    void                                                    setLinkedFunctions(const class LinkedFunctions* linkedFunctions);
373
374    bool                                                    supportAddingBinaryFunctions() const;
375    void                                                    setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions);
376
377    NS::UInteger                                            maxCallStackDepth() const;
378    void                                                    setMaxCallStackDepth(NS::UInteger maxCallStackDepth);
379
380    void                                                    reset();
381};
382
383}
384
385// static method: alloc
386_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptor* MTL::RenderPipelineColorAttachmentDescriptor::alloc()
387{
388    return NS::Object::alloc<MTL::RenderPipelineColorAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPipelineColorAttachmentDescriptor));
389}
390
391// method: init
392_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptor* MTL::RenderPipelineColorAttachmentDescriptor::init()
393{
394    return NS::Object::init<MTL::RenderPipelineColorAttachmentDescriptor>();
395}
396
397// property: pixelFormat
398_MTL_INLINE MTL::PixelFormat MTL::RenderPipelineColorAttachmentDescriptor::pixelFormat() const
399{
400    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(pixelFormat));
401}
402
403_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setPixelFormat(MTL::PixelFormat pixelFormat)
404{
405    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPixelFormat_), pixelFormat);
406}
407
408// property: blendingEnabled
409_MTL_INLINE bool MTL::RenderPipelineColorAttachmentDescriptor::blendingEnabled() const
410{
411    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isBlendingEnabled));
412}
413
414_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setBlendingEnabled(bool blendingEnabled)
415{
416    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBlendingEnabled_), blendingEnabled);
417}
418
419// property: sourceRGBBlendFactor
420_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::sourceRGBBlendFactor() const
421{
422    return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(sourceRGBBlendFactor));
423}
424
425_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setSourceRGBBlendFactor(MTL::BlendFactor sourceRGBBlendFactor)
426{
427    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSourceRGBBlendFactor_), sourceRGBBlendFactor);
428}
429
430// property: destinationRGBBlendFactor
431_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::destinationRGBBlendFactor() const
432{
433    return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(destinationRGBBlendFactor));
434}
435
436_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setDestinationRGBBlendFactor(MTL::BlendFactor destinationRGBBlendFactor)
437{
438    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDestinationRGBBlendFactor_), destinationRGBBlendFactor);
439}
440
441// property: rgbBlendOperation
442_MTL_INLINE MTL::BlendOperation MTL::RenderPipelineColorAttachmentDescriptor::rgbBlendOperation() const
443{
444    return Object::sendMessage<MTL::BlendOperation>(this, _MTL_PRIVATE_SEL(rgbBlendOperation));
445}
446
447_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setRgbBlendOperation(MTL::BlendOperation rgbBlendOperation)
448{
449    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRgbBlendOperation_), rgbBlendOperation);
450}
451
452// property: sourceAlphaBlendFactor
453_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::sourceAlphaBlendFactor() const
454{
455    return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(sourceAlphaBlendFactor));
456}
457
458_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setSourceAlphaBlendFactor(MTL::BlendFactor sourceAlphaBlendFactor)
459{
460    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSourceAlphaBlendFactor_), sourceAlphaBlendFactor);
461}
462
463// property: destinationAlphaBlendFactor
464_MTL_INLINE MTL::BlendFactor MTL::RenderPipelineColorAttachmentDescriptor::destinationAlphaBlendFactor() const
465{
466    return Object::sendMessage<MTL::BlendFactor>(this, _MTL_PRIVATE_SEL(destinationAlphaBlendFactor));
467}
468
469_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setDestinationAlphaBlendFactor(MTL::BlendFactor destinationAlphaBlendFactor)
470{
471    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDestinationAlphaBlendFactor_), destinationAlphaBlendFactor);
472}
473
474// property: alphaBlendOperation
475_MTL_INLINE MTL::BlendOperation MTL::RenderPipelineColorAttachmentDescriptor::alphaBlendOperation() const
476{
477    return Object::sendMessage<MTL::BlendOperation>(this, _MTL_PRIVATE_SEL(alphaBlendOperation));
478}
479
480_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setAlphaBlendOperation(MTL::BlendOperation alphaBlendOperation)
481{
482    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaBlendOperation_), alphaBlendOperation);
483}
484
485// property: writeMask
486_MTL_INLINE MTL::ColorWriteMask MTL::RenderPipelineColorAttachmentDescriptor::writeMask() const
487{
488    return Object::sendMessage<MTL::ColorWriteMask>(this, _MTL_PRIVATE_SEL(writeMask));
489}
490
491_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptor::setWriteMask(MTL::ColorWriteMask writeMask)
492{
493    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setWriteMask_), writeMask);
494}
495
496// static method: alloc
497_MTL_INLINE MTL::RenderPipelineReflection* MTL::RenderPipelineReflection::alloc()
498{
499    return NS::Object::alloc<MTL::RenderPipelineReflection>(_MTL_PRIVATE_CLS(MTLRenderPipelineReflection));
500}
501
502// method: init
503_MTL_INLINE MTL::RenderPipelineReflection* MTL::RenderPipelineReflection::init()
504{
505    return NS::Object::init<MTL::RenderPipelineReflection>();
506}
507
508// property: vertexArguments
509_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::vertexArguments() const
510{
511    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexArguments));
512}
513
514// property: fragmentArguments
515_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::fragmentArguments() const
516{
517    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(fragmentArguments));
518}
519
520// property: tileArguments
521_MTL_INLINE NS::Array* MTL::RenderPipelineReflection::tileArguments() const
522{
523    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(tileArguments));
524}
525
526// static method: alloc
527_MTL_INLINE MTL::RenderPipelineDescriptor* MTL::RenderPipelineDescriptor::alloc()
528{
529    return NS::Object::alloc<MTL::RenderPipelineDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPipelineDescriptor));
530}
531
532// method: init
533_MTL_INLINE MTL::RenderPipelineDescriptor* MTL::RenderPipelineDescriptor::init()
534{
535    return NS::Object::init<MTL::RenderPipelineDescriptor>();
536}
537
538// property: label
539_MTL_INLINE NS::String* MTL::RenderPipelineDescriptor::label() const
540{
541    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
542}
543
544_MTL_INLINE void MTL::RenderPipelineDescriptor::setLabel(const NS::String* label)
545{
546    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
547}
548
549// property: vertexFunction
550_MTL_INLINE MTL::Function* MTL::RenderPipelineDescriptor::vertexFunction() const
551{
552    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(vertexFunction));
553}
554
555_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexFunction(const MTL::Function* vertexFunction)
556{
557    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexFunction_), vertexFunction);
558}
559
560// property: fragmentFunction
561_MTL_INLINE MTL::Function* MTL::RenderPipelineDescriptor::fragmentFunction() const
562{
563    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(fragmentFunction));
564}
565
566_MTL_INLINE void MTL::RenderPipelineDescriptor::setFragmentFunction(const MTL::Function* fragmentFunction)
567{
568    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentFunction_), fragmentFunction);
569}
570
571// property: vertexDescriptor
572_MTL_INLINE MTL::VertexDescriptor* MTL::RenderPipelineDescriptor::vertexDescriptor() const
573{
574    return Object::sendMessage<MTL::VertexDescriptor*>(this, _MTL_PRIVATE_SEL(vertexDescriptor));
575}
576
577_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexDescriptor(const MTL::VertexDescriptor* vertexDescriptor)
578{
579    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexDescriptor_), vertexDescriptor);
580}
581
582// property: sampleCount
583_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::sampleCount() const
584{
585    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(sampleCount));
586}
587
588_MTL_INLINE void MTL::RenderPipelineDescriptor::setSampleCount(NS::UInteger sampleCount)
589{
590    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleCount_), sampleCount);
591}
592
593// property: rasterSampleCount
594_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::rasterSampleCount() const
595{
596    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(rasterSampleCount));
597}
598
599_MTL_INLINE void MTL::RenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount)
600{
601    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount);
602}
603
604// property: alphaToCoverageEnabled
605_MTL_INLINE bool MTL::RenderPipelineDescriptor::alphaToCoverageEnabled() const
606{
607    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isAlphaToCoverageEnabled));
608}
609
610_MTL_INLINE void MTL::RenderPipelineDescriptor::setAlphaToCoverageEnabled(bool alphaToCoverageEnabled)
611{
612    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaToCoverageEnabled_), alphaToCoverageEnabled);
613}
614
615// property: alphaToOneEnabled
616_MTL_INLINE bool MTL::RenderPipelineDescriptor::alphaToOneEnabled() const
617{
618    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isAlphaToOneEnabled));
619}
620
621_MTL_INLINE void MTL::RenderPipelineDescriptor::setAlphaToOneEnabled(bool alphaToOneEnabled)
622{
623    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setAlphaToOneEnabled_), alphaToOneEnabled);
624}
625
626// property: rasterizationEnabled
627_MTL_INLINE bool MTL::RenderPipelineDescriptor::rasterizationEnabled() const
628{
629    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isRasterizationEnabled));
630}
631
632_MTL_INLINE void MTL::RenderPipelineDescriptor::setRasterizationEnabled(bool rasterizationEnabled)
633{
634    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterizationEnabled_), rasterizationEnabled);
635}
636
637// property: maxVertexAmplificationCount
638_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxVertexAmplificationCount() const
639{
640    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxVertexAmplificationCount));
641}
642
643_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxVertexAmplificationCount(NS::UInteger maxVertexAmplificationCount)
644{
645    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxVertexAmplificationCount_), maxVertexAmplificationCount);
646}
647
648// property: colorAttachments
649_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptorArray* MTL::RenderPipelineDescriptor::colorAttachments() const
650{
651    return Object::sendMessage<MTL::RenderPipelineColorAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(colorAttachments));
652}
653
654// property: depthAttachmentPixelFormat
655_MTL_INLINE MTL::PixelFormat MTL::RenderPipelineDescriptor::depthAttachmentPixelFormat() const
656{
657    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(depthAttachmentPixelFormat));
658}
659
660_MTL_INLINE void MTL::RenderPipelineDescriptor::setDepthAttachmentPixelFormat(MTL::PixelFormat depthAttachmentPixelFormat)
661{
662    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthAttachmentPixelFormat_), depthAttachmentPixelFormat);
663}
664
665// property: stencilAttachmentPixelFormat
666_MTL_INLINE MTL::PixelFormat MTL::RenderPipelineDescriptor::stencilAttachmentPixelFormat() const
667{
668    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(stencilAttachmentPixelFormat));
669}
670
671_MTL_INLINE void MTL::RenderPipelineDescriptor::setStencilAttachmentPixelFormat(MTL::PixelFormat stencilAttachmentPixelFormat)
672{
673    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilAttachmentPixelFormat_), stencilAttachmentPixelFormat);
674}
675
676// property: inputPrimitiveTopology
677_MTL_INLINE MTL::PrimitiveTopologyClass MTL::RenderPipelineDescriptor::inputPrimitiveTopology() const
678{
679    return Object::sendMessage<MTL::PrimitiveTopologyClass>(this, _MTL_PRIVATE_SEL(inputPrimitiveTopology));
680}
681
682_MTL_INLINE void MTL::RenderPipelineDescriptor::setInputPrimitiveTopology(MTL::PrimitiveTopologyClass inputPrimitiveTopology)
683{
684    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setInputPrimitiveTopology_), inputPrimitiveTopology);
685}
686
687// property: tessellationPartitionMode
688_MTL_INLINE MTL::TessellationPartitionMode MTL::RenderPipelineDescriptor::tessellationPartitionMode() const
689{
690    return Object::sendMessage<MTL::TessellationPartitionMode>(this, _MTL_PRIVATE_SEL(tessellationPartitionMode));
691}
692
693_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationPartitionMode(MTL::TessellationPartitionMode tessellationPartitionMode)
694{
695    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationPartitionMode_), tessellationPartitionMode);
696}
697
698// property: maxTessellationFactor
699_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxTessellationFactor() const
700{
701    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTessellationFactor));
702}
703
704_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxTessellationFactor(NS::UInteger maxTessellationFactor)
705{
706    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTessellationFactor_), maxTessellationFactor);
707}
708
709// property: tessellationFactorScaleEnabled
710_MTL_INLINE bool MTL::RenderPipelineDescriptor::tessellationFactorScaleEnabled() const
711{
712    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isTessellationFactorScaleEnabled));
713}
714
715_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationFactorScaleEnabled(bool tessellationFactorScaleEnabled)
716{
717    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationFactorScaleEnabled_), tessellationFactorScaleEnabled);
718}
719
720// property: tessellationFactorFormat
721_MTL_INLINE MTL::TessellationFactorFormat MTL::RenderPipelineDescriptor::tessellationFactorFormat() const
722{
723    return Object::sendMessage<MTL::TessellationFactorFormat>(this, _MTL_PRIVATE_SEL(tessellationFactorFormat));
724}
725
726_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationFactorFormat(MTL::TessellationFactorFormat tessellationFactorFormat)
727{
728    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationFactorFormat_), tessellationFactorFormat);
729}
730
731// property: tessellationControlPointIndexType
732_MTL_INLINE MTL::TessellationControlPointIndexType MTL::RenderPipelineDescriptor::tessellationControlPointIndexType() const
733{
734    return Object::sendMessage<MTL::TessellationControlPointIndexType>(this, _MTL_PRIVATE_SEL(tessellationControlPointIndexType));
735}
736
737_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationControlPointIndexType(MTL::TessellationControlPointIndexType tessellationControlPointIndexType)
738{
739    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationControlPointIndexType_), tessellationControlPointIndexType);
740}
741
742// property: tessellationFactorStepFunction
743_MTL_INLINE MTL::TessellationFactorStepFunction MTL::RenderPipelineDescriptor::tessellationFactorStepFunction() const
744{
745    return Object::sendMessage<MTL::TessellationFactorStepFunction>(this, _MTL_PRIVATE_SEL(tessellationFactorStepFunction));
746}
747
748_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationFactorStepFunction(MTL::TessellationFactorStepFunction tessellationFactorStepFunction)
749{
750    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationFactorStepFunction_), tessellationFactorStepFunction);
751}
752
753// property: tessellationOutputWindingOrder
754_MTL_INLINE MTL::Winding MTL::RenderPipelineDescriptor::tessellationOutputWindingOrder() const
755{
756    return Object::sendMessage<MTL::Winding>(this, _MTL_PRIVATE_SEL(tessellationOutputWindingOrder));
757}
758
759_MTL_INLINE void MTL::RenderPipelineDescriptor::setTessellationOutputWindingOrder(MTL::Winding tessellationOutputWindingOrder)
760{
761    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTessellationOutputWindingOrder_), tessellationOutputWindingOrder);
762}
763
764// property: vertexBuffers
765_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::RenderPipelineDescriptor::vertexBuffers() const
766{
767    return Object::sendMessage<MTL::PipelineBufferDescriptorArray*>(this, _MTL_PRIVATE_SEL(vertexBuffers));
768}
769
770// property: fragmentBuffers
771_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::RenderPipelineDescriptor::fragmentBuffers() const
772{
773    return Object::sendMessage<MTL::PipelineBufferDescriptorArray*>(this, _MTL_PRIVATE_SEL(fragmentBuffers));
774}
775
776// property: supportIndirectCommandBuffers
777_MTL_INLINE bool MTL::RenderPipelineDescriptor::supportIndirectCommandBuffers() const
778{
779    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers));
780}
781
782_MTL_INLINE void MTL::RenderPipelineDescriptor::setSupportIndirectCommandBuffers(bool supportIndirectCommandBuffers)
783{
784    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportIndirectCommandBuffers_), supportIndirectCommandBuffers);
785}
786
787// property: binaryArchives
788_MTL_INLINE NS::Array* MTL::RenderPipelineDescriptor::binaryArchives() const
789{
790    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryArchives));
791}
792
793_MTL_INLINE void MTL::RenderPipelineDescriptor::setBinaryArchives(const NS::Array* binaryArchives)
794{
795    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives);
796}
797
798// property: vertexPreloadedLibraries
799_MTL_INLINE NS::Array* MTL::RenderPipelineDescriptor::vertexPreloadedLibraries() const
800{
801    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexPreloadedLibraries));
802}
803
804_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexPreloadedLibraries(const NS::Array* vertexPreloadedLibraries)
805{
806    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexPreloadedLibraries_), vertexPreloadedLibraries);
807}
808
809// property: fragmentPreloadedLibraries
810_MTL_INLINE NS::Array* MTL::RenderPipelineDescriptor::fragmentPreloadedLibraries() const
811{
812    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(fragmentPreloadedLibraries));
813}
814
815_MTL_INLINE void MTL::RenderPipelineDescriptor::setFragmentPreloadedLibraries(const NS::Array* fragmentPreloadedLibraries)
816{
817    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentPreloadedLibraries_), fragmentPreloadedLibraries);
818}
819
820// property: vertexLinkedFunctions
821_MTL_INLINE MTL::LinkedFunctions* MTL::RenderPipelineDescriptor::vertexLinkedFunctions() const
822{
823    return Object::sendMessage<MTL::LinkedFunctions*>(this, _MTL_PRIVATE_SEL(vertexLinkedFunctions));
824}
825
826_MTL_INLINE void MTL::RenderPipelineDescriptor::setVertexLinkedFunctions(const MTL::LinkedFunctions* vertexLinkedFunctions)
827{
828    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexLinkedFunctions_), vertexLinkedFunctions);
829}
830
831// property: fragmentLinkedFunctions
832_MTL_INLINE MTL::LinkedFunctions* MTL::RenderPipelineDescriptor::fragmentLinkedFunctions() const
833{
834    return Object::sendMessage<MTL::LinkedFunctions*>(this, _MTL_PRIVATE_SEL(fragmentLinkedFunctions));
835}
836
837_MTL_INLINE void MTL::RenderPipelineDescriptor::setFragmentLinkedFunctions(const MTL::LinkedFunctions* fragmentLinkedFunctions)
838{
839    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentLinkedFunctions_), fragmentLinkedFunctions);
840}
841
842// property: supportAddingVertexBinaryFunctions
843_MTL_INLINE bool MTL::RenderPipelineDescriptor::supportAddingVertexBinaryFunctions() const
844{
845    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportAddingVertexBinaryFunctions));
846}
847
848_MTL_INLINE void MTL::RenderPipelineDescriptor::setSupportAddingVertexBinaryFunctions(bool supportAddingVertexBinaryFunctions)
849{
850    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportAddingVertexBinaryFunctions_), supportAddingVertexBinaryFunctions);
851}
852
853// property: supportAddingFragmentBinaryFunctions
854_MTL_INLINE bool MTL::RenderPipelineDescriptor::supportAddingFragmentBinaryFunctions() const
855{
856    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportAddingFragmentBinaryFunctions));
857}
858
859_MTL_INLINE void MTL::RenderPipelineDescriptor::setSupportAddingFragmentBinaryFunctions(bool supportAddingFragmentBinaryFunctions)
860{
861    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportAddingFragmentBinaryFunctions_), supportAddingFragmentBinaryFunctions);
862}
863
864// property: maxVertexCallStackDepth
865_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxVertexCallStackDepth() const
866{
867    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxVertexCallStackDepth));
868}
869
870_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxVertexCallStackDepth(NS::UInteger maxVertexCallStackDepth)
871{
872    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxVertexCallStackDepth_), maxVertexCallStackDepth);
873}
874
875// property: maxFragmentCallStackDepth
876_MTL_INLINE NS::UInteger MTL::RenderPipelineDescriptor::maxFragmentCallStackDepth() const
877{
878    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxFragmentCallStackDepth));
879}
880
881_MTL_INLINE void MTL::RenderPipelineDescriptor::setMaxFragmentCallStackDepth(NS::UInteger maxFragmentCallStackDepth)
882{
883    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxFragmentCallStackDepth_), maxFragmentCallStackDepth);
884}
885
886// method: reset
887_MTL_INLINE void MTL::RenderPipelineDescriptor::reset()
888{
889    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
890}
891
892// static method: alloc
893_MTL_INLINE MTL::RenderPipelineFunctionsDescriptor* MTL::RenderPipelineFunctionsDescriptor::alloc()
894{
895    return NS::Object::alloc<MTL::RenderPipelineFunctionsDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPipelineFunctionsDescriptor));
896}
897
898// method: init
899_MTL_INLINE MTL::RenderPipelineFunctionsDescriptor* MTL::RenderPipelineFunctionsDescriptor::init()
900{
901    return NS::Object::init<MTL::RenderPipelineFunctionsDescriptor>();
902}
903
904// property: vertexAdditionalBinaryFunctions
905_MTL_INLINE NS::Array* MTL::RenderPipelineFunctionsDescriptor::vertexAdditionalBinaryFunctions() const
906{
907    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(vertexAdditionalBinaryFunctions));
908}
909
910_MTL_INLINE void MTL::RenderPipelineFunctionsDescriptor::setVertexAdditionalBinaryFunctions(const NS::Array* vertexAdditionalBinaryFunctions)
911{
912    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVertexAdditionalBinaryFunctions_), vertexAdditionalBinaryFunctions);
913}
914
915// property: fragmentAdditionalBinaryFunctions
916_MTL_INLINE NS::Array* MTL::RenderPipelineFunctionsDescriptor::fragmentAdditionalBinaryFunctions() const
917{
918    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(fragmentAdditionalBinaryFunctions));
919}
920
921_MTL_INLINE void MTL::RenderPipelineFunctionsDescriptor::setFragmentAdditionalBinaryFunctions(const NS::Array* fragmentAdditionalBinaryFunctions)
922{
923    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFragmentAdditionalBinaryFunctions_), fragmentAdditionalBinaryFunctions);
924}
925
926// property: tileAdditionalBinaryFunctions
927_MTL_INLINE NS::Array* MTL::RenderPipelineFunctionsDescriptor::tileAdditionalBinaryFunctions() const
928{
929    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(tileAdditionalBinaryFunctions));
930}
931
932_MTL_INLINE void MTL::RenderPipelineFunctionsDescriptor::setTileAdditionalBinaryFunctions(const NS::Array* tileAdditionalBinaryFunctions)
933{
934    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileAdditionalBinaryFunctions_), tileAdditionalBinaryFunctions);
935}
936
937// property: label
938_MTL_INLINE NS::String* MTL::RenderPipelineState::label() const
939{
940    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
941}
942
943// property: device
944_MTL_INLINE MTL::Device* MTL::RenderPipelineState::device() const
945{
946    return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
947}
948
949// property: maxTotalThreadsPerThreadgroup
950_MTL_INLINE NS::UInteger MTL::RenderPipelineState::maxTotalThreadsPerThreadgroup() const
951{
952    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
953}
954
955// property: threadgroupSizeMatchesTileSize
956_MTL_INLINE bool MTL::RenderPipelineState::threadgroupSizeMatchesTileSize() const
957{
958    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(threadgroupSizeMatchesTileSize));
959}
960
961// property: imageblockSampleLength
962_MTL_INLINE NS::UInteger MTL::RenderPipelineState::imageblockSampleLength() const
963{
964    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(imageblockSampleLength));
965}
966
967// method: imageblockMemoryLengthForDimensions:
968_MTL_INLINE NS::UInteger MTL::RenderPipelineState::imageblockMemoryLength(MTL::Size imageblockDimensions)
969{
970    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(imageblockMemoryLengthForDimensions_), imageblockDimensions);
971}
972
973// property: supportIndirectCommandBuffers
974_MTL_INLINE bool MTL::RenderPipelineState::supportIndirectCommandBuffers() const
975{
976    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportIndirectCommandBuffers));
977}
978
979// method: functionHandleWithFunction:stage:
980_MTL_INLINE MTL::FunctionHandle* MTL::RenderPipelineState::functionHandle(const MTL::Function* function, MTL::RenderStages stage)
981{
982    return Object::sendMessage<MTL::FunctionHandle*>(this, _MTL_PRIVATE_SEL(functionHandleWithFunction_stage_), function, stage);
983}
984
985// method: newVisibleFunctionTableWithDescriptor:stage:
986_MTL_INLINE MTL::VisibleFunctionTable* MTL::RenderPipelineState::newVisibleFunctionTable(const MTL::VisibleFunctionTableDescriptor* descriptor, MTL::RenderStages stage)
987{
988    return Object::sendMessage<MTL::VisibleFunctionTable*>(this, _MTL_PRIVATE_SEL(newVisibleFunctionTableWithDescriptor_stage_), descriptor, stage);
989}
990
991// method: newIntersectionFunctionTableWithDescriptor:stage:
992_MTL_INLINE MTL::IntersectionFunctionTable* MTL::RenderPipelineState::newIntersectionFunctionTable(const MTL::IntersectionFunctionTableDescriptor* descriptor, MTL::RenderStages stage)
993{
994    return Object::sendMessage<MTL::IntersectionFunctionTable*>(this, _MTL_PRIVATE_SEL(newIntersectionFunctionTableWithDescriptor_stage_), descriptor, stage);
995}
996
997// method: newRenderPipelineStateWithAdditionalBinaryFunctions:error:
998_MTL_INLINE MTL::RenderPipelineState* MTL::RenderPipelineState::newRenderPipelineState(const MTL::RenderPipelineFunctionsDescriptor* additionalBinaryFunctions, NS::Error** error)
999{
1000    return Object::sendMessage<MTL::RenderPipelineState*>(this, _MTL_PRIVATE_SEL(newRenderPipelineStateWithAdditionalBinaryFunctions_error_), additionalBinaryFunctions, error);
1001}
1002
1003// static method: alloc
1004_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptorArray* MTL::RenderPipelineColorAttachmentDescriptorArray::alloc()
1005{
1006    return NS::Object::alloc<MTL::RenderPipelineColorAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLRenderPipelineColorAttachmentDescriptorArray));
1007}
1008
1009// method: init
1010_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptorArray* MTL::RenderPipelineColorAttachmentDescriptorArray::init()
1011{
1012    return NS::Object::init<MTL::RenderPipelineColorAttachmentDescriptorArray>();
1013}
1014
1015// method: objectAtIndexedSubscript:
1016_MTL_INLINE MTL::RenderPipelineColorAttachmentDescriptor* MTL::RenderPipelineColorAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
1017{
1018    return Object::sendMessage<MTL::RenderPipelineColorAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
1019}
1020
1021// method: setObject:atIndexedSubscript:
1022_MTL_INLINE void MTL::RenderPipelineColorAttachmentDescriptorArray::setObject(const MTL::RenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
1023{
1024    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
1025}
1026
1027// static method: alloc
1028_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptor* MTL::TileRenderPipelineColorAttachmentDescriptor::alloc()
1029{
1030    return NS::Object::alloc<MTL::TileRenderPipelineColorAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLTileRenderPipelineColorAttachmentDescriptor));
1031}
1032
1033// method: init
1034_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptor* MTL::TileRenderPipelineColorAttachmentDescriptor::init()
1035{
1036    return NS::Object::init<MTL::TileRenderPipelineColorAttachmentDescriptor>();
1037}
1038
1039// property: pixelFormat
1040_MTL_INLINE MTL::PixelFormat MTL::TileRenderPipelineColorAttachmentDescriptor::pixelFormat() const
1041{
1042    return Object::sendMessage<MTL::PixelFormat>(this, _MTL_PRIVATE_SEL(pixelFormat));
1043}
1044
1045_MTL_INLINE void MTL::TileRenderPipelineColorAttachmentDescriptor::setPixelFormat(MTL::PixelFormat pixelFormat)
1046{
1047    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPixelFormat_), pixelFormat);
1048}
1049
1050// static method: alloc
1051_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptorArray* MTL::TileRenderPipelineColorAttachmentDescriptorArray::alloc()
1052{
1053    return NS::Object::alloc<MTL::TileRenderPipelineColorAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLTileRenderPipelineColorAttachmentDescriptorArray));
1054}
1055
1056// method: init
1057_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptorArray* MTL::TileRenderPipelineColorAttachmentDescriptorArray::init()
1058{
1059    return NS::Object::init<MTL::TileRenderPipelineColorAttachmentDescriptorArray>();
1060}
1061
1062// method: objectAtIndexedSubscript:
1063_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptor* MTL::TileRenderPipelineColorAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
1064{
1065    return Object::sendMessage<MTL::TileRenderPipelineColorAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
1066}
1067
1068// method: setObject:atIndexedSubscript:
1069_MTL_INLINE void MTL::TileRenderPipelineColorAttachmentDescriptorArray::setObject(const MTL::TileRenderPipelineColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
1070{
1071    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
1072}
1073
1074// static method: alloc
1075_MTL_INLINE MTL::TileRenderPipelineDescriptor* MTL::TileRenderPipelineDescriptor::alloc()
1076{
1077    return NS::Object::alloc<MTL::TileRenderPipelineDescriptor>(_MTL_PRIVATE_CLS(MTLTileRenderPipelineDescriptor));
1078}
1079
1080// method: init
1081_MTL_INLINE MTL::TileRenderPipelineDescriptor* MTL::TileRenderPipelineDescriptor::init()
1082{
1083    return NS::Object::init<MTL::TileRenderPipelineDescriptor>();
1084}
1085
1086// property: label
1087_MTL_INLINE NS::String* MTL::TileRenderPipelineDescriptor::label() const
1088{
1089    return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
1090}
1091
1092_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setLabel(const NS::String* label)
1093{
1094    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
1095}
1096
1097// property: tileFunction
1098_MTL_INLINE MTL::Function* MTL::TileRenderPipelineDescriptor::tileFunction() const
1099{
1100    return Object::sendMessage<MTL::Function*>(this, _MTL_PRIVATE_SEL(tileFunction));
1101}
1102
1103_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setTileFunction(const MTL::Function* tileFunction)
1104{
1105    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileFunction_), tileFunction);
1106}
1107
1108// property: rasterSampleCount
1109_MTL_INLINE NS::UInteger MTL::TileRenderPipelineDescriptor::rasterSampleCount() const
1110{
1111    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(rasterSampleCount));
1112}
1113
1114_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setRasterSampleCount(NS::UInteger rasterSampleCount)
1115{
1116    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterSampleCount_), rasterSampleCount);
1117}
1118
1119// property: colorAttachments
1120_MTL_INLINE MTL::TileRenderPipelineColorAttachmentDescriptorArray* MTL::TileRenderPipelineDescriptor::colorAttachments() const
1121{
1122    return Object::sendMessage<MTL::TileRenderPipelineColorAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(colorAttachments));
1123}
1124
1125// property: threadgroupSizeMatchesTileSize
1126_MTL_INLINE bool MTL::TileRenderPipelineDescriptor::threadgroupSizeMatchesTileSize() const
1127{
1128    return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(threadgroupSizeMatchesTileSize));
1129}
1130
1131_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setThreadgroupSizeMatchesTileSize(bool threadgroupSizeMatchesTileSize)
1132{
1133    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupSizeMatchesTileSize_), threadgroupSizeMatchesTileSize);
1134}
1135
1136// property: tileBuffers
1137_MTL_INLINE MTL::PipelineBufferDescriptorArray* MTL::TileRenderPipelineDescriptor::tileBuffers() const
1138{
1139    return Object::sendMessage<MTL::PipelineBufferDescriptorArray*>(this, _MTL_PRIVATE_SEL(tileBuffers));
1140}
1141
1142// property: maxTotalThreadsPerThreadgroup
1143_MTL_INLINE NS::UInteger MTL::TileRenderPipelineDescriptor::maxTotalThreadsPerThreadgroup() const
1144{
1145    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxTotalThreadsPerThreadgroup));
1146}
1147
1148_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setMaxTotalThreadsPerThreadgroup(NS::UInteger maxTotalThreadsPerThreadgroup)
1149{
1150    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxTotalThreadsPerThreadgroup_), maxTotalThreadsPerThreadgroup);
1151}
1152
1153// property: binaryArchives
1154_MTL_INLINE NS::Array* MTL::TileRenderPipelineDescriptor::binaryArchives() const
1155{
1156    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(binaryArchives));
1157}
1158
1159_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setBinaryArchives(const NS::Array* binaryArchives)
1160{
1161    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBinaryArchives_), binaryArchives);
1162}
1163
1164// property: preloadedLibraries
1165_MTL_INLINE NS::Array* MTL::TileRenderPipelineDescriptor::preloadedLibraries() const
1166{
1167    return Object::sendMessage<NS::Array*>(this, _MTL_PRIVATE_SEL(preloadedLibraries));
1168}
1169
1170_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setPreloadedLibraries(const NS::Array* preloadedLibraries)
1171{
1172    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setPreloadedLibraries_), preloadedLibraries);
1173}
1174
1175// property: linkedFunctions
1176_MTL_INLINE MTL::LinkedFunctions* MTL::TileRenderPipelineDescriptor::linkedFunctions() const
1177{
1178    return Object::sendMessage<MTL::LinkedFunctions*>(this, _MTL_PRIVATE_SEL(linkedFunctions));
1179}
1180
1181_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setLinkedFunctions(const MTL::LinkedFunctions* linkedFunctions)
1182{
1183    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLinkedFunctions_), linkedFunctions);
1184}
1185
1186// property: supportAddingBinaryFunctions
1187_MTL_INLINE bool MTL::TileRenderPipelineDescriptor::supportAddingBinaryFunctions() const
1188{
1189    return Object::sendMessageSafe<bool>(this, _MTL_PRIVATE_SEL(supportAddingBinaryFunctions));
1190}
1191
1192_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setSupportAddingBinaryFunctions(bool supportAddingBinaryFunctions)
1193{
1194    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSupportAddingBinaryFunctions_), supportAddingBinaryFunctions);
1195}
1196
1197// property: maxCallStackDepth
1198_MTL_INLINE NS::UInteger MTL::TileRenderPipelineDescriptor::maxCallStackDepth() const
1199{
1200    return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(maxCallStackDepth));
1201}
1202
1203_MTL_INLINE void MTL::TileRenderPipelineDescriptor::setMaxCallStackDepth(NS::UInteger maxCallStackDepth)
1204{
1205    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setMaxCallStackDepth_), maxCallStackDepth);
1206}
1207
1208// method: reset
1209_MTL_INLINE void MTL::TileRenderPipelineDescriptor::reset()
1210{
1211    Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(reset));
1212}