1  //-------------------------------------------------------------------------------------------------------------------------------------------------------------
  2  //
  3  // Metal/MTLDepthStencil.hpp
  4  //
  5  // Copyright 2020-2024 Apple Inc.
  6  //
  7  // Licensed under the Apache License, Version 2.0 (the "License");
  8  // you may not use this file except in compliance with the License.
  9  // You may obtain a copy of the License at
 10  //
 11  //     http://www.apache.org/licenses/LICENSE-2.0
 12  //
 13  // Unless required by applicable law or agreed to in writing, software
 14  // distributed under the License is distributed on an "AS IS" BASIS,
 15  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 16  // See the License for the specific language governing permissions and
 17  // limitations under the License.
 18  //
 19  //-------------------------------------------------------------------------------------------------------------------------------------------------------------
 20  
 21  #pragma once
 22  
 23  #include "MTLDefines.hpp"
 24  #include "MTLHeaderBridge.hpp"
 25  #include "MTLPrivate.hpp"
 26  
 27  #include <Foundation/Foundation.hpp>
 28  
 29  #include "MTLDepthStencil.hpp"
 30  
 31  namespace MTL
 32  {
 33  _MTL_ENUM(NS::UInteger, CompareFunction) {
 34      CompareFunctionNever = 0,
 35      CompareFunctionLess = 1,
 36      CompareFunctionEqual = 2,
 37      CompareFunctionLessEqual = 3,
 38      CompareFunctionGreater = 4,
 39      CompareFunctionNotEqual = 5,
 40      CompareFunctionGreaterEqual = 6,
 41      CompareFunctionAlways = 7,
 42  };
 43  
 44  _MTL_ENUM(NS::UInteger, StencilOperation) {
 45      StencilOperationKeep = 0,
 46      StencilOperationZero = 1,
 47      StencilOperationReplace = 2,
 48      StencilOperationIncrementClamp = 3,
 49      StencilOperationDecrementClamp = 4,
 50      StencilOperationInvert = 5,
 51      StencilOperationIncrementWrap = 6,
 52      StencilOperationDecrementWrap = 7,
 53  };
 54  
 55  class StencilDescriptor : public NS::Copying<StencilDescriptor>
 56  {
 57  public:
 58      static class StencilDescriptor* alloc();
 59  
 60      class StencilDescriptor*        init();
 61  
 62      MTL::CompareFunction            stencilCompareFunction() const;
 63      void                            setStencilCompareFunction(MTL::CompareFunction stencilCompareFunction);
 64  
 65      MTL::StencilOperation           stencilFailureOperation() const;
 66      void                            setStencilFailureOperation(MTL::StencilOperation stencilFailureOperation);
 67  
 68      MTL::StencilOperation           depthFailureOperation() const;
 69      void                            setDepthFailureOperation(MTL::StencilOperation depthFailureOperation);
 70  
 71      MTL::StencilOperation           depthStencilPassOperation() const;
 72      void                            setDepthStencilPassOperation(MTL::StencilOperation depthStencilPassOperation);
 73  
 74      uint32_t                        readMask() const;
 75      void                            setReadMask(uint32_t readMask);
 76  
 77      uint32_t                        writeMask() const;
 78      void                            setWriteMask(uint32_t writeMask);
 79  };
 80  
 81  class DepthStencilDescriptor : public NS::Copying<DepthStencilDescriptor>
 82  {
 83  public:
 84      static class DepthStencilDescriptor* alloc();
 85  
 86      class DepthStencilDescriptor*        init();
 87  
 88      MTL::CompareFunction                 depthCompareFunction() const;
 89      void                                 setDepthCompareFunction(MTL::CompareFunction depthCompareFunction);
 90  
 91      bool                                 depthWriteEnabled() const;
 92      void                                 setDepthWriteEnabled(bool depthWriteEnabled);
 93  
 94      class StencilDescriptor*             frontFaceStencil() const;
 95      void                                 setFrontFaceStencil(const class StencilDescriptor* frontFaceStencil);
 96  
 97      class StencilDescriptor*             backFaceStencil() const;
 98      void                                 setBackFaceStencil(const class StencilDescriptor* backFaceStencil);
 99  
100      NS::String*                          label() const;
101      void                                 setLabel(const NS::String* label);
102  };
103  
104  class DepthStencilState : public NS::Referencing<DepthStencilState>
105  {
106  public:
107      NS::String*   label() const;
108  
109      class Device* device() const;
110  };
111  
112  }
113  
114  // static method: alloc
115  _MTL_INLINE MTL::StencilDescriptor* MTL::StencilDescriptor::alloc()
116  {
117      return NS::Object::alloc<MTL::StencilDescriptor>(_MTL_PRIVATE_CLS(MTLStencilDescriptor));
118  }
119  
120  // method: init
121  _MTL_INLINE MTL::StencilDescriptor* MTL::StencilDescriptor::init()
122  {
123      return NS::Object::init<MTL::StencilDescriptor>();
124  }
125  
126  // property: stencilCompareFunction
127  _MTL_INLINE MTL::CompareFunction MTL::StencilDescriptor::stencilCompareFunction() const
128  {
129      return Object::sendMessage<MTL::CompareFunction>(this, _MTL_PRIVATE_SEL(stencilCompareFunction));
130  }
131  
132  _MTL_INLINE void MTL::StencilDescriptor::setStencilCompareFunction(MTL::CompareFunction stencilCompareFunction)
133  {
134      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilCompareFunction_), stencilCompareFunction);
135  }
136  
137  // property: stencilFailureOperation
138  _MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::stencilFailureOperation() const
139  {
140      return Object::sendMessage<MTL::StencilOperation>(this, _MTL_PRIVATE_SEL(stencilFailureOperation));
141  }
142  
143  _MTL_INLINE void MTL::StencilDescriptor::setStencilFailureOperation(MTL::StencilOperation stencilFailureOperation)
144  {
145      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setStencilFailureOperation_), stencilFailureOperation);
146  }
147  
148  // property: depthFailureOperation
149  _MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::depthFailureOperation() const
150  {
151      return Object::sendMessage<MTL::StencilOperation>(this, _MTL_PRIVATE_SEL(depthFailureOperation));
152  }
153  
154  _MTL_INLINE void MTL::StencilDescriptor::setDepthFailureOperation(MTL::StencilOperation depthFailureOperation)
155  {
156      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthFailureOperation_), depthFailureOperation);
157  }
158  
159  // property: depthStencilPassOperation
160  _MTL_INLINE MTL::StencilOperation MTL::StencilDescriptor::depthStencilPassOperation() const
161  {
162      return Object::sendMessage<MTL::StencilOperation>(this, _MTL_PRIVATE_SEL(depthStencilPassOperation));
163  }
164  
165  _MTL_INLINE void MTL::StencilDescriptor::setDepthStencilPassOperation(MTL::StencilOperation depthStencilPassOperation)
166  {
167      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthStencilPassOperation_), depthStencilPassOperation);
168  }
169  
170  // property: readMask
171  _MTL_INLINE uint32_t MTL::StencilDescriptor::readMask() const
172  {
173      return Object::sendMessage<uint32_t>(this, _MTL_PRIVATE_SEL(readMask));
174  }
175  
176  _MTL_INLINE void MTL::StencilDescriptor::setReadMask(uint32_t readMask)
177  {
178      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setReadMask_), readMask);
179  }
180  
181  // property: writeMask
182  _MTL_INLINE uint32_t MTL::StencilDescriptor::writeMask() const
183  {
184      return Object::sendMessage<uint32_t>(this, _MTL_PRIVATE_SEL(writeMask));
185  }
186  
187  _MTL_INLINE void MTL::StencilDescriptor::setWriteMask(uint32_t writeMask)
188  {
189      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setWriteMask_), writeMask);
190  }
191  
192  // static method: alloc
193  _MTL_INLINE MTL::DepthStencilDescriptor* MTL::DepthStencilDescriptor::alloc()
194  {
195      return NS::Object::alloc<MTL::DepthStencilDescriptor>(_MTL_PRIVATE_CLS(MTLDepthStencilDescriptor));
196  }
197  
198  // method: init
199  _MTL_INLINE MTL::DepthStencilDescriptor* MTL::DepthStencilDescriptor::init()
200  {
201      return NS::Object::init<MTL::DepthStencilDescriptor>();
202  }
203  
204  // property: depthCompareFunction
205  _MTL_INLINE MTL::CompareFunction MTL::DepthStencilDescriptor::depthCompareFunction() const
206  {
207      return Object::sendMessage<MTL::CompareFunction>(this, _MTL_PRIVATE_SEL(depthCompareFunction));
208  }
209  
210  _MTL_INLINE void MTL::DepthStencilDescriptor::setDepthCompareFunction(MTL::CompareFunction depthCompareFunction)
211  {
212      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthCompareFunction_), depthCompareFunction);
213  }
214  
215  // property: depthWriteEnabled
216  _MTL_INLINE bool MTL::DepthStencilDescriptor::depthWriteEnabled() const
217  {
218      return Object::sendMessage<bool>(this, _MTL_PRIVATE_SEL(isDepthWriteEnabled));
219  }
220  
221  _MTL_INLINE void MTL::DepthStencilDescriptor::setDepthWriteEnabled(bool depthWriteEnabled)
222  {
223      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setDepthWriteEnabled_), depthWriteEnabled);
224  }
225  
226  // property: frontFaceStencil
227  _MTL_INLINE MTL::StencilDescriptor* MTL::DepthStencilDescriptor::frontFaceStencil() const
228  {
229      return Object::sendMessage<MTL::StencilDescriptor*>(this, _MTL_PRIVATE_SEL(frontFaceStencil));
230  }
231  
232  _MTL_INLINE void MTL::DepthStencilDescriptor::setFrontFaceStencil(const MTL::StencilDescriptor* frontFaceStencil)
233  {
234      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setFrontFaceStencil_), frontFaceStencil);
235  }
236  
237  // property: backFaceStencil
238  _MTL_INLINE MTL::StencilDescriptor* MTL::DepthStencilDescriptor::backFaceStencil() const
239  {
240      return Object::sendMessage<MTL::StencilDescriptor*>(this, _MTL_PRIVATE_SEL(backFaceStencil));
241  }
242  
243  _MTL_INLINE void MTL::DepthStencilDescriptor::setBackFaceStencil(const MTL::StencilDescriptor* backFaceStencil)
244  {
245      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setBackFaceStencil_), backFaceStencil);
246  }
247  
248  // property: label
249  _MTL_INLINE NS::String* MTL::DepthStencilDescriptor::label() const
250  {
251      return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
252  }
253  
254  _MTL_INLINE void MTL::DepthStencilDescriptor::setLabel(const NS::String* label)
255  {
256      Object::sendMessage<void>(this, _MTL_PRIVATE_SEL(setLabel_), label);
257  }
258  
259  // property: label
260  _MTL_INLINE NS::String* MTL::DepthStencilState::label() const
261  {
262      return Object::sendMessage<NS::String*>(this, _MTL_PRIVATE_SEL(label));
263  }
264  
265  // property: device
266  _MTL_INLINE MTL::Device* MTL::DepthStencilState::device() const
267  {
268      return Object::sendMessage<MTL::Device*>(this, _MTL_PRIVATE_SEL(device));
269  }