?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add ClusterShadingStage
[opensg.git] / Source / Contrib / Techniques / OSGClusterShadingStageBase.cpp
blobf0acfe26625027697954fc64233c15c9554a95f5
1 /*---------------------------------------------------------------------------*\
2 * OpenSG *
3 * *
4 * *
5 * Copyright (C) 2000-2013 by the OpenSG Forum *
6 * *
7 * www.opensg.org *
8 * *
9 * contact: dirk@opensg.org, gerrit.voss@vossg.org, carsten_neumann@gmx.net *
10 * *
11 \*---------------------------------------------------------------------------*/
12 /*---------------------------------------------------------------------------*\
13 * License *
14 * *
15 * This library is free software; you can redistribute it and/or modify it *
16 * under the terms of the GNU Library General Public License as published *
17 * by the Free Software Foundation, version 2. *
18 * *
19 * This library is distributed in the hope that it will be useful, but *
20 * WITHOUT ANY WARRANTY; without even the implied warranty of *
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU *
22 * Library General Public License for more details. *
23 * *
24 * You should have received a copy of the GNU Library General Public *
25 * License along with this library; if not, write to the Free Software *
26 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. *
27 * *
28 \*---------------------------------------------------------------------------*/
29 /*---------------------------------------------------------------------------*\
30 * Changes *
31 * *
32 * *
33 * *
34 * *
35 * *
36 * *
37 \*---------------------------------------------------------------------------*/
38
39 /*****************************************************************************\
40 *****************************************************************************
41 ** **
42 ** This file is automatically generated. **
43 ** **
44 ** Any changes made to this file WILL be lost when it is **
45 ** regenerated, which can become necessary at any time. **
46 ** **
47 ** Do not change this file, changes should be done in the derived **
48 ** class ClusterShadingStage!
49 ** **
50 *****************************************************************************
51 \*****************************************************************************/
52
53 #include <cstdlib>
54 #include <cstdio>
55
56 #ifdef WIN32
57 #pragma warning(disable: 4355) // turn off 'this' : used in base member initializer list warning
58 #pragma warning(disable: 4290) // disable exception specification warning
59 #endif
60
61 #include "OSGConfig.h"
62
63
64
65 #include "OSGNode.h" // FrustNode Class
66 #include "OSGAlgorithmComputeElement.h" // FrustAlgoElement Class
67 #include "OSGComputeShaderAlgorithm.h" // FrustCompShaderAlgo Class
68 #include "OSGMultiLightChunk.h" // MultiLightChunk Class
69 #include "OSGShaderProgramChunk.h" // ShaderProgChunk Class
70
71 #include "OSGClusterShadingStageBase.h"
72 #include "OSGClusterShadingStage.h"
73
74 #include <boost/bind.hpp>
75
76 OSG_BEGIN_NAMESPACE
77
78 /***************************************************************************\
79 * Description *
80 \***************************************************************************/
81
82 /*! \class OSG::ClusterShadingStage
83
84 */
85
86 /***************************************************************************\
87 * Field Documentation *
88 \***************************************************************************/
89
90 /*! \var UInt32 ClusterShadingStageBase::_sfBlockSize
91 The number of compute shader work group threads per xy-direction
92 */
93
94 /*! \var UInt32 ClusterShadingStageBase::_sfTileSize
95 The number of pixel per cluster tile per xy-direction. The overall number if
96 clusters is then tileSize^2 * numClusterZ.
97 */
98
99 /*! \var UInt32 ClusterShadingStageBase::_sfNumClusterZ
100 The number of clusters in the z direction. The overall number if
101 clusters is then tileSize^2 * numClusterZ.
102 */
103
104 /*! \var Real32 ClusterShadingStageBase::_sfNearPlaneOffset
105 z-coords below of zNear + near_plane_offset are mapped to cluster key 0, i.e.
106 the logarithmic clustering starts at zNear + near_plane_offset with key 1. Key 0
107 is therefor artificially. With this parameter you can enhance the cluster utilization.
108 */
109
110 /*! \var UInt32 ClusterShadingStageBase::_sfDispatchDataBindingPnt
111 The fragment shader binding point for the clustering data UBO.
112 */
113
114 /*! \var UInt32 ClusterShadingStageBase::_sfClusterDataBindingPnt
115 The fragment shader binding point for the clustering data UBO.
116 */
117
118 /*! \var UInt32 ClusterShadingStageBase::_sfLightBindingPnt
119 The fragment shader SSBO binding point for the multi light chunk.
120 */
121
122 /*! \var UInt32 ClusterShadingStageBase::_sfAffectedLightIndexListBindingPnt
123 The fragment shader binding point for the index list SSBO of the view frustum affecting lights.
124 */
125
126 /*! \var UInt32 ClusterShadingStageBase::_sfFrustumBindingPnt
127 The frustum and cull light computation shader binding point for the SSBO frustum buffer.
128 */
129
130 /*! \var UInt32 ClusterShadingStageBase::_sfLightIndexListBindingPnt
131 The fragment shader binding point for the index list SSBO of the cluster shading lights.
132 */
133
134 /*! \var UInt32 ClusterShadingStageBase::_sfLightIndexCounterBindingPnt
135 The fragment shader binding point for the index list global counter SSBO.
136 */
137
138 /*! \var UInt32 ClusterShadingStageBase::_sfLightGridBindingPnt
139 The fragment shader binding point for the texture image of the light grid.
140 */
141
142 /*! \var std::string ClusterShadingStageBase::_sfAffectedLightIndexListBlockName
143 The shader storage buffer block name for the affected light index buffer.
144 */
145
146 /*! \var std::string ClusterShadingStageBase::_sfAffectedLightIndexListVariableName
147 The variable name for the affected light index buffer.
148 */
149
150 /*! \var std::string ClusterShadingStageBase::_sfLightIndexListBlockName
151 The shader storage buffer block name for the global light index buffer.
152 */
153
154 /*! \var std::string ClusterShadingStageBase::_sfLightIndexListVariableName
155 The variable name for the global light index buffer.
156 */
157
158 /*! \var std::string ClusterShadingStageBase::_sfClusteringDataBlockName
159 The uniform buffer block name for the clustering data buffer.
160 */
161
162 /*! \var std::string ClusterShadingStageBase::_sfClusteringDataVariableName
163 The variable name for the clustering data buffer.
164 */
165
166 /*! \var std::string ClusterShadingStageBase::_sfLightGridVariableName
167 The variable name for the uniform light grid image array .
168 */
169
170 /*! \var bool ClusterShadingStageBase::_sfCalcFrustumsOnCPU
171 Calculate the view frustums on the CPU.
172 */
173
174 /*! \var bool ClusterShadingStageBase::_sfCullLighsOnCPU
175 Cull the lights on the CPU.
176 */
177
178 /*! \var bool ClusterShadingStageBase::_sfDisabled
179 Disable the stage completely. The geometry fragment shaders must act accordingly.
180 */
181
182 /*! \var UInt32 ClusterShadingStageBase::_sfMaxLightIndexListSize
183 The maximal number of light indices, i.e. the accumulated sum of all cluster lights. If the light index
184 list is completely filled all additional lights are silently dropped.
185 */
186
187 /*! \var UInt32 ClusterShadingStageBase::_sfMaxClusterLightCount
188 The maximal number of lights that can be attributed to one specific cluster. Realize, that
189 the accumulated sum of all cluster attributed lights must not exceed the maxLightIndexListSize.
190 If the number of lights for one cluster exceeds this limit the excessive lights are silently dropped.
191 */
192
193 /*! \var Node * ClusterShadingStageBase::_sfFrustNode
194 The frustum computation node.
195 */
196
197 /*! \var AlgorithmComputeElement * ClusterShadingStageBase::_sfFrustAlgoElement
198 The frustum algorithm computation element.
199 */
200
201 /*! \var ComputeShaderAlgorithm * ClusterShadingStageBase::_sfFrustCompShaderAlgo
202 The frustum computation shader algorithm.
203 */
204
205 /*! \var Node * ClusterShadingStageBase::_sfCullNode
206 The frustum computation node.
207 */
208
209 /*! \var AlgorithmComputeElement * ClusterShadingStageBase::_sfCullAlgoElement
210 The frustum algorithm computation element.
211 */
212
213 /*! \var ComputeShaderAlgorithm * ClusterShadingStageBase::_sfCullCompShaderAlgo
214 The frustum computation shader algorithm.
215 */
216
217 /*! \var MultiLightChunk * ClusterShadingStageBase::_sfMultiLightChunk
218 The multi light chunk.
219 */
220
221 /*! \var ShaderProgramChunk * ClusterShadingStageBase::_sfShaderProgChunk
222 The shader program chunk.
223 */
224
225
226 /***************************************************************************\
227 * FieldType/FieldTrait Instantiation *
228 \***************************************************************************/
229
230 #if !defined(OSG_DO_DOC) || defined(OSG_DOC_DEV)
231 PointerType FieldTraits<ClusterShadingStage *, nsOSG>::_type(
232 "ClusterShadingStagePtr",
233 "StagePtr",
234 ClusterShadingStage::getClassType(),
235 nsOSG);
236 #endif
237
238 OSG_FIELDTRAITS_GETTYPE_NS(ClusterShadingStage *, nsOSG)
239
240 /***************************************************************************\
241 * Field Description *
242 \***************************************************************************/
243
244 void ClusterShadingStageBase::classDescInserter(TypeObject &oType)
245 {
246 FieldDescriptionBase *pDesc = NULL;
247
248
249 pDesc = new SFUInt32::Description(
250 SFUInt32::getClassType(),
251 "blockSize",
252 "The number of compute shader work group threads per xy-direction\n",
253 BlockSizeFieldId, BlockSizeFieldMask,
254 false,
255 (Field::SFDefaultFlags | Field::FStdAccess),
256 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleBlockSize),
257 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleBlockSize));
258
259 oType.addInitialDesc(pDesc);
260
261 pDesc = new SFUInt32::Description(
262 SFUInt32::getClassType(),
263 "tileSize",
264 "The number of pixel per cluster tile per xy-direction. The overall number if\n"
265 "clusters is then tileSize^2 * numClusterZ.\n",
266 TileSizeFieldId, TileSizeFieldMask,
267 false,
268 (Field::SFDefaultFlags | Field::FStdAccess),
269 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleTileSize),
270 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleTileSize));
271
272 oType.addInitialDesc(pDesc);
273
274 pDesc = new SFUInt32::Description(
275 SFUInt32::getClassType(),
276 "numClusterZ",
277 "The number of clusters in the z direction. The overall number if\n"
278 "clusters is then tileSize^2 * numClusterZ.\n",
279 NumClusterZFieldId, NumClusterZFieldMask,
280 false,
281 (Field::SFDefaultFlags | Field::FStdAccess),
282 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleNumClusterZ),
283 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleNumClusterZ));
284
285 oType.addInitialDesc(pDesc);
286
287 pDesc = new SFReal32::Description(
288 SFReal32::getClassType(),
289 "nearPlaneOffset",
290 "z-coords below of zNear + near_plane_offset are mapped to cluster key 0, i.e.\n"
291 "the logarithmic clustering starts at zNear + near_plane_offset with key 1. Key 0\n"
292 "is therefor artificially. With this parameter you can enhance the cluster utilization.\n",
293 NearPlaneOffsetFieldId, NearPlaneOffsetFieldMask,
294 false,
295 (Field::SFDefaultFlags | Field::FStdAccess),
296 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleNearPlaneOffset),
297 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleNearPlaneOffset));
298
299 oType.addInitialDesc(pDesc);
300
301 pDesc = new SFUInt32::Description(
302 SFUInt32::getClassType(),
303 "dispatchDataBindingPnt",
304 "The fragment shader binding point for the clustering data UBO.\n",
305 DispatchDataBindingPntFieldId, DispatchDataBindingPntFieldMask,
306 false,
307 (Field::SFDefaultFlags | Field::FStdAccess),
308 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleDispatchDataBindingPnt),
309 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleDispatchDataBindingPnt));
310
311 oType.addInitialDesc(pDesc);
312
313 pDesc = new SFUInt32::Description(
314 SFUInt32::getClassType(),
315 "clusterDataBindingPnt",
316 "The fragment shader binding point for the clustering data UBO.\n",
317 ClusterDataBindingPntFieldId, ClusterDataBindingPntFieldMask,
318 false,
319 (Field::SFDefaultFlags | Field::FStdAccess),
320 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleClusterDataBindingPnt),
321 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleClusterDataBindingPnt));
322
323 oType.addInitialDesc(pDesc);
324
325 pDesc = new SFUInt32::Description(
326 SFUInt32::getClassType(),
327 "lightBindingPnt",
328 "The fragment shader SSBO binding point for the multi light chunk.\n",
329 LightBindingPntFieldId, LightBindingPntFieldMask,
330 false,
331 (Field::SFDefaultFlags | Field::FStdAccess),
332 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleLightBindingPnt),
333 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleLightBindingPnt));
334
335 oType.addInitialDesc(pDesc);
336
337 pDesc = new SFUInt32::Description(
338 SFUInt32::getClassType(),
339 "affectedLightIndexListBindingPnt",
340 "The fragment shader binding point for the index list SSBO of the view frustum affecting lights.\n",
341 AffectedLightIndexListBindingPntFieldId, AffectedLightIndexListBindingPntFieldMask,
342 false,
343 (Field::SFDefaultFlags | Field::FStdAccess),
344 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleAffectedLightIndexListBindingPnt),
345 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleAffectedLightIndexListBindingPnt));
346
347 oType.addInitialDesc(pDesc);
348
349 pDesc = new SFUInt32::Description(
350 SFUInt32::getClassType(),
351 "frustumBindingPnt",
352 "The frustum and cull light computation shader binding point for the SSBO frustum buffer.\n",
353 FrustumBindingPntFieldId, FrustumBindingPntFieldMask,
354 false,
355 (Field::SFDefaultFlags | Field::FStdAccess),
356 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleFrustumBindingPnt),
357 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleFrustumBindingPnt));
358
359 oType.addInitialDesc(pDesc);
360
361 pDesc = new SFUInt32::Description(
362 SFUInt32::getClassType(),
363 "lightIndexListBindingPnt",
364 "The fragment shader binding point for the index list SSBO of the cluster shading lights.\n",
365 LightIndexListBindingPntFieldId, LightIndexListBindingPntFieldMask,
366 false,
367 (Field::SFDefaultFlags | Field::FStdAccess),
368 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleLightIndexListBindingPnt),
369 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleLightIndexListBindingPnt));
370
371 oType.addInitialDesc(pDesc);
372
373 pDesc = new SFUInt32::Description(
374 SFUInt32::getClassType(),
375 "lightIndexCounterBindingPnt",
376 "The fragment shader binding point for the index list global counter SSBO.\n",
377 LightIndexCounterBindingPntFieldId, LightIndexCounterBindingPntFieldMask,
378 false,
379 (Field::SFDefaultFlags | Field::FStdAccess),
380 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleLightIndexCounterBindingPnt),
381 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleLightIndexCounterBindingPnt));
382
383 oType.addInitialDesc(pDesc);
384
385 pDesc = new SFUInt32::Description(
386 SFUInt32::getClassType(),
387 "lightGridBindingPnt",
388 "The fragment shader binding point for the texture image of the light grid.\n",
389 LightGridBindingPntFieldId, LightGridBindingPntFieldMask,
390 false,
391 (Field::SFDefaultFlags | Field::FStdAccess),
392 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleLightGridBindingPnt),
393 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleLightGridBindingPnt));
394
395 oType.addInitialDesc(pDesc);
396
397 pDesc = new SFString::Description(
398 SFString::getClassType(),
399 "affectedLightIndexListBlockName",
400 "The shader storage buffer block name for the affected light index buffer.\n",
401 AffectedLightIndexListBlockNameFieldId, AffectedLightIndexListBlockNameFieldMask,
402 false,
403 (Field::SFDefaultFlags | Field::FStdAccess),
404 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleAffectedLightIndexListBlockName),
405 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleAffectedLightIndexListBlockName));
406
407 oType.addInitialDesc(pDesc);
408
409 pDesc = new SFString::Description(
410 SFString::getClassType(),
411 "affectedLightIndexListVariableName",
412 "The variable name for the affected light index buffer.\n",
413 AffectedLightIndexListVariableNameFieldId, AffectedLightIndexListVariableNameFieldMask,
414 false,
415 (Field::SFDefaultFlags | Field::FStdAccess),
416 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleAffectedLightIndexListVariableName),
417 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleAffectedLightIndexListVariableName));
418
419 oType.addInitialDesc(pDesc);
420
421 pDesc = new SFString::Description(
422 SFString::getClassType(),
423 "lightIndexListBlockName",
424 "The shader storage buffer block name for the global light index buffer.\n",
425 LightIndexListBlockNameFieldId, LightIndexListBlockNameFieldMask,
426 false,
427 (Field::SFDefaultFlags | Field::FStdAccess),
428 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleLightIndexListBlockName),
429 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleLightIndexListBlockName));
430
431 oType.addInitialDesc(pDesc);
432
433 pDesc = new SFString::Description(
434 SFString::getClassType(),
435 "lightIndexListVariableName",
436 "The variable name for the global light index buffer.\n",
437 LightIndexListVariableNameFieldId, LightIndexListVariableNameFieldMask,
438 false,
439 (Field::SFDefaultFlags | Field::FStdAccess),
440 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleLightIndexListVariableName),
441 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleLightIndexListVariableName));
442
443 oType.addInitialDesc(pDesc);
444
445 pDesc = new SFString::Description(
446 SFString::getClassType(),
447 "clusteringDataBlockName",
448 "The uniform buffer block name for the clustering data buffer.\n",
449 ClusteringDataBlockNameFieldId, ClusteringDataBlockNameFieldMask,
450 false,
451 (Field::SFDefaultFlags | Field::FStdAccess),
452 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleClusteringDataBlockName),
453 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleClusteringDataBlockName));
454
455 oType.addInitialDesc(pDesc);
456
457 pDesc = new SFString::Description(
458 SFString::getClassType(),
459 "clusteringDataVariableName",
460 "The variable name for the clustering data buffer.\n",
461 ClusteringDataVariableNameFieldId, ClusteringDataVariableNameFieldMask,
462 false,
463 (Field::SFDefaultFlags | Field::FStdAccess),
464 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleClusteringDataVariableName),
465 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleClusteringDataVariableName));
466
467 oType.addInitialDesc(pDesc);
468
469 pDesc = new SFString::Description(
470 SFString::getClassType(),
471 "lightGridVariableName",
472 "The variable name for the uniform light grid image array .\n",
473 LightGridVariableNameFieldId, LightGridVariableNameFieldMask,
474 false,
475 (Field::SFDefaultFlags | Field::FStdAccess),
476 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleLightGridVariableName),
477 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleLightGridVariableName));
478
479 oType.addInitialDesc(pDesc);
480
481 pDesc = new SFBool::Description(
482 SFBool::getClassType(),
483 "calcFrustumsOnCPU",
484 "Calculate the view frustums on the CPU.\n",
485 CalcFrustumsOnCPUFieldId, CalcFrustumsOnCPUFieldMask,
486 false,
487 (Field::SFDefaultFlags | Field::FStdAccess),
488 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleCalcFrustumsOnCPU),
489 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleCalcFrustumsOnCPU));
490
491 oType.addInitialDesc(pDesc);
492
493 pDesc = new SFBool::Description(
494 SFBool::getClassType(),
495 "cullLighsOnCPU",
496 "Cull the lights on the CPU.\n",
497 CullLighsOnCPUFieldId, CullLighsOnCPUFieldMask,
498 false,
499 (Field::SFDefaultFlags | Field::FStdAccess),
500 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleCullLighsOnCPU),
501 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleCullLighsOnCPU));
502
503 oType.addInitialDesc(pDesc);
504
505 pDesc = new SFBool::Description(
506 SFBool::getClassType(),
507 "disabled",
508 "Disable the stage completely. The geometry fragment shaders must act accordingly.\n",
509 DisabledFieldId, DisabledFieldMask,
510 false,
511 (Field::SFDefaultFlags | Field::FStdAccess),
512 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleDisabled),
513 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleDisabled));
514
515 oType.addInitialDesc(pDesc);
516
517 pDesc = new SFUInt32::Description(
518 SFUInt32::getClassType(),
519 "maxLightIndexListSize",
520 "The maximal number of light indices, i.e. the accumulated sum of all cluster lights. If the light index\n"
521 "list is completely filled all additional lights are silently dropped.\n",
522 MaxLightIndexListSizeFieldId, MaxLightIndexListSizeFieldMask,
523 false,
524 (Field::SFDefaultFlags | Field::FStdAccess),
525 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleMaxLightIndexListSize),
526 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleMaxLightIndexListSize));
527
528 oType.addInitialDesc(pDesc);
529
530 pDesc = new SFUInt32::Description(
531 SFUInt32::getClassType(),
532 "maxClusterLightCount",
533 "The maximal number of lights that can be attributed to one specific cluster. Realize, that\n"
534 "the accumulated sum of all cluster attributed lights must not exceed the maxLightIndexListSize.\n"
535 "If the number of lights for one cluster exceeds this limit the excessive lights are silently dropped.\n",
536 MaxClusterLightCountFieldId, MaxClusterLightCountFieldMask,
537 false,
538 (Field::SFDefaultFlags | Field::FStdAccess),
539 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleMaxClusterLightCount),
540 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleMaxClusterLightCount));
541
542 oType.addInitialDesc(pDesc);
543
544 pDesc = new SFUnrecNodePtr::Description(
545 SFUnrecNodePtr::getClassType(),
546 "frustNode",
547 "The frustum computation node.\n",
548 FrustNodeFieldId, FrustNodeFieldMask,
549 true,
550 (Field::SFDefaultFlags | Field::FStdAccess),
551 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleFrustNode),
552 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleFrustNode));
553
554 oType.addInitialDesc(pDesc);
555
556 pDesc = new SFUnrecAlgorithmComputeElementPtr::Description(
557 SFUnrecAlgorithmComputeElementPtr::getClassType(),
558 "frustAlgoElement",
559 "The frustum algorithm computation element.\n",
560 FrustAlgoElementFieldId, FrustAlgoElementFieldMask,
561 true,
562 (Field::SFDefaultFlags | Field::FStdAccess),
563 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleFrustAlgoElement),
564 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleFrustAlgoElement));
565
566 oType.addInitialDesc(pDesc);
567
568 pDesc = new SFUnrecComputeShaderAlgorithmPtr::Description(
569 SFUnrecComputeShaderAlgorithmPtr::getClassType(),
570 "frustCompShaderAlgo",
571 "The frustum computation shader algorithm.\n",
572 FrustCompShaderAlgoFieldId, FrustCompShaderAlgoFieldMask,
573 true,
574 (Field::SFDefaultFlags | Field::FStdAccess),
575 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleFrustCompShaderAlgo),
576 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleFrustCompShaderAlgo));
577
578 oType.addInitialDesc(pDesc);
579
580 pDesc = new SFUnrecNodePtr::Description(
581 SFUnrecNodePtr::getClassType(),
582 "cullNode",
583 "The frustum computation node.\n",
584 CullNodeFieldId, CullNodeFieldMask,
585 true,
586 (Field::SFDefaultFlags | Field::FStdAccess),
587 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleCullNode),
588 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleCullNode));
589
590 oType.addInitialDesc(pDesc);
591
592 pDesc = new SFUnrecAlgorithmComputeElementPtr::Description(
593 SFUnrecAlgorithmComputeElementPtr::getClassType(),
594 "cullAlgoElement",
595 "The frustum algorithm computation element.\n",
596 CullAlgoElementFieldId, CullAlgoElementFieldMask,
597 true,
598 (Field::SFDefaultFlags | Field::FStdAccess),
599 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleCullAlgoElement),
600 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleCullAlgoElement));
601
602 oType.addInitialDesc(pDesc);
603
604 pDesc = new SFUnrecComputeShaderAlgorithmPtr::Description(
605 SFUnrecComputeShaderAlgorithmPtr::getClassType(),
606 "cullCompShaderAlgo",
607 "The frustum computation shader algorithm.\n",
608 CullCompShaderAlgoFieldId, CullCompShaderAlgoFieldMask,
609 true,
610 (Field::SFDefaultFlags | Field::FStdAccess),
611 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleCullCompShaderAlgo),
612 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleCullCompShaderAlgo));
613
614 oType.addInitialDesc(pDesc);
615
616 pDesc = new SFUnrecMultiLightChunkPtr::Description(
617 SFUnrecMultiLightChunkPtr::getClassType(),
618 "multiLightChunk",
619 "The multi light chunk.\n",
620 MultiLightChunkFieldId, MultiLightChunkFieldMask,
621 false,
622 (Field::SFDefaultFlags | Field::FStdAccess),
623 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleMultiLightChunk),
624 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleMultiLightChunk));
625
626 oType.addInitialDesc(pDesc);
627
628 pDesc = new SFUnrecShaderProgramChunkPtr::Description(
629 SFUnrecShaderProgramChunkPtr::getClassType(),
630 "shaderProgChunk",
631 "The shader program chunk.\n",
632 ShaderProgChunkFieldId, ShaderProgChunkFieldMask,
633 true,
634 (Field::SFDefaultFlags | Field::FStdAccess),
635 static_cast<FieldEditMethodSig>(&ClusterShadingStage::editHandleShaderProgChunk),
636 static_cast<FieldGetMethodSig >(&ClusterShadingStage::getHandleShaderProgChunk));
637
638 oType.addInitialDesc(pDesc);
639 }
640
641
642 ClusterShadingStageBase::TypeObject ClusterShadingStageBase::_type(
643 ClusterShadingStageBase::getClassname(),
644 Inherited::getClassname(),
645 "NULL",
646 nsOSG, //Namespace
647 reinterpret_cast<PrototypeCreateF>(&ClusterShadingStageBase::createEmptyLocal),
648 reinterpret_cast<InitContainerF>(&ClusterShadingStage::initMethod),
649 reinterpret_cast<ExitContainerF>(&ClusterShadingStage::exitMethod),
650 reinterpret_cast<InitalInsertDescFunc>(&ClusterShadingStage::classDescInserter),
651 false,
652 0,
653 "<?xml version=\"1.0\"?>\n"
654 "\n"
655 "<FieldContainer\n"
656 " name=\"ClusterShadingStage\"\n"
657 " parent=\"Stage\"\n"
658 " library=\"ContribTechniques\"\n"
659 " pointerfieldtypes=\"none\"\n"
660 " structure=\"concrete\"\n"
661 " systemcomponent=\"true\"\n"
662 " parentsystemcomponent=\"true\"\n"
663 " decoratable=\"false\"\n"
664 " useLocalIncludes=\"false\"\n"
665 " isNodeCore=\"true\"\n"
666 " isBundle=\"false\"\n"
667 " >\n"
668 "\n"
669 " <Field\n"
670 " name=\"blockSize\"\n"
671 " type=\"UInt32\"\n"
672 " cardinality=\"single\"\n"
673 " visibility=\"external\"\n"
674 " defaultValue=\"16\"\n"
675 " access=\"public\"\n"
676 " >\n"
677 " The number of compute shader work group threads per xy-direction\n"
678 " </Field>\n"
679 "\n"
680 " <Field\n"
681 " name=\"tileSize\"\n"
682 " type=\"UInt32\"\n"
683 " cardinality=\"single\"\n"
684 " visibility=\"external\"\n"
685 " defaultValue=\"64\"\n"
686 " access=\"public\"\n"
687 " >\n"
688 " The number of pixel per cluster tile per xy-direction. The overall number if\n"
689 " clusters is then tileSize^2 * numClusterZ.\n"
690 " </Field>\n"
691 "\n"
692 " <Field\n"
693 " name=\"numClusterZ\"\n"
694 " type=\"UInt32\"\n"
695 " cardinality=\"single\"\n"
696 " visibility=\"external\"\n"
697 " defaultValue=\"32\"\n"
698 " access=\"public\"\n"
699 " >\n"
700 " The number of clusters in the z direction. The overall number if\n"
701 " clusters is then tileSize^2 * numClusterZ.\n"
702 " </Field>\n"
703 "\n"
704 " <Field\n"
705 " name=\"nearPlaneOffset\"\n"
706 " type=\"Real32\"\n"
707 " cardinality=\"single\"\n"
708 " visibility=\"external\"\n"
709 " defaultValue=\"5.f\"\n"
710 " access=\"public\"\n"
711 " >\n"
712 " z-coords below of zNear + near_plane_offset are mapped to cluster key 0, i.e.\n"
713 " the logarithmic clustering starts at zNear + near_plane_offset with key 1. Key 0\n"
714 " is therefor artificially. With this parameter you can enhance the cluster utilization.\n"
715 " </Field>\n"
716 "\n"
717 " <Field\n"
718 " name=\"dispatchDataBindingPnt\"\n"
719 " type=\"UInt32\"\n"
720 " cardinality=\"single\"\n"
721 " visibility=\"external\"\n"
722 " defaultValue=\"1\"\n"
723 " access=\"public\"\n"
724 " >\n"
725 " The fragment shader binding point for the clustering data UBO.\n"
726 " </Field>\n"
727 "\n"
728 " <Field\n"
729 " name=\"clusterDataBindingPnt\"\n"
730 " type=\"UInt32\"\n"
731 " cardinality=\"single\"\n"
732 " visibility=\"external\"\n"
733 " defaultValue=\"2\"\n"
734 " access=\"public\"\n"
735 " >\n"
736 " The fragment shader binding point for the clustering data UBO.\n"
737 " </Field>\n"
738 "\n"
739 " <Field\n"
740 " name=\"lightBindingPnt\"\n"
741 " type=\"UInt32\"\n"
742 " cardinality=\"single\"\n"
743 " visibility=\"external\"\n"
744 " defaultValue=\"1\"\n"
745 " access=\"public\"\n"
746 " >\n"
747 " The fragment shader SSBO binding point for the multi light chunk.\n"
748 " </Field>\n"
749 "\n"
750 " <Field\n"
751 " name=\"affectedLightIndexListBindingPnt\"\n"
752 " type=\"UInt32\"\n"
753 " cardinality=\"single\"\n"
754 " visibility=\"external\"\n"
755 " defaultValue=\"2\"\n"
756 " access=\"public\"\n"
757 " >\n"
758 " The fragment shader binding point for the index list SSBO of the view frustum affecting lights.\n"
759 " </Field>\n"
760 "\n"
761 " <Field\n"
762 " name=\"frustumBindingPnt\"\n"
763 " type=\"UInt32\"\n"
764 " cardinality=\"single\"\n"
765 " visibility=\"external\"\n"
766 " defaultValue=\"3\"\n"
767 " access=\"public\"\n"
768 " >\n"
769 " The frustum and cull light computation shader binding point for the SSBO frustum buffer.\n"
770 " </Field>\n"
771 "\n"
772 " <Field\n"
773 " name=\"lightIndexListBindingPnt\"\n"
774 " type=\"UInt32\"\n"
775 " cardinality=\"single\"\n"
776 " visibility=\"external\"\n"
777 " defaultValue=\"4\"\n"
778 " access=\"public\"\n"
779 " >\n"
780 " The fragment shader binding point for the index list SSBO of the cluster shading lights.\n"
781 " </Field>\n"
782 "\n"
783 " <Field\n"
784 " name=\"lightIndexCounterBindingPnt\"\n"
785 " type=\"UInt32\"\n"
786 " cardinality=\"single\"\n"
787 " visibility=\"external\"\n"
788 " defaultValue=\"5\"\n"
789 " access=\"public\"\n"
790 " >\n"
791 " The fragment shader binding point for the index list global counter SSBO.\n"
792 " </Field>\n"
793 "\n"
794 " <Field\n"
795 " name=\"lightGridBindingPnt\"\n"
796 " type=\"UInt32\"\n"
797 " cardinality=\"single\"\n"
798 " visibility=\"external\"\n"
799 " defaultValue=\"0\"\n"
800 " access=\"public\"\n"
801 " >\n"
802 " The fragment shader binding point for the texture image of the light grid.\n"
803 " </Field>\n"
804 "\n"
805 " <Field\n"
806 " name=\"affectedLightIndexListBlockName\"\n"
807 " type=\"std::string\"\n"
808 " cardinality=\"single\"\n"
809 " visibility=\"external\"\n"
810 " access=\"public\"\n"
811 " defaultValue='\"AffectedLightIndexList\"'\n"
812 " >\n"
813 " The shader storage buffer block name for the affected light index buffer.\n"
814 " </Field>\n"
815 "\n"
816 " <Field\n"
817 " name=\"affectedLightIndexListVariableName\"\n"
818 " type=\"std::string\"\n"
819 " cardinality=\"single\"\n"
820 " visibility=\"external\"\n"
821 " access=\"public\"\n"
822 " defaultValue='\"affectedLightIndexList\"'\n"
823 " >\n"
824 " The variable name for the affected light index buffer.\n"
825 " </Field>\n"
826 "\n"
827 " <Field\n"
828 " name=\"lightIndexListBlockName\"\n"
829 " type=\"std::string\"\n"
830 " cardinality=\"single\"\n"
831 " visibility=\"external\"\n"
832 " access=\"public\"\n"
833 " defaultValue='\"LightIndexList\"'\n"
834 " >\n"
835 " The shader storage buffer block name for the global light index buffer.\n"
836 " </Field>\n"
837 "\n"
838 " <Field\n"
839 " name=\"lightIndexListVariableName\"\n"
840 " type=\"std::string\"\n"
841 " cardinality=\"single\"\n"
842 " visibility=\"external\"\n"
843 " access=\"public\"\n"
844 " defaultValue='\"lightIndexList\"'\n"
845 " >\n"
846 " The variable name for the global light index buffer.\n"
847 " </Field>\n"
848 "\n"
849 " <Field\n"
850 " name=\"clusteringDataBlockName\"\n"
851 " type=\"std::string\"\n"
852 " cardinality=\"single\"\n"
853 " visibility=\"external\"\n"
854 " access=\"public\"\n"
855 " defaultValue='\"ClusteringData\"'\n"
856 " >\n"
857 " The uniform buffer block name for the clustering data buffer.\n"
858 " </Field>\n"
859 "\n"
860 " <Field\n"
861 " name=\"clusteringDataVariableName\"\n"
862 " type=\"std::string\"\n"
863 " cardinality=\"single\"\n"
864 " visibility=\"external\"\n"
865 " access=\"public\"\n"
866 " defaultValue='\"clusteringData\"'\n"
867 " >\n"
868 " The variable name for the clustering data buffer.\n"
869 " </Field>\n"
870 "\n"
871 " <Field\n"
872 " name=\"lightGridVariableName\"\n"
873 " type=\"std::string\"\n"
874 " cardinality=\"single\"\n"
875 " visibility=\"external\"\n"
876 " access=\"public\"\n"
877 " defaultValue='\"light_grid\"'\n"
878 " >\n"
879 " The variable name for the uniform light grid image array .\n"
880 " </Field>\n"
881 "\n"
882 " <Field\n"
883 " name=\"calcFrustumsOnCPU\"\n"
884 " type=\"bool\"\n"
885 " cardinality=\"single\"\n"
886 " visibility=\"external\"\n"
887 " defaultValue=\"false\"\n"
888 " access=\"public\"\n"
889 " >\n"
890 " Calculate the view frustums on the CPU.\n"
891 " </Field>\n"
892 "\n"
893 " <Field\n"
894 " name=\"cullLighsOnCPU\"\n"
895 " type=\"bool\"\n"
896 " cardinality=\"single\"\n"
897 " visibility=\"external\"\n"
898 " defaultValue=\"false\"\n"
899 " access=\"public\"\n"
900 " >\n"
901 " Cull the lights on the CPU.\n"
902 " </Field>\n"
903 "\n"
904 " <Field\n"
905 " name=\"disabled\"\n"
906 " type=\"bool\"\n"
907 " cardinality=\"single\"\n"
908 " visibility=\"external\"\n"
909 " defaultValue=\"false\"\n"
910 " access=\"public\"\n"
911 " >\n"
912 " Disable the stage completely. The geometry fragment shaders must act accordingly.\n"
913 " </Field>\n"
914 "\n"
915 " <Field\n"
916 " name=\"maxLightIndexListSize\"\n"
917 " type=\"UInt32\"\n"
918 " cardinality=\"single\"\n"
919 " visibility=\"external\"\n"
920 " defaultValue=\"2097152\"\n"
921 " access=\"public\"\n"
922 " >\n"
923 " The maximal number of light indices, i.e. the accumulated sum of all cluster lights. If the light index\n"
924 " list is completely filled all additional lights are silently dropped.\n"
925 " </Field>\n"
926 "\n"
927 " <Field\n"
928 " name=\"maxClusterLightCount\"\n"
929 " type=\"UInt32\"\n"
930 " cardinality=\"single\"\n"
931 " visibility=\"external\"\n"
932 " defaultValue=\"1024\"\n"
933 " access=\"public\"\n"
934 " >\n"
935 " The maximal number of lights that can be attributed to one specific cluster. Realize, that\n"
936 " the accumulated sum of all cluster attributed lights must not exceed the maxLightIndexListSize.\n"
937 " If the number of lights for one cluster exceeds this limit the excessive lights are silently dropped.\n"
938 " </Field>\n"
939 "\n"
940 " <Field\n"
941 " name=\"frustNode\"\n"
942 " type=\"NodePtr\"\n"
943 " cardinality=\"single\"\n"
944 " visibility=\"internal\"\n"
945 " defaultValue=\"NULL\"\n"
946 " access=\"protected\"\n"
947 " >\n"
948 " The frustum computation node.\n"
949 " </Field>\n"
950 "\n"
951 " <Field\n"
952 " name=\"frustAlgoElement\"\n"
953 " type=\"AlgorithmComputeElementPtr\"\n"
954 " cardinality=\"single\"\n"
955 " visibility=\"internal\"\n"
956 " defaultValue=\"NULL\"\n"
957 " access=\"protected\"\n"
958 " >\n"
959 " The frustum algorithm computation element.\n"
960 " </Field>\n"
961 "\n"
962 " <Field\n"
963 " name=\"frustCompShaderAlgo\"\n"
964 " type=\"ComputeShaderAlgorithmPtr\"\n"
965 " cardinality=\"single\"\n"
966 " visibility=\"internal\"\n"
967 " defaultValue=\"NULL\"\n"
968 " access=\"protected\"\n"
969 " >\n"
970 " The frustum computation shader algorithm.\n"
971 " </Field>\n"
972 "\n"
973 " <Field\n"
974 " name=\"cullNode\"\n"
975 " type=\"NodePtr\"\n"
976 " cardinality=\"single\"\n"
977 " visibility=\"internal\"\n"
978 " defaultValue=\"NULL\"\n"
979 " access=\"protected\"\n"
980 " >\n"
981 " The frustum computation node.\n"
982 " </Field>\n"
983 "\n"
984 " <Field\n"
985 " name=\"cullAlgoElement\"\n"
986 " type=\"AlgorithmComputeElementPtr\"\n"
987 " cardinality=\"single\"\n"
988 " visibility=\"internal\"\n"
989 " defaultValue=\"NULL\"\n"
990 " access=\"protected\"\n"
991 " >\n"
992 " The frustum algorithm computation element.\n"
993 " </Field>\n"
994 "\n"
995 " <Field\n"
996 " name=\"cullCompShaderAlgo\"\n"
997 " type=\"ComputeShaderAlgorithmPtr\"\n"
998 " cardinality=\"single\"\n"
999 " visibility=\"internal\"\n"
1000 " defaultValue=\"NULL\"\n"
1001 " access=\"protected\"\n"
1002 " >\n"
1003 " The frustum computation shader algorithm.\n"
1004 " </Field>\n"
1005 "\n"
1006 " <Field\n"
1007 " name=\"multiLightChunk\"\n"
1008 " type=\"MultiLightChunkPtr\"\n"
1009 " cardinality=\"single\"\n"
1010 " visibility=\"external\"\n"
1011 " defaultValue=\"NULL\"\n"
1012 " access=\"public\"\n"
1013 " >\n"
1014 " The multi light chunk.\n"
1015 " </Field>\n"
1016 "\n"
1017 " <Field\n"
1018 " name=\"shaderProgChunk\"\n"
1019 " type=\"ShaderProgramChunkPtr\"\n"
1020 " cardinality=\"single\"\n"
1021 " visibility=\"internal\"\n"
1022 " defaultValue=\"NULL\"\n"
1023 " access=\"protected\"\n"
1024 " >\n"
1025 " The shader program chunk.\n"
1026 " </Field>\n"
1027 "\n"
1028 "</FieldContainer>\n",
1029 ""
1030 );
1031
1032 /*------------------------------ get -----------------------------------*/
1033
1034 FieldContainerType &ClusterShadingStageBase::getType(void)
1035 {
1036 return _type;
1037 }
1038
1039 const FieldContainerType &ClusterShadingStageBase::getType(void) const
1040 {
1041 return _type;
1042 }
1043
1044 UInt32 ClusterShadingStageBase::getContainerSize(void) const
1045 {
1046 return sizeof(ClusterShadingStage);
1047 }
1048
1049 /*------------------------- decorator get ------------------------------*/
1050
1051
1052 SFUInt32 *ClusterShadingStageBase::editSFBlockSize(void)
1053 {
1054 editSField(BlockSizeFieldMask);
1055
1056 return &_sfBlockSize;
1057 }
1058
1059 const SFUInt32 *ClusterShadingStageBase::getSFBlockSize(void) const
1060 {
1061 return &_sfBlockSize;
1062 }
1063
1064
1065 SFUInt32 *ClusterShadingStageBase::editSFTileSize(void)
1066 {
1067 editSField(TileSizeFieldMask);
1068
1069 return &_sfTileSize;
1070 }
1071
1072 const SFUInt32 *ClusterShadingStageBase::getSFTileSize(void) const
1073 {
1074 return &_sfTileSize;
1075 }
1076
1077
1078 SFUInt32 *ClusterShadingStageBase::editSFNumClusterZ(void)
1079 {
1080 editSField(NumClusterZFieldMask);
1081
1082 return &_sfNumClusterZ;
1083 }
1084
1085 const SFUInt32 *ClusterShadingStageBase::getSFNumClusterZ(void) const
1086 {
1087 return &_sfNumClusterZ;
1088 }
1089
1090
1091 SFReal32 *ClusterShadingStageBase::editSFNearPlaneOffset(void)
1092 {
1093 editSField(NearPlaneOffsetFieldMask);
1094
1095 return &_sfNearPlaneOffset;
1096 }
1097
1098 const SFReal32 *ClusterShadingStageBase::getSFNearPlaneOffset(void) const
1099 {
1100 return &_sfNearPlaneOffset;
1101 }
1102
1103
1104 SFUInt32 *ClusterShadingStageBase::editSFDispatchDataBindingPnt(void)
1105 {
1106 editSField(DispatchDataBindingPntFieldMask);
1107
1108 return &_sfDispatchDataBindingPnt;
1109 }
1110
1111 const SFUInt32 *ClusterShadingStageBase::getSFDispatchDataBindingPnt(void) const
1112 {
1113 return &_sfDispatchDataBindingPnt;
1114 }
1115
1116
1117 SFUInt32 *ClusterShadingStageBase::editSFClusterDataBindingPnt(void)
1118 {
1119 editSField(ClusterDataBindingPntFieldMask);
1120
1121 return &_sfClusterDataBindingPnt;
1122 }
1123
1124 const SFUInt32 *ClusterShadingStageBase::getSFClusterDataBindingPnt(void) const
1125 {
1126 return &_sfClusterDataBindingPnt;
1127 }
1128
1129
1130 SFUInt32 *ClusterShadingStageBase::editSFLightBindingPnt(void)
1131 {
1132 editSField(LightBindingPntFieldMask);
1133
1134 return &_sfLightBindingPnt;
1135 }
1136
1137 const SFUInt32 *ClusterShadingStageBase::getSFLightBindingPnt(void) const
1138 {
1139 return &_sfLightBindingPnt;
1140 }
1141
1142
1143 SFUInt32 *ClusterShadingStageBase::editSFAffectedLightIndexListBindingPnt(void)
1144 {
1145 editSField(AffectedLightIndexListBindingPntFieldMask);
1146
1147 return &_sfAffectedLightIndexListBindingPnt;
1148 }
1149
1150 const SFUInt32 *ClusterShadingStageBase::getSFAffectedLightIndexListBindingPnt(void) const
1151 {
1152 return &_sfAffectedLightIndexListBindingPnt;
1153 }
1154
1155
1156 SFUInt32 *ClusterShadingStageBase::editSFFrustumBindingPnt(void)
1157 {
1158 editSField(FrustumBindingPntFieldMask);
1159
1160 return &_sfFrustumBindingPnt;
1161 }
1162
1163 const SFUInt32 *ClusterShadingStageBase::getSFFrustumBindingPnt(void) const
1164 {
1165 return &_sfFrustumBindingPnt;
1166 }
1167
1168
1169 SFUInt32 *ClusterShadingStageBase::editSFLightIndexListBindingPnt(void)
1170 {
1171 editSField(LightIndexListBindingPntFieldMask);
1172
1173 return &_sfLightIndexListBindingPnt;
1174 }
1175
1176 const SFUInt32 *ClusterShadingStageBase::getSFLightIndexListBindingPnt(void) const
1177 {
1178 return &_sfLightIndexListBindingPnt;
1179 }
1180
1181
1182 SFUInt32 *ClusterShadingStageBase::editSFLightIndexCounterBindingPnt(void)
1183 {
1184 editSField(LightIndexCounterBindingPntFieldMask);
1185
1186 return &_sfLightIndexCounterBindingPnt;
1187 }
1188
1189 const SFUInt32 *ClusterShadingStageBase::getSFLightIndexCounterBindingPnt(void) const
1190 {
1191 return &_sfLightIndexCounterBindingPnt;
1192 }
1193
1194
1195 SFUInt32 *ClusterShadingStageBase::editSFLightGridBindingPnt(void)
1196 {
1197 editSField(LightGridBindingPntFieldMask);
1198
1199 return &_sfLightGridBindingPnt;
1200 }
1201
1202 const SFUInt32 *ClusterShadingStageBase::getSFLightGridBindingPnt(void) const
1203 {
1204 return &_sfLightGridBindingPnt;
1205 }
1206
1207
1208 SFString *ClusterShadingStageBase::editSFAffectedLightIndexListBlockName(void)
1209 {
1210 editSField(AffectedLightIndexListBlockNameFieldMask);
1211
1212 return &_sfAffectedLightIndexListBlockName;
1213 }
1214
1215 const SFString *ClusterShadingStageBase::getSFAffectedLightIndexListBlockName(void) const
1216 {
1217 return &_sfAffectedLightIndexListBlockName;
1218 }
1219
1220
1221 SFString *ClusterShadingStageBase::editSFAffectedLightIndexListVariableName(void)
1222 {
1223 editSField(AffectedLightIndexListVariableNameFieldMask);
1224
1225 return &_sfAffectedLightIndexListVariableName;
1226 }
1227
1228 const SFString *ClusterShadingStageBase::getSFAffectedLightIndexListVariableName(void) const
1229 {
1230 return &_sfAffectedLightIndexListVariableName;
1231 }
1232
1233
1234 SFString *ClusterShadingStageBase::editSFLightIndexListBlockName(void)
1235 {
1236 editSField(LightIndexListBlockNameFieldMask);
1237
1238 return &_sfLightIndexListBlockName;
1239 }
1240
1241 const SFString *ClusterShadingStageBase::getSFLightIndexListBlockName(void) const
1242 {
1243 return &_sfLightIndexListBlockName;
1244 }
1245
1246
1247 SFString *ClusterShadingStageBase::editSFLightIndexListVariableName(void)
1248 {
1249 editSField(LightIndexListVariableNameFieldMask);
1250
1251 return &_sfLightIndexListVariableName;
1252 }
1253
1254 const SFString *ClusterShadingStageBase::getSFLightIndexListVariableName(void) const
1255 {
1256 return &_sfLightIndexListVariableName;
1257 }
1258
1259
1260 SFString *ClusterShadingStageBase::editSFClusteringDataBlockName(void)
1261 {
1262 editSField(ClusteringDataBlockNameFieldMask);
1263
1264 return &_sfClusteringDataBlockName;
1265 }
1266
1267 const SFString *ClusterShadingStageBase::getSFClusteringDataBlockName(void) const
1268 {
1269 return &_sfClusteringDataBlockName;
1270 }
1271
1272
1273 SFString *ClusterShadingStageBase::editSFClusteringDataVariableName(void)
1274 {
1275 editSField(ClusteringDataVariableNameFieldMask);
1276
1277 return &_sfClusteringDataVariableName;
1278 }
1279
1280 const SFString *ClusterShadingStageBase::getSFClusteringDataVariableName(void) const
1281 {
1282 return &_sfClusteringDataVariableName;
1283 }
1284
1285
1286 SFString *ClusterShadingStageBase::editSFLightGridVariableName(void)
1287 {
1288 editSField(LightGridVariableNameFieldMask);
1289
1290 return &_sfLightGridVariableName;
1291 }
1292
1293 const SFString *ClusterShadingStageBase::getSFLightGridVariableName(void) const
1294 {
1295 return &_sfLightGridVariableName;
1296 }
1297
1298
1299 SFBool *ClusterShadingStageBase::editSFCalcFrustumsOnCPU(void)
1300 {
1301 editSField(CalcFrustumsOnCPUFieldMask);
1302
1303 return &_sfCalcFrustumsOnCPU;
1304 }
1305
1306 const SFBool *ClusterShadingStageBase::getSFCalcFrustumsOnCPU(void) const
1307 {
1308 return &_sfCalcFrustumsOnCPU;
1309 }
1310
1311
1312 SFBool *ClusterShadingStageBase::editSFCullLighsOnCPU(void)
1313 {
1314 editSField(CullLighsOnCPUFieldMask);
1315
1316 return &_sfCullLighsOnCPU;
1317 }
1318
1319 const SFBool *ClusterShadingStageBase::getSFCullLighsOnCPU(void) const
1320 {
1321 return &_sfCullLighsOnCPU;
1322 }
1323
1324
1325 SFBool *ClusterShadingStageBase::editSFDisabled(void)
1326 {
1327 editSField(DisabledFieldMask);
1328
1329 return &_sfDisabled;
1330 }
1331
1332 const SFBool *ClusterShadingStageBase::getSFDisabled(void) const
1333 {
1334 return &_sfDisabled;
1335 }
1336
1337
1338 SFUInt32 *ClusterShadingStageBase::editSFMaxLightIndexListSize(void)
1339 {
1340 editSField(MaxLightIndexListSizeFieldMask);
1341
1342 return &_sfMaxLightIndexListSize;
1343 }
1344
1345 const SFUInt32 *ClusterShadingStageBase::getSFMaxLightIndexListSize(void) const
1346 {
1347 return &_sfMaxLightIndexListSize;
1348 }
1349
1350
1351 SFUInt32 *ClusterShadingStageBase::editSFMaxClusterLightCount(void)
1352 {
1353 editSField(MaxClusterLightCountFieldMask);
1354
1355 return &_sfMaxClusterLightCount;
1356 }
1357
1358 const SFUInt32 *ClusterShadingStageBase::getSFMaxClusterLightCount(void) const
1359 {
1360 return &_sfMaxClusterLightCount;
1361 }
1362
1363
1364 //! Get the ClusterShadingStage::_sfFrustNode field.
1365 const SFUnrecNodePtr *ClusterShadingStageBase::getSFFrustNode(void) const
1366 {
1367 return &_sfFrustNode;
1368 }
1369
1370 SFUnrecNodePtr *ClusterShadingStageBase::editSFFrustNode (void)
1371 {
1372 editSField(FrustNodeFieldMask);
1373
1374 return &_sfFrustNode;
1375 }
1376
1377 //! Get the value of the ClusterShadingStage::_sfFrustNode field.
1378 Node * ClusterShadingStageBase::getFrustNode(void) const
1379 {
1380 return _sfFrustNode.getValue();
1381 }
1382
1383 //! Set the value of the ClusterShadingStage::_sfFrustNode field.
1384 void ClusterShadingStageBase::setFrustNode(Node * const value)
1385 {
1386 editSField(FrustNodeFieldMask);
1387
1388 _sfFrustNode.setValue(value);
1389 }
1390
1391
1392 //! Get the ClusterShadingStage::_sfFrustAlgoElement field.
1393 const SFUnrecAlgorithmComputeElementPtr *ClusterShadingStageBase::getSFFrustAlgoElement(void) const
1394 {
1395 return &_sfFrustAlgoElement;
1396 }
1397
1398 SFUnrecAlgorithmComputeElementPtr *ClusterShadingStageBase::editSFFrustAlgoElement(void)
1399 {
1400 editSField(FrustAlgoElementFieldMask);
1401
1402 return &_sfFrustAlgoElement;
1403 }
1404
1405 //! Get the value of the ClusterShadingStage::_sfFrustAlgoElement field.
1406 AlgorithmComputeElement * ClusterShadingStageBase::getFrustAlgoElement(void) const
1407 {
1408 return _sfFrustAlgoElement.getValue();
1409 }
1410
1411 //! Set the value of the ClusterShadingStage::_sfFrustAlgoElement field.
1412 void ClusterShadingStageBase::setFrustAlgoElement(AlgorithmComputeElement * const value)
1413 {
1414 editSField(FrustAlgoElementFieldMask);
1415
1416 _sfFrustAlgoElement.setValue(value);
1417 }
1418
1419
1420 //! Get the ClusterShadingStage::_sfFrustCompShaderAlgo field.
1421 const SFUnrecComputeShaderAlgorithmPtr *ClusterShadingStageBase::getSFFrustCompShaderAlgo(void) const
1422 {
1423 return &_sfFrustCompShaderAlgo;
1424 }
1425
1426 SFUnrecComputeShaderAlgorithmPtr *ClusterShadingStageBase::editSFFrustCompShaderAlgo(void)
1427 {
1428 editSField(FrustCompShaderAlgoFieldMask);
1429
1430 return &_sfFrustCompShaderAlgo;
1431 }
1432
1433 //! Get the value of the ClusterShadingStage::_sfFrustCompShaderAlgo field.
1434 ComputeShaderAlgorithm * ClusterShadingStageBase::getFrustCompShaderAlgo(void) const
1435 {
1436 return _sfFrustCompShaderAlgo.getValue();
1437 }
1438
1439 //! Set the value of the ClusterShadingStage::_sfFrustCompShaderAlgo field.
1440 void ClusterShadingStageBase::setFrustCompShaderAlgo(ComputeShaderAlgorithm * const value)
1441 {
1442 editSField(FrustCompShaderAlgoFieldMask);
1443
1444 _sfFrustCompShaderAlgo.setValue(value);
1445 }
1446
1447
1448 //! Get the ClusterShadingStage::_sfCullNode field.
1449 const SFUnrecNodePtr *ClusterShadingStageBase::getSFCullNode(void) const
1450 {
1451 return &_sfCullNode;
1452 }
1453
1454 SFUnrecNodePtr *ClusterShadingStageBase::editSFCullNode (void)
1455 {
1456 editSField(CullNodeFieldMask);
1457
1458 return &_sfCullNode;
1459 }
1460
1461 //! Get the value of the ClusterShadingStage::_sfCullNode field.
1462 Node * ClusterShadingStageBase::getCullNode(void) const
1463 {
1464 return _sfCullNode.getValue();
1465 }
1466
1467 //! Set the value of the ClusterShadingStage::_sfCullNode field.
1468 void ClusterShadingStageBase::setCullNode(Node * const value)
1469 {
1470 editSField(CullNodeFieldMask);
1471
1472 _sfCullNode.setValue(value);
1473 }
1474
1475
1476 //! Get the ClusterShadingStage::_sfCullAlgoElement field.
1477 const SFUnrecAlgorithmComputeElementPtr *ClusterShadingStageBase::getSFCullAlgoElement(void) const
1478 {
1479 return &_sfCullAlgoElement;
1480 }
1481
1482 SFUnrecAlgorithmComputeElementPtr *ClusterShadingStageBase::editSFCullAlgoElement(void)
1483 {
1484 editSField(CullAlgoElementFieldMask);
1485
1486 return &_sfCullAlgoElement;
1487 }
1488
1489 //! Get the value of the ClusterShadingStage::_sfCullAlgoElement field.
1490 AlgorithmComputeElement * ClusterShadingStageBase::getCullAlgoElement(void) const
1491 {
1492 return _sfCullAlgoElement.getValue();
1493 }
1494
1495 //! Set the value of the ClusterShadingStage::_sfCullAlgoElement field.
1496 void ClusterShadingStageBase::setCullAlgoElement(AlgorithmComputeElement * const value)
1497 {
1498 editSField(CullAlgoElementFieldMask);
1499
1500 _sfCullAlgoElement.setValue(value);
1501 }
1502
1503
1504 //! Get the ClusterShadingStage::_sfCullCompShaderAlgo field.
1505 const SFUnrecComputeShaderAlgorithmPtr *ClusterShadingStageBase::getSFCullCompShaderAlgo(void) const
1506 {
1507 return &_sfCullCompShaderAlgo;
1508 }
1509
1510 SFUnrecComputeShaderAlgorithmPtr *ClusterShadingStageBase::editSFCullCompShaderAlgo(void)
1511 {
1512 editSField(CullCompShaderAlgoFieldMask);
1513
1514 return &_sfCullCompShaderAlgo;
1515 }
1516
1517 //! Get the value of the ClusterShadingStage::_sfCullCompShaderAlgo field.
1518 ComputeShaderAlgorithm * ClusterShadingStageBase::getCullCompShaderAlgo(void) const
1519 {
1520 return _sfCullCompShaderAlgo.getValue();
1521 }
1522
1523 //! Set the value of the ClusterShadingStage::_sfCullCompShaderAlgo field.
1524 void ClusterShadingStageBase::setCullCompShaderAlgo(ComputeShaderAlgorithm * const value)
1525 {
1526 editSField(CullCompShaderAlgoFieldMask);
1527
1528 _sfCullCompShaderAlgo.setValue(value);
1529 }
1530
1531
1532 //! Get the ClusterShadingStage::_sfMultiLightChunk field.
1533 const SFUnrecMultiLightChunkPtr *ClusterShadingStageBase::getSFMultiLightChunk(void) const
1534 {
1535 return &_sfMultiLightChunk;
1536 }
1537
1538 SFUnrecMultiLightChunkPtr *ClusterShadingStageBase::editSFMultiLightChunk(void)
1539 {
1540 editSField(MultiLightChunkFieldMask);
1541
1542 return &_sfMultiLightChunk;
1543 }
1544
1545 //! Get the value of the ClusterShadingStage::_sfMultiLightChunk field.
1546 MultiLightChunk * ClusterShadingStageBase::getMultiLightChunk(void) const
1547 {
1548 return _sfMultiLightChunk.getValue();
1549 }
1550
1551 //! Set the value of the ClusterShadingStage::_sfMultiLightChunk field.
1552 void ClusterShadingStageBase::setMultiLightChunk(MultiLightChunk * const value)
1553 {
1554 editSField(MultiLightChunkFieldMask);
1555
1556 _sfMultiLightChunk.setValue(value);
1557 }
1558
1559
1560 //! Get the ClusterShadingStage::_sfShaderProgChunk field.
1561 const SFUnrecShaderProgramChunkPtr *ClusterShadingStageBase::getSFShaderProgChunk(void) const
1562 {
1563 return &_sfShaderProgChunk;
1564 }
1565
1566 SFUnrecShaderProgramChunkPtr *ClusterShadingStageBase::editSFShaderProgChunk(void)
1567 {
1568 editSField(ShaderProgChunkFieldMask);
1569
1570 return &_sfShaderProgChunk;
1571 }
1572
1573 //! Get the value of the ClusterShadingStage::_sfShaderProgChunk field.
1574 ShaderProgramChunk * ClusterShadingStageBase::getShaderProgChunk(void) const
1575 {
1576 return _sfShaderProgChunk.getValue();
1577 }
1578
1579 //! Set the value of the ClusterShadingStage::_sfShaderProgChunk field.
1580 void ClusterShadingStageBase::setShaderProgChunk(ShaderProgramChunk * const value)
1581 {
1582 editSField(ShaderProgChunkFieldMask);
1583
1584 _sfShaderProgChunk.setValue(value);
1585 }
1586
1587
1588
1589
1590
1591
1592 /*------------------------------ access -----------------------------------*/
1593
1594 SizeT ClusterShadingStageBase::getBinSize(ConstFieldMaskArg whichField)
1595 {
1596 SizeT returnValue = Inherited::getBinSize(whichField);
1597
1598 if(FieldBits::NoField != (BlockSizeFieldMask & whichField))
1599 {
1600 returnValue += _sfBlockSize.getBinSize();
1601 }
1602 if(FieldBits::NoField != (TileSizeFieldMask & whichField))
1603 {
1604 returnValue += _sfTileSize.getBinSize();
1605 }
1606 if(FieldBits::NoField != (NumClusterZFieldMask & whichField))
1607 {
1608 returnValue += _sfNumClusterZ.getBinSize();
1609 }
1610 if(FieldBits::NoField != (NearPlaneOffsetFieldMask & whichField))
1611 {
1612 returnValue += _sfNearPlaneOffset.getBinSize();
1613 }
1614 if(FieldBits::NoField != (DispatchDataBindingPntFieldMask & whichField))
1615 {
1616 returnValue += _sfDispatchDataBindingPnt.getBinSize();
1617 }
1618 if(FieldBits::NoField != (ClusterDataBindingPntFieldMask & whichField))
1619 {
1620 returnValue += _sfClusterDataBindingPnt.getBinSize();
1621 }
1622 if(FieldBits::NoField != (LightBindingPntFieldMask & whichField))
1623 {
1624 returnValue += _sfLightBindingPnt.getBinSize();
1625 }
1626 if(FieldBits::NoField != (AffectedLightIndexListBindingPntFieldMask & whichField))
1627 {
1628 returnValue += _sfAffectedLightIndexListBindingPnt.getBinSize();
1629 }
1630 if(FieldBits::NoField != (FrustumBindingPntFieldMask & whichField))
1631 {
1632 returnValue += _sfFrustumBindingPnt.getBinSize();
1633 }
1634 if(FieldBits::NoField != (LightIndexListBindingPntFieldMask & whichField))
1635 {
1636 returnValue += _sfLightIndexListBindingPnt.getBinSize();
1637 }
1638 if(FieldBits::NoField != (LightIndexCounterBindingPntFieldMask & whichField))
1639 {
1640 returnValue += _sfLightIndexCounterBindingPnt.getBinSize();
1641 }
1642 if(FieldBits::NoField != (LightGridBindingPntFieldMask & whichField))
1643 {
1644 returnValue += _sfLightGridBindingPnt.getBinSize();
1645 }
1646 if(FieldBits::NoField != (AffectedLightIndexListBlockNameFieldMask & whichField))
1647 {
1648 returnValue += _sfAffectedLightIndexListBlockName.getBinSize();
1649 }
1650 if(FieldBits::NoField != (AffectedLightIndexListVariableNameFieldMask & whichField))
1651 {
1652 returnValue += _sfAffectedLightIndexListVariableName.getBinSize();
1653 }
1654 if(FieldBits::NoField != (LightIndexListBlockNameFieldMask & whichField))
1655 {
1656 returnValue += _sfLightIndexListBlockName.getBinSize();
1657 }
1658 if(FieldBits::NoField != (LightIndexListVariableNameFieldMask & whichField))
1659 {
1660 returnValue += _sfLightIndexListVariableName.getBinSize();
1661 }
1662 if(FieldBits::NoField != (ClusteringDataBlockNameFieldMask & whichField))
1663 {
1664 returnValue += _sfClusteringDataBlockName.getBinSize();
1665 }
1666 if(FieldBits::NoField != (ClusteringDataVariableNameFieldMask & whichField))
1667 {
1668 returnValue += _sfClusteringDataVariableName.getBinSize();
1669 }
1670 if(FieldBits::NoField != (LightGridVariableNameFieldMask & whichField))
1671 {
1672 returnValue += _sfLightGridVariableName.getBinSize();
1673 }
1674 if(FieldBits::NoField != (CalcFrustumsOnCPUFieldMask & whichField))
1675 {
1676 returnValue += _sfCalcFrustumsOnCPU.getBinSize();
1677 }
1678 if(FieldBits::NoField != (CullLighsOnCPUFieldMask & whichField))
1679 {
1680 returnValue += _sfCullLighsOnCPU.getBinSize();
1681 }
1682 if(FieldBits::NoField != (DisabledFieldMask & whichField))
1683 {
1684 returnValue += _sfDisabled.getBinSize();
1685 }
1686 if(FieldBits::NoField != (MaxLightIndexListSizeFieldMask & whichField))
1687 {
1688 returnValue += _sfMaxLightIndexListSize.getBinSize();
1689 }
1690 if(FieldBits::NoField != (MaxClusterLightCountFieldMask & whichField))
1691 {
1692 returnValue += _sfMaxClusterLightCount.getBinSize();
1693 }
1694 if(FieldBits::NoField != (FrustNodeFieldMask & whichField))
1695 {
1696 returnValue += _sfFrustNode.getBinSize();
1697 }
1698 if(FieldBits::NoField != (FrustAlgoElementFieldMask & whichField))
1699 {
1700 returnValue += _sfFrustAlgoElement.getBinSize();
1701 }
1702 if(FieldBits::NoField != (FrustCompShaderAlgoFieldMask & whichField))
1703 {
1704 returnValue += _sfFrustCompShaderAlgo.getBinSize();
1705 }
1706 if(FieldBits::NoField != (CullNodeFieldMask & whichField))
1707 {
1708 returnValue += _sfCullNode.getBinSize();
1709 }
1710 if(FieldBits::NoField != (CullAlgoElementFieldMask & whichField))
1711 {
1712 returnValue += _sfCullAlgoElement.getBinSize();
1713 }
1714 if(FieldBits::NoField != (CullCompShaderAlgoFieldMask & whichField))
1715 {
1716 returnValue += _sfCullCompShaderAlgo.getBinSize();
1717 }
1718 if(FieldBits::NoField != (MultiLightChunkFieldMask & whichField))
1719 {
1720 returnValue += _sfMultiLightChunk.getBinSize();
1721 }
1722 if(FieldBits::NoField != (ShaderProgChunkFieldMask & whichField))
1723 {
1724 returnValue += _sfShaderProgChunk.getBinSize();
1725 }
1726
1727 return returnValue;
1728 }
1729
1730 void ClusterShadingStageBase::copyToBin(BinaryDataHandler &pMem,
1731 ConstFieldMaskArg whichField)
1732 {
1733 Inherited::copyToBin(pMem, whichField);
1734
1735 if(FieldBits::NoField != (BlockSizeFieldMask & whichField))
1736 {
1737 _sfBlockSize.copyToBin(pMem);
1738 }
1739 if(FieldBits::NoField != (TileSizeFieldMask & whichField))
1740 {
1741 _sfTileSize.copyToBin(pMem);
1742 }
1743 if(FieldBits::NoField != (NumClusterZFieldMask & whichField))
1744 {
1745 _sfNumClusterZ.copyToBin(pMem);
1746 }
1747 if(FieldBits::NoField != (NearPlaneOffsetFieldMask & whichField))
1748 {
1749 _sfNearPlaneOffset.copyToBin(pMem);
1750 }
1751 if(FieldBits::NoField != (DispatchDataBindingPntFieldMask & whichField))
1752 {
1753 _sfDispatchDataBindingPnt.copyToBin(pMem);
1754 }
1755 if(FieldBits::NoField != (ClusterDataBindingPntFieldMask & whichField))
1756 {
1757 _sfClusterDataBindingPnt.copyToBin(pMem);
1758 }
1759 if(FieldBits::NoField != (LightBindingPntFieldMask & whichField))
1760 {
1761 _sfLightBindingPnt.copyToBin(pMem);
1762 }
1763 if(FieldBits::NoField != (AffectedLightIndexListBindingPntFieldMask & whichField))
1764 {
1765 _sfAffectedLightIndexListBindingPnt.copyToBin(pMem);
1766 }
1767 if(FieldBits::NoField != (FrustumBindingPntFieldMask & whichField))
1768 {
1769 _sfFrustumBindingPnt.copyToBin(pMem);
1770 }
1771 if(FieldBits::NoField != (LightIndexListBindingPntFieldMask & whichField))
1772 {
1773 _sfLightIndexListBindingPnt.copyToBin(pMem);
1774 }
1775 if(FieldBits::NoField != (LightIndexCounterBindingPntFieldMask & whichField))
1776 {
1777 _sfLightIndexCounterBindingPnt.copyToBin(pMem);
1778 }
1779 if(FieldBits::NoField != (LightGridBindingPntFieldMask & whichField))
1780 {
1781 _sfLightGridBindingPnt.copyToBin(pMem);
1782 }
1783 if(FieldBits::NoField != (AffectedLightIndexListBlockNameFieldMask & whichField))
1784 {
1785 _sfAffectedLightIndexListBlockName.copyToBin(pMem);
1786 }
1787 if(FieldBits::NoField != (AffectedLightIndexListVariableNameFieldMask & whichField))
1788 {
1789 _sfAffectedLightIndexListVariableName.copyToBin(pMem);
1790 }
1791 if(FieldBits::NoField != (LightIndexListBlockNameFieldMask & whichField))
1792 {
1793 _sfLightIndexListBlockName.copyToBin(pMem);
1794 }
1795 if(FieldBits::NoField != (LightIndexListVariableNameFieldMask & whichField))
1796 {
1797 _sfLightIndexListVariableName.copyToBin(pMem);
1798 }
1799 if(FieldBits::NoField != (ClusteringDataBlockNameFieldMask & whichField))
1800 {
1801 _sfClusteringDataBlockName.copyToBin(pMem);
1802 }
1803 if(FieldBits::NoField != (ClusteringDataVariableNameFieldMask & whichField))
1804 {
1805 _sfClusteringDataVariableName.copyToBin(pMem);
1806 }
1807 if(FieldBits::NoField != (LightGridVariableNameFieldMask & whichField))
1808 {
1809 _sfLightGridVariableName.copyToBin(pMem);
1810 }
1811 if(FieldBits::NoField != (CalcFrustumsOnCPUFieldMask & whichField))
1812 {
1813 _sfCalcFrustumsOnCPU.copyToBin(pMem);
1814 }
1815 if(FieldBits::NoField != (CullLighsOnCPUFieldMask & whichField))
1816 {
1817 _sfCullLighsOnCPU.copyToBin(pMem);
1818 }
1819 if(FieldBits::NoField != (DisabledFieldMask & whichField))
1820 {
1821 _sfDisabled.copyToBin(pMem);
1822 }
1823 if(FieldBits::NoField != (MaxLightIndexListSizeFieldMask & whichField))
1824 {
1825 _sfMaxLightIndexListSize.copyToBin(pMem);
1826 }
1827 if(FieldBits::NoField != (MaxClusterLightCountFieldMask & whichField))
1828 {
1829 _sfMaxClusterLightCount.copyToBin(pMem);
1830 }
1831 if(FieldBits::NoField != (FrustNodeFieldMask & whichField))
1832 {
1833 _sfFrustNode.copyToBin(pMem);
1834 }
1835 if(FieldBits::NoField != (FrustAlgoElementFieldMask & whichField))
1836 {
1837 _sfFrustAlgoElement.copyToBin(pMem);
1838 }
1839 if(FieldBits::NoField != (FrustCompShaderAlgoFieldMask & whichField))
1840 {
1841 _sfFrustCompShaderAlgo.copyToBin(pMem);
1842 }
1843 if(FieldBits::NoField != (CullNodeFieldMask & whichField))
1844 {
1845 _sfCullNode.copyToBin(pMem);
1846 }
1847 if(FieldBits::NoField != (CullAlgoElementFieldMask & whichField))
1848 {
1849 _sfCullAlgoElement.copyToBin(pMem);
1850 }
1851 if(FieldBits::NoField != (CullCompShaderAlgoFieldMask & whichField))
1852 {
1853 _sfCullCompShaderAlgo.copyToBin(pMem);
1854 }
1855 if(FieldBits::NoField != (MultiLightChunkFieldMask & whichField))
1856 {
1857 _sfMultiLightChunk.copyToBin(pMem);
1858 }
1859 if(FieldBits::NoField != (ShaderProgChunkFieldMask & whichField))
1860 {
1861 _sfShaderProgChunk.copyToBin(pMem);
1862 }
1863 }
1864
1865 void ClusterShadingStageBase::copyFromBin(BinaryDataHandler &pMem,
1866 ConstFieldMaskArg whichField)
1867 {
1868 Inherited::copyFromBin(pMem, whichField);
1869
1870 if(FieldBits::NoField != (BlockSizeFieldMask & whichField))
1871 {
1872 editSField(BlockSizeFieldMask);
1873 _sfBlockSize.copyFromBin(pMem);
1874 }
1875 if(FieldBits::NoField != (TileSizeFieldMask & whichField))
1876 {
1877 editSField(TileSizeFieldMask);
1878 _sfTileSize.copyFromBin(pMem);
1879 }
1880 if(FieldBits::NoField != (NumClusterZFieldMask & whichField))
1881 {
1882 editSField(NumClusterZFieldMask);
1883 _sfNumClusterZ.copyFromBin(pMem);
1884 }
1885 if(FieldBits::NoField != (NearPlaneOffsetFieldMask & whichField))
1886 {
1887 editSField(NearPlaneOffsetFieldMask);
1888 _sfNearPlaneOffset.copyFromBin(pMem);
1889 }
1890 if(FieldBits::NoField != (DispatchDataBindingPntFieldMask & whichField))
1891 {
1892 editSField(DispatchDataBindingPntFieldMask);
1893 _sfDispatchDataBindingPnt.copyFromBin(pMem);
1894 }
1895 if(FieldBits::NoField != (ClusterDataBindingPntFieldMask & whichField))
1896 {
1897 editSField(ClusterDataBindingPntFieldMask);
1898 _sfClusterDataBindingPnt.copyFromBin(pMem);
1899 }
1900 if(FieldBits::NoField != (LightBindingPntFieldMask & whichField))
1901 {
1902 editSField(LightBindingPntFieldMask);
1903 _sfLightBindingPnt.copyFromBin(pMem);
1904 }
1905 if(FieldBits::NoField != (AffectedLightIndexListBindingPntFieldMask & whichField))
1906 {
1907 editSField(AffectedLightIndexListBindingPntFieldMask);
1908 _sfAffectedLightIndexListBindingPnt.copyFromBin(pMem);
1909 }
1910 if(FieldBits::NoField != (FrustumBindingPntFieldMask & whichField))
1911 {
1912 editSField(FrustumBindingPntFieldMask);
1913 _sfFrustumBindingPnt.copyFromBin(pMem);
1914 }
1915 if(FieldBits::NoField != (LightIndexListBindingPntFieldMask & whichField))
1916 {
1917 editSField(LightIndexListBindingPntFieldMask);
1918 _sfLightIndexListBindingPnt.copyFromBin(pMem);
1919 }
1920 if(FieldBits::NoField != (LightIndexCounterBindingPntFieldMask & whichField))
1921 {
1922 editSField(LightIndexCounterBindingPntFieldMask);
1923 _sfLightIndexCounterBindingPnt.copyFromBin(pMem);
1924 }
1925 if(FieldBits::NoField != (LightGridBindingPntFieldMask & whichField))
1926 {
1927 editSField(LightGridBindingPntFieldMask);
1928 _sfLightGridBindingPnt.copyFromBin(pMem);
1929 }
1930 if(FieldBits::NoField != (AffectedLightIndexListBlockNameFieldMask & whichField))
1931 {
1932 editSField(AffectedLightIndexListBlockNameFieldMask);
1933 _sfAffectedLightIndexListBlockName.copyFromBin(pMem);
1934 }
1935 if(FieldBits::NoField != (AffectedLightIndexListVariableNameFieldMask & whichField))
1936 {
1937 editSField(AffectedLightIndexListVariableNameFieldMask);
1938 _sfAffectedLightIndexListVariableName.copyFromBin(pMem);
1939 }
1940 if(FieldBits::NoField != (LightIndexListBlockNameFieldMask & whichField))
1941 {
1942 editSField(LightIndexListBlockNameFieldMask);
1943 _sfLightIndexListBlockName.copyFromBin(pMem);
1944 }
1945 if(FieldBits::NoField != (LightIndexListVariableNameFieldMask & whichField))
1946 {
1947 editSField(LightIndexListVariableNameFieldMask);
1948 _sfLightIndexListVariableName.copyFromBin(pMem);
1949 }
1950 if(FieldBits::NoField != (ClusteringDataBlockNameFieldMask & whichField))
1951 {
1952 editSField(ClusteringDataBlockNameFieldMask);
1953 _sfClusteringDataBlockName.copyFromBin(pMem);
1954 }
1955 if(FieldBits::NoField != (ClusteringDataVariableNameFieldMask & whichField))
1956 {
1957 editSField(ClusteringDataVariableNameFieldMask);
1958 _sfClusteringDataVariableName.copyFromBin(pMem);
1959 }
1960 if(FieldBits::NoField != (LightGridVariableNameFieldMask & whichField))
1961 {
1962 editSField(LightGridVariableNameFieldMask);
1963 _sfLightGridVariableName.copyFromBin(pMem);
1964 }
1965 if(FieldBits::NoField != (CalcFrustumsOnCPUFieldMask & whichField))
1966 {
1967 editSField(CalcFrustumsOnCPUFieldMask);
1968 _sfCalcFrustumsOnCPU.copyFromBin(pMem);
1969 }
1970 if(FieldBits::NoField != (CullLighsOnCPUFieldMask & whichField))
1971 {
1972 editSField(CullLighsOnCPUFieldMask);
1973 _sfCullLighsOnCPU.copyFromBin(pMem);
1974 }
1975 if(FieldBits::NoField != (DisabledFieldMask & whichField))
1976 {
1977 editSField(DisabledFieldMask);
1978 _sfDisabled.copyFromBin(pMem);
1979 }
1980 if(FieldBits::NoField != (MaxLightIndexListSizeFieldMask & whichField))
1981 {
1982 editSField(MaxLightIndexListSizeFieldMask);
1983 _sfMaxLightIndexListSize.copyFromBin(pMem);
1984 }
1985 if(FieldBits::NoField != (MaxClusterLightCountFieldMask & whichField))
1986 {
1987 editSField(MaxClusterLightCountFieldMask);
1988 _sfMaxClusterLightCount.copyFromBin(pMem);
1989 }
1990 if(FieldBits::NoField != (FrustNodeFieldMask & whichField))
1991 {
1992 editSField(FrustNodeFieldMask);
1993 _sfFrustNode.copyFromBin(pMem);
1994 }
1995 if(FieldBits::NoField != (FrustAlgoElementFieldMask & whichField))
1996 {
1997 editSField(FrustAlgoElementFieldMask);
1998 _sfFrustAlgoElement.copyFromBin(pMem);
1999 }
2000 if(FieldBits::NoField != (FrustCompShaderAlgoFieldMask & whichField))
2001 {
2002 editSField(FrustCompShaderAlgoFieldMask);
2003 _sfFrustCompShaderAlgo.copyFromBin(pMem);
2004 }
2005 if(FieldBits::NoField != (CullNodeFieldMask & whichField))
2006 {
2007 editSField(CullNodeFieldMask);
2008 _sfCullNode.copyFromBin(pMem);
2009 }
2010 if(FieldBits::NoField != (CullAlgoElementFieldMask & whichField))
2011 {
2012 editSField(CullAlgoElementFieldMask);
2013 _sfCullAlgoElement.copyFromBin(pMem);
2014 }
2015 if(FieldBits::NoField != (CullCompShaderAlgoFieldMask & whichField))
2016 {
2017 editSField(CullCompShaderAlgoFieldMask);
2018 _sfCullCompShaderAlgo.copyFromBin(pMem);
2019 }
2020 if(FieldBits::NoField != (MultiLightChunkFieldMask & whichField))
2021 {
2022 editSField(MultiLightChunkFieldMask);
2023 _sfMultiLightChunk.copyFromBin(pMem);
2024 }
2025 if(FieldBits::NoField != (ShaderProgChunkFieldMask & whichField))
2026 {
2027 editSField(ShaderProgChunkFieldMask);
2028 _sfShaderProgChunk.copyFromBin(pMem);
2029 }
2030 }
2031
2032 //! create a new instance of the class
2033 ClusterShadingStageTransitPtr ClusterShadingStageBase::createLocal(BitVector bFlags)
2034 {
2035 ClusterShadingStageTransitPtr fc;
2036
2037 if(getClassType().getPrototype() != NULL)
2038 {
2039 FieldContainerTransitPtr tmpPtr =
2040 getClassType().getPrototype()-> shallowCopyLocal(bFlags);
2041
2042 fc = dynamic_pointer_cast<ClusterShadingStage>(tmpPtr);
2043 }
2044
2045 return fc;
2046 }
2047
2048 //! create a new instance of the class, copy the container flags
2049 ClusterShadingStageTransitPtr ClusterShadingStageBase::createDependent(BitVector bFlags)
2050 {
2051 ClusterShadingStageTransitPtr fc;
2052
2053 if(getClassType().getPrototype() != NULL)
2054 {
2055 FieldContainerTransitPtr tmpPtr =
2056 getClassType().getPrototype()-> shallowCopyDependent(bFlags);
2057
2058 fc = dynamic_pointer_cast<ClusterShadingStage>(tmpPtr);
2059 }
2060
2061 return fc;
2062 }
2063
2064 //! create a new instance of the class
2065 ClusterShadingStageTransitPtr ClusterShadingStageBase::create(void)
2066 {
2067 ClusterShadingStageTransitPtr fc;
2068
2069 if(getClassType().getPrototype() != NULL)
2070 {
2071 FieldContainerTransitPtr tmpPtr =
2072 getClassType().getPrototype()-> shallowCopy();
2073
2074 fc = dynamic_pointer_cast<ClusterShadingStage>(tmpPtr);
2075 }
2076
2077 return fc;
2078 }
2079
2080 ClusterShadingStage *ClusterShadingStageBase::createEmptyLocal(BitVector bFlags)
2081 {
2082 ClusterShadingStage *returnValue;
2083
2084 newPtr<ClusterShadingStage>(returnValue, bFlags);
2085
2086 returnValue->_pFieldFlags->_bNamespaceMask &= ~bFlags;
2087
2088 return returnValue;
2089 }
2090
2091 //! create an empty new instance of the class, do not copy the prototype
2092 ClusterShadingStage *ClusterShadingStageBase::createEmpty(void)
2093 {
2094 ClusterShadingStage *returnValue;
2095
2096 newPtr<ClusterShadingStage>(returnValue, Thread::getCurrentLocalFlags());
2097
2098 returnValue->_pFieldFlags->_bNamespaceMask &=
2099 ~Thread::getCurrentLocalFlags();
2100
2101 return returnValue;
2102 }
2103
2104
2105 FieldContainerTransitPtr ClusterShadingStageBase::shallowCopyLocal(
2106 BitVector bFlags) const
2107 {
2108 ClusterShadingStage *tmpPtr;
2109
2110 newPtr(tmpPtr, dynamic_cast<const ClusterShadingStage *>(this), bFlags);
2111
2112 FieldContainerTransitPtr returnValue(tmpPtr);
2113
2114 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~bFlags;
2115
2116 return returnValue;
2117 }
2118
2119 FieldContainerTransitPtr ClusterShadingStageBase::shallowCopyDependent(
2120 BitVector bFlags) const
2121 {
2122 ClusterShadingStage *tmpPtr;
2123
2124 newPtr(tmpPtr, dynamic_cast<const ClusterShadingStage *>(this), ~bFlags);
2125
2126 FieldContainerTransitPtr returnValue(tmpPtr);
2127
2128 tmpPtr->_pFieldFlags->_bNamespaceMask = bFlags;
2129
2130 return returnValue;
2131 }
2132
2133 FieldContainerTransitPtr ClusterShadingStageBase::shallowCopy(void) const
2134 {
2135 ClusterShadingStage *tmpPtr;
2136
2137 newPtr(tmpPtr,
2138 dynamic_cast<const ClusterShadingStage *>(this),
2139 Thread::getCurrentLocalFlags());
2140
2141 tmpPtr->_pFieldFlags->_bNamespaceMask &= ~Thread::getCurrentLocalFlags();
2142
2143 FieldContainerTransitPtr returnValue(tmpPtr);
2144
2145 return returnValue;
2146 }
2147
2148
2149
2150
2151 /*------------------------- constructors ----------------------------------*/
2152
2153 ClusterShadingStageBase::ClusterShadingStageBase(void) :
2154 Inherited(),
2155 _sfBlockSize (UInt32(16)),
2156 _sfTileSize (UInt32(64)),
2157 _sfNumClusterZ (UInt32(32)),
2158 _sfNearPlaneOffset (Real32(5.f)),
2159 _sfDispatchDataBindingPnt (UInt32(1)),
2160 _sfClusterDataBindingPnt (UInt32(2)),
2161 _sfLightBindingPnt (UInt32(1)),
2162 _sfAffectedLightIndexListBindingPnt(UInt32(2)),
2163 _sfFrustumBindingPnt (UInt32(3)),
2164 _sfLightIndexListBindingPnt(UInt32(4)),
2165 _sfLightIndexCounterBindingPnt(UInt32(5)),
2166 _sfLightGridBindingPnt (UInt32(0)),
2167 _sfAffectedLightIndexListBlockName(std::string("AffectedLightIndexList")),
2168 _sfAffectedLightIndexListVariableName(std::string("affectedLightIndexList")),
2169 _sfLightIndexListBlockName(std::string("LightIndexList")),
2170 _sfLightIndexListVariableName(std::string("lightIndexList")),
2171 _sfClusteringDataBlockName(std::string("ClusteringData")),
2172 _sfClusteringDataVariableName(std::string("clusteringData")),
2173 _sfLightGridVariableName (std::string("light_grid")),
2174 _sfCalcFrustumsOnCPU (bool(false)),
2175 _sfCullLighsOnCPU (bool(false)),
2176 _sfDisabled (bool(false)),
2177 _sfMaxLightIndexListSize (UInt32(2097152)),
2178 _sfMaxClusterLightCount (UInt32(1024)),
2179 _sfFrustNode (NULL),
2180 _sfFrustAlgoElement (NULL),
2181 _sfFrustCompShaderAlgo (NULL),
2182 _sfCullNode (NULL),
2183 _sfCullAlgoElement (NULL),
2184 _sfCullCompShaderAlgo (NULL),
2185 _sfMultiLightChunk (NULL),
2186 _sfShaderProgChunk (NULL)
2187 {
2188 }
2189
2190 ClusterShadingStageBase::ClusterShadingStageBase(const ClusterShadingStageBase &source) :
2191 Inherited(source),
2192 _sfBlockSize (source._sfBlockSize ),
2193 _sfTileSize (source._sfTileSize ),
2194 _sfNumClusterZ (source._sfNumClusterZ ),
2195 _sfNearPlaneOffset (source._sfNearPlaneOffset ),
2196 _sfDispatchDataBindingPnt (source._sfDispatchDataBindingPnt ),
2197 _sfClusterDataBindingPnt (source._sfClusterDataBindingPnt ),
2198 _sfLightBindingPnt (source._sfLightBindingPnt ),
2199 _sfAffectedLightIndexListBindingPnt(source._sfAffectedLightIndexListBindingPnt),
2200 _sfFrustumBindingPnt (source._sfFrustumBindingPnt ),
2201 _sfLightIndexListBindingPnt(source._sfLightIndexListBindingPnt),
2202 _sfLightIndexCounterBindingPnt(source._sfLightIndexCounterBindingPnt),
2203 _sfLightGridBindingPnt (source._sfLightGridBindingPnt ),
2204 _sfAffectedLightIndexListBlockName(source._sfAffectedLightIndexListBlockName),
2205 _sfAffectedLightIndexListVariableName(source._sfAffectedLightIndexListVariableName),
2206 _sfLightIndexListBlockName(source._sfLightIndexListBlockName),
2207 _sfLightIndexListVariableName(source._sfLightIndexListVariableName),
2208 _sfClusteringDataBlockName(source._sfClusteringDataBlockName),
2209 _sfClusteringDataVariableName(source._sfClusteringDataVariableName),
2210 _sfLightGridVariableName (source._sfLightGridVariableName ),
2211 _sfCalcFrustumsOnCPU (source._sfCalcFrustumsOnCPU ),
2212 _sfCullLighsOnCPU (source._sfCullLighsOnCPU ),
2213 _sfDisabled (source._sfDisabled ),
2214 _sfMaxLightIndexListSize (source._sfMaxLightIndexListSize ),
2215 _sfMaxClusterLightCount (source._sfMaxClusterLightCount ),
2216 _sfFrustNode (NULL),
2217 _sfFrustAlgoElement (NULL),
2218 _sfFrustCompShaderAlgo (NULL),
2219 _sfCullNode (NULL),
2220 _sfCullAlgoElement (NULL),
2221 _sfCullCompShaderAlgo (NULL),
2222 _sfMultiLightChunk (NULL),
2223 _sfShaderProgChunk (NULL)
2224 {
2225 }
2226
2227
2228 /*-------------------------- destructors ----------------------------------*/
2229
2230 ClusterShadingStageBase::~ClusterShadingStageBase(void)
2231 {
2232 }
2233
2234 void ClusterShadingStageBase::onCreate(const ClusterShadingStage *source)
2235 {
2236 Inherited::onCreate(source);
2237
2238 if(source != NULL)
2239 {
2240 ClusterShadingStage *pThis = static_cast<ClusterShadingStage *>(this);
2241
2242 pThis->setFrustNode(source->getFrustNode());
2243
2244 pThis->setFrustAlgoElement(source->getFrustAlgoElement());
2245
2246 pThis->setFrustCompShaderAlgo(source->getFrustCompShaderAlgo());
2247
2248 pThis->setCullNode(source->getCullNode());
2249
2250 pThis->setCullAlgoElement(source->getCullAlgoElement());
2251
2252 pThis->setCullCompShaderAlgo(source->getCullCompShaderAlgo());
2253
2254 pThis->setMultiLightChunk(source->getMultiLightChunk());
2255
2256 pThis->setShaderProgChunk(source->getShaderProgChunk());
2257 }
2258 }
2259
2260 GetFieldHandlePtr ClusterShadingStageBase::getHandleBlockSize (void) const
2261 {
2262 SFUInt32::GetHandlePtr returnValue(
2263 new SFUInt32::GetHandle(
2264 &_sfBlockSize,
2265 this->getType().getFieldDesc(BlockSizeFieldId),
2266 const_cast<ClusterShadingStageBase *>(this)));
2267
2268 return returnValue;
2269 }
2270
2271 EditFieldHandlePtr ClusterShadingStageBase::editHandleBlockSize (void)
2272 {
2273 SFUInt32::EditHandlePtr returnValue(
2274 new SFUInt32::EditHandle(
2275 &_sfBlockSize,
2276 this->getType().getFieldDesc(BlockSizeFieldId),
2277 this));
2278
2279
2280 editSField(BlockSizeFieldMask);
2281
2282 return returnValue;
2283 }
2284
2285 GetFieldHandlePtr ClusterShadingStageBase::getHandleTileSize (void) const
2286 {
2287 SFUInt32::GetHandlePtr returnValue(
2288 new SFUInt32::GetHandle(
2289 &_sfTileSize,
2290 this->getType().getFieldDesc(TileSizeFieldId),
2291 const_cast<ClusterShadingStageBase *>(this)));
2292
2293 return returnValue;
2294 }
2295
2296 EditFieldHandlePtr ClusterShadingStageBase::editHandleTileSize (void)
2297 {
2298 SFUInt32::EditHandlePtr returnValue(
2299 new SFUInt32::EditHandle(
2300 &_sfTileSize,
2301 this->getType().getFieldDesc(TileSizeFieldId),
2302 this));
2303
2304
2305 editSField(TileSizeFieldMask);
2306
2307 return returnValue;
2308 }
2309
2310 GetFieldHandlePtr ClusterShadingStageBase::getHandleNumClusterZ (void) const
2311 {
2312 SFUInt32::GetHandlePtr returnValue(
2313 new SFUInt32::GetHandle(
2314 &_sfNumClusterZ,
2315 this->getType().getFieldDesc(NumClusterZFieldId),
2316 const_cast<ClusterShadingStageBase *>(this)));
2317
2318 return returnValue;
2319 }
2320
2321 EditFieldHandlePtr ClusterShadingStageBase::editHandleNumClusterZ (void)
2322 {
2323 SFUInt32::EditHandlePtr returnValue(
2324 new SFUInt32::EditHandle(
2325 &_sfNumClusterZ,
2326 this->getType().getFieldDesc(NumClusterZFieldId),
2327 this));
2328
2329
2330 editSField(NumClusterZFieldMask);
2331
2332 return returnValue;
2333 }
2334
2335 GetFieldHandlePtr ClusterShadingStageBase::getHandleNearPlaneOffset (void) const
2336 {
2337 SFReal32::GetHandlePtr returnValue(
2338 new SFReal32::GetHandle(
2339 &_sfNearPlaneOffset,
2340 this->getType().getFieldDesc(NearPlaneOffsetFieldId),
2341 const_cast<ClusterShadingStageBase *>(this)));
2342
2343 return returnValue;
2344 }
2345
2346 EditFieldHandlePtr ClusterShadingStageBase::editHandleNearPlaneOffset(void)
2347 {
2348 SFReal32::EditHandlePtr returnValue(
2349 new SFReal32::EditHandle(
2350 &_sfNearPlaneOffset,
2351 this->getType().getFieldDesc(NearPlaneOffsetFieldId),
2352 this));
2353
2354
2355 editSField(NearPlaneOffsetFieldMask);
2356
2357 return returnValue;
2358 }
2359
2360 GetFieldHandlePtr ClusterShadingStageBase::getHandleDispatchDataBindingPnt (void) const
2361 {
2362 SFUInt32::GetHandlePtr returnValue(
2363 new SFUInt32::GetHandle(
2364 &_sfDispatchDataBindingPnt,
2365 this->getType().getFieldDesc(DispatchDataBindingPntFieldId),
2366 const_cast<ClusterShadingStageBase *>(this)));
2367
2368 return returnValue;
2369 }
2370
2371 EditFieldHandlePtr ClusterShadingStageBase::editHandleDispatchDataBindingPnt(void)
2372 {
2373 SFUInt32::EditHandlePtr returnValue(
2374 new SFUInt32::EditHandle(
2375 &_sfDispatchDataBindingPnt,
2376 this->getType().getFieldDesc(DispatchDataBindingPntFieldId),
2377 this));
2378
2379
2380 editSField(DispatchDataBindingPntFieldMask);
2381
2382 return returnValue;
2383 }
2384
2385 GetFieldHandlePtr ClusterShadingStageBase::getHandleClusterDataBindingPnt (void) const
2386 {
2387 SFUInt32::GetHandlePtr returnValue(
2388 new SFUInt32::GetHandle(
2389 &_sfClusterDataBindingPnt,
2390 this->getType().getFieldDesc(ClusterDataBindingPntFieldId),
2391 const_cast<ClusterShadingStageBase *>(this)));
2392
2393 return returnValue;
2394 }
2395
2396 EditFieldHandlePtr ClusterShadingStageBase::editHandleClusterDataBindingPnt(void)
2397 {
2398 SFUInt32::EditHandlePtr returnValue(
2399 new SFUInt32::EditHandle(
2400 &_sfClusterDataBindingPnt,
2401 this->getType().getFieldDesc(ClusterDataBindingPntFieldId),
2402 this));
2403
2404
2405 editSField(ClusterDataBindingPntFieldMask);
2406
2407 return returnValue;
2408 }
2409
2410 GetFieldHandlePtr ClusterShadingStageBase::getHandleLightBindingPnt (void) const
2411 {
2412 SFUInt32::GetHandlePtr returnValue(
2413 new SFUInt32::GetHandle(
2414 &_sfLightBindingPnt,
2415 this->getType().getFieldDesc(LightBindingPntFieldId),
2416 const_cast<ClusterShadingStageBase *>(this)));
2417
2418 return returnValue;
2419 }
2420
2421 EditFieldHandlePtr ClusterShadingStageBase::editHandleLightBindingPnt(void)
2422 {
2423 SFUInt32::EditHandlePtr returnValue(
2424 new SFUInt32::EditHandle(
2425 &_sfLightBindingPnt,
2426 this->getType().getFieldDesc(LightBindingPntFieldId),
2427 this));
2428
2429
2430 editSField(LightBindingPntFieldMask);
2431
2432 return returnValue;
2433 }
2434
2435 GetFieldHandlePtr ClusterShadingStageBase::getHandleAffectedLightIndexListBindingPnt (void) const
2436 {
2437 SFUInt32::GetHandlePtr returnValue(
2438 new SFUInt32::GetHandle(
2439 &_sfAffectedLightIndexListBindingPnt,
2440 this->getType().getFieldDesc(AffectedLightIndexListBindingPntFieldId),
2441 const_cast<ClusterShadingStageBase *>(this)));
2442
2443 return returnValue;
2444 }
2445
2446 EditFieldHandlePtr ClusterShadingStageBase::editHandleAffectedLightIndexListBindingPnt(void)
2447 {
2448 SFUInt32::EditHandlePtr returnValue(
2449 new SFUInt32::EditHandle(
2450 &_sfAffectedLightIndexListBindingPnt,
2451 this->getType().getFieldDesc(AffectedLightIndexListBindingPntFieldId),
2452 this));
2453
2454
2455 editSField(AffectedLightIndexListBindingPntFieldMask);
2456
2457 return returnValue;
2458 }
2459
2460 GetFieldHandlePtr ClusterShadingStageBase::getHandleFrustumBindingPnt (void) const
2461 {
2462 SFUInt32::GetHandlePtr returnValue(
2463 new SFUInt32::GetHandle(
2464 &_sfFrustumBindingPnt,
2465 this->getType().getFieldDesc(FrustumBindingPntFieldId),
2466 const_cast<ClusterShadingStageBase *>(this)));
2467
2468 return returnValue;
2469 }
2470
2471 EditFieldHandlePtr ClusterShadingStageBase::editHandleFrustumBindingPnt(void)
2472 {
2473 SFUInt32::EditHandlePtr returnValue(
2474 new SFUInt32::EditHandle(
2475 &_sfFrustumBindingPnt,
2476 this->getType().getFieldDesc(FrustumBindingPntFieldId),
2477 this));
2478
2479
2480 editSField(FrustumBindingPntFieldMask);
2481
2482 return returnValue;
2483 }
2484
2485 GetFieldHandlePtr ClusterShadingStageBase::getHandleLightIndexListBindingPnt (void) const
2486 {
2487 SFUInt32::GetHandlePtr returnValue(
2488 new SFUInt32::GetHandle(
2489 &_sfLightIndexListBindingPnt,
2490 this->getType().getFieldDesc(LightIndexListBindingPntFieldId),
2491 const_cast<ClusterShadingStageBase *>(this)));
2492
2493 return returnValue;
2494 }
2495
2496 EditFieldHandlePtr ClusterShadingStageBase::editHandleLightIndexListBindingPnt(void)
2497 {
2498 SFUInt32::EditHandlePtr returnValue(
2499 new SFUInt32::EditHandle(
2500 &_sfLightIndexListBindingPnt,
2501 this->getType().getFieldDesc(LightIndexListBindingPntFieldId),
2502 this));
2503
2504
2505 editSField(LightIndexListBindingPntFieldMask);
2506
2507 return returnValue;
2508 }
2509
2510 GetFieldHandlePtr ClusterShadingStageBase::getHandleLightIndexCounterBindingPnt (void) const
2511 {
2512 SFUInt32::GetHandlePtr returnValue(
2513 new SFUInt32::GetHandle(
2514 &_sfLightIndexCounterBindingPnt,
2515 this->getType().getFieldDesc(LightIndexCounterBindingPntFieldId),
2516 const_cast<ClusterShadingStageBase *>(this)));
2517
2518 return returnValue;
2519 }
2520
2521 EditFieldHandlePtr ClusterShadingStageBase::editHandleLightIndexCounterBindingPnt(void)
2522 {
2523 SFUInt32::EditHandlePtr returnValue(
2524 new SFUInt32::EditHandle(
2525 &_sfLightIndexCounterBindingPnt,
2526 this->getType().getFieldDesc(LightIndexCounterBindingPntFieldId),
2527 this));
2528
2529
2530 editSField(LightIndexCounterBindingPntFieldMask);
2531
2532 return returnValue;
2533 }
2534
2535 GetFieldHandlePtr ClusterShadingStageBase::getHandleLightGridBindingPnt (void) const
2536 {
2537 SFUInt32::GetHandlePtr returnValue(
2538 new SFUInt32::GetHandle(
2539 &_sfLightGridBindingPnt,
2540 this->getType().getFieldDesc(LightGridBindingPntFieldId),
2541 const_cast<ClusterShadingStageBase *>(this)));
2542
2543 return returnValue;
2544 }
2545
2546 EditFieldHandlePtr ClusterShadingStageBase::editHandleLightGridBindingPnt(void)
2547 {
2548 SFUInt32::EditHandlePtr returnValue(
2549 new SFUInt32::EditHandle(
2550 &_sfLightGridBindingPnt,
2551 this->getType().getFieldDesc(LightGridBindingPntFieldId),
2552 this));
2553
2554
2555 editSField(LightGridBindingPntFieldMask);
2556
2557 return returnValue;
2558 }
2559
2560 GetFieldHandlePtr ClusterShadingStageBase::getHandleAffectedLightIndexListBlockName (void) const
2561 {
2562 SFString::GetHandlePtr returnValue(
2563 new SFString::GetHandle(
2564 &_sfAffectedLightIndexListBlockName,
2565 this->getType().getFieldDesc(AffectedLightIndexListBlockNameFieldId),
2566 const_cast<ClusterShadingStageBase *>(this)));
2567
2568 return returnValue;
2569 }
2570
2571 EditFieldHandlePtr ClusterShadingStageBase::editHandleAffectedLightIndexListBlockName(void)
2572 {
2573 SFString::EditHandlePtr returnValue(
2574 new SFString::EditHandle(
2575 &_sfAffectedLightIndexListBlockName,
2576 this->getType().getFieldDesc(AffectedLightIndexListBlockNameFieldId),
2577 this));
2578
2579
2580 editSField(AffectedLightIndexListBlockNameFieldMask);
2581
2582 return returnValue;
2583 }
2584
2585 GetFieldHandlePtr ClusterShadingStageBase::getHandleAffectedLightIndexListVariableName (void) const
2586 {
2587 SFString::GetHandlePtr returnValue(
2588 new SFString::GetHandle(
2589 &_sfAffectedLightIndexListVariableName,
2590 this->getType().getFieldDesc(AffectedLightIndexListVariableNameFieldId),
2591 const_cast<ClusterShadingStageBase *>(this)));
2592
2593 return returnValue;
2594 }
2595
2596 EditFieldHandlePtr ClusterShadingStageBase::editHandleAffectedLightIndexListVariableName(void)
2597 {
2598 SFString::EditHandlePtr returnValue(
2599 new SFString::EditHandle(
2600 &_sfAffectedLightIndexListVariableName,
2601 this->getType().getFieldDesc(AffectedLightIndexListVariableNameFieldId),
2602 this));
2603
2604
2605 editSField(AffectedLightIndexListVariableNameFieldMask);
2606
2607 return returnValue;
2608 }
2609
2610 GetFieldHandlePtr ClusterShadingStageBase::getHandleLightIndexListBlockName (void) const
2611 {
2612 SFString::GetHandlePtr returnValue(
2613 new SFString::GetHandle(
2614 &_sfLightIndexListBlockName,
2615 this->getType().getFieldDesc(LightIndexListBlockNameFieldId),
2616 const_cast<ClusterShadingStageBase *>(this)));
2617
2618 return returnValue;
2619 }
2620
2621 EditFieldHandlePtr ClusterShadingStageBase::editHandleLightIndexListBlockName(void)
2622 {
2623 SFString::EditHandlePtr returnValue(
2624 new SFString::EditHandle(
2625 &_sfLightIndexListBlockName,
2626 this->getType().getFieldDesc(LightIndexListBlockNameFieldId),
2627 this));
2628
2629
2630 editSField(LightIndexListBlockNameFieldMask);
2631
2632 return returnValue;
2633 }
2634
2635 GetFieldHandlePtr ClusterShadingStageBase::getHandleLightIndexListVariableName (void) const
2636 {
2637 SFString::GetHandlePtr returnValue(
2638 new SFString::GetHandle(
2639 &_sfLightIndexListVariableName,
2640 this->getType().getFieldDesc(LightIndexListVariableNameFieldId),
2641 const_cast<ClusterShadingStageBase *>(this)));
2642
2643 return returnValue;
2644 }
2645
2646 EditFieldHandlePtr ClusterShadingStageBase::editHandleLightIndexListVariableName(void)
2647 {
2648 SFString::EditHandlePtr returnValue(
2649 new SFString::EditHandle(
2650 &_sfLightIndexListVariableName,
2651 this->getType().getFieldDesc(LightIndexListVariableNameFieldId),
2652 this));
2653
2654
2655 editSField(LightIndexListVariableNameFieldMask);
2656
2657 return returnValue;
2658 }
2659
2660 GetFieldHandlePtr ClusterShadingStageBase::getHandleClusteringDataBlockName (void) const
2661 {
2662 SFString::GetHandlePtr returnValue(
2663 new SFString::GetHandle(
2664 &_sfClusteringDataBlockName,
2665 this->getType().getFieldDesc(ClusteringDataBlockNameFieldId),
2666 const_cast<ClusterShadingStageBase *>(this)));
2667
2668 return returnValue;
2669 }
2670
2671 EditFieldHandlePtr ClusterShadingStageBase::editHandleClusteringDataBlockName(void)
2672 {
2673 SFString::EditHandlePtr returnValue(
2674 new SFString::EditHandle(
2675 &_sfClusteringDataBlockName,
2676 this->getType().getFieldDesc(ClusteringDataBlockNameFieldId),
2677 this));
2678
2679
2680 editSField(ClusteringDataBlockNameFieldMask);
2681
2682 return returnValue;
2683 }
2684
2685 GetFieldHandlePtr ClusterShadingStageBase::getHandleClusteringDataVariableName (void) const
2686 {
2687 SFString::GetHandlePtr returnValue(
2688 new SFString::GetHandle(
2689 &_sfClusteringDataVariableName,
2690 this->getType().getFieldDesc(ClusteringDataVariableNameFieldId),
2691 const_cast<ClusterShadingStageBase *>(this)));
2692
2693 return returnValue;
2694 }
2695
2696 EditFieldHandlePtr ClusterShadingStageBase::editHandleClusteringDataVariableName(void)
2697 {
2698 SFString::EditHandlePtr returnValue(
2699 new SFString::EditHandle(
2700 &_sfClusteringDataVariableName,
2701 this->getType().getFieldDesc(ClusteringDataVariableNameFieldId),
2702 this));
2703
2704
2705 editSField(ClusteringDataVariableNameFieldMask);
2706
2707 return returnValue;
2708 }
2709
2710 GetFieldHandlePtr ClusterShadingStageBase::getHandleLightGridVariableName (void) const
2711 {
2712 SFString::GetHandlePtr returnValue(
2713 new SFString::GetHandle(
2714 &_sfLightGridVariableName,
2715 this->getType().getFieldDesc(LightGridVariableNameFieldId),
2716 const_cast<ClusterShadingStageBase *>(this)));
2717
2718 return returnValue;
2719 }
2720
2721 EditFieldHandlePtr ClusterShadingStageBase::editHandleLightGridVariableName(void)
2722 {
2723 SFString::EditHandlePtr returnValue(
2724 new SFString::EditHandle(
2725 &_sfLightGridVariableName,
2726 this->getType().getFieldDesc(LightGridVariableNameFieldId),
2727 this));
2728
2729
2730 editSField(LightGridVariableNameFieldMask);
2731
2732 return returnValue;
2733 }
2734
2735 GetFieldHandlePtr ClusterShadingStageBase::getHandleCalcFrustumsOnCPU (void) const
2736 {
2737 SFBool::GetHandlePtr returnValue(
2738 new SFBool::GetHandle(
2739 &_sfCalcFrustumsOnCPU,
2740 this->getType().getFieldDesc(CalcFrustumsOnCPUFieldId),
2741 const_cast<ClusterShadingStageBase *>(this)));
2742
2743 return returnValue;
2744 }
2745
2746 EditFieldHandlePtr ClusterShadingStageBase::editHandleCalcFrustumsOnCPU(void)
2747 {
2748 SFBool::EditHandlePtr returnValue(
2749 new SFBool::EditHandle(
2750 &_sfCalcFrustumsOnCPU,
2751 this->getType().getFieldDesc(CalcFrustumsOnCPUFieldId),
2752 this));
2753
2754
2755 editSField(CalcFrustumsOnCPUFieldMask);
2756
2757 return returnValue;
2758 }
2759
2760 GetFieldHandlePtr ClusterShadingStageBase::getHandleCullLighsOnCPU (void) const
2761 {
2762 SFBool::GetHandlePtr returnValue(
2763 new SFBool::GetHandle(
2764 &_sfCullLighsOnCPU,
2765 this->getType().getFieldDesc(CullLighsOnCPUFieldId),
2766 const_cast<ClusterShadingStageBase *>(this)));
2767
2768 return returnValue;
2769 }
2770
2771 EditFieldHandlePtr ClusterShadingStageBase::editHandleCullLighsOnCPU (void)
2772 {
2773 SFBool::EditHandlePtr returnValue(
2774 new SFBool::EditHandle(
2775 &_sfCullLighsOnCPU,
2776 this->getType().getFieldDesc(CullLighsOnCPUFieldId),
2777 this));
2778
2779
2780 editSField(CullLighsOnCPUFieldMask);
2781
2782 return returnValue;
2783 }
2784
2785 GetFieldHandlePtr ClusterShadingStageBase::getHandleDisabled (void) const
2786 {
2787 SFBool::GetHandlePtr returnValue(
2788 new SFBool::GetHandle(
2789 &_sfDisabled,
2790 this->getType().getFieldDesc(DisabledFieldId),
2791 const_cast<ClusterShadingStageBase *>(this)));
2792
2793 return returnValue;
2794 }
2795
2796 EditFieldHandlePtr ClusterShadingStageBase::editHandleDisabled (void)
2797 {
2798 SFBool::EditHandlePtr returnValue(
2799 new SFBool::EditHandle(
2800 &_sfDisabled,
2801 this->getType().getFieldDesc(DisabledFieldId),
2802 this));
2803
2804
2805 editSField(DisabledFieldMask);
2806
2807 return returnValue;
2808 }
2809
2810 GetFieldHandlePtr ClusterShadingStageBase::getHandleMaxLightIndexListSize (void) const
2811 {
2812 SFUInt32::GetHandlePtr returnValue(
2813 new SFUInt32::GetHandle(
2814 &_sfMaxLightIndexListSize,
2815 this->getType().getFieldDesc(MaxLightIndexListSizeFieldId),
2816 const_cast<ClusterShadingStageBase *>(this)));
2817
2818 return returnValue;
2819 }
2820
2821 EditFieldHandlePtr ClusterShadingStageBase::editHandleMaxLightIndexListSize(void)
2822 {
2823 SFUInt32::EditHandlePtr returnValue(
2824 new SFUInt32::EditHandle(
2825 &_sfMaxLightIndexListSize,
2826 this->getType().getFieldDesc(MaxLightIndexListSizeFieldId),
2827 this));
2828
2829
2830 editSField(MaxLightIndexListSizeFieldMask);
2831
2832 return returnValue;
2833 }
2834
2835 GetFieldHandlePtr ClusterShadingStageBase::getHandleMaxClusterLightCount (void) const
2836 {
2837 SFUInt32::GetHandlePtr returnValue(
2838 new SFUInt32::GetHandle(
2839 &_sfMaxClusterLightCount,
2840 this->getType().getFieldDesc(MaxClusterLightCountFieldId),
2841 const_cast<ClusterShadingStageBase *>(this)));
2842
2843 return returnValue;
2844 }
2845
2846 EditFieldHandlePtr ClusterShadingStageBase::editHandleMaxClusterLightCount(void)
2847 {
2848 SFUInt32::EditHandlePtr returnValue(
2849 new SFUInt32::EditHandle(
2850 &_sfMaxClusterLightCount,
2851 this->getType().getFieldDesc(MaxClusterLightCountFieldId),
2852 this));
2853
2854
2855 editSField(MaxClusterLightCountFieldMask);
2856
2857 return returnValue;
2858 }
2859
2860 GetFieldHandlePtr ClusterShadingStageBase::getHandleFrustNode (void) const
2861 {
2862 SFUnrecNodePtr::GetHandlePtr returnValue(
2863 new SFUnrecNodePtr::GetHandle(
2864 &_sfFrustNode,
2865 this->getType().getFieldDesc(FrustNodeFieldId),
2866 const_cast<ClusterShadingStageBase *>(this)));
2867
2868 return returnValue;
2869 }
2870
2871 EditFieldHandlePtr ClusterShadingStageBase::editHandleFrustNode (void)
2872 {
2873 SFUnrecNodePtr::EditHandlePtr returnValue(
2874 new SFUnrecNodePtr::EditHandle(
2875 &_sfFrustNode,
2876 this->getType().getFieldDesc(FrustNodeFieldId),
2877 this));
2878
2879 returnValue->setSetMethod(
2880 boost::bind(&ClusterShadingStage::setFrustNode,
2881 static_cast<ClusterShadingStage *>(this), _1));
2882
2883 editSField(FrustNodeFieldMask);
2884
2885 return returnValue;
2886 }
2887
2888 GetFieldHandlePtr ClusterShadingStageBase::getHandleFrustAlgoElement (void) const
2889 {
2890 SFUnrecAlgorithmComputeElementPtr::GetHandlePtr returnValue(
2891 new SFUnrecAlgorithmComputeElementPtr::GetHandle(
2892 &_sfFrustAlgoElement,
2893 this->getType().getFieldDesc(FrustAlgoElementFieldId),
2894 const_cast<ClusterShadingStageBase *>(this)));
2895
2896 return returnValue;
2897 }
2898
2899 EditFieldHandlePtr ClusterShadingStageBase::editHandleFrustAlgoElement(void)
2900 {
2901 SFUnrecAlgorithmComputeElementPtr::EditHandlePtr returnValue(
2902 new SFUnrecAlgorithmComputeElementPtr::EditHandle(
2903 &_sfFrustAlgoElement,
2904 this->getType().getFieldDesc(FrustAlgoElementFieldId),
2905 this));
2906
2907 returnValue->setSetMethod(
2908 boost::bind(&ClusterShadingStage::setFrustAlgoElement,
2909 static_cast<ClusterShadingStage *>(this), _1));
2910
2911 editSField(FrustAlgoElementFieldMask);
2912
2913 return returnValue;
2914 }
2915
2916 GetFieldHandlePtr ClusterShadingStageBase::getHandleFrustCompShaderAlgo (void) const
2917 {
2918 SFUnrecComputeShaderAlgorithmPtr::GetHandlePtr returnValue(
2919 new SFUnrecComputeShaderAlgorithmPtr::GetHandle(
2920 &_sfFrustCompShaderAlgo,
2921 this->getType().getFieldDesc(FrustCompShaderAlgoFieldId),
2922 const_cast<ClusterShadingStageBase *>(this)));
2923
2924 return returnValue;
2925 }
2926
2927 EditFieldHandlePtr ClusterShadingStageBase::editHandleFrustCompShaderAlgo(void)
2928 {
2929 SFUnrecComputeShaderAlgorithmPtr::EditHandlePtr returnValue(
2930 new SFUnrecComputeShaderAlgorithmPtr::EditHandle(
2931 &_sfFrustCompShaderAlgo,
2932 this->getType().getFieldDesc(FrustCompShaderAlgoFieldId),
2933 this));
2934
2935 returnValue->setSetMethod(
2936 boost::bind(&ClusterShadingStage::setFrustCompShaderAlgo,
2937 static_cast<ClusterShadingStage *>(this), _1));
2938
2939 editSField(FrustCompShaderAlgoFieldMask);
2940
2941 return returnValue;
2942 }
2943
2944 GetFieldHandlePtr ClusterShadingStageBase::getHandleCullNode (void) const
2945 {
2946 SFUnrecNodePtr::GetHandlePtr returnValue(
2947 new SFUnrecNodePtr::GetHandle(
2948 &_sfCullNode,
2949 this->getType().getFieldDesc(CullNodeFieldId),
2950 const_cast<ClusterShadingStageBase *>(this)));
2951
2952 return returnValue;
2953 }
2954
2955 EditFieldHandlePtr ClusterShadingStageBase::editHandleCullNode (void)
2956 {
2957 SFUnrecNodePtr::EditHandlePtr returnValue(
2958 new SFUnrecNodePtr::EditHandle(
2959 &_sfCullNode,
2960 this->getType().getFieldDesc(CullNodeFieldId),
2961 this));
2962
2963 returnValue->setSetMethod(
2964 boost::bind(&ClusterShadingStage::setCullNode,
2965 static_cast<ClusterShadingStage *>(this), _1));
2966
2967 editSField(CullNodeFieldMask);
2968
2969 return returnValue;
2970 }
2971
2972 GetFieldHandlePtr ClusterShadingStageBase::getHandleCullAlgoElement (void) const
2973 {
2974 SFUnrecAlgorithmComputeElementPtr::GetHandlePtr returnValue(
2975 new SFUnrecAlgorithmComputeElementPtr::GetHandle(
2976 &_sfCullAlgoElement,
2977 this->getType().getFieldDesc(CullAlgoElementFieldId),
2978 const_cast<ClusterShadingStageBase *>(this)));
2979
2980 return returnValue;
2981 }
2982
2983 EditFieldHandlePtr ClusterShadingStageBase::editHandleCullAlgoElement(void)
2984 {
2985 SFUnrecAlgorithmComputeElementPtr::EditHandlePtr returnValue(
2986 new SFUnrecAlgorithmComputeElementPtr::EditHandle(
2987 &_sfCullAlgoElement,
2988 this->getType().getFieldDesc(CullAlgoElementFieldId),
2989 this));
2990
2991 returnValue->setSetMethod(
2992 boost::bind(&ClusterShadingStage::setCullAlgoElement,
2993 static_cast<ClusterShadingStage *>(this), _1));
2994
2995 editSField(CullAlgoElementFieldMask);
2996
2997 return returnValue;
2998 }
2999
3000 GetFieldHandlePtr ClusterShadingStageBase::getHandleCullCompShaderAlgo (void) const
3001 {
3002 SFUnrecComputeShaderAlgorithmPtr::GetHandlePtr returnValue(
3003 new SFUnrecComputeShaderAlgorithmPtr::GetHandle(
3004 &_sfCullCompShaderAlgo,
3005 this->getType().getFieldDesc(CullCompShaderAlgoFieldId),
3006 const_cast<ClusterShadingStageBase *>(this)));
3007
3008 return returnValue;
3009 }
3010
3011 EditFieldHandlePtr ClusterShadingStageBase::editHandleCullCompShaderAlgo(void)
3012 {
3013 SFUnrecComputeShaderAlgorithmPtr::EditHandlePtr returnValue(
3014 new SFUnrecComputeShaderAlgorithmPtr::EditHandle(
3015 &_sfCullCompShaderAlgo,
3016 this->getType().getFieldDesc(CullCompShaderAlgoFieldId),
3017 this));
3018
3019 returnValue->setSetMethod(
3020 boost::bind(&ClusterShadingStage::setCullCompShaderAlgo,
3021 static_cast<ClusterShadingStage *>(this), _1));
3022
3023 editSField(CullCompShaderAlgoFieldMask);
3024
3025 return returnValue;
3026 }
3027
3028 GetFieldHandlePtr ClusterShadingStageBase::getHandleMultiLightChunk (void) const
3029 {
3030 SFUnrecMultiLightChunkPtr::GetHandlePtr returnValue(
3031 new SFUnrecMultiLightChunkPtr::GetHandle(
3032 &_sfMultiLightChunk,
3033 this->getType().getFieldDesc(MultiLightChunkFieldId),
3034 const_cast<ClusterShadingStageBase *>(this)));
3035
3036 return returnValue;
3037 }
3038
3039 EditFieldHandlePtr ClusterShadingStageBase::editHandleMultiLightChunk(void)
3040 {
3041 SFUnrecMultiLightChunkPtr::EditHandlePtr returnValue(
3042 new SFUnrecMultiLightChunkPtr::EditHandle(
3043 &_sfMultiLightChunk,
3044 this->getType().getFieldDesc(MultiLightChunkFieldId),
3045 this));
3046
3047 returnValue->setSetMethod(
3048 boost::bind(&ClusterShadingStage::setMultiLightChunk,
3049 static_cast<ClusterShadingStage *>(this), _1));
3050
3051 editSField(MultiLightChunkFieldMask);
3052
3053 return returnValue;
3054 }
3055
3056 GetFieldHandlePtr ClusterShadingStageBase::getHandleShaderProgChunk (void) const
3057 {
3058 SFUnrecShaderProgramChunkPtr::GetHandlePtr returnValue(
3059 new SFUnrecShaderProgramChunkPtr::GetHandle(
3060 &_sfShaderProgChunk,
3061 this->getType().getFieldDesc(ShaderProgChunkFieldId),
3062 const_cast<ClusterShadingStageBase *>(this)));
3063
3064 return returnValue;
3065 }
3066
3067 EditFieldHandlePtr ClusterShadingStageBase::editHandleShaderProgChunk(void)
3068 {
3069 SFUnrecShaderProgramChunkPtr::EditHandlePtr returnValue(
3070 new SFUnrecShaderProgramChunkPtr::EditHandle(
3071 &_sfShaderProgChunk,
3072 this->getType().getFieldDesc(ShaderProgChunkFieldId),
3073 this));
3074
3075 returnValue->setSetMethod(
3076 boost::bind(&ClusterShadingStage::setShaderProgChunk,
3077 static_cast<ClusterShadingStage *>(this), _1));
3078
3079 editSField(ShaderProgChunkFieldMask);
3080
3081 return returnValue;
3082 }
3083
3084
3085 #ifdef OSG_MT_CPTR_ASPECT
3086 void ClusterShadingStageBase::execSyncV( FieldContainer &oFrom,
3087 ConstFieldMaskArg whichField,
3088 AspectOffsetStore &oOffsets,
3089 ConstFieldMaskArg syncMode,
3090 const UInt32 uiSyncInfo)
3091 {
3092 ClusterShadingStage *pThis = static_cast<ClusterShadingStage *>(this);
3093
3094 pThis->execSync(static_cast<ClusterShadingStage *>(&oFrom),
3095 whichField,
3096 oOffsets,
3097 syncMode,
3098 uiSyncInfo);
3099 }
3100 #endif
3101
3102
3103 #ifdef OSG_MT_CPTR_ASPECT
3104 FieldContainer *ClusterShadingStageBase::createAspectCopy(
3105 const FieldContainer *pRefAspect) const
3106 {
3107 ClusterShadingStage *returnValue;
3108
3109 newAspectCopy(returnValue,
3110 dynamic_cast<const ClusterShadingStage *>(pRefAspect),
3111 dynamic_cast<const ClusterShadingStage *>(this));
3112
3113 return returnValue;
3114 }
3115 #endif
3116
3117 void ClusterShadingStageBase::resolveLinks(void)
3118 {
3119 Inherited::resolveLinks();
3120
3121 static_cast<ClusterShadingStage *>(this)->setFrustNode(NULL);
3122
3123 static_cast<ClusterShadingStage *>(this)->setFrustAlgoElement(NULL);
3124
3125 static_cast<ClusterShadingStage *>(this)->setFrustCompShaderAlgo(NULL);
3126
3127 static_cast<ClusterShadingStage *>(this)->setCullNode(NULL);
3128
3129 static_cast<ClusterShadingStage *>(this)->setCullAlgoElement(NULL);
3130
3131 static_cast<ClusterShadingStage *>(this)->setCullCompShaderAlgo(NULL);
3132
3133 static_cast<ClusterShadingStage *>(this)->setMultiLightChunk(NULL);
3134
3135 static_cast<ClusterShadingStage *>(this)->setShaderProgChunk(NULL);
3136
3137
3138 }
3139
3140
3141 OSG_END_NAMESPACE