HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
SOP_VolumeVisualization.proto.h
Go to the documentation of this file.
1 /* Automagically Generated by generate_proto.py
2  * Do not Edit
3  */
4 #pragma once
5 
6 #include <SOP/SOP_NodeVerb.h>
7 #include <OP/OP_Utils.h>
8 #include <PRM/PRM_Parm.h>
9 #include <UT/UT_IStream.h>
10 #include <UT/UT_NTStreamUtil.h>
11 #include <UT/UT_Ramp.h>
12 #include <UT/UT_SharedPtr.h>
13 #include <UT/UT_StringHolder.h>
14 #include <UT/UT_StringStream.h>
15 #include <UT/UT_VectorTypes.h>
16 #include <SYS/SYS_Types.h>
17 
18 using namespace UT::Literal;
19 
20 class DEP_MicroNode;
21 namespace SOP_VolumeVisualizationEnums
22 {
23  enum class VisMode
24  {
25  NONE = 0,
26  SMOKE,
27  HEIGHTFIELD
28  };
29  enum class Densityrampmode
30  {
31  NONE = 0,
32  CLAMP,
33  PERIODIC
34  };
35  enum class Densitypreset
36  {
37  NONE = 0,
38  INCREASING,
39  DESCREASING,
40  HILL,
41  VALLEY,
42  STEP,
43  SQUARE
44  };
45  enum class Cdrampmode
46  {
47  NONE = 0,
48  CLAMP,
49  PERIODIC
50  };
51  enum class Cdpreset
52  {
53  NONE = 0,
54  _FALSE,
55  PINK,
56  MONO,
57  BLACKBODY,
58  BIPARTITE
59  };
60  enum class Emitrampmode
61  {
62  NONE = 0,
63  CLAMP,
64  PERIODIC
65  };
66  enum class Emitpreset
67  {
68  NONE = 0,
69  INCREASING,
70  DESCREASING,
71  HILL,
72  VALLEY,
73  STEP,
74  SQUARE
75  };
76  enum class Emitcdrampmode
77  {
78  NONE = 0,
79  CLAMP,
80  PERIODIC
81  };
82  enum class Emitcdpreset
83  {
84  NONE = 0,
85  _FALSE,
86  PINK,
87  MONO,
88  BLACKBODY,
89  BIPARTITE
90  };
91 }
92 
93 
95 {
96 public:
97  static int version() { return 1; }
98 
100  {
101  myVisMode = 1;
102  myRangemin = 0;
103  myRangemax = 1;
104  myDensityscale = 1;
105  myShadowscale = 1;
106  mySetmaxres = false;
107  myMaxres = 128;
108  myDensityfield = ""_sh;
109  myDensityrampmode = 1;
110  myDensitypreset = 0;
111  myDensityramp = UT_SharedPtr<UT_Ramp>(0);
112  myCdfield = ""_sh;
113  myCdrangeoverride = false;
114  myCdrange = UT_Vector2D(0,1);
115  myCdrampmode = 1;
116  myCdpreset = 0;
117  myCdramp = UT_SharedPtr<UT_Ramp>(0);
118  myEmitscale = 0;
119  myEmitfield = ""_sh;
120  myEmitrangeoverride = false;
121  myEmitrange = UT_Vector2D(0,1);
122  myEmitrampmode = 1;
123  myEmitpreset = 0;
124  myEmitramp = UT_SharedPtr<UT_Ramp>(0);
125  myEmitcdfield = ""_sh;
126  myEmitcdrangeoverride = false;
127  myEmitcdrange = UT_Vector2D(0,1);
128  myEmitcdrampmode = 1;
129  myEmitcdpreset = 0;
130  myEmitcdramp = UT_SharedPtr<UT_Ramp>(0);
131 
132  }
133 
135 
137 
139  {
140  if (myVisMode != src.myVisMode) return false;
141  if (myRangemin != src.myRangemin) return false;
142  if (myRangemax != src.myRangemax) return false;
143  if (myDensityscale != src.myDensityscale) return false;
144  if (myShadowscale != src.myShadowscale) return false;
145  if (mySetmaxres != src.mySetmaxres) return false;
146  if (myMaxres != src.myMaxres) return false;
147  if (myDensityfield != src.myDensityfield) return false;
148  if (myDensityrampmode != src.myDensityrampmode) return false;
149  if (myDensitypreset != src.myDensitypreset) return false;
150  if (myDensityramp != src.myDensityramp) return false;
151  if (myCdfield != src.myCdfield) return false;
152  if (myCdrangeoverride != src.myCdrangeoverride) return false;
153  if (myCdrange != src.myCdrange) return false;
154  if (myCdrampmode != src.myCdrampmode) return false;
155  if (myCdpreset != src.myCdpreset) return false;
156  if (myCdramp != src.myCdramp) return false;
157  if (myEmitscale != src.myEmitscale) return false;
158  if (myEmitfield != src.myEmitfield) return false;
159  if (myEmitrangeoverride != src.myEmitrangeoverride) return false;
160  if (myEmitrange != src.myEmitrange) return false;
161  if (myEmitrampmode != src.myEmitrampmode) return false;
162  if (myEmitpreset != src.myEmitpreset) return false;
163  if (myEmitramp != src.myEmitramp) return false;
164  if (myEmitcdfield != src.myEmitcdfield) return false;
165  if (myEmitcdrangeoverride != src.myEmitcdrangeoverride) return false;
166  if (myEmitcdrange != src.myEmitcdrange) return false;
167  if (myEmitcdrampmode != src.myEmitcdrampmode) return false;
168  if (myEmitcdpreset != src.myEmitcdpreset) return false;
169  if (myEmitcdramp != src.myEmitcdramp) return false;
170 
171  return true;
172  }
182 
183 
184 
185  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
186  {
187  if (true)
188  OP_Utils::evalOpParm(myVisMode, node, "vismode", time, 0);
189  else myVisMode = 1;
190  if (true)
191  OP_Utils::evalOpParm(myRangemin, node, "rangemin", time, 0);
192  else myRangemin = 0;
193  if (true)
194  OP_Utils::evalOpParm(myRangemax, node, "rangemax", time, 0);
195  else myRangemax = 1;
196  if (true)
197  OP_Utils::evalOpParm(myDensityscale, node, "densityscale", time, 0);
198  else myDensityscale = 1;
199  if (true)
200  OP_Utils::evalOpParm(myShadowscale, node, "shadowscale", time, 0);
201  else myShadowscale = 1;
202  if (true)
203  OP_Utils::evalOpParm(mySetmaxres, node, "setmaxres", time, 0);
204  else mySetmaxres = false;
205  if (true && ( (!(((getSetmaxres()==0)))) ) )
206  OP_Utils::evalOpParm(myMaxres, node, "maxres", time, 0);
207  else myMaxres = 128;
208  if (true)
209  OP_Utils::evalOpParm(myDensityfield, node, "densityfield", time, 0);
210  else myDensityfield = ""_sh;
211  if (true)
212  OP_Utils::evalOpParm(myDensityrampmode, node, "densityrampmode", time, 0);
213  else myDensityrampmode = 1;
214  if (true)
215  OP_Utils::evalOpParm(myDensitypreset, node, "densitypreset", time, 0);
216  else myDensitypreset = 0;
217  if (true && ( (!(((int64(getDensityrampmode())==0)))) ) )
218  OP_Utils::evalOpParm(myDensityramp, node, "densityramp", time, 0);
219  else myDensityramp = UT_SharedPtr<UT_Ramp>(0);
220  if (true)
221  OP_Utils::evalOpParm(myCdfield, node, "cdfield", time, 0);
222  else myCdfield = ""_sh;
223  if (true)
224  OP_Utils::evalOpParm(myCdrangeoverride, node, "cdrangeoverride", time, 0);
225  else myCdrangeoverride = false;
226  if (true && ( (!(((getCdrangeoverride()==0)))) ) )
227  OP_Utils::evalOpParm(myCdrange, node, "cdrange", time, 0);
228  else myCdrange = UT_Vector2D(0,1);
229  if (true)
230  OP_Utils::evalOpParm(myCdrampmode, node, "cdrampmode", time, 0);
231  else myCdrampmode = 1;
232  if (true)
233  OP_Utils::evalOpParm(myCdpreset, node, "cdpreset", time, 0);
234  else myCdpreset = 0;
235  if (true && ( (!(((int64(getCdrampmode())==0)))) ) )
236  OP_Utils::evalOpParm(myCdramp, node, "cdramp", time, 0);
237  else myCdramp = UT_SharedPtr<UT_Ramp>(0);
238  if (true)
239  OP_Utils::evalOpParm(myEmitscale, node, "emitscale", time, 0);
240  else myEmitscale = 0;
241  if (true)
242  OP_Utils::evalOpParm(myEmitfield, node, "emitfield", time, 0);
243  else myEmitfield = ""_sh;
244  if (true)
245  OP_Utils::evalOpParm(myEmitrangeoverride, node, "emitrangeoverride", time, 0);
246  else myEmitrangeoverride = false;
247  if (true && ( (!(((getEmitrangeoverride()==0)))) ) )
248  OP_Utils::evalOpParm(myEmitrange, node, "emitrange", time, 0);
249  else myEmitrange = UT_Vector2D(0,1);
250  if (true)
251  OP_Utils::evalOpParm(myEmitrampmode, node, "emitrampmode", time, 0);
252  else myEmitrampmode = 1;
253  if (true)
254  OP_Utils::evalOpParm(myEmitpreset, node, "emitpreset", time, 0);
255  else myEmitpreset = 0;
256  if (true && ( (!(((int64(getEmitrampmode())==0)))) ) )
257  OP_Utils::evalOpParm(myEmitramp, node, "emitramp", time, 0);
258  else myEmitramp = UT_SharedPtr<UT_Ramp>(0);
259  if (true)
260  OP_Utils::evalOpParm(myEmitcdfield, node, "emitcdfield", time, 0);
261  else myEmitcdfield = ""_sh;
262  if (true)
263  OP_Utils::evalOpParm(myEmitcdrangeoverride, node, "emitcdrangeoverride", time, 0);
264  else myEmitcdrangeoverride = false;
265  if (true && ( (!(((getEmitcdrangeoverride()==0)))) ) )
266  OP_Utils::evalOpParm(myEmitcdrange, node, "emitcdrange", time, 0);
267  else myEmitcdrange = UT_Vector2D(0,1);
268  if (true)
269  OP_Utils::evalOpParm(myEmitcdrampmode, node, "emitcdrampmode", time, 0);
270  else myEmitcdrampmode = 1;
271  if (true)
272  OP_Utils::evalOpParm(myEmitcdpreset, node, "emitcdpreset", time, 0);
273  else myEmitcdpreset = 0;
274  if (true && ( (!(((int64(getEmitcdrampmode())==0)))) ) )
275  OP_Utils::evalOpParm(myEmitcdramp, node, "emitcdramp", time, 0);
276  else myEmitcdramp = UT_SharedPtr<UT_Ramp>(0);
277 
278  }
279 
280 
281  virtual void loadFromOpSubclass(const LoadParms &loadparms)
282  {
283  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
284  }
285 
286 
287  virtual void copyFrom(const SOP_NodeParms *src)
288  {
289  *this = *((const SOP_VolumeVisualizationParms *)src);
290  }
291 
292  template <typename T>
293  void
294  doGetParmValue(exint idx, T &value) const
295  {
296  switch (idx)
297  {
298  case 0:
299  coerceValue(value, myVisMode);
300  break;
301  case 1:
302  coerceValue(value, myRangemin);
303  break;
304  case 2:
305  coerceValue(value, myRangemax);
306  break;
307  case 3:
308  coerceValue(value, myDensityscale);
309  break;
310  case 4:
311  coerceValue(value, myShadowscale);
312  break;
313  case 5:
314  coerceValue(value, mySetmaxres);
315  break;
316  case 6:
317  coerceValue(value, myMaxres);
318  break;
319  case 7:
320  coerceValue(value, myDensityfield);
321  break;
322  case 8:
323  coerceValue(value, myDensityrampmode);
324  break;
325  case 9:
326  coerceValue(value, myDensitypreset);
327  break;
328  case 10:
329  coerceValue(value, myDensityramp);
330  break;
331  case 11:
332  coerceValue(value, myCdfield);
333  break;
334  case 12:
335  coerceValue(value, myCdrangeoverride);
336  break;
337  case 13:
338  coerceValue(value, myCdrange);
339  break;
340  case 14:
341  coerceValue(value, myCdrampmode);
342  break;
343  case 15:
344  coerceValue(value, myCdpreset);
345  break;
346  case 16:
347  coerceValue(value, myCdramp);
348  break;
349  case 17:
350  coerceValue(value, myEmitscale);
351  break;
352  case 18:
353  coerceValue(value, myEmitfield);
354  break;
355  case 19:
356  coerceValue(value, myEmitrangeoverride);
357  break;
358  case 20:
359  coerceValue(value, myEmitrange);
360  break;
361  case 21:
362  coerceValue(value, myEmitrampmode);
363  break;
364  case 22:
365  coerceValue(value, myEmitpreset);
366  break;
367  case 23:
368  coerceValue(value, myEmitramp);
369  break;
370  case 24:
371  coerceValue(value, myEmitcdfield);
372  break;
373  case 25:
374  coerceValue(value, myEmitcdrangeoverride);
375  break;
376  case 26:
377  coerceValue(value, myEmitcdrange);
378  break;
379  case 27:
380  coerceValue(value, myEmitcdrampmode);
381  break;
382  case 28:
383  coerceValue(value, myEmitcdpreset);
384  break;
385  case 29:
386  coerceValue(value, myEmitcdramp);
387  break;
388 
389  }
390  }
391 
392  void getParmValue(exint idx, exint &value) const
393  { doGetParmValue(idx, value); }
394  void getParmValue(exint idx, fpreal &value) const
395  { doGetParmValue(idx, value); }
397  { doGetParmValue(idx, value); }
399  { doGetParmValue(idx, value); }
401  { doGetParmValue(idx, value); }
403  { doGetParmValue(idx, value); }
405  { doGetParmValue(idx, value); }
407  { doGetParmValue(idx, value); }
409  { doGetParmValue(idx, value); }
411  { doGetParmValue(idx, value); }
413  { doGetParmValue(idx, value); }
414 
415  template <typename T>
416  void
417  doSetParmValue(exint idx, const T &value)
418  {
419  switch (idx)
420  {
421  case 0:
422  coerceValue(myVisMode, value);
423  break;
424  case 1:
425  coerceValue(myRangemin, value);
426  break;
427  case 2:
428  coerceValue(myRangemax, value);
429  break;
430  case 3:
431  coerceValue(myDensityscale, value);
432  break;
433  case 4:
434  coerceValue(myShadowscale, value);
435  break;
436  case 5:
437  coerceValue(mySetmaxres, value);
438  break;
439  case 6:
440  coerceValue(myMaxres, value);
441  break;
442  case 7:
443  coerceValue(myDensityfield, value);
444  break;
445  case 8:
446  coerceValue(myDensityrampmode, value);
447  break;
448  case 9:
449  coerceValue(myDensitypreset, value);
450  break;
451  case 10:
452  coerceValue(myDensityramp, value);
453  break;
454  case 11:
455  coerceValue(myCdfield, value);
456  break;
457  case 12:
458  coerceValue(myCdrangeoverride, value);
459  break;
460  case 13:
461  coerceValue(myCdrange, value);
462  break;
463  case 14:
464  coerceValue(myCdrampmode, value);
465  break;
466  case 15:
467  coerceValue(myCdpreset, value);
468  break;
469  case 16:
470  coerceValue(myCdramp, value);
471  break;
472  case 17:
473  coerceValue(myEmitscale, value);
474  break;
475  case 18:
476  coerceValue(myEmitfield, value);
477  break;
478  case 19:
479  coerceValue(myEmitrangeoverride, value);
480  break;
481  case 20:
482  coerceValue(myEmitrange, value);
483  break;
484  case 21:
485  coerceValue(myEmitrampmode, value);
486  break;
487  case 22:
488  coerceValue(myEmitpreset, value);
489  break;
490  case 23:
491  coerceValue(myEmitramp, value);
492  break;
493  case 24:
494  coerceValue(myEmitcdfield, value);
495  break;
496  case 25:
497  coerceValue(myEmitcdrangeoverride, value);
498  break;
499  case 26:
500  coerceValue(myEmitcdrange, value);
501  break;
502  case 27:
503  coerceValue(myEmitcdrampmode, value);
504  break;
505  case 28:
506  coerceValue(myEmitcdpreset, value);
507  break;
508  case 29:
509  coerceValue(myEmitcdramp, value);
510  break;
511 
512  }
513  }
514 
515  void setParmValue(exint idx, const exint &value)
516  { doSetParmValue(idx, value); }
517  void setParmValue(exint idx, const fpreal &value)
518  { doSetParmValue(idx, value); }
519  void setParmValue(exint idx, const UT_Vector2D &value)
520  { doSetParmValue(idx, value); }
521  void setParmValue(exint idx, const UT_Vector3D &value)
522  { doSetParmValue(idx, value); }
523  void setParmValue(exint idx, const UT_Vector4D &value)
524  { doSetParmValue(idx, value); }
525  void setParmValue(exint idx, const UT_Matrix2D &value)
526  { doSetParmValue(idx, value); }
527  void setParmValue(exint idx, const UT_Matrix3D &value)
528  { doSetParmValue(idx, value); }
529  void setParmValue(exint idx, const UT_Matrix4D &value)
530  { doSetParmValue(idx, value); }
532  { doSetParmValue(idx, value); }
534  { doSetParmValue(idx, value); }
536  { doSetParmValue(idx, value); }
537 
538  virtual exint getNumParms() const
539  {
540  return 30;
541  }
542 
543  virtual const char *getParmName(exint fieldnum) const
544  {
545  switch (fieldnum)
546  {
547  case 0:
548  return "vismode";
549  case 1:
550  return "rangemin";
551  case 2:
552  return "rangemax";
553  case 3:
554  return "densityscale";
555  case 4:
556  return "shadowscale";
557  case 5:
558  return "setmaxres";
559  case 6:
560  return "maxres";
561  case 7:
562  return "densityfield";
563  case 8:
564  return "densityrampmode";
565  case 9:
566  return "densitypreset";
567  case 10:
568  return "densityramp";
569  case 11:
570  return "cdfield";
571  case 12:
572  return "cdrangeoverride";
573  case 13:
574  return "cdrange";
575  case 14:
576  return "cdrampmode";
577  case 15:
578  return "cdpreset";
579  case 16:
580  return "cdramp";
581  case 17:
582  return "emitscale";
583  case 18:
584  return "emitfield";
585  case 19:
586  return "emitrangeoverride";
587  case 20:
588  return "emitrange";
589  case 21:
590  return "emitrampmode";
591  case 22:
592  return "emitpreset";
593  case 23:
594  return "emitramp";
595  case 24:
596  return "emitcdfield";
597  case 25:
598  return "emitcdrangeoverride";
599  case 26:
600  return "emitcdrange";
601  case 27:
602  return "emitcdrampmode";
603  case 28:
604  return "emitcdpreset";
605  case 29:
606  return "emitcdramp";
607 
608  }
609  return 0;
610  }
611 
612  virtual ParmType getParmType(exint fieldnum) const
613  {
614  switch (fieldnum)
615  {
616  case 0:
617  return PARM_INTEGER;
618  case 1:
619  return PARM_FLOAT;
620  case 2:
621  return PARM_FLOAT;
622  case 3:
623  return PARM_FLOAT;
624  case 4:
625  return PARM_FLOAT;
626  case 5:
627  return PARM_INTEGER;
628  case 6:
629  return PARM_INTEGER;
630  case 7:
631  return PARM_STRING;
632  case 8:
633  return PARM_INTEGER;
634  case 9:
635  return PARM_INTEGER;
636  case 10:
637  return PARM_RAMP;
638  case 11:
639  return PARM_STRING;
640  case 12:
641  return PARM_INTEGER;
642  case 13:
643  return PARM_VECTOR2;
644  case 14:
645  return PARM_INTEGER;
646  case 15:
647  return PARM_INTEGER;
648  case 16:
649  return PARM_RAMP;
650  case 17:
651  return PARM_FLOAT;
652  case 18:
653  return PARM_STRING;
654  case 19:
655  return PARM_INTEGER;
656  case 20:
657  return PARM_VECTOR2;
658  case 21:
659  return PARM_INTEGER;
660  case 22:
661  return PARM_INTEGER;
662  case 23:
663  return PARM_RAMP;
664  case 24:
665  return PARM_STRING;
666  case 25:
667  return PARM_INTEGER;
668  case 26:
669  return PARM_VECTOR2;
670  case 27:
671  return PARM_INTEGER;
672  case 28:
673  return PARM_INTEGER;
674  case 29:
675  return PARM_RAMP;
676 
677  }
678  return PARM_UNSUPPORTED;
679  }
680 
681  // Boiler plate to load individual types.
682  static void loadData(UT_IStream &is, int64 &v)
683  { is.bread(&v, 1); }
684  static void loadData(UT_IStream &is, bool &v)
685  { int64 iv; is.bread(&iv, 1); v = iv; }
686  static void loadData(UT_IStream &is, fpreal64 &v)
687  { is.bread<fpreal64>(&v, 1); }
688  static void loadData(UT_IStream &is, UT_Vector2D &v)
689  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
690  static void loadData(UT_IStream &is, UT_Vector3D &v)
691  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
692  is.bread<fpreal64>(&v.z(), 1); }
693  static void loadData(UT_IStream &is, UT_Vector4D &v)
694  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
695  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
696  static void loadData(UT_IStream &is, UT_Matrix2D &v)
697  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
698  static void loadData(UT_IStream &is, UT_Matrix3D &v)
699  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
700  static void loadData(UT_IStream &is, UT_Matrix4D &v)
701  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
702  static void loadData(UT_IStream &is, UT_Vector2I &v)
703  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
704  static void loadData(UT_IStream &is, UT_Vector3I &v)
705  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
706  is.bread<int64>(&v.z(), 1); }
707  static void loadData(UT_IStream &is, UT_Vector4I &v)
708  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
709  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
711  { is.bread(v); }
713  { UT_StringHolder rampdata;
714  loadData(is, rampdata);
715  if (rampdata.isstring())
716  {
717  v.reset(new UT_Ramp());
718  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
719  v->load(istr);
720  }
721  else v.reset();
722  }
725  loadData(is, data);
726  if (data.isstring())
727  {
728  // Find the data type.
729  char *colon = UT_StringWrap(data).findChar(':');
730  if (colon)
731  {
732  int typelen = colon - data.buffer();
734  type.strncpy(data.buffer(), typelen);
735  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
736 
737  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
738  }
739  }
740  else v.reset();
741  }
742 
743  static void saveData(std::ostream &os, int64 v)
744  { UTwrite(os, &v); }
745  static void saveData(std::ostream &os, bool v)
746  { int64 iv = v; UTwrite(os, &iv); }
747  static void saveData(std::ostream &os, fpreal64 v)
748  { UTwrite<fpreal64>(os, &v); }
749  static void saveData(std::ostream &os, UT_Vector2D v)
750  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
751  static void saveData(std::ostream &os, UT_Vector3D v)
752  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
753  UTwrite<fpreal64>(os, &v.z()); }
754  static void saveData(std::ostream &os, UT_Vector4D v)
755  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
756  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
757  static void saveData(std::ostream &os, UT_Matrix2D v)
759  static void saveData(std::ostream &os, UT_Matrix3D v)
761  static void saveData(std::ostream &os, UT_Matrix4D v)
763  static void saveData(std::ostream &os, UT_StringHolder s)
764  { UT_StringWrap(s).saveBinary(os); }
765  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
766  { UT_StringHolder result;
767  UT_OStringStream ostr;
768  if (s) s->save(ostr);
769  result = ostr.str();
770  saveData(os, result);
771  }
772  static void saveData(std::ostream &os, PRM_DataItemHandle s)
773  { UT_StringHolder result;
774  UT_OStringStream ostr;
775  if (s)
776  {
777  ostr << s->getDataTypeToken();
778  ostr << ":";
779  s->saveBinary(ostr);
780  }
781  result = ostr.str();
782  saveData(os, result);
783  }
784 
785 
786  void save(std::ostream &os) const
787  {
788  int32 v = version();
789  UTwrite(os, &v);
790  saveData(os, myVisMode);
791  saveData(os, myRangemin);
792  saveData(os, myRangemax);
793  saveData(os, myDensityscale);
794  saveData(os, myShadowscale);
795  saveData(os, mySetmaxres);
796  saveData(os, myMaxres);
797  saveData(os, myDensityfield);
798  saveData(os, myDensityrampmode);
799  saveData(os, myDensitypreset);
800  saveData(os, myDensityramp);
801  saveData(os, myCdfield);
802  saveData(os, myCdrangeoverride);
803  saveData(os, myCdrange);
804  saveData(os, myCdrampmode);
805  saveData(os, myCdpreset);
806  saveData(os, myCdramp);
807  saveData(os, myEmitscale);
808  saveData(os, myEmitfield);
809  saveData(os, myEmitrangeoverride);
810  saveData(os, myEmitrange);
811  saveData(os, myEmitrampmode);
812  saveData(os, myEmitpreset);
813  saveData(os, myEmitramp);
814  saveData(os, myEmitcdfield);
815  saveData(os, myEmitcdrangeoverride);
816  saveData(os, myEmitcdrange);
817  saveData(os, myEmitcdrampmode);
818  saveData(os, myEmitcdpreset);
819  saveData(os, myEmitcdramp);
820 
821  }
822 
823  bool load(UT_IStream &is)
824  {
825  int32 v;
826  is.bread(&v, 1);
827  if (version() != v)
828  {
829  // Fail incompatible versions
830  return false;
831  }
832  loadData(is, myVisMode);
833  loadData(is, myRangemin);
834  loadData(is, myRangemax);
835  loadData(is, myDensityscale);
836  loadData(is, myShadowscale);
837  loadData(is, mySetmaxres);
838  loadData(is, myMaxres);
839  loadData(is, myDensityfield);
840  loadData(is, myDensityrampmode);
841  loadData(is, myDensitypreset);
842  loadData(is, myDensityramp);
843  loadData(is, myCdfield);
844  loadData(is, myCdrangeoverride);
845  loadData(is, myCdrange);
846  loadData(is, myCdrampmode);
847  loadData(is, myCdpreset);
848  loadData(is, myCdramp);
849  loadData(is, myEmitscale);
850  loadData(is, myEmitfield);
851  loadData(is, myEmitrangeoverride);
852  loadData(is, myEmitrange);
853  loadData(is, myEmitrampmode);
854  loadData(is, myEmitpreset);
855  loadData(is, myEmitramp);
856  loadData(is, myEmitcdfield);
857  loadData(is, myEmitcdrangeoverride);
858  loadData(is, myEmitcdrange);
859  loadData(is, myEmitcdrampmode);
860  loadData(is, myEmitcdpreset);
861  loadData(is, myEmitcdramp);
862 
863  return true;
864  }
865 
866  VisMode getVisMode() const { return VisMode(myVisMode); }
867  void setVisMode(VisMode val) { myVisMode = int64(val); }
868  VisMode opVisMode(const SOP_NodeVerb::CookParms &cookparms) const
869  {
870  SOP_Node *thissop = cookparms.getNode();
871  if (!thissop) return getVisMode();
872  int64 result;
873  OP_Utils::evalOpParm(result, thissop, "vismode", cookparms.getCookTime(), 0);
874  return VisMode(result);
875  }
876  fpreal64 getRangemin() const { return myRangemin; }
877  void setRangemin(fpreal64 val) { myRangemin = val; }
879  {
880  SOP_Node *thissop = cookparms.getNode();
881  if (!thissop) return getRangemin();
882  fpreal64 result;
883  OP_Utils::evalOpParm(result, thissop, "rangemin", cookparms.getCookTime(), 0);
884  return result;
885  }
886  fpreal64 getRangemax() const { return myRangemax; }
887  void setRangemax(fpreal64 val) { myRangemax = val; }
889  {
890  SOP_Node *thissop = cookparms.getNode();
891  if (!thissop) return getRangemax();
892  fpreal64 result;
893  OP_Utils::evalOpParm(result, thissop, "rangemax", cookparms.getCookTime(), 0);
894  return result;
895  }
896  fpreal64 getDensityscale() const { return myDensityscale; }
897  void setDensityscale(fpreal64 val) { myDensityscale = val; }
899  {
900  SOP_Node *thissop = cookparms.getNode();
901  if (!thissop) return getDensityscale();
902  fpreal64 result;
903  OP_Utils::evalOpParm(result, thissop, "densityscale", cookparms.getCookTime(), 0);
904  return result;
905  }
906  fpreal64 getShadowscale() const { return myShadowscale; }
907  void setShadowscale(fpreal64 val) { myShadowscale = val; }
909  {
910  SOP_Node *thissop = cookparms.getNode();
911  if (!thissop) return getShadowscale();
912  fpreal64 result;
913  OP_Utils::evalOpParm(result, thissop, "shadowscale", cookparms.getCookTime(), 0);
914  return result;
915  }
916  bool getSetmaxres() const { return mySetmaxres; }
917  void setSetmaxres(bool val) { mySetmaxres = val; }
918  bool opSetmaxres(const SOP_NodeVerb::CookParms &cookparms) const
919  {
920  SOP_Node *thissop = cookparms.getNode();
921  if (!thissop) return getSetmaxres();
922  bool result;
923  OP_Utils::evalOpParm(result, thissop, "setmaxres", cookparms.getCookTime(), 0);
924  return result;
925  }
926  int64 getMaxres() const { return myMaxres; }
927  void setMaxres(int64 val) { myMaxres = val; }
928  int64 opMaxres(const SOP_NodeVerb::CookParms &cookparms) const
929  {
930  SOP_Node *thissop = cookparms.getNode();
931  if (!thissop) return getMaxres();
932  int64 result;
933  OP_Utils::evalOpParm(result, thissop, "maxres", cookparms.getCookTime(), 0);
934  return result;
935  }
936  const UT_StringHolder & getDensityfield() const { return myDensityfield; }
937  void setDensityfield(const UT_StringHolder & val) { myDensityfield = val; }
939  {
940  SOP_Node *thissop = cookparms.getNode();
941  if (!thissop) return getDensityfield();
942  UT_StringHolder result;
943  OP_Utils::evalOpParm(result, thissop, "densityfield", cookparms.getCookTime(), 0);
944  return result;
945  }
946  Densityrampmode getDensityrampmode() const { return Densityrampmode(myDensityrampmode); }
947  void setDensityrampmode(Densityrampmode val) { myDensityrampmode = int64(val); }
949  {
950  SOP_Node *thissop = cookparms.getNode();
951  if (!thissop) return getDensityrampmode();
952  int64 result;
953  OP_Utils::evalOpParm(result, thissop, "densityrampmode", cookparms.getCookTime(), 0);
954  return Densityrampmode(result);
955  }
956  Densitypreset getDensitypreset() const { return Densitypreset(myDensitypreset); }
957  void setDensitypreset(Densitypreset val) { myDensitypreset = int64(val); }
959  {
960  SOP_Node *thissop = cookparms.getNode();
961  if (!thissop) return getDensitypreset();
962  int64 result;
963  OP_Utils::evalOpParm(result, thissop, "densitypreset", cookparms.getCookTime(), 0);
964  return Densitypreset(result);
965  }
966  UT_SharedPtr<UT_Ramp> getDensityramp() const { return myDensityramp; }
967  void setDensityramp(UT_SharedPtr<UT_Ramp> val) { myDensityramp = val; }
969  {
970  SOP_Node *thissop = cookparms.getNode();
971  if (!thissop) return getDensityramp();
972  UT_SharedPtr<UT_Ramp> result;
973  OP_Utils::evalOpParm(result, thissop, "densityramp", cookparms.getCookTime(), 0);
974  return result;
975  }
976  const UT_StringHolder & getCdfield() const { return myCdfield; }
977  void setCdfield(const UT_StringHolder & val) { myCdfield = val; }
979  {
980  SOP_Node *thissop = cookparms.getNode();
981  if (!thissop) return getCdfield();
982  UT_StringHolder result;
983  OP_Utils::evalOpParm(result, thissop, "cdfield", cookparms.getCookTime(), 0);
984  return result;
985  }
986  bool getCdrangeoverride() const { return myCdrangeoverride; }
987  void setCdrangeoverride(bool val) { myCdrangeoverride = val; }
988  bool opCdrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
989  {
990  SOP_Node *thissop = cookparms.getNode();
991  if (!thissop) return getCdrangeoverride();
992  bool result;
993  OP_Utils::evalOpParm(result, thissop, "cdrangeoverride", cookparms.getCookTime(), 0);
994  return result;
995  }
996  UT_Vector2D getCdrange() const { return myCdrange; }
997  void setCdrange(UT_Vector2D val) { myCdrange = val; }
999  {
1000  SOP_Node *thissop = cookparms.getNode();
1001  if (!thissop) return getCdrange();
1002  UT_Vector2D result;
1003  OP_Utils::evalOpParm(result, thissop, "cdrange", cookparms.getCookTime(), 0);
1004  return result;
1005  }
1006  Cdrampmode getCdrampmode() const { return Cdrampmode(myCdrampmode); }
1007  void setCdrampmode(Cdrampmode val) { myCdrampmode = int64(val); }
1009  {
1010  SOP_Node *thissop = cookparms.getNode();
1011  if (!thissop) return getCdrampmode();
1012  int64 result;
1013  OP_Utils::evalOpParm(result, thissop, "cdrampmode", cookparms.getCookTime(), 0);
1014  return Cdrampmode(result);
1015  }
1016  Cdpreset getCdpreset() const { return Cdpreset(myCdpreset); }
1017  void setCdpreset(Cdpreset val) { myCdpreset = int64(val); }
1019  {
1020  SOP_Node *thissop = cookparms.getNode();
1021  if (!thissop) return getCdpreset();
1022  int64 result;
1023  OP_Utils::evalOpParm(result, thissop, "cdpreset", cookparms.getCookTime(), 0);
1024  return Cdpreset(result);
1025  }
1026  UT_SharedPtr<UT_Ramp> getCdramp() const { return myCdramp; }
1027  void setCdramp(UT_SharedPtr<UT_Ramp> val) { myCdramp = val; }
1029  {
1030  SOP_Node *thissop = cookparms.getNode();
1031  if (!thissop) return getCdramp();
1032  UT_SharedPtr<UT_Ramp> result;
1033  OP_Utils::evalOpParm(result, thissop, "cdramp", cookparms.getCookTime(), 0);
1034  return result;
1035  }
1036  fpreal64 getEmitscale() const { return myEmitscale; }
1037  void setEmitscale(fpreal64 val) { myEmitscale = val; }
1039  {
1040  SOP_Node *thissop = cookparms.getNode();
1041  if (!thissop) return getEmitscale();
1042  fpreal64 result;
1043  OP_Utils::evalOpParm(result, thissop, "emitscale", cookparms.getCookTime(), 0);
1044  return result;
1045  }
1046  const UT_StringHolder & getEmitfield() const { return myEmitfield; }
1047  void setEmitfield(const UT_StringHolder & val) { myEmitfield = val; }
1049  {
1050  SOP_Node *thissop = cookparms.getNode();
1051  if (!thissop) return getEmitfield();
1052  UT_StringHolder result;
1053  OP_Utils::evalOpParm(result, thissop, "emitfield", cookparms.getCookTime(), 0);
1054  return result;
1055  }
1056  bool getEmitrangeoverride() const { return myEmitrangeoverride; }
1057  void setEmitrangeoverride(bool val) { myEmitrangeoverride = val; }
1058  bool opEmitrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
1059  {
1060  SOP_Node *thissop = cookparms.getNode();
1061  if (!thissop) return getEmitrangeoverride();
1062  bool result;
1063  OP_Utils::evalOpParm(result, thissop, "emitrangeoverride", cookparms.getCookTime(), 0);
1064  return result;
1065  }
1066  UT_Vector2D getEmitrange() const { return myEmitrange; }
1067  void setEmitrange(UT_Vector2D val) { myEmitrange = val; }
1069  {
1070  SOP_Node *thissop = cookparms.getNode();
1071  if (!thissop) return getEmitrange();
1072  UT_Vector2D result;
1073  OP_Utils::evalOpParm(result, thissop, "emitrange", cookparms.getCookTime(), 0);
1074  return result;
1075  }
1076  Emitrampmode getEmitrampmode() const { return Emitrampmode(myEmitrampmode); }
1077  void setEmitrampmode(Emitrampmode val) { myEmitrampmode = int64(val); }
1079  {
1080  SOP_Node *thissop = cookparms.getNode();
1081  if (!thissop) return getEmitrampmode();
1082  int64 result;
1083  OP_Utils::evalOpParm(result, thissop, "emitrampmode", cookparms.getCookTime(), 0);
1084  return Emitrampmode(result);
1085  }
1086  Emitpreset getEmitpreset() const { return Emitpreset(myEmitpreset); }
1087  void setEmitpreset(Emitpreset val) { myEmitpreset = int64(val); }
1089  {
1090  SOP_Node *thissop = cookparms.getNode();
1091  if (!thissop) return getEmitpreset();
1092  int64 result;
1093  OP_Utils::evalOpParm(result, thissop, "emitpreset", cookparms.getCookTime(), 0);
1094  return Emitpreset(result);
1095  }
1096  UT_SharedPtr<UT_Ramp> getEmitramp() const { return myEmitramp; }
1097  void setEmitramp(UT_SharedPtr<UT_Ramp> val) { myEmitramp = val; }
1099  {
1100  SOP_Node *thissop = cookparms.getNode();
1101  if (!thissop) return getEmitramp();
1102  UT_SharedPtr<UT_Ramp> result;
1103  OP_Utils::evalOpParm(result, thissop, "emitramp", cookparms.getCookTime(), 0);
1104  return result;
1105  }
1106  const UT_StringHolder & getEmitcdfield() const { return myEmitcdfield; }
1107  void setEmitcdfield(const UT_StringHolder & val) { myEmitcdfield = val; }
1109  {
1110  SOP_Node *thissop = cookparms.getNode();
1111  if (!thissop) return getEmitcdfield();
1112  UT_StringHolder result;
1113  OP_Utils::evalOpParm(result, thissop, "emitcdfield", cookparms.getCookTime(), 0);
1114  return result;
1115  }
1116  bool getEmitcdrangeoverride() const { return myEmitcdrangeoverride; }
1117  void setEmitcdrangeoverride(bool val) { myEmitcdrangeoverride = val; }
1118  bool opEmitcdrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
1119  {
1120  SOP_Node *thissop = cookparms.getNode();
1121  if (!thissop) return getEmitcdrangeoverride();
1122  bool result;
1123  OP_Utils::evalOpParm(result, thissop, "emitcdrangeoverride", cookparms.getCookTime(), 0);
1124  return result;
1125  }
1126  UT_Vector2D getEmitcdrange() const { return myEmitcdrange; }
1127  void setEmitcdrange(UT_Vector2D val) { myEmitcdrange = val; }
1129  {
1130  SOP_Node *thissop = cookparms.getNode();
1131  if (!thissop) return getEmitcdrange();
1132  UT_Vector2D result;
1133  OP_Utils::evalOpParm(result, thissop, "emitcdrange", cookparms.getCookTime(), 0);
1134  return result;
1135  }
1136  Emitcdrampmode getEmitcdrampmode() const { return Emitcdrampmode(myEmitcdrampmode); }
1137  void setEmitcdrampmode(Emitcdrampmode val) { myEmitcdrampmode = int64(val); }
1139  {
1140  SOP_Node *thissop = cookparms.getNode();
1141  if (!thissop) return getEmitcdrampmode();
1142  int64 result;
1143  OP_Utils::evalOpParm(result, thissop, "emitcdrampmode", cookparms.getCookTime(), 0);
1144  return Emitcdrampmode(result);
1145  }
1146  Emitcdpreset getEmitcdpreset() const { return Emitcdpreset(myEmitcdpreset); }
1147  void setEmitcdpreset(Emitcdpreset val) { myEmitcdpreset = int64(val); }
1149  {
1150  SOP_Node *thissop = cookparms.getNode();
1151  if (!thissop) return getEmitcdpreset();
1152  int64 result;
1153  OP_Utils::evalOpParm(result, thissop, "emitcdpreset", cookparms.getCookTime(), 0);
1154  return Emitcdpreset(result);
1155  }
1156  UT_SharedPtr<UT_Ramp> getEmitcdramp() const { return myEmitcdramp; }
1157  void setEmitcdramp(UT_SharedPtr<UT_Ramp> val) { myEmitcdramp = val; }
1159  {
1160  SOP_Node *thissop = cookparms.getNode();
1161  if (!thissop) return getEmitcdramp();
1162  UT_SharedPtr<UT_Ramp> result;
1163  OP_Utils::evalOpParm(result, thissop, "emitcdramp", cookparms.getCookTime(), 0);
1164  return result;
1165  }
1166 
1167 private:
1168  int64 myVisMode;
1169  fpreal64 myRangemin;
1170  fpreal64 myRangemax;
1171  fpreal64 myDensityscale;
1172  fpreal64 myShadowscale;
1173  bool mySetmaxres;
1174  int64 myMaxres;
1175  UT_StringHolder myDensityfield;
1176  int64 myDensityrampmode;
1177  int64 myDensitypreset;
1178  UT_SharedPtr<UT_Ramp> myDensityramp;
1179  UT_StringHolder myCdfield;
1180  bool myCdrangeoverride;
1181  UT_Vector2D myCdrange;
1182  int64 myCdrampmode;
1183  int64 myCdpreset;
1184  UT_SharedPtr<UT_Ramp> myCdramp;
1185  fpreal64 myEmitscale;
1186  UT_StringHolder myEmitfield;
1187  bool myEmitrangeoverride;
1188  UT_Vector2D myEmitrange;
1189  int64 myEmitrampmode;
1190  int64 myEmitpreset;
1191  UT_SharedPtr<UT_Ramp> myEmitramp;
1192  UT_StringHolder myEmitcdfield;
1193  bool myEmitcdrangeoverride;
1194  UT_Vector2D myEmitcdrange;
1195  int64 myEmitcdrampmode;
1196  int64 myEmitcdpreset;
1197  UT_SharedPtr<UT_Ramp> myEmitcdramp;
1198 
1199 };
bool opEmitrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector2I &v)
void setParmValue(exint idx, const UT_Vector3D &value)
Emitpreset opEmitpreset(const SOP_NodeVerb::CookParms &cookparms) const
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:492
T & z(void)
Definition: UT_Vector4.h:372
fpreal64 opEmitscale(const SOP_NodeVerb::CookParms &cookparms) const
virtual const char * getParmName(exint fieldnum) const
UT_SharedPtr< UT_Ramp > opEmitcdramp(const SOP_NodeVerb::CookParms &cookparms) const
exint bread(int32 *buffer, exint asize=1)
UT_SharedPtr< UT_Ramp > opDensityramp(const SOP_NodeVerb::CookParms &cookparms) const
fpreal getTime() const
Definition: OP_Context.h:34
const GLdouble * v
Definition: glcorearb.h:836
UT_Vector2T< fpreal64 > UT_Vector2D
bool operator==(const SOP_VolumeVisualizationParms &src) const
void save(std::ostream &os) const
static void loadData(UT_IStream &is, UT_Matrix3D &v)
void doSetParmValue(exint idx, const T &value)
T & x(void)
Definition: UT_Vector2.h:284
UT_SharedPtr< UT_Ramp > opEmitramp(const SOP_NodeVerb::CookParms &cookparms) const
An output stream object that owns its own string buffer storage.
Cdpreset opCdpreset(const SOP_NodeVerb::CookParms &cookparms) const
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
void setEmitcdfield(const UT_StringHolder &val)
UT_StringHolder opEmitcdfield(const SOP_NodeVerb::CookParms &cookparms) const
UT_SharedPtr< UT_Ramp > getEmitcdramp() const
void setParmValue(exint idx, const fpreal &value)
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:581
UT_SharedPtr< UT_Ramp > getDensityramp() const
bool opEmitcdrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
void getParmValue(exint idx, UT_Matrix3D &value) const
Densityrampmode opDensityrampmode(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_Vector2D &value) const
fpreal64 opDensityscale(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector2D &v)
void setParmValue(exint idx, const PRM_DataItemHandle &value)
UT_SharedPtr< UT_Ramp > getEmitramp() const
void setDensityramp(UT_SharedPtr< UT_Ramp > val)
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
UT_SharedPtr< UT_Ramp > opCdramp(const SOP_NodeVerb::CookParms &cookparms) const
fpreal64 opShadowscale(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_Matrix2D &value)
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:585
fpreal64 opRangemin(const SOP_NodeVerb::CookParms &cookparms) const
long long int64
Definition: SYS_Types.h:100
UT_StringHolder opDensityfield(const SOP_NodeVerb::CookParms &cookparms) const
Emitrampmode opEmitrampmode(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
void setParmValue(exint idx, const UT_StringHolder &value)
int64 opMaxres(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector2D opEmitrange(const SOP_NodeVerb::CookParms &cookparms) const
void doGetParmValue(exint idx, T &value) const
static void saveData(std::ostream &os, int64 v)
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
static void loadData(UT_IStream &is, fpreal64 &v)
UT_Vector2D opEmitcdrange(const SOP_NodeVerb::CookParms &cookparms) const
SYS_FORCE_INLINE const char * buffer() const
static void loadData(UT_IStream &is, UT_Vector4I &v)
int64 exint
Definition: SYS_Types.h:109
static void saveData(std::ostream &os, UT_Matrix3D v)
static void saveData(std::ostream &os, UT_Matrix4D v)
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
UT_SharedPtr< UT_Ramp > getCdramp() const
double fpreal64
Definition: SYS_Types.h:185
static void loadData(UT_IStream &is, UT_Matrix4D &v)
static void loadData(UT_IStream &is, bool &v)
static void saveData(std::ostream &os, UT_Matrix2D v)
void setParmValue(exint idx, const UT_Matrix3D &value)
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
bool opCdrangeoverride(const SOP_NodeVerb::CookParms &cookparms) const
void setEmitramp(UT_SharedPtr< UT_Ramp > val)
UT_Vector2D opCdrange(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getEmitcdfield() const
GLboolean * data
Definition: glcorearb.h:130
void setDensityfield(const UT_StringHolder &val)
int int32
Definition: SYS_Types.h:28
T & y(void)
Definition: UT_Vector4.h:370
static void saveData(std::ostream &os, UT_Vector2D v)
static void saveData(std::ostream &os, fpreal64 v)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
void setParmValue(exint idx, const UT_Vector4D &value)
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
fpreal64 opRangemax(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
SYS_FORCE_INLINE T & y(void)
Definition: UT_Vector3.h:583
GLsizei const GLfloat * value
Definition: glcorearb.h:823
static void loadData(UT_IStream &is, UT_Vector3I &v)
double fpreal
Definition: SYS_Types.h:263
UT_StringHolder opCdfield(const SOP_NodeVerb::CookParms &cookparms) const
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
void strncpy(const char *src, exint maxlen)
void getParmValue(exint idx, UT_Matrix2D &value) const
virtual void copyFrom(const SOP_NodeParms *src)
Emitcdrampmode opEmitcdrampmode(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector4D v)
Densitypreset opDensitypreset(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_Matrix4D &value)
static void loadData(UT_IStream &is, UT_StringHolder &v)
void getParmValue(exint idx, PRM_DataItemHandle &value) const
const UT_StringHolder & getDensityfield() const
void setCdramp(UT_SharedPtr< UT_Ramp > val)
static void loadData(UT_IStream &is, UT_Matrix2D &v)
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
void setCdfield(const UT_StringHolder &val)
GLuint GLfloat * val
Definition: glcorearb.h:1607
void getParmValue(exint idx, UT_Vector3D &value) const
#define SOP_API
Definition: SOP_API.h:10
virtual ParmType getParmType(exint fieldnum) const
Emitcdpreset opEmitcdpreset(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, bool v)
const char * buffer() const
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:499
T & x(void)
Definition: UT_Vector4.h:368
void getParmValue(exint idx, UT_Matrix4D &value) const
T & y(void)
Definition: UT_Vector2.h:286
static void saveData(std::ostream &os, UT_Vector3D v)
const UT_StringHolder & getEmitfield() const
UT_StringHolder opEmitfield(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const exint &value)
const UT_StringHolder & getCdfield() const
void setEmitcdramp(UT_SharedPtr< UT_Ramp > val)
GLboolean r
Definition: glcorearb.h:1221
void getParmValue(exint idx, UT_Vector4D &value) const
T & w(void)
Definition: UT_Vector4.h:374
static void loadData(UT_IStream &is, UT_Vector3D &v)
void getParmValue(exint idx, UT_StringHolder &value) const
static void saveData(std::ostream &os, UT_StringHolder s)
void setDensityrampmode(Densityrampmode val)
bool opSetmaxres(const SOP_NodeVerb::CookParms &cookparms) const
void setEmitfield(const UT_StringHolder &val)
static void loadData(UT_IStream &is, UT_Vector4D &v)
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
void setParmValue(exint idx, const UT_Vector2D &value)
void getParmValue(exint idx, exint &value) const
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
SYS_FORCE_INLINE bool isstring() const
void getParmValue(exint idx, fpreal &value) const
static void loadData(UT_IStream &is, int64 &v)
virtual void loadFromOpSubclass(const LoadParms &loadparms)
Cdrampmode opCdrampmode(const SOP_NodeVerb::CookParms &cookparms) const
GLenum src
Definition: glcorearb.h:1792
VisMode opVisMode(const SOP_NodeVerb::CookParms &cookparms) const