1  //-------------------------------------------------------------------------------------------------------------------------------------------------------------
  2  //
  3  // Metal/MTLRenderPass.hpp
  4  //
  5  // Copyright 2020-2024 Apple Inc.
  6  //
  7  // Licensed under the Apache License, Version 2.0 (the "License");
  8  // you may not use this file except in compliance with the License.
  9  // You may obtain a copy of the License at
 10  //
 11  //     http://www.apache.org/licenses/LICENSE-2.0
 12  //
 13  // Unless required by applicable law or agreed to in writing, software
 14  // distributed under the License is distributed on an "AS IS" BASIS,
 15  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 16  // See the License for the specific language governing permissions and
 17  // limitations under the License.
 18  //
 19  //-------------------------------------------------------------------------------------------------------------------------------------------------------------
 20  
 21  #pragma once
 22  
 23  #include "MTLDefines.hpp"
 24  #include "MTLHeaderBridge.hpp"
 25  #include "MTLPrivate.hpp"
 26  #include "MTLTypes.hpp"
 27  
 28  #include <Foundation/Foundation.hpp>
 29  
 30  #include "MTLRenderPass.hpp"
 31  
 32  namespace MTL
 33  {
 34  struct ClearColor
 35  {
 36      static ClearColor Make(double red, double green, double blue, double alpha);
 37  
 38      ClearColor() = default;
 39  
 40      ClearColor(double red, double green, double blue, double alpha);
 41  
 42      double red;
 43      double green;
 44      double blue;
 45      double alpha;
 46  } _MTL_PACKED;
 47  
 48  _MTL_ENUM(NS::UInteger, LoadAction) {
 49      LoadActionDontCare = 0,
 50      LoadActionLoad = 1,
 51      LoadActionClear = 2,
 52  };
 53  
 54  _MTL_ENUM(NS::UInteger, StoreAction) {
 55      StoreActionDontCare = 0,
 56      StoreActionStore = 1,
 57      StoreActionMultisampleResolve = 2,
 58      StoreActionStoreAndMultisampleResolve = 3,
 59      StoreActionUnknown = 4,
 60      StoreActionCustomSampleDepthStore = 5,
 61  };
 62  
 63  _MTL_OPTIONS(NS::UInteger, StoreActionOptions) {
 64      StoreActionOptionNone = 0,
 65      StoreActionOptionCustomSamplePositions = 1,
 66      StoreActionOptionValidMask = 1,
 67  };
 68  
 69  class RenderPassAttachmentDescriptor : public NS::Copying<RenderPassAttachmentDescriptor>
 70  {
 71  public:
 72      static class RenderPassAttachmentDescriptor* alloc();
 73  
 74      class RenderPassAttachmentDescriptor*        init();
 75  
 76      class Texture*                               texture() const;
 77      void                                         setTexture(const class Texture* texture);
 78  
 79      NS::UInteger                                 level() const;
 80      void                                         setLevel(NS::UInteger level);
 81  
 82      NS::UInteger                                 slice() const;
 83      void                                         setSlice(NS::UInteger slice);
 84  
 85      NS::UInteger                                 depthPlane() const;
 86      void                                         setDepthPlane(NS::UInteger depthPlane);
 87  
 88      class Texture*                               resolveTexture() const;
 89      void                                         setResolveTexture(const class Texture* resolveTexture);
 90  
 91      NS::UInteger                                 resolveLevel() const;
 92      void                                         setResolveLevel(NS::UInteger resolveLevel);
 93  
 94      NS::UInteger                                 resolveSlice() const;
 95      void                                         setResolveSlice(NS::UInteger resolveSlice);
 96  
 97      NS::UInteger                                 resolveDepthPlane() const;
 98      void                                         setResolveDepthPlane(NS::UInteger resolveDepthPlane);
 99  
100      MTL::LoadAction                              loadAction() const;
101      void                                         setLoadAction(MTL::LoadAction loadAction);
102  
103      MTL::StoreAction                             storeAction() const;
104      void                                         setStoreAction(MTL::StoreAction storeAction);
105  
106      MTL::StoreActionOptions                      storeActionOptions() const;
107      void                                         setStoreActionOptions(MTL::StoreActionOptions storeActionOptions);
108  };
109  
110  class RenderPassColorAttachmentDescriptor : public NS::Copying<RenderPassColorAttachmentDescriptor, MTL::RenderPassAttachmentDescriptor>
111  {
112  public:
113      static class RenderPassColorAttachmentDescriptor* alloc();
114  
115      class RenderPassColorAttachmentDescriptor*        init();
116  
117      MTL::ClearColor                                   clearColor() const;
118      void                                              setClearColor(MTL::ClearColor clearColor);
119  };
120  
121  _MTL_ENUM(NS::UInteger, MultisampleDepthResolveFilter) {
122      MultisampleDepthResolveFilterSample0 = 0,
123      MultisampleDepthResolveFilterMin = 1,
124      MultisampleDepthResolveFilterMax = 2,
125  };
126  
127  class RenderPassDepthAttachmentDescriptor : public NS::Copying<RenderPassDepthAttachmentDescriptor, MTL::RenderPassAttachmentDescriptor>
128  {
129  public:
130      static class RenderPassDepthAttachmentDescriptor* alloc();
131  
132      class RenderPassDepthAttachmentDescriptor*        init();
133  
134      double                                            clearDepth() const;
135      void                                              setClearDepth(double clearDepth);
136  
137      MTL::MultisampleDepthResolveFilter                depthResolveFilter() const;
138      void                                              setDepthResolveFilter(MTL::MultisampleDepthResolveFilter depthResolveFilter);
139  };
140  
141  _MTL_ENUM(NS::UInteger, MultisampleStencilResolveFilter) {
142      MultisampleStencilResolveFilterSample0 = 0,
143      MultisampleStencilResolveFilterDepthResolvedSample = 1,
144  };
145  
146  class RenderPassStencilAttachmentDescriptor : public NS::Copying<RenderPassStencilAttachmentDescriptor, MTL::RenderPassAttachmentDescriptor>
147  {
148  public:
149      static class RenderPassStencilAttachmentDescriptor* alloc();
150  
151      class RenderPassStencilAttachmentDescriptor*        init();
152  
153      uint32_t                                            clearStencil() const;
154      void                                                setClearStencil(uint32_t clearStencil);
155  
156      MTL::MultisampleStencilResolveFilter                stencilResolveFilter() const;
157      void                                                setStencilResolveFilter(MTL::MultisampleStencilResolveFilter stencilResolveFilter);
158  };
159  
160  class RenderPassColorAttachmentDescriptorArray : public NS::Referencing<RenderPassColorAttachmentDescriptorArray>
161  {
162  public:
163      static class RenderPassColorAttachmentDescriptorArray* alloc();
164  
165      class RenderPassColorAttachmentDescriptorArray*        init();
166  
167      class RenderPassColorAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
168  
169      void                                                   setObject(const class RenderPassColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
170  };
171  
172  class RenderPassSampleBufferAttachmentDescriptor : public NS::Copying<RenderPassSampleBufferAttachmentDescriptor>
173  {
174  public:
175      static class RenderPassSampleBufferAttachmentDescriptor* alloc();
176  
177      class RenderPassSampleBufferAttachmentDescriptor*        init();
178  
179      class CounterSampleBuffer*                               sampleBuffer() const;
180      void                                                     setSampleBuffer(const class CounterSampleBuffer* sampleBuffer);
181  
182      NS::UInteger                                             startOfVertexSampleIndex() const;
183      void                                                     setStartOfVertexSampleIndex(NS::UInteger startOfVertexSampleIndex);
184  
185      NS::UInteger                                             endOfVertexSampleIndex() const;
186      void                                                     setEndOfVertexSampleIndex(NS::UInteger endOfVertexSampleIndex);
187  
188      NS::UInteger                                             startOfFragmentSampleIndex() const;
189      void                                                     setStartOfFragmentSampleIndex(NS::UInteger startOfFragmentSampleIndex);
190  
191      NS::UInteger                                             endOfFragmentSampleIndex() const;
192      void                                                     setEndOfFragmentSampleIndex(NS::UInteger endOfFragmentSampleIndex);
193  };
194  
195  class RenderPassSampleBufferAttachmentDescriptorArray : public NS::Referencing<RenderPassSampleBufferAttachmentDescriptorArray>
196  {
197  public:
198      static class RenderPassSampleBufferAttachmentDescriptorArray* alloc();
199  
200      class RenderPassSampleBufferAttachmentDescriptorArray*        init();
201  
202      class RenderPassSampleBufferAttachmentDescriptor*             object(NS::UInteger attachmentIndex);
203  
204      void                                                          setObject(const class RenderPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex);
205  };
206  
207  class RenderPassDescriptor : public NS::Copying<RenderPassDescriptor>
208  {
209  public:
210      static class RenderPassDescriptor*                     alloc();
211  
212      class RenderPassDescriptor*                            init();
213  
214      static class RenderPassDescriptor*                     renderPassDescriptor();
215  
216      class RenderPassColorAttachmentDescriptorArray*        colorAttachments() const;
217  
218      class RenderPassDepthAttachmentDescriptor*             depthAttachment() const;
219      void                                                   setDepthAttachment(const class RenderPassDepthAttachmentDescriptor* depthAttachment);
220  
221      class RenderPassStencilAttachmentDescriptor*           stencilAttachment() const;
222      void                                                   setStencilAttachment(const class RenderPassStencilAttachmentDescriptor* stencilAttachment);
223  
224      class Buffer*                                          visibilityResultBuffer() const;
225      void                                                   setVisibilityResultBuffer(const class Buffer* visibilityResultBuffer);
226  
227      NS::UInteger                                           renderTargetArrayLength() const;
228      void                                                   setRenderTargetArrayLength(NS::UInteger renderTargetArrayLength);
229  
230      NS::UInteger                                           imageblockSampleLength() const;
231      void                                                   setImageblockSampleLength(NS::UInteger imageblockSampleLength);
232  
233      NS::UInteger                                           threadgroupMemoryLength() const;
234      void                                                   setThreadgroupMemoryLength(NS::UInteger threadgroupMemoryLength);
235  
236      NS::UInteger                                           tileWidth() const;
237      void                                                   setTileWidth(NS::UInteger tileWidth);
238  
239      NS::UInteger                                           tileHeight() const;
240      void                                                   setTileHeight(NS::UInteger tileHeight);
241  
242      NS::UInteger                                           defaultRasterSampleCount() const;
243      void                                                   setDefaultRasterSampleCount(NS::UInteger defaultRasterSampleCount);
244  
245      NS::UInteger                                           renderTargetWidth() const;
246      void                                                   setRenderTargetWidth(NS::UInteger renderTargetWidth);
247  
248      NS::UInteger                                           renderTargetHeight() const;
249      void                                                   setRenderTargetHeight(NS::UInteger renderTargetHeight);
250  
251      void                                                   setSamplePositions(const MTL::SamplePosition* positions, NS::UInteger count);
252  
253      NS::UInteger                                           getSamplePositions(MTL::SamplePosition* positions, NS::UInteger count);
254  
255      class RasterizationRateMap*                            rasterizationRateMap() const;
256      void                                                   setRasterizationRateMap(const class RasterizationRateMap* rasterizationRateMap);
257  
258      class RenderPassSampleBufferAttachmentDescriptorArray* sampleBufferAttachments() const;
259  };
260  
261  }
262  
263  _MTL_INLINE MTL::ClearColor MTL::ClearColor::Make(double red, double green, double blue, double alpha)
264  {
265      return ClearColor(red, green, blue, alpha);
266  }
267  
268  _MTL_INLINE MTL::ClearColor::ClearColor(double _red, double _green, double _blue, double _alpha)
269      : red(_red)
270      , green(_green)
271      , blue(_blue)
272      , alpha(_alpha)
273  {
274  }
275  
276  // static method: alloc
277  _MTL_INLINE MTL::RenderPassAttachmentDescriptor* MTL::RenderPassAttachmentDescriptor::alloc()
278  {
279      return NS::Object::alloc<MTL::RenderPassAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassAttachmentDescriptor));
280  }
281  
282  // method: init
283  _MTL_INLINE MTL::RenderPassAttachmentDescriptor* MTL::RenderPassAttachmentDescriptor::init()
284  {
285      return NS::Object::init<MTL::RenderPassAttachmentDescriptor>();
286  }
287  
288  // property: texture
289  _MTL_INLINE MTL::Texture* MTL::RenderPassAttachmentDescriptor::texture() const
290  {
291      return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(texture));
292  }
293  
294  _MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setTexture(const MTL::Texture* texture)
295  {
296      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTexture_), texture);
297  }
298  
299  // property: level
300  _MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::level() const
301  {
302      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(level));
303  }
304  
305  _MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setLevel(NS::UInteger level)
306  {
307      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLevel_), level);
308  }
309  
310  // property: slice
311  _MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::slice() const
312  {
313      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(slice));
314  }
315  
316  _MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setSlice(NS::UInteger slice)
317  {
318      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSlice_), slice);
319  }
320  
321  // property: depthPlane
322  _MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::depthPlane() const
323  {
324      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(depthPlane));
325  }
326  
327  _MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setDepthPlane(NS::UInteger depthPlane)
328  {
329      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthPlane_), depthPlane);
330  }
331  
332  // property: resolveTexture
333  _MTL_INLINE MTL::Texture* MTL::RenderPassAttachmentDescriptor::resolveTexture() const
334  {
335      return Object::sendMessage<MTL::Texture*>(this, _MTL_PRIVATE_SEL(resolveTexture));
336  }
337  
338  _MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveTexture(const MTL::Texture* resolveTexture)
339  {
340      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResolveTexture_), resolveTexture);
341  }
342  
343  // property: resolveLevel
344  _MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::resolveLevel() const
345  {
346      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(resolveLevel));
347  }
348  
349  _MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveLevel(NS::UInteger resolveLevel)
350  {
351      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResolveLevel_), resolveLevel);
352  }
353  
354  // property: resolveSlice
355  _MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::resolveSlice() const
356  {
357      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(resolveSlice));
358  }
359  
360  _MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveSlice(NS::UInteger resolveSlice)
361  {
362      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResolveSlice_), resolveSlice);
363  }
364  
365  // property: resolveDepthPlane
366  _MTL_INLINE NS::UInteger MTL::RenderPassAttachmentDescriptor::resolveDepthPlane() const
367  {
368      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(resolveDepthPlane));
369  }
370  
371  _MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setResolveDepthPlane(NS::UInteger resolveDepthPlane)
372  {
373      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setResolveDepthPlane_), resolveDepthPlane);
374  }
375  
376  // property: loadAction
377  _MTL_INLINE MTL::LoadAction MTL::RenderPassAttachmentDescriptor::loadAction() const
378  {
379      return Object::sendMessage<MTL::LoadAction>(this, _MTL_PRIVATE_SEL(loadAction));
380  }
381  
382  _MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setLoadAction(MTL::LoadAction loadAction)
383  {
384      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLoadAction_), loadAction);
385  }
386  
387  // property: storeAction
388  _MTL_INLINE MTL::StoreAction MTL::RenderPassAttachmentDescriptor::storeAction() const
389  {
390      return Object::sendMessage<MTL::StoreAction>(this, _MTL_PRIVATE_SEL(storeAction));
391  }
392  
393  _MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setStoreAction(MTL::StoreAction storeAction)
394  {
395      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStoreAction_), storeAction);
396  }
397  
398  // property: storeActionOptions
399  _MTL_INLINE MTL::StoreActionOptions MTL::RenderPassAttachmentDescriptor::storeActionOptions() const
400  {
401      return Object::sendMessage<MTL::StoreActionOptions>(this, _MTL_PRIVATE_SEL(storeActionOptions));
402  }
403  
404  _MTL_INLINE void MTL::RenderPassAttachmentDescriptor::setStoreActionOptions(MTL::StoreActionOptions storeActionOptions)
405  {
406      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStoreActionOptions_), storeActionOptions);
407  }
408  
409  // static method: alloc
410  _MTL_INLINE MTL::RenderPassColorAttachmentDescriptor* MTL::RenderPassColorAttachmentDescriptor::alloc()
411  {
412      return NS::Object::alloc<MTL::RenderPassColorAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassColorAttachmentDescriptor));
413  }
414  
415  // method: init
416  _MTL_INLINE MTL::RenderPassColorAttachmentDescriptor* MTL::RenderPassColorAttachmentDescriptor::init()
417  {
418      return NS::Object::init<MTL::RenderPassColorAttachmentDescriptor>();
419  }
420  
421  // property: clearColor
422  _MTL_INLINE MTL::ClearColor MTL::RenderPassColorAttachmentDescriptor::clearColor() const
423  {
424      return Object::sendMessage<MTL::ClearColor>(this, _MTL_PRIVATE_SEL(clearColor));
425  }
426  
427  _MTL_INLINE void MTL::RenderPassColorAttachmentDescriptor::setClearColor(MTL::ClearColor clearColor)
428  {
429      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setClearColor_), clearColor);
430  }
431  
432  // static method: alloc
433  _MTL_INLINE MTL::RenderPassDepthAttachmentDescriptor* MTL::RenderPassDepthAttachmentDescriptor::alloc()
434  {
435      return NS::Object::alloc<MTL::RenderPassDepthAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassDepthAttachmentDescriptor));
436  }
437  
438  // method: init
439  _MTL_INLINE MTL::RenderPassDepthAttachmentDescriptor* MTL::RenderPassDepthAttachmentDescriptor::init()
440  {
441      return NS::Object::init<MTL::RenderPassDepthAttachmentDescriptor>();
442  }
443  
444  // property: clearDepth
445  _MTL_INLINE double MTL::RenderPassDepthAttachmentDescriptor::clearDepth() const
446  {
447      return Object::sendMessage<double>(this, _MTL_PRIVATE_SEL(clearDepth));
448  }
449  
450  _MTL_INLINE void MTL::RenderPassDepthAttachmentDescriptor::setClearDepth(double clearDepth)
451  {
452      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setClearDepth_), clearDepth);
453  }
454  
455  // property: depthResolveFilter
456  _MTL_INLINE MTL::MultisampleDepthResolveFilter MTL::RenderPassDepthAttachmentDescriptor::depthResolveFilter() const
457  {
458      return Object::sendMessage<MTL::MultisampleDepthResolveFilter>(this, _MTL_PRIVATE_SEL(depthResolveFilter));
459  }
460  
461  _MTL_INLINE void MTL::RenderPassDepthAttachmentDescriptor::setDepthResolveFilter(MTL::MultisampleDepthResolveFilter depthResolveFilter)
462  {
463      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthResolveFilter_), depthResolveFilter);
464  }
465  
466  // static method: alloc
467  _MTL_INLINE MTL::RenderPassStencilAttachmentDescriptor* MTL::RenderPassStencilAttachmentDescriptor::alloc()
468  {
469      return NS::Object::alloc<MTL::RenderPassStencilAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassStencilAttachmentDescriptor));
470  }
471  
472  // method: init
473  _MTL_INLINE MTL::RenderPassStencilAttachmentDescriptor* MTL::RenderPassStencilAttachmentDescriptor::init()
474  {
475      return NS::Object::init<MTL::RenderPassStencilAttachmentDescriptor>();
476  }
477  
478  // property: clearStencil
479  _MTL_INLINE uint32_t MTL::RenderPassStencilAttachmentDescriptor::clearStencil() const
480  {
481      return Object::sendMessage<uint32_t>(this, _MTL_PRIVATE_SEL(clearStencil));
482  }
483  
484  _MTL_INLINE void MTL::RenderPassStencilAttachmentDescriptor::setClearStencil(uint32_t clearStencil)
485  {
486      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setClearStencil_), clearStencil);
487  }
488  
489  // property: stencilResolveFilter
490  _MTL_INLINE MTL::MultisampleStencilResolveFilter MTL::RenderPassStencilAttachmentDescriptor::stencilResolveFilter() const
491  {
492      return Object::sendMessage<MTL::MultisampleStencilResolveFilter>(this, _MTL_PRIVATE_SEL(stencilResolveFilter));
493  }
494  
495  _MTL_INLINE void MTL::RenderPassStencilAttachmentDescriptor::setStencilResolveFilter(MTL::MultisampleStencilResolveFilter stencilResolveFilter)
496  {
497      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilResolveFilter_), stencilResolveFilter);
498  }
499  
500  // static method: alloc
501  _MTL_INLINE MTL::RenderPassColorAttachmentDescriptorArray* MTL::RenderPassColorAttachmentDescriptorArray::alloc()
502  {
503      return NS::Object::alloc<MTL::RenderPassColorAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLRenderPassColorAttachmentDescriptorArray));
504  }
505  
506  // method: init
507  _MTL_INLINE MTL::RenderPassColorAttachmentDescriptorArray* MTL::RenderPassColorAttachmentDescriptorArray::init()
508  {
509      return NS::Object::init<MTL::RenderPassColorAttachmentDescriptorArray>();
510  }
511  
512  // method: objectAtIndexedSubscript:
513  _MTL_INLINE MTL::RenderPassColorAttachmentDescriptor* MTL::RenderPassColorAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
514  {
515      return Object::sendMessage<MTL::RenderPassColorAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
516  }
517  
518  // method: setObject:atIndexedSubscript:
519  _MTL_INLINE void MTL::RenderPassColorAttachmentDescriptorArray::setObject(const MTL::RenderPassColorAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
520  {
521      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
522  }
523  
524  // static method: alloc
525  _MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptor* MTL::RenderPassSampleBufferAttachmentDescriptor::alloc()
526  {
527      return NS::Object::alloc<MTL::RenderPassSampleBufferAttachmentDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassSampleBufferAttachmentDescriptor));
528  }
529  
530  // method: init
531  _MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptor* MTL::RenderPassSampleBufferAttachmentDescriptor::init()
532  {
533      return NS::Object::init<MTL::RenderPassSampleBufferAttachmentDescriptor>();
534  }
535  
536  // property: sampleBuffer
537  _MTL_INLINE MTL::CounterSampleBuffer* MTL::RenderPassSampleBufferAttachmentDescriptor::sampleBuffer() const
538  {
539      return Object::sendMessage<MTL::CounterSampleBuffer*>(this, _MTL_PRIVATE_SEL(sampleBuffer));
540  }
541  
542  _MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setSampleBuffer(const MTL::CounterSampleBuffer* sampleBuffer)
543  {
544      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSampleBuffer_), sampleBuffer);
545  }
546  
547  // property: startOfVertexSampleIndex
548  _MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::startOfVertexSampleIndex() const
549  {
550      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(startOfVertexSampleIndex));
551  }
552  
553  _MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setStartOfVertexSampleIndex(NS::UInteger startOfVertexSampleIndex)
554  {
555      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStartOfVertexSampleIndex_), startOfVertexSampleIndex);
556  }
557  
558  // property: endOfVertexSampleIndex
559  _MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::endOfVertexSampleIndex() const
560  {
561      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(endOfVertexSampleIndex));
562  }
563  
564  _MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setEndOfVertexSampleIndex(NS::UInteger endOfVertexSampleIndex)
565  {
566      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEndOfVertexSampleIndex_), endOfVertexSampleIndex);
567  }
568  
569  // property: startOfFragmentSampleIndex
570  _MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::startOfFragmentSampleIndex() const
571  {
572      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(startOfFragmentSampleIndex));
573  }
574  
575  _MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setStartOfFragmentSampleIndex(NS::UInteger startOfFragmentSampleIndex)
576  {
577      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStartOfFragmentSampleIndex_), startOfFragmentSampleIndex);
578  }
579  
580  // property: endOfFragmentSampleIndex
581  _MTL_INLINE NS::UInteger MTL::RenderPassSampleBufferAttachmentDescriptor::endOfFragmentSampleIndex() const
582  {
583      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(endOfFragmentSampleIndex));
584  }
585  
586  _MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptor::setEndOfFragmentSampleIndex(NS::UInteger endOfFragmentSampleIndex)
587  {
588      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setEndOfFragmentSampleIndex_), endOfFragmentSampleIndex);
589  }
590  
591  // static method: alloc
592  _MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptorArray* MTL::RenderPassSampleBufferAttachmentDescriptorArray::alloc()
593  {
594      return NS::Object::alloc<MTL::RenderPassSampleBufferAttachmentDescriptorArray>(_MTL_PRIVATE_CLS(MTLRenderPassSampleBufferAttachmentDescriptorArray));
595  }
596  
597  // method: init
598  _MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptorArray* MTL::RenderPassSampleBufferAttachmentDescriptorArray::init()
599  {
600      return NS::Object::init<MTL::RenderPassSampleBufferAttachmentDescriptorArray>();
601  }
602  
603  // method: objectAtIndexedSubscript:
604  _MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptor* MTL::RenderPassSampleBufferAttachmentDescriptorArray::object(NS::UInteger attachmentIndex)
605  {
606      return Object::sendMessage<MTL::RenderPassSampleBufferAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(objectAtIndexedSubscript_), attachmentIndex);
607  }
608  
609  // method: setObject:atIndexedSubscript:
610  _MTL_INLINE void MTL::RenderPassSampleBufferAttachmentDescriptorArray::setObject(const MTL::RenderPassSampleBufferAttachmentDescriptor* attachment, NS::UInteger attachmentIndex)
611  {
612      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setObject_atIndexedSubscript_), attachment, attachmentIndex);
613  }
614  
615  // static method: alloc
616  _MTL_INLINE MTL::RenderPassDescriptor* MTL::RenderPassDescriptor::alloc()
617  {
618      return NS::Object::alloc<MTL::RenderPassDescriptor>(_MTL_PRIVATE_CLS(MTLRenderPassDescriptor));
619  }
620  
621  // method: init
622  _MTL_INLINE MTL::RenderPassDescriptor* MTL::RenderPassDescriptor::init()
623  {
624      return NS::Object::init<MTL::RenderPassDescriptor>();
625  }
626  
627  // static method: renderPassDescriptor
628  _MTL_INLINE MTL::RenderPassDescriptor* MTL::RenderPassDescriptor::renderPassDescriptor()
629  {
630      return Object::sendMessage<MTL::RenderPassDescriptor*>(_MTL_PRIVATE_CLS(MTLRenderPassDescriptor), _MTL_PRIVATE_SEL(renderPassDescriptor));
631  }
632  
633  // property: colorAttachments
634  _MTL_INLINE MTL::RenderPassColorAttachmentDescriptorArray* MTL::RenderPassDescriptor::colorAttachments() const
635  {
636      return Object::sendMessage<MTL::RenderPassColorAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(colorAttachments));
637  }
638  
639  // property: depthAttachment
640  _MTL_INLINE MTL::RenderPassDepthAttachmentDescriptor* MTL::RenderPassDescriptor::depthAttachment() const
641  {
642      return Object::sendMessage<MTL::RenderPassDepthAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(depthAttachment));
643  }
644  
645  _MTL_INLINE void MTL::RenderPassDescriptor::setDepthAttachment(const MTL::RenderPassDepthAttachmentDescriptor* depthAttachment)
646  {
647      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthAttachment_), depthAttachment);
648  }
649  
650  // property: stencilAttachment
651  _MTL_INLINE MTL::RenderPassStencilAttachmentDescriptor* MTL::RenderPassDescriptor::stencilAttachment() const
652  {
653      return Object::sendMessage<MTL::RenderPassStencilAttachmentDescriptor*>(this, _MTL_PRIVATE_SEL(stencilAttachment));
654  }
655  
656  _MTL_INLINE void MTL::RenderPassDescriptor::setStencilAttachment(const MTL::RenderPassStencilAttachmentDescriptor* stencilAttachment)
657  {
658      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilAttachment_), stencilAttachment);
659  }
660  
661  // property: visibilityResultBuffer
662  _MTL_INLINE MTL::Buffer* MTL::RenderPassDescriptor::visibilityResultBuffer() const
663  {
664      return Object::sendMessage<MTL::Buffer*>(this, _MTL_PRIVATE_SEL(visibilityResultBuffer));
665  }
666  
667  _MTL_INLINE void MTL::RenderPassDescriptor::setVisibilityResultBuffer(const MTL::Buffer* visibilityResultBuffer)
668  {
669      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setVisibilityResultBuffer_), visibilityResultBuffer);
670  }
671  
672  // property: renderTargetArrayLength
673  _MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::renderTargetArrayLength() const
674  {
675      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(renderTargetArrayLength));
676  }
677  
678  _MTL_INLINE void MTL::RenderPassDescriptor::setRenderTargetArrayLength(NS::UInteger renderTargetArrayLength)
679  {
680      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderTargetArrayLength_), renderTargetArrayLength);
681  }
682  
683  // property: imageblockSampleLength
684  _MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::imageblockSampleLength() const
685  {
686      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(imageblockSampleLength));
687  }
688  
689  _MTL_INLINE void MTL::RenderPassDescriptor::setImageblockSampleLength(NS::UInteger imageblockSampleLength)
690  {
691      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setImageblockSampleLength_), imageblockSampleLength);
692  }
693  
694  // property: threadgroupMemoryLength
695  _MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::threadgroupMemoryLength() const
696  {
697      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(threadgroupMemoryLength));
698  }
699  
700  _MTL_INLINE void MTL::RenderPassDescriptor::setThreadgroupMemoryLength(NS::UInteger threadgroupMemoryLength)
701  {
702      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setThreadgroupMemoryLength_), threadgroupMemoryLength);
703  }
704  
705  // property: tileWidth
706  _MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::tileWidth() const
707  {
708      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileWidth));
709  }
710  
711  _MTL_INLINE void MTL::RenderPassDescriptor::setTileWidth(NS::UInteger tileWidth)
712  {
713      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileWidth_), tileWidth);
714  }
715  
716  // property: tileHeight
717  _MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::tileHeight() const
718  {
719      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(tileHeight));
720  }
721  
722  _MTL_INLINE void MTL::RenderPassDescriptor::setTileHeight(NS::UInteger tileHeight)
723  {
724      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setTileHeight_), tileHeight);
725  }
726  
727  // property: defaultRasterSampleCount
728  _MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::defaultRasterSampleCount() const
729  {
730      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(defaultRasterSampleCount));
731  }
732  
733  _MTL_INLINE void MTL::RenderPassDescriptor::setDefaultRasterSampleCount(NS::UInteger defaultRasterSampleCount)
734  {
735      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDefaultRasterSampleCount_), defaultRasterSampleCount);
736  }
737  
738  // property: renderTargetWidth
739  _MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::renderTargetWidth() const
740  {
741      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(renderTargetWidth));
742  }
743  
744  _MTL_INLINE void MTL::RenderPassDescriptor::setRenderTargetWidth(NS::UInteger renderTargetWidth)
745  {
746      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderTargetWidth_), renderTargetWidth);
747  }
748  
749  // property: renderTargetHeight
750  _MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::renderTargetHeight() const
751  {
752      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(renderTargetHeight));
753  }
754  
755  _MTL_INLINE void MTL::RenderPassDescriptor::setRenderTargetHeight(NS::UInteger renderTargetHeight)
756  {
757      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRenderTargetHeight_), renderTargetHeight);
758  }
759  
760  // method: setSamplePositions:count:
761  _MTL_INLINE void MTL::RenderPassDescriptor::setSamplePositions(const MTL::SamplePosition* positions, NS::UInteger count)
762  {
763      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setSamplePositions_count_), positions, count);
764  }
765  
766  // method: getSamplePositions:count:
767  _MTL_INLINE NS::UInteger MTL::RenderPassDescriptor::getSamplePositions(MTL::SamplePosition* positions, NS::UInteger count)
768  {
769      return Object::sendMessage<NS::UInteger>(this, _MTL_PRIVATE_SEL(getSamplePositions_count_), positions, count);
770  }
771  
772  // property: rasterizationRateMap
773  _MTL_INLINE MTL::RasterizationRateMap* MTL::RenderPassDescriptor::rasterizationRateMap() const
774  {
775      return Object::sendMessage<MTL::RasterizationRateMap*>(this, _MTL_PRIVATE_SEL(rasterizationRateMap));
776  }
777  
778  _MTL_INLINE void MTL::RenderPassDescriptor::setRasterizationRateMap(const MTL::RasterizationRateMap* rasterizationRateMap)
779  {
780      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setRasterizationRateMap_), rasterizationRateMap);
781  }
782  
783  // property: sampleBufferAttachments
784  _MTL_INLINE MTL::RenderPassSampleBufferAttachmentDescriptorArray* MTL::RenderPassDescriptor::sampleBufferAttachments() const
785  {
786      return Object::sendMessage<MTL::RenderPassSampleBufferAttachmentDescriptorArray*>(this, _MTL_PRIVATE_SEL(sampleBufferAttachments));
787  }