HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
GR_Uniforms.h
Go to the documentation of this file.
1 /*
2  * PROPRIETARY INFORMATION. This software is proprietary to
3  * Side Effects Software Inc., and is not to be reproduced,
4  * transmitted, or disclosed in any way without written permission.
5  *
6  * NAME: GR_Uniforms.h ( GR Library, C++)
7  *
8  * COMMENTS:
9  * Uniform parameters for rendering GR_GeoRenders
10  */
11 #ifndef GR_Uniforms_h
12 #define GR_Uniforms_h
13 
14 #include "GR_API.h"
15 
16 #include "GR_Defines.h"
17 #include "GR_DisplayOption.h"
18 #include "GR_TextureRef.h"
19 
20 #include <GU/GU_SelectType.h>
21 #include <GT/GT_RefineParms.h>
22 #include <GU/GU_DetailHandle.h>
23 
24 #include <RE/RE_Render.h>
25 #include <RE/RE_RenderContext.h>
26 #include <RE/RE_Material.h>
27 #include <RE/RE_CachedObject.h>
28 #include <RE/RE_OGLFramebuffer.h>
29 
30 #include <UT/UT_Matrix4.h>
31 #include <UT/UT_StringHolder.h>
32 #include <UT/UT_Map.h>
33 
34 class GR_MaterialGroups;
35 
36 class OP_Node;
37 
38 class RE_Render;
39 
40 class RV_Instance;
41 class RV_Render;
42 class RV_ShaderBlock;
43 class RV_ShaderProgram;
46 class RV_VKBuffer;
47 class RV_VKImage;
48 
49 // helper macro: check value before setting var, which also sets dirty flag
50 #define SET_GLOBAL(name, v) \
51  if (((const GR_Uniforms*)this)->globals().name != v) \
52  { globals().name = (v); } \
53 // end SET_GLOBAL
54 
55 /// set of parameters sent to GR_Primitive::update()
57 {
58 public:
60  GR_Uniforms();
61  ~GR_Uniforms();
62 
63  void copyUniforms(const GR_Uniforms* other)
64  {
65  UT_ASSERT(other);
66  objects() = other->objects();
67  globals() = other->globals();
68  }
69  exint pushObjectUniforms();
70  void popObjectUniforms(exint l=-1);
71 
72  // ~~~~~~~~~~~~~~~~
73  // RE Helpers
74 
75  // Init by copying values from RE_
76  // TODO: assign to rational defaults, or taken from DisplaySettings
77  // like in DM_VPortAgent::setupViewUniforms
78  void init(RE_RenderContext rc);
79 
80  // Helpers for pushing our CPU options int RE_
81  void pushToRE(RE_Render* r);
82  void popFromRE(RE_Render* r);
83  void assignRE(RE_Render* r);
84 
85  // ~~~~~~~~~~~~~~~~~
86  // RV Helpers
87  void assignRVBlock(
88  RV_Render *r,
89  RV_ShaderBlock *block,
90  const RV_ShaderProgram *opt_shr) const;
91 
92  void assignRVBindings(
93  RV_Render* r,
95  const RV_ShaderProgram* opt_shr) const;
96 
97  void assignRVGlobalBlock(RV_Render *r, RV_ShaderBlock *block) const;
98  bool bindRVGlobalBlock(RV_Render *r, const RV_ShaderProgramBase *shader);
99 
100  // ~~~~~~~~~~~~~~~~~~~
101  // Object Vars
102 
103  // Values that are expected to change for each object rendered
104  // Can be pushed/popped
105 
106  // Object Matrix
107  void setObjModelMatrix(const UT_Matrix4D &v, const UT_Matrix4D *inv = nullptr)
108  {
109  objects().myModel = v;
110 
111  // setup dependent matrices
112  if (inv)
113  {
114  objects().myInvModel = *inv;
115  }
116  else
117  {
118  objects().myInvModel = objects().myModel;
119  objects().myInvModel.invert();
120  }
121 
122  // ensure it's const, so it doesn't trigger update
123  const GlobalUniforms& global_var = ((const GR_Uniforms*)this)->globals();
124 
125  objects().myModelView = objects().myModel * global_var.myView;
126 
127  objects().myModelF = objects().myModel;
128  objects().myInvModelF = objects().myInvModel;
129  objects().myModelViewF = objects().myModelView;
130  }
131  const UT_Matrix4D &getObjModelMatrix() const { return objects().myModel; }
132  const UT_Matrix4D &getObjInvModelMatrix() const { return objects().myModel; }
133  const UT_Matrix3D &getObjNormalMatrix() const { return globals().myNormalMat; }
134  const UT_Matrix4D &getObjModelViewMatrix() const { return objects().myModelView; }
135 
137  {
138  globals().myView = v;
139 
140  // setup dependent matrices
141  globals().myInvView = globals().myView;
142  globals().myInvView.invert();
143 
144  globals().myNormalMat = globals().myView;
145  globals().myNormalMat.invert();
146  globals().myNormalMat.transpose();
147 
148  globals().myViewF = globals().myView;
149  globals().myInvViewF = globals().myInvView;
150  globals().myNormalMatF = globals().myNormalMat;
151  globals().myNormalMatFr1 = globals().myNormalMat[0];
152  globals().myNormalMatFr2 = globals().myNormalMat[1];
153  globals().myNormalMatFr3 = globals().myNormalMat[2];
154 
155  objects().myModelView = globals().myView * objects().myModel;
156  objects().myModelViewF = objects().myModelView;
157  }
158  const UT_Matrix4D &getViewMatrix() const { return globals().myView; }
159  const UT_Matrix4D &getInvViewMatrix() const { return globals().myInvView; }
160  const UT_Matrix3D &getNormalMatrix() const { return globals().myNormalMat; }
161 
162  // correct controls whether to apply OpenGL to Vulkan correction, to
163  // account for different coordinate spaces
164  void setProjectMatrix(const UT_Matrix4D &v, bool correct = true, bool is_ortho = false)
165  {
166  globals().myProjection = v;
167 
168  // setup dependent matrices
169  globals().myInvProjection = globals().myProjection;
170  globals().myInvProjection.invert();
171 
172  // NOTE: NDC space in Vulkan has a z-range of [0, 1] instead of [-1, 1]
173  // and a downward-facing y-direction. appending transform after
174  // projection matrix to correct for these
175  if(correct)
176  {
177  UT_Matrix4F correction(1.0f, 0.0f, 0.0f, 0.0f,
178  0.0f, 1.0f, 0.0f, 0.0f,
179  0.0f, 0.0f, 0.5f, 0.0f,
180  0.0f, 0.0f, 0.5f, 1.0f);
181  globals().myProjectionF =
182  UT_Matrix4F(globals().myProjection) * correction;
183  }
184  else
185  globals().myProjectionF = UT_Matrix4F(globals().myProjection);
186  globals().myInvProjectionF = globals().myProjectionF;
187  globals().myInvProjectionF.invert();
188  globals().myIsOrtho = is_ortho;
189  }
190  void useVulkanProjection(bool use_vk) { myUseVulkanProjection=use_vk; }
191  bool getUseVulkanProjection() const { return myUseVulkanProjection; }
192  const UT_Matrix4D &getProjectionMatrix() const { return globals().myProjection; }
193  const UT_Matrix4D &getInvProjectionMatrix() const { return globals().myInvProjection; }
194  bool getIsOrtho() const { return globals().myIsOrtho; }
195 
196  void setDepthRange(const UT_Vector2F &r) { SET_GLOBAL(myDepthRange, r); }
197  void setDepthProject(const UT_Vector2F &p) { SET_GLOBAL(myDepthProject, p); }
198 
199  void setShadowmapIndex(const int32 index) { SET_GLOBAL(myShadowmapIndex, index); }
200  int32 getShadowmapIndex() const { return globals().myShadowmapIndex; }
201 
202  // These are technically Vector3s, but GLSL expects Vector3s to be 4-byte
203  // aligned, so we add one more float for the C++ alignment to match the
204  // GLSL alignment.
206  void setCSMRegionInvExts(const CSMRegionInvExts &e) { SET_GLOBAL(myCSMRegionInvExts, e); }
207  const CSMRegionInvExts &getCSMRegionInvExts() const { return globals().myCSMRegionInvExts; }
208 
210  void setCSMRegionOffsets(const CSMRegionInvExts &e) { SET_GLOBAL(myCSMRegionOffsets, e); }
211  const CSMRegionInvExts &getCSMRegionOffsets() const { return globals().myCSMRegionOffsets; }
212 
213  void setObjWireColor(const UT_Vector4 &v) { objects().myWireColor = v; }
214  const UT_Vector4 &getObjWireColor() const { return objects().myWireColor; }
215 
216  void setObjWireframeColor(const UT_Vector4 &v) { objects().myWireframeColor = v; }
217  const UT_Vector4 &getObjWireframeColor() const { return objects().myWireframeColor; }
218 
219  void setObjWireThickness(const float &v) { objects().myWireThickness = v; }
220  float getObjWireThickness() const { return objects().myWireThickness; }
221 
222  void setObjConstColor(const UT_Vector4 &v) { objects().myConstColor = v; }
223  const UT_Vector4 &getObjConstColor() const { return objects().myConstColor; }
224 
226  {
227  objects().myConstColorMap = v;
228  objects().myConstColorEnableVK = v.isVulkan();
229  objects().myConstColorEnableGL = v.isGL();
230  }
231 
233  {
234  objects().myEmitColor = c;
235  }
236  void setObjGhosting(const UT_Vector4 &v, float gfact=0.5)
237  {
238  objects().myGhostColor = v;
239  objects().myGhostFactor = gfact;
240  objects().myHasGhosting = true;
241  }
242  const UT_Vector4 &getObjGhostColor() const { return objects().myGhostColor; }
243  float getObjGhostFactor() const { return objects().myGhostFactor; }
244 
245  void setObjBackfaceTint(const UT_Vector3 &v, float gfact=0.5)
246  {
247  objects().myBackfaceColor = UT_Vector4(v, gfact);
248  objects().myHasBackfaceTint = true;
249  }
250  const UT_Vector4 &getObjBackfaceColor() const { return objects().myBackfaceColor; }
251  float getObjBackfaceFactor() const { return objects().myBackfaceColor[3]; }
252 
253  void setObjSelectColor(const UT_Vector4 &v) { objects().mySelectColor = v; }
254  const UT_Vector4 &getObjSelectColor() const { return objects().mySelectColor; }
255 
256  void setObjSelectSecondaryColor(const UT_Vector4 &v) { objects().mySelectSecondaryColor = v; }
257  const UT_Vector4 &getObjSelectSecondaryColor() const { return objects().mySelectSecondaryColor; }
258 
259  void setObjSelectMode(int v) { objects().mySelectMode = v; }
260  int getObjSelectMode() const { return objects().mySelectMode; }
261 
262  void setObjSelectType(int v) { objects().mySelectType = v; }
263  int getObjSelectType() const { return objects().mySelectType; }
264 
265  void setObjSelectInstance(int v) { objects().mySelectInstance = v; }
266  int getObjSelectInstance() const { return objects().mySelectInstance; }
267 
268  void setObjFillSelection(int v) { objects().myFillSelection = v; }
269  int getObjFillSelection() const { return objects().myFillSelection; }
270 
271  void setObjPrimConstandID(int v) { objects().myPrimConstantID = v; }
272  int getObjPrimConstandID() const { return objects().myPrimConstantID; }
273 
274  void setObjDecorationScale(float v) { objects().myDecorationScale = v; }
275  float getObjDecorationScale() const { return objects().myDecorationScale; }
276 
278  { objects().myPickBaseID = v; }
280  { return objects().myPickBaseID; }
281 
283  { objects().myPickComponentID = v; }
285  { return objects().myPickComponentID; }
286 
288  {
289  objects().myColorRamp = v;
290  objects().myColorRampEnableVK = v.isVulkan();
291  objects().myColorRampEnableGL = v.isGL();
292 
293  objects().myColorRange = range;
294  }
295 
296  void setObjColorIgnoreGeo(bool v)
297  {
298  objects().myColorIgnoreGeo = v;
299  }
300  bool getObjColorIgnoreGeo() const
301  {
302  return objects().myColorIgnoreGeo;
303  }
304 
305  // Use -1 flag to force use of geo color, ignoring
306  // any per-material geo color disable
308  {
309  objects().myColorIgnoreGeo = -1;
310  }
311 
313  {
314  objects().myColorTransformMode = mode;
315  objects().myColorTransformRef = ref;
316  }
317 
319  {
320  objects().myUseInstancePrimId = v;
321  }
322 
324  { objects().myMaxLocatedId = v; }
325 
327  { return objects().myMaxLocatedId; }
328 
330  { objects().myMinLocatedId = v; }
331 
333  { return objects().myMinLocatedId; }
334 
335 
337  {
338  objects().myLocatedBufVK = buf;
339  objects().myUseLocatedBufVK = buf ? 1 : 0;
340  }
341 
343  {
344  UT_ASSERT(!buf || buf->getTextureType() == RE_TEXTURE_BUFFER);
345  objects().myLocatedBufGL = buf;
346  objects().myUseLocatedBufGL = buf ? 1 : 0;
347  }
348 
350  { objects().myLightingEnabled = v; }
351 
353  { return objects().myLightingEnabled; }
354 
356  { objects().myTexturesEnabled = v; }
357 
359  { return objects().myTexturesEnabled; }
360 
361  // Values which may be changed per-object
363  {
364 
365  #define VK_BLOCK_START (offsetof(ObjectUniforms, myModelF))
366  // begin VK block
369 
371  UT_Vector4F myBackfaceColor = UT_Vector4F(0,0,0,0);
375  UT_Vector4F myEmitColor = UT_Vector4F(0,0,0,0);
376 
377  int mySelectMode = 0;
378  int mySelectType = 0;
379  int mySelectInstance = 0;
380  int myFillSelection = 0;
381 
382  int myPrimConstantID = 0;
383  int myPrimInstanceBase = 0;
384 
387 
389  int32 myColorRampEnableVK = 0;
390  int32 myColorIgnoreGeo = 0;
391 
393  int32 myColorTransformMode = 0;
394 
395  // NOTE: only used in locate highlight rendering
396  int32 myUseInstancePrimId = 0;
397  int32 myMaxLocatedId = 0;
398  int32 myMinLocatedId = 0;
399  int32 myUseLocatedBufVK = 0;
400 
401  // NOTE: only used in pick buffer rendering
403  int32 myPickDepthPass = 0;
405 
406  int32 myConstColorEnableVK = 0;
407  int32 myLightMask = 0xFFFFFFFF;
408  int32 myLightingEnabled = 1;
409  int32 myTexturesEnabled = 1;
410 
411  // end VK block
412  #define VK_BLOCK_END (offsetof(ObjectUniforms, myTexturesEnabled )\
413  + sizeof(ObjectUniforms::myTexturesEnabled))
414 
415  // Ghosting
418 
419  bool myHasPrimLightMask = false;
420 
421  // Backface Tinting
422  bool myHasBackfaceTint = false;
423 
424  // Selection
426 
427  // Wire color
429 
430  // color mapping
431  int32 myConstColorEnableGL = 0;
433 
434  // Color Transform
435  int32 myColorRampEnableGL = 0;
437 
439 
443 
445 
446  RV_VKBuffer* myLocatedBufVK = nullptr;
447  RE_Texture* myLocatedBufGL = nullptr;
448  int32 myUseLocatedMap = 0; // redundant
449  int32 myUseLocatedBufGL = 0;
450  };
451  static constexpr int32 VkBlockSize = VK_BLOCK_END - VK_BLOCK_START;
452 
453  // ~~~~~~~~~~~~~
454  // Global Vars
455  //
456  // Values static across the whole render
457  // typically may be changed between passes of different types
458  // Can be set, but not push/popped
459 
460  void setEmission(float v) { SET_GLOBAL(myEmissionFactor, v); }
461  float getEmission() const { return globals().myEmissionFactor; }
462 
463  void setSpecular(float v) { SET_GLOBAL(mySpeculaFactor, v); }
464  float getSpecular() const { return globals().mySpeculaFactor; }
465 
466  void setDiffuse(float v) { SET_GLOBAL(myDiffuseFactor, v); }
467  float getDiffuse() const { return globals().myDiffuseFactor; }
468 
469  void setAmbient(float v) { SET_GLOBAL(myAmbientFactor, v); }
470  float getAmbient() const { return globals().myAmbientFactor; }
471 
472  void setAlphaPass(int v) { SET_GLOBAL(myAlphaPass, v); }
473  int getAlphaPass() const { return globals().myAlphaPass; }
474 
475  void setLightMask(unsigned mask) { objects().myLightMask = mask; }
476  unsigned getLightMask() const { return objects().myLightMask; }
477 
478  void setUseHeadlight(bool use_headlight)
479  { SET_GLOBAL(myUseHeadlight, (int32)use_headlight); }
480  bool useHeadlight() const { return globals().myUseHeadlight; }
483  float ambient,
484  float soft,
485  bool use_spec,
486  bool use_world_space)
487  {
488  SET_GLOBAL(myHeadlightDir, dir);
489  SET_GLOBAL(myHeadlightColor, color);
490  SET_GLOBAL(myHeadlightSpec, (int32)(use_spec?1:0));
491  SET_GLOBAL(myHeadlightWorldSpace, (int32)use_world_space);
492  SET_GLOBAL(myHeadlightAmbient, ambient);
493  SET_GLOBAL(myHeadlightSoft, soft);
494  }
495  UT_Vector3F headlightDir() { return globals().myHeadlightDir; }
496  UT_Vector3F headlightColor() { return globals().myHeadlightColor; }
497  void setUseFilllight(bool use_fill)
498  { SET_GLOBAL(myUseFilllight, (int32)use_fill); }
500  {
501  SET_GLOBAL(myFilllightDir, dir);
502  SET_GLOBAL(myFilllightColor, color);
503  }
504  UT_Vector3F filllightDir() { return globals().myFilllightDir; }
505  UT_Vector3F filllightColor() { return globals().myFilllightColor; }
506  void setUseBacklight(bool use_back)
507  { SET_GLOBAL(myUseBacklight, (int32)use_back); }
509  {
510  SET_GLOBAL(myBacklightDir, dir);
511  SET_GLOBAL(myBacklightColor, color);
512  }
513  UT_Vector3F backlightDir() { return globals().myBacklightDir; }
514  UT_Vector3F backlightColor() { return globals().myBacklightColor; }
515 
516 
517  void setEnvlightMapRotate(const UT_Vector3F &rot);
518  void setEnvlightMapTint(const UT_Vector3F &tint)
519  { SET_GLOBAL(myEnvlightTint, UT_Vector4F(tint, 1.0)); }
520  void setUseEnvlight(bool use_env)
521  { SET_GLOBAL(myUseEnvlight, (int32)use_env); }
522  bool useEnvlight() const { return globals().myUseEnvlight; }
523  UT_Matrix4F getEnvlightRotate() const { return globals().myEnvlightRotate; }
525  { return UT_Vector3F(globals().myEnvlightTint); }
526 #ifdef USE_VULKAN
527  RV_TextureRef &envlightMap() { return globals().myEnvlightMapRef; }
528  RV_TextureRef &bgenvMap() { return globals().myBGEnvMapRef; }
529 #endif
530 
531  void setHasPrimLightMask(bool m) { objects().myHasPrimLightMask = m; }
532  bool hasPrimLightMask() const { return objects().myHasPrimLightMask; }
533 
535  {
536  RENDER_MATERIAL = 0,
537  RENDER_CONST = 1,
538  RENDER_OTHER = 2,
539  };
541  { SET_GLOBAL(myRenderPass, v); }
543  { return RenderPass(globals().myRenderPass); }
544 
545  void setAlphaCutoff(float v) { SET_GLOBAL(myAlphaCutoff, v); }
546  float getAlphaCutoff() const { return globals().myAlphaCutoff; }
547 
548  void setCamView(const UT_Matrix4D& v) { globals().myCamView = v;}
549  const UT_Matrix4D &getCamView() const { return globals().myCamView;}
550 
551  void setCamProject(const UT_Matrix4D& v) { globals().myCamProject = v;}
552  const UT_Matrix4D &getCamProject() const { return globals().myCamProject;}
553 
554  void setScreenSize(const UT_Vector2& v) { SET_GLOBAL(myScreenSize, v); }
555  const UT_Vector2& getScreenSize() const { return globals().myScreenSize; }
556 
557  void setLODParms(const UT_Vector2& v) { SET_GLOBAL(myLODParms, v); }
558  const UT_Vector2& getLODParms() const { return globals().myLODParms; }
559 
560  void setPickArea(const UT_Vector4F& v) { SET_GLOBAL(myPickArea, v); }
561  const UT_Vector4F& getPickArea() const { return globals().myPickArea; }
562 
563  void setPickMap(GR_TextureRef v, bool use = true)
564  {
565  SET_GLOBAL(myPickMap, v);
566  SET_GLOBAL(myPickHasMapVK, (use && globals().myPickMap.isVulkan()));
567  SET_GLOBAL(myPickHasMapGL, (use && globals().myPickMap.isGL()));
568  }
569 
570  void setDepthMap(GR_TextureRef v, bool use = true)
571  {
572  SET_GLOBAL(myDepthMap, v);
573  SET_GLOBAL(myHasDepthMapVK, (use && globals().myDepthMap.isVulkan()));
574  SET_GLOBAL(myHasDepthMapGL, (use && globals().myDepthMap.isGL()));
575  }
576 
577  void setSnapDistances(const UT_Vector3i &v) { SET_GLOBAL(mySnapDistances, v);}
578  const UT_Vector3i &getSnapDistances() const { return globals().mySnapDistances;}
579 
580  void setSnapParms(int32 v) { SET_GLOBAL(mySnapParams, v);}
581  int32 getSnapParms() const { return globals().mySnapParams;}
582 
583  void setDecorationLocate(const UT_Vector4F& v) { SET_GLOBAL(myDecorLocate, v); }
584  const UT_Vector4F& getDecorationLocate() const { return globals().myDecorLocate; }
585 
586 
587  void print();
588 
589  // TODO: use these maybe ?
590  bool myIsGlobalUniformLocked = false;
592  {
593  myIsGlobalUniformLocked = true;
594  }
596  {
597  myIsGlobalUniformLocked = false;
598  }
599  bool myGlobalUniformDirty = true;
600 
601  #define UT_Vector2F_UBO alignas(8) UT_Vector2F
602  #define UT_Vector3F_UBO alignas(16) UT_Vector3F
603  #define UT_Vector4F_UBO alignas(16) UT_Vector4F
604  #define UT_Vector2i_UBO alignas(8) UT_Vector2i
605  #define UT_Vector3i_UBO alignas(16) UT_Vector3i
606  #define UT_Vector4i_UBO alignas(16) UT_Vector4i
607  #define UT_Matrix4F_UBO alignas(16) UT_Matrix4F
608 
610  {
611  #define VK_GLOBAL_BLOCK_START (offsetof(GlobalUniforms, myProjectionF))
612  // float versions for VK
615  UT_Vector3F_UBO myNormalMatFr1; // store `mat3` as 3 `vec3`s to match UBO spacing
622 
623  // Inverses (reciprocals) of the extents of the cascading shadowmap regions.
626 
627  // TODO: make this a push constant
629 
630  // Screen/Framebuffer info
633 
636  int32 myHasDepthMapVK = 0;
637 
638  // Enum code indicating whether or not inside a
639  // transparency rendering pass, or what kind of pass
640  int32 myRenderPass = RENDER_MATERIAL;
641  int32 myAlphaPass = 0;
642 
643  int32 myMaterialLayer = 0;
644  int32 myOnionSkinGroup = 0;
645 
646  fpreal32 SceneIOR = 1.0;
647 
648  // Multipliers for different aspects of lighting,
649  // typically 0.0 or 1.0
650  fpreal32 myEmissionFactor = 1.0;
651  fpreal32 myDiffuseFactor = 1.0;
652  fpreal32 myAmbientFactor = 1.0;
653  fpreal32 mySpeculaFactor = 1.0;
654 
656 
657  fpreal32 myAlphaCutoff = 1e-3;
658 
659  int32 myNumSamples = 4;
660 
661  int32 myIsOrtho = 0;
663 
664  // NOTE: only used in pick rendering
666  int32 myPickHasMapVK = 0;
667 
668  // NOTE: only used in snap rendering
670  int32 mySnapParams = 0;
671 
672  // NOTE: only used in decoration rendering
674  float myDecorOcclusionFade = 1.0;
675 
676  int32 myHeadlightWorldSpace = 0;
677  fpreal32 myHeadlightAmbient = 0.02;
678 
680  int32 myHeadlightSpec = 1;
682  int32 myUseHeadlight = 0;
683  fpreal32 myHeadlightSoft = 0.0;
684 
686  int32 myUseFilllight = 0;
688 
690  int32 myUseBacklight = 0;
692 
695  int32 myUseEnvlight = 0;
696 
697  #define VK_GLOBAL_BLOCK_END (offsetof(GlobalUniforms, myUseEnvlight ) \
698  + sizeof(GlobalUniforms::myUseEnvlight))
699 
701 
709 
710  // NOTE: only used in pick rendering
712  int32 myPickHasMapGL = 0;
713 
714  // NOTE: only used in shadow map rendering
716  int32 myHasDepthMapGL = 0;
717  fpreal32 myDepthBufferFar = 1.0;
718 
719 #ifdef USE_VULKAN
720  RV_TextureRef myEnvlightMapRef;
721  RV_TextureRef myBGEnvMapRef;
722 #endif
723  };
724  static constexpr int32 VkGlobalBlockSize = VK_GLOBAL_BLOCK_END
726 
727 #ifdef USE_VULKAN
728  static void initStaticResources(RV_Instance* inst);
729  static void cleanupStaticResources();
730 
731  static void prepareThreadedUniforms(exint num_threads);
732  static void returnThreadedUniforms();
733 
734  static GR_Uniforms* getForThread(int* level, int idx);
735  static void returnForThread(int* level);
736 #endif
737 
739  {
740  return myObjectUniforms.last();
741  }
742  const ObjectUniforms& objects() const
743  {
744  return myObjectUniforms.last();
745  }
746 
748  {
749  UT_ASSERT(!myIsGlobalUniformLocked);
750  myGlobalUniformDirty = true;
751  return myGlobalUniforms;
752  }
753  const GlobalUniforms& globals() const
754  {
755  return myGlobalUniforms;
756  }
757 
758 private:
759  UT_ValArray<ObjectUniforms> myObjectUniforms;
760  GlobalUniforms myGlobalUniforms;
761 
762  // ~~~~~~~~~~~~~~~
763  // RE Private Helpers
764 
765  // RE_Render stack helpers
766  bool myIsREPushed = false;
767 
768  // Ghosting setup taken form GUI_GeoRender::setupGhosting
769  struct RECachedState
770  {
771  bool useSampleMask;
772  int sampleMask;
773  bool multisample;
774  } myCachedREState;
775 
776  // Special handlers for ghosting state -- changes some Render state as well
777  // as pushing uniforms
778  void pushGhosting(RE_Render* r);
779  void assignGhosting(RE_Render* r);
780  void popGhosting(RE_Render* r);
781 
782 private:
783  bool myUseVulkanProjection = false;
784 #ifdef USE_VULKAN
785  struct gr_SetCache
786  {
787  // Array doing linear lookup, fine if number of sets small
788  // TODO: could do a hashmap
790  UT_Array<bool> myDirtyFlags;
791 
793  RV_Render *r,
794  int set_num,
796  bool* out_is_new_or_dirty);
797  };
798  gr_SetCache myGlobalSet;
799  UT_UniquePtr<RV_ShaderBlock> myPassInfoBlock;
800 #endif
801 };
802 
803 
804 #endif
void setObjColorForceUseGeo()
Definition: GR_Uniforms.h:307
A collection of Vulkan UBO, SSBO, and Image shader bindings (descriptor set)
const UT_Vector4 & getObjWireframeColor() const
Definition: GR_Uniforms.h:217
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glcorearb.h:2540
void setAlphaCutoff(float v)
Definition: GR_Uniforms.h:545
void setObjLocatedBuffer(RE_Texture *buf)
Definition: GR_Uniforms.h:342
UT_Vector3F headlightDir()
Definition: GR_Uniforms.h:495
UT_Vector3F filllightColor()
Definition: GR_Uniforms.h:505
int int32
Definition: SYS_Types.h:39
GLenum GLint * range
Definition: glcorearb.h:1925
const UT_Vector4 & getObjBackfaceColor() const
Definition: GR_Uniforms.h:250
void setObjFillSelection(int v)
Definition: GR_Uniforms.h:268
const UT_Matrix4D & getViewMatrix() const
Definition: GR_Uniforms.h:158
void setObjConstColorMap(GR_TextureRef v)
Definition: GR_Uniforms.h:225
void setPickMap(GR_TextureRef v, bool use=true)
Definition: GR_Uniforms.h:563
void setObjEmission(const UT_Vector4F &c)
Definition: GR_Uniforms.h:232
UT_Vector3F getEnvlightMapTint() const
Definition: GR_Uniforms.h:524
void setObjTexturesEnabled(int v)
Definition: GR_Uniforms.h:355
void setUseHeadlight(bool use_headlight)
Definition: GR_Uniforms.h:478
void setShadowmapIndex(const int32 index)
Definition: GR_Uniforms.h:199
const GLdouble * v
Definition: glcorearb.h:837
void setObjWireThickness(const float &v)
Definition: GR_Uniforms.h:219
bool getIsOrtho() const
Definition: GR_Uniforms.h:194
void setObjSelectColor(const UT_Vector4 &v)
Definition: GR_Uniforms.h:253
exint getObjMaxLocatedID() const
Definition: GR_Uniforms.h:326
void setLightMask(unsigned mask)
Definition: GR_Uniforms.h:475
CSMRegionInvExts myCSMRegionInvExts
Definition: GR_Uniforms.h:624
int getAlphaPass() const
Definition: GR_Uniforms.h:473
int getObjPrimConstandID() const
Definition: GR_Uniforms.h:272
const UT_Vector4F & getPickArea() const
Definition: GR_Uniforms.h:561
exint getObjMinLocatedID() const
Definition: GR_Uniforms.h:332
GA_API const UT_StringHolder rot
void setEnvlightMapTint(const UT_Vector3F &tint)
Definition: GR_Uniforms.h:518
void setObjColorRamp(GR_TextureRef v, UT_Vector2F range=UT_Vector2F())
Definition: GR_Uniforms.h:287
void setUseEnvlight(bool use_env)
Definition: GR_Uniforms.h:520
int getObjTexturesEnabled() const
Definition: GR_Uniforms.h:358
const UT_Matrix3D & getNormalMatrix() const
Definition: GR_Uniforms.h:160
int64 exint
Definition: SYS_Types.h:125
GLint level
Definition: glcorearb.h:108
void setObjMaxLocatedID(exint v)
Definition: GR_Uniforms.h:323
UT_Vector3F filllightDir()
Definition: GR_Uniforms.h:504
RenderPass getRenderPass() const
Definition: GR_Uniforms.h:542
void setObjPickBaseID(const UT_Vector3i &v)
Definition: GR_Uniforms.h:277
float getAmbient() const
Definition: GR_Uniforms.h:470
void copyUniforms(const GR_Uniforms *other)
Definition: GR_Uniforms.h:63
UT_Vector3i_UBO myCoverageMask
Definition: GR_Uniforms.h:655
Opaque reference to a texture stored in the RV_TextureCache.
Definition: RV_Type.h:203
const UT_Vector4 & getObjSelectSecondaryColor() const
Definition: GR_Uniforms.h:257
bool isGL() const
Definition: GR_TextureRef.h:38
UT_Matrix4F_UBO myCamViewF
Definition: GR_Uniforms.h:620
void setObjWireframeColor(const UT_Vector4 &v)
Definition: GR_Uniforms.h:216
void setObjGhosting(const UT_Vector4 &v, float gfact=0.5)
Definition: GR_Uniforms.h:236
void setObjColorTransform(int32 mode, UT_Vector3F ref=UT_Vector3F())
Definition: GR_Uniforms.h:312
const UT_Vector4 & getObjWireColor() const
Definition: GR_Uniforms.h:214
void useVulkanProjection(bool use_vk)
Definition: GR_Uniforms.h:190
UT_Matrix4F_UBO myCamProjectF
Definition: GR_Uniforms.h:621
void setObjSelectSecondaryColor(const UT_Vector4 &v)
Definition: GR_Uniforms.h:256
UT_Vector3F backlightDir()
Definition: GR_Uniforms.h:513
float getObjBackfaceFactor() const
Definition: GR_Uniforms.h:251
void setHasPrimLightMask(bool m)
Definition: GR_Uniforms.h:531
void setViewMatrix(const UT_Matrix4D &v)
Definition: GR_Uniforms.h:136
const UT_Matrix4D & getInvViewMatrix() const
Definition: GR_Uniforms.h:159
float fpreal32
Definition: SYS_Types.h:200
A class that manages material assignments to different groups of primitives.
Temporary container for either a RV_Render and an RE_Render.
GR_API bool createOrReuseSet(RV_Render *r, UT_UniquePtr< RV_ShaderVariableSet > &set, int set_num, const RV_ShaderProgramBase *shader, bool *created=nullptr, const char *name=nullptr)
void setAlphaPass(int v)
Definition: GR_Uniforms.h:472
void setUseBacklight(bool use_back)
Definition: GR_Uniforms.h:506
#define VK_BLOCK_END
Definition: GR_Uniforms.h:412
UT_Vector4F_UBO myDecorLocate
Definition: GR_Uniforms.h:673
UT_Vector4F_UBO myEnvlightTint
Definition: GR_Uniforms.h:694
void setEmission(float v)
Definition: GR_Uniforms.h:460
CSMRegionOffsets myCSMRegionOffsets
Definition: GR_Uniforms.h:625
void setBacklightParms(UT_Vector3F dir, UT_Vector3F color)
Definition: GR_Uniforms.h:508
UT_Vector3F_UBO myBacklightColor
Definition: GR_Uniforms.h:691
std::unique_ptr< T, Deleter > UT_UniquePtr
A smart pointer for unique ownership of dynamically allocated objects.
Definition: UT_UniquePtr.h:39
UT_Vector3F_UBO myHeadlightDir
Definition: GR_Uniforms.h:679
RE_TextureDimension getTextureType() const
#define SET_GLOBAL(name, v)
Definition: GR_Uniforms.h:50
#define UT_Vector2F_UBO
Definition: GR_Uniforms.h:601
void setPickArea(const UT_Vector4F &v)
Definition: GR_Uniforms.h:560
float getObjWireThickness() const
Definition: GR_Uniforms.h:220
UT_Vector3F backlightColor()
Definition: GR_Uniforms.h:514
void setUseFilllight(bool use_fill)
Definition: GR_Uniforms.h:497
void setSpecular(float v)
Definition: GR_Uniforms.h:463
#define VK_GLOBAL_BLOCK_START
Definition: GR_Uniforms.h:611
UT_Matrix4F_UBO myInvViewF
Definition: GR_Uniforms.h:619
GLfloat f
Definition: glcorearb.h:1926
UT_Vector4T< float > UT_Vector4
UT_Vector2F_UBO myLODParms
Definition: GR_Uniforms.h:632
const UT_Matrix4D & getObjModelMatrix() const
Definition: GR_Uniforms.h:131
std::array< T, N > UT_FixedArray
Definition: UT_FixedArray.h:19
float getEmission() const
Definition: GR_Uniforms.h:461
UT_Vector4F_UBO myPickArea
Definition: GR_Uniforms.h:665
bool getObjColorIgnoreGeo() const
Definition: GR_Uniforms.h:300
UT_Vector3F_UBO myBacklightDir
Definition: GR_Uniforms.h:689
void setDepthMap(GR_TextureRef v, bool use=true)
Definition: GR_Uniforms.h:570
void unlockGlobalUniforms()
Definition: GR_Uniforms.h:595
const UT_Vector3i & getSnapDistances() const
Definition: GR_Uniforms.h:578
GlobalUniforms & globals()
Definition: GR_Uniforms.h:747
GR_TextureRef myConstColorMap
Definition: GR_Uniforms.h:432
UT_Vector2F_UBO myScreenSize
Definition: GR_Uniforms.h:631
GLint ref
Definition: glcorearb.h:124
void setCSMRegionOffsets(const CSMRegionInvExts &e)
Definition: GR_Uniforms.h:210
UT_Vector3i getObjPickBaseID() const
Definition: GR_Uniforms.h:279
void lockGlobalUniforms()
Definition: GR_Uniforms.h:591
UT_Vector2F_UBO myDepthRange
Definition: GR_Uniforms.h:634
void setObjPickComponentID(const UT_Vector3i &v)
Definition: GR_Uniforms.h:282
constexpr auto set(type rhs) -> int
Definition: core.h:610
int getObjSelectInstance() const
Definition: GR_Uniforms.h:266
int32 getSnapParms() const
Definition: GR_Uniforms.h:581
const UT_Vector4 & getObjSelectColor() const
Definition: GR_Uniforms.h:254
UT_Vector3F headlightColor()
Definition: GR_Uniforms.h:496
void setCamView(const UT_Matrix4D &v)
Definition: GR_Uniforms.h:548
bool useEnvlight() const
Definition: GR_Uniforms.h:522
const UT_Matrix4D & getInvProjectionMatrix() const
Definition: GR_Uniforms.h:193
void setFilllightParms(UT_Vector3F dir, UT_Vector3F color)
Definition: GR_Uniforms.h:499
GLint GLuint mask
Definition: glcorearb.h:124
ObjectUniforms & objects()
Definition: GR_Uniforms.h:738
void setCSMRegionInvExts(const CSMRegionInvExts &e)
Definition: GR_Uniforms.h:206
UT_Matrix4T< fpreal32 > UT_Matrix4F
void setRenderPass(RenderPass v)
Definition: GR_Uniforms.h:540
#define GR_API
Definition: GR_API.h:10
UT_Matrix4F_UBO myInvProjectionF
Definition: GR_Uniforms.h:618
UT_Vector2F_UBO myDepthOffset
Definition: GR_Uniforms.h:662
const UT_Vector4 & getObjConstColor() const
Definition: GR_Uniforms.h:223
const GlobalUniforms & globals() const
Definition: GR_Uniforms.h:753
#define UT_Vector4F_UBO
Definition: GR_Uniforms.h:603
float getObjDecorationScale() const
Definition: GR_Uniforms.h:275
void setObjSelectMode(int v)
Definition: GR_Uniforms.h:259
bool getUseVulkanProjection() const
Definition: GR_Uniforms.h:191
void setProjectMatrix(const UT_Matrix4D &v, bool correct=true, bool is_ortho=false)
Definition: GR_Uniforms.h:164
float getSpecular() const
Definition: GR_Uniforms.h:464
void setAmbient(float v)
Definition: GR_Uniforms.h:469
void setObjUseInstancePrimId(int32 v)
Definition: GR_Uniforms.h:318
Handle to the main interface of Vulkan.
Definition: RV_Instance.h:44
void setCamProject(const UT_Matrix4D &v)
Definition: GR_Uniforms.h:551
int getObjSelectMode() const
Definition: GR_Uniforms.h:260
void setObjSelectType(int v)
Definition: GR_Uniforms.h:262
float getObjGhostFactor() const
Definition: GR_Uniforms.h:243
int32 getShadowmapIndex() const
Definition: GR_Uniforms.h:200
GLenum mode
Definition: glcorearb.h:99
void setObjWireColor(const UT_Vector4 &v)
Definition: GR_Uniforms.h:213
const UT_Vector2 & getLODParms() const
Definition: GR_Uniforms.h:558
bool isVulkan() const
Definition: GR_TextureRef.h:39
UT_Vector3T< fpreal32 > UT_Vector3F
#define UT_Vector3F_UBO
Definition: GR_Uniforms.h:602
const CSMRegionInvExts & getCSMRegionOffsets() const
Definition: GR_Uniforms.h:211
const UT_Vector4F & getDecorationLocate() const
Definition: GR_Uniforms.h:584
UT_FixedArray< UT_Vector4, 4 > CSMRegionInvExts
Definition: GR_Uniforms.h:205
float getAlphaCutoff() const
Definition: GR_Uniforms.h:546
GLuint shader
Definition: glcorearb.h:785
const UT_Matrix4D & getObjModelViewMatrix() const
Definition: GR_Uniforms.h:134
UT_Vector3F_UBO myHeadlightColor
Definition: GR_Uniforms.h:681
UT_Vector3F_UBO myNormalMatFr1
Definition: GR_Uniforms.h:615
#define VK_BLOCK_START
Definition: GR_Uniforms.h:365
UT_Vector2T< fpreal32 > UT_Vector2F
void setObjModelMatrix(const UT_Matrix4D &v, const UT_Matrix4D *inv=nullptr)
Definition: GR_Uniforms.h:107
const UT_Vector2 & getScreenSize() const
Definition: GR_Uniforms.h:555
void setObjColorIgnoreGeo(bool v)
Definition: GR_Uniforms.h:296
UT_Vector4T< fpreal32 > UT_Vector4F
GLuint color
Definition: glcorearb.h:1261
UT_Vector3F_UBO myFilllightDir
Definition: GR_Uniforms.h:685
#define UT_Vector3i_UBO
Definition: GR_Uniforms.h:605
const CSMRegionInvExts & getCSMRegionInvExts() const
Definition: GR_Uniforms.h:207
UT_Vector2F_UBO myDepthProject
Definition: GR_Uniforms.h:635
void setSnapDistances(const UT_Vector3i &v)
Definition: GR_Uniforms.h:577
#define VK_GLOBAL_BLOCK_END
Definition: GR_Uniforms.h:697
void setScreenSize(const UT_Vector2 &v)
Definition: GR_Uniforms.h:554
UT_Matrix4F_UBO myProjectionF
Definition: GR_Uniforms.h:613
const UT_Matrix4D & getProjectionMatrix() const
Definition: GR_Uniforms.h:192
GLuint index
Definition: glcorearb.h:786
UT_Vector3i getObjPickComponentID() const
Definition: GR_Uniforms.h:284
bool hasPrimLightMask() const
Definition: GR_Uniforms.h:532
void setDiffuse(float v)
Definition: GR_Uniforms.h:466
void setDepthProject(const UT_Vector2F &p)
Definition: GR_Uniforms.h:197
void setObjMinLocatedID(exint v)
Definition: GR_Uniforms.h:329
void setObjDecorationScale(float v)
Definition: GR_Uniforms.h:274
const UT_Matrix4D & getObjInvModelMatrix() const
Definition: GR_Uniforms.h:132
UT_Vector3F_UBO myFilllightColor
Definition: GR_Uniforms.h:687
const UT_Matrix4D & getCamProject() const
Definition: GR_Uniforms.h:552
const UT_Vector4 & getObjGhostColor() const
Definition: GR_Uniforms.h:242
unsigned getLightMask() const
Definition: GR_Uniforms.h:476
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:156
UT_Matrix4F getEnvlightRotate() const
Definition: GR_Uniforms.h:523
UT_Vector3i_UBO mySnapDistances
Definition: GR_Uniforms.h:669
GLboolean r
Definition: glcorearb.h:1222
set of parameters sent to GR_Primitive::update()
Definition: GR_Uniforms.h:56
void setObjSelectInstance(int v)
Definition: GR_Uniforms.h:265
A vulkan buffer object.
Definition: RV_VKBuffer.h:81
int getObjFillSelection() const
Definition: GR_Uniforms.h:269
UT_FixedArray< UT_Vector4, 4 > CSMRegionOffsets
Definition: GR_Uniforms.h:209
void setObjPrimConstandID(int v)
Definition: GR_Uniforms.h:271
UT_Vector3F_UBO myNormalMatFr3
Definition: GR_Uniforms.h:617
void setObjLocatedBuffer(RV_VKBuffer *buf)
Definition: GR_Uniforms.h:336
UT_Matrix4F_UBO myEnvlightRotate
Definition: GR_Uniforms.h:693
#define UT_Matrix4F_UBO
Definition: GR_Uniforms.h:607
FMT_INLINE void print(format_string< T...> fmt, T &&...args)
Definition: core.h:2903
int getObjSelectType() const
Definition: GR_Uniforms.h:263
void setSnapParms(int32 v)
Definition: GR_Uniforms.h:580
const UT_Matrix4D & getCamView() const
Definition: GR_Uniforms.h:549
const UT_Matrix3D & getObjNormalMatrix() const
Definition: GR_Uniforms.h:133
void setObjConstColor(const UT_Vector4 &v)
Definition: GR_Uniforms.h:222
float getDiffuse() const
Definition: GR_Uniforms.h:467
void setDecorationLocate(const UT_Vector4F &v)
Definition: GR_Uniforms.h:583
void setObjBackfaceTint(const UT_Vector3 &v, float gfact=0.5)
Definition: GR_Uniforms.h:245
void setLODParms(const UT_Vector2 &v)
Definition: GR_Uniforms.h:557
void setObjLightingEnabled(int v)
Definition: GR_Uniforms.h:349
void setDepthRange(const UT_Vector2F &r)
Definition: GR_Uniforms.h:196
const ObjectUniforms & objects() const
Definition: GR_Uniforms.h:742
bool useHeadlight() const
Definition: GR_Uniforms.h:480
void setHeadlightParms(UT_Vector3F dir, UT_Vector3F color, float ambient, float soft, bool use_spec, bool use_world_space)
Definition: GR_Uniforms.h:481
UT_Vector3F_UBO myNormalMatFr2
Definition: GR_Uniforms.h:616
int getObjLightingEnabled() const
Definition: GR_Uniforms.h:352