HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SOP_Detangle.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 
23 {
24 public:
25  static int version() { return 1; }
26 
28  {
29  myPrevpos = ""_sh;
30  myDisableSelfAttr = "disableself"_sh;
31  myDisableExternalAttr = "disableexternal"_sh;
32  myWeldAttr = "weld"_sh;
33  myThickness = 0.05;
34  myDoSelf = false;
35  myDoTet = false;
36  myUpdateDisable = false;
37  myResetDetangledPoints = false;
38  myDoMark = false;
39  myMarkAttr = "changed"_sh;
40  myDoresolve = false;
41  myMaxWeight = 1.0;
42  myCapDisplace = false;
43  myMaxDisplace = 0.5;
44  myResolveAll = false;
45  myResolveAllMax = 10;
46  myResolveFreeEdges = false;
47  myLayerAttr = "layer"_sh;
48  myLayerShock = 4.0;
49  myExternalFriction = 1.0;
50  mySelfFriction = 1.0;
51  myStaticThreshold = 0.5;
52  myKineticScale = 0.1;
53  myConstantCollisionTopology = true;
54  mySharedCache = ""_sh;
55  myResetKey = -1;
56  myUpdateOverlap = false;
57 
58  }
59 
60  explicit SOP_DetangleParms(const SOP_DetangleParms &) = default;
61 
62  virtual ~SOP_DetangleParms() {}
63 
64  bool operator==(const SOP_DetangleParms &src) const
65  {
66  if (myPrevpos != src.myPrevpos) return false;
67  if (myDisableSelfAttr != src.myDisableSelfAttr) return false;
68  if (myDisableExternalAttr != src.myDisableExternalAttr) return false;
69  if (myWeldAttr != src.myWeldAttr) return false;
70  if (myThickness != src.myThickness) return false;
71  if (myDoSelf != src.myDoSelf) return false;
72  if (myDoTet != src.myDoTet) return false;
73  if (myUpdateDisable != src.myUpdateDisable) return false;
74  if (myResetDetangledPoints != src.myResetDetangledPoints) return false;
75  if (myDoMark != src.myDoMark) return false;
76  if (myMarkAttr != src.myMarkAttr) return false;
77  if (myDoresolve != src.myDoresolve) return false;
78  if (myMaxWeight != src.myMaxWeight) return false;
79  if (myCapDisplace != src.myCapDisplace) return false;
80  if (myMaxDisplace != src.myMaxDisplace) return false;
81  if (myResolveAll != src.myResolveAll) return false;
82  if (myResolveAllMax != src.myResolveAllMax) return false;
83  if (myResolveFreeEdges != src.myResolveFreeEdges) return false;
84  if (myLayerAttr != src.myLayerAttr) return false;
85  if (myLayerShock != src.myLayerShock) return false;
86  if (myExternalFriction != src.myExternalFriction) return false;
87  if (mySelfFriction != src.mySelfFriction) return false;
88  if (myStaticThreshold != src.myStaticThreshold) return false;
89  if (myKineticScale != src.myKineticScale) return false;
90  if (myConstantCollisionTopology != src.myConstantCollisionTopology) return false;
91  if (mySharedCache != src.mySharedCache) return false;
92  if (myResetKey != src.myResetKey) return false;
93  if (myUpdateOverlap != src.myUpdateOverlap) return false;
94 
95  return true;
96  }
97  bool operator!=(const SOP_DetangleParms &src) const
98  {
99  return !operator==(src);
100  }
101 
102 
103 
104  void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
105  {
106  if (true)
107  OP_Utils::evalOpParm(myPrevpos, node, "prevpos", time, 0);
108  else myPrevpos = ""_sh;
109  if (true)
110  OP_Utils::evalOpParm(myDisableSelfAttr, node, "disableselfattr", time, 0);
111  else myDisableSelfAttr = "disableself"_sh;
112  if (true)
113  OP_Utils::evalOpParm(myDisableExternalAttr, node, "disableexternalattr", time, 0);
114  else myDisableExternalAttr = "disableexternal"_sh;
115  if (true)
116  OP_Utils::evalOpParm(myWeldAttr, node, "weldattr", time, 0);
117  else myWeldAttr = "weld"_sh;
118  if (true)
119  OP_Utils::evalOpParm(myThickness, node, "thickness", time, 0);
120  else myThickness = 0.05;
121  if (true)
122  OP_Utils::evalOpParm(myDoSelf, node, "doself", time, 0);
123  else myDoSelf = false;
124  if (true)
125  OP_Utils::evalOpParm(myDoTet, node, "dotet", time, 0);
126  else myDoTet = false;
127  if (true)
128  OP_Utils::evalOpParm(myUpdateDisable, node, "updatedisable", time, 0);
129  else myUpdateDisable = false;
130  if (true && ( (!(((getUpdateDisable()==0)))) ) )
131  OP_Utils::evalOpParm(myResetDetangledPoints, node, "resetdetangled", time, 0);
132  else myResetDetangledPoints = false;
133  if (true)
134  OP_Utils::evalOpParm(myDoMark, node, "domark", time, 0);
135  else myDoMark = false;
136  if (true && ( (!(((getDoMark()==0)))) ) )
137  OP_Utils::evalOpParm(myMarkAttr, node, "markattr", time, 0);
138  else myMarkAttr = "changed"_sh;
139  if (true && ( (!(((getUpdateDisable()==1)))) ) )
140  OP_Utils::evalOpParm(myDoresolve, node, "doresolve", time, 0);
141  else myDoresolve = false;
142  if (true)
143  OP_Utils::evalOpParm(myMaxWeight, node, "maxweight", time, 0);
144  else myMaxWeight = 1.0;
145  if (true)
146  OP_Utils::evalOpParm(myCapDisplace, node, "capdisplace", time, 0);
147  else myCapDisplace = false;
148  if (true && ( (!(((getCapDisplace()==0)))) ) )
149  OP_Utils::evalOpParm(myMaxDisplace, node, "maxdisplace", time, 0);
150  else myMaxDisplace = 0.5;
151  if (true && ( (!(((getUpdateDisable()==1))||((getDoresolve()==0)))) ) )
152  OP_Utils::evalOpParm(myResolveAll, node, "resolveall", time, 0);
153  else myResolveAll = false;
154  if (true && ( (!(((getUpdateDisable()==1))||((getDoresolve()==0))||((getResolveAll()==0)))) ) )
155  OP_Utils::evalOpParm(myResolveAllMax, node, "resolveallmax", time, 0);
156  else myResolveAllMax = 10;
157  if (true && ( (!(((getUpdateDisable()==1))||((getDoresolve()==0))||((getResolveAll()==0)))) ) )
158  OP_Utils::evalOpParm(myResolveFreeEdges, node, "resolvealledges", time, 0);
159  else myResolveFreeEdges = false;
160  if (true && ( (!(((getUpdateDisable()==1))||((getDoresolve()==0)))) ) )
161  OP_Utils::evalOpParm(myLayerAttr, node, "layerattr", time, 0);
162  else myLayerAttr = "layer"_sh;
163  if (true && ( (!(((getUpdateDisable()==1))||((getDoresolve()==0)))) ) )
164  OP_Utils::evalOpParm(myLayerShock, node, "layershock", time, 0);
165  else myLayerShock = 4.0;
166  if (true && ( (!(((getDoresolve()==0)))) ) )
167  OP_Utils::evalOpParm(myExternalFriction, node, "externalfriction", time, 0);
168  else myExternalFriction = 1.0;
169  if (true && ( (!(((getDoresolve()==0)))) ) )
170  OP_Utils::evalOpParm(mySelfFriction, node, "selffriction", time, 0);
171  else mySelfFriction = 1.0;
172  if (true && ( (!(((getDoresolve()==0)))) ) )
173  OP_Utils::evalOpParm(myStaticThreshold, node, "static_threshold", time, 0);
174  else myStaticThreshold = 0.5;
175  if (true && ( (!(((getDoresolve()==0)))) ) )
176  OP_Utils::evalOpParm(myKineticScale, node, "kinetic_scale", time, 0);
177  else myKineticScale = 0.1;
178  if (true)
179  OP_Utils::evalOpParm(myConstantCollisionTopology, node, "constantcollisiontopology", time, 0);
180  else myConstantCollisionTopology = true;
181  if (true)
182  OP_Utils::evalOpParm(mySharedCache, node, "sharedcache", time, 0);
183  else mySharedCache = ""_sh;
184  if (true)
185  OP_Utils::evalOpParm(myResetKey, node, "resetkey", time, 0);
186  else myResetKey = -1;
187  if (true && ( (!(((getUpdateDisable()==0)&&(getDoresolve()==1)))) ) )
188  OP_Utils::evalOpParm(myUpdateOverlap, node, "updateoverlap", time, 0);
189  else myUpdateOverlap = false;
190 
191  }
192 
193 
194  virtual void loadFromOpSubclass(const LoadParms &loadparms)
195  {
196  buildFromOp(loadparms.node(), loadparms.context().getTime(), loadparms.depnode());
197  }
198 
199 
200  virtual void copyFrom(const SOP_NodeParms *src)
201  {
202  *this = *((const SOP_DetangleParms *)src);
203  }
204 
205  template <typename T>
206  void
207  doGetParmValue(exint idx, T &value) const
208  {
209  switch (idx)
210  {
211  case 0:
212  coerceValue(value, myPrevpos);
213  break;
214  case 1:
215  coerceValue(value, myDisableSelfAttr);
216  break;
217  case 2:
218  coerceValue(value, myDisableExternalAttr);
219  break;
220  case 3:
221  coerceValue(value, myWeldAttr);
222  break;
223  case 4:
224  coerceValue(value, myThickness);
225  break;
226  case 5:
227  coerceValue(value, myDoSelf);
228  break;
229  case 6:
230  coerceValue(value, myDoTet);
231  break;
232  case 7:
233  coerceValue(value, myUpdateDisable);
234  break;
235  case 8:
236  coerceValue(value, myResetDetangledPoints);
237  break;
238  case 9:
239  coerceValue(value, myDoMark);
240  break;
241  case 10:
242  coerceValue(value, myMarkAttr);
243  break;
244  case 11:
245  coerceValue(value, myDoresolve);
246  break;
247  case 12:
248  coerceValue(value, myMaxWeight);
249  break;
250  case 13:
251  coerceValue(value, myCapDisplace);
252  break;
253  case 14:
254  coerceValue(value, myMaxDisplace);
255  break;
256  case 15:
257  coerceValue(value, myResolveAll);
258  break;
259  case 16:
260  coerceValue(value, myResolveAllMax);
261  break;
262  case 17:
263  coerceValue(value, myResolveFreeEdges);
264  break;
265  case 18:
266  coerceValue(value, myLayerAttr);
267  break;
268  case 19:
269  coerceValue(value, myLayerShock);
270  break;
271  case 20:
272  coerceValue(value, myExternalFriction);
273  break;
274  case 21:
275  coerceValue(value, mySelfFriction);
276  break;
277  case 22:
278  coerceValue(value, myStaticThreshold);
279  break;
280  case 23:
281  coerceValue(value, myKineticScale);
282  break;
283  case 24:
284  coerceValue(value, myConstantCollisionTopology);
285  break;
286  case 25:
287  coerceValue(value, mySharedCache);
288  break;
289  case 26:
290  coerceValue(value, myResetKey);
291  break;
292  case 27:
293  coerceValue(value, myUpdateOverlap);
294  break;
295 
296  }
297  }
298 
299  void getParmValue(exint idx, exint &value) const
300  { doGetParmValue(idx, value); }
301  void getParmValue(exint idx, fpreal &value) const
302  { doGetParmValue(idx, value); }
304  { doGetParmValue(idx, value); }
306  { doGetParmValue(idx, value); }
308  { doGetParmValue(idx, value); }
310  { doGetParmValue(idx, value); }
312  { doGetParmValue(idx, value); }
314  { doGetParmValue(idx, value); }
316  { doGetParmValue(idx, value); }
318  { doGetParmValue(idx, value); }
320  { doGetParmValue(idx, value); }
321 
322  template <typename T>
323  void
324  doSetParmValue(exint idx, const T &value)
325  {
326  switch (idx)
327  {
328  case 0:
329  coerceValue(myPrevpos, value);
330  break;
331  case 1:
332  coerceValue(myDisableSelfAttr, value);
333  break;
334  case 2:
335  coerceValue(myDisableExternalAttr, value);
336  break;
337  case 3:
338  coerceValue(myWeldAttr, value);
339  break;
340  case 4:
341  coerceValue(myThickness, value);
342  break;
343  case 5:
344  coerceValue(myDoSelf, value);
345  break;
346  case 6:
347  coerceValue(myDoTet, value);
348  break;
349  case 7:
350  coerceValue(myUpdateDisable, value);
351  break;
352  case 8:
353  coerceValue(myResetDetangledPoints, value);
354  break;
355  case 9:
356  coerceValue(myDoMark, value);
357  break;
358  case 10:
359  coerceValue(myMarkAttr, value);
360  break;
361  case 11:
362  coerceValue(myDoresolve, value);
363  break;
364  case 12:
365  coerceValue(myMaxWeight, value);
366  break;
367  case 13:
368  coerceValue(myCapDisplace, value);
369  break;
370  case 14:
371  coerceValue(myMaxDisplace, value);
372  break;
373  case 15:
374  coerceValue(myResolveAll, value);
375  break;
376  case 16:
377  coerceValue(myResolveAllMax, value);
378  break;
379  case 17:
380  coerceValue(myResolveFreeEdges, value);
381  break;
382  case 18:
383  coerceValue(myLayerAttr, value);
384  break;
385  case 19:
386  coerceValue(myLayerShock, value);
387  break;
388  case 20:
389  coerceValue(myExternalFriction, value);
390  break;
391  case 21:
392  coerceValue(mySelfFriction, value);
393  break;
394  case 22:
395  coerceValue(myStaticThreshold, value);
396  break;
397  case 23:
398  coerceValue(myKineticScale, value);
399  break;
400  case 24:
401  coerceValue(myConstantCollisionTopology, value);
402  break;
403  case 25:
404  coerceValue(mySharedCache, value);
405  break;
406  case 26:
407  coerceValue(myResetKey, value);
408  break;
409  case 27:
410  coerceValue(myUpdateOverlap, value);
411  break;
412 
413  }
414  }
415 
416  void setParmValue(exint idx, const exint &value)
417  { doSetParmValue(idx, value); }
418  void setParmValue(exint idx, const fpreal &value)
419  { doSetParmValue(idx, value); }
420  void setParmValue(exint idx, const UT_Vector2D &value)
421  { doSetParmValue(idx, value); }
422  void setParmValue(exint idx, const UT_Vector3D &value)
423  { doSetParmValue(idx, value); }
424  void setParmValue(exint idx, const UT_Vector4D &value)
425  { doSetParmValue(idx, value); }
426  void setParmValue(exint idx, const UT_Matrix2D &value)
427  { doSetParmValue(idx, value); }
428  void setParmValue(exint idx, const UT_Matrix3D &value)
429  { doSetParmValue(idx, value); }
430  void setParmValue(exint idx, const UT_Matrix4D &value)
431  { doSetParmValue(idx, value); }
433  { doSetParmValue(idx, value); }
435  { doSetParmValue(idx, value); }
437  { doSetParmValue(idx, value); }
438 
439  virtual exint getNumParms() const
440  {
441  return 28;
442  }
443 
444  virtual const char *getParmName(exint fieldnum) const
445  {
446  switch (fieldnum)
447  {
448  case 0:
449  return "prevpos";
450  case 1:
451  return "disableselfattr";
452  case 2:
453  return "disableexternalattr";
454  case 3:
455  return "weldattr";
456  case 4:
457  return "thickness";
458  case 5:
459  return "doself";
460  case 6:
461  return "dotet";
462  case 7:
463  return "updatedisable";
464  case 8:
465  return "resetdetangled";
466  case 9:
467  return "domark";
468  case 10:
469  return "markattr";
470  case 11:
471  return "doresolve";
472  case 12:
473  return "maxweight";
474  case 13:
475  return "capdisplace";
476  case 14:
477  return "maxdisplace";
478  case 15:
479  return "resolveall";
480  case 16:
481  return "resolveallmax";
482  case 17:
483  return "resolvealledges";
484  case 18:
485  return "layerattr";
486  case 19:
487  return "layershock";
488  case 20:
489  return "externalfriction";
490  case 21:
491  return "selffriction";
492  case 22:
493  return "static_threshold";
494  case 23:
495  return "kinetic_scale";
496  case 24:
497  return "constantcollisiontopology";
498  case 25:
499  return "sharedcache";
500  case 26:
501  return "resetkey";
502  case 27:
503  return "updateoverlap";
504 
505  }
506  return 0;
507  }
508 
509  virtual ParmType getParmType(exint fieldnum) const
510  {
511  switch (fieldnum)
512  {
513  case 0:
514  return PARM_STRING;
515  case 1:
516  return PARM_STRING;
517  case 2:
518  return PARM_STRING;
519  case 3:
520  return PARM_STRING;
521  case 4:
522  return PARM_FLOAT;
523  case 5:
524  return PARM_INTEGER;
525  case 6:
526  return PARM_INTEGER;
527  case 7:
528  return PARM_INTEGER;
529  case 8:
530  return PARM_INTEGER;
531  case 9:
532  return PARM_INTEGER;
533  case 10:
534  return PARM_STRING;
535  case 11:
536  return PARM_INTEGER;
537  case 12:
538  return PARM_FLOAT;
539  case 13:
540  return PARM_INTEGER;
541  case 14:
542  return PARM_FLOAT;
543  case 15:
544  return PARM_INTEGER;
545  case 16:
546  return PARM_INTEGER;
547  case 17:
548  return PARM_INTEGER;
549  case 18:
550  return PARM_STRING;
551  case 19:
552  return PARM_FLOAT;
553  case 20:
554  return PARM_FLOAT;
555  case 21:
556  return PARM_FLOAT;
557  case 22:
558  return PARM_FLOAT;
559  case 23:
560  return PARM_FLOAT;
561  case 24:
562  return PARM_INTEGER;
563  case 25:
564  return PARM_STRING;
565  case 26:
566  return PARM_FLOAT;
567  case 27:
568  return PARM_INTEGER;
569 
570  }
571  return PARM_UNSUPPORTED;
572  }
573 
574  // Boiler plate to load individual types.
575  static void loadData(UT_IStream &is, int64 &v)
576  { is.bread(&v, 1); }
577  static void loadData(UT_IStream &is, bool &v)
578  { int64 iv; is.bread(&iv, 1); v = iv; }
579  static void loadData(UT_IStream &is, fpreal64 &v)
580  { is.bread<fpreal64>(&v, 1); }
581  static void loadData(UT_IStream &is, UT_Vector2D &v)
582  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1); }
583  static void loadData(UT_IStream &is, UT_Vector3D &v)
584  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
585  is.bread<fpreal64>(&v.z(), 1); }
586  static void loadData(UT_IStream &is, UT_Vector4D &v)
587  { is.bread<fpreal64>(&v.x(), 1); is.bread<fpreal64>(&v.y(), 1);
588  is.bread<fpreal64>(&v.z(), 1); is.bread<fpreal64>(&v.w(), 1); }
589  static void loadData(UT_IStream &is, UT_Matrix2D &v)
590  { for (int r = 0; r < 2; r++) for (int c = 0; c < 2; c++) is.bread<fpreal64>(&v(r, c), 1); }
591  static void loadData(UT_IStream &is, UT_Matrix3D &v)
592  { for (int r = 0; r < 3; r++) for (int c = 0; c < 3; c++) is.bread<fpreal64>(&v(r, c), 1); }
593  static void loadData(UT_IStream &is, UT_Matrix4D &v)
594  { for (int r = 0; r < 4; r++) for (int c = 0; c < 4; c++) is.bread<fpreal64>(&v(r, c), 1); }
595  static void loadData(UT_IStream &is, UT_Vector2I &v)
596  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1); }
597  static void loadData(UT_IStream &is, UT_Vector3I &v)
598  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
599  is.bread<int64>(&v.z(), 1); }
600  static void loadData(UT_IStream &is, UT_Vector4I &v)
601  { is.bread<int64>(&v.x(), 1); is.bread<int64>(&v.y(), 1);
602  is.bread<int64>(&v.z(), 1); is.bread<int64>(&v.w(), 1); }
604  { is.bread(v); }
606  { UT_StringHolder rampdata;
607  loadData(is, rampdata);
608  if (rampdata.isstring())
609  {
610  v.reset(new UT_Ramp());
611  UT_IStream istr((const char *) rampdata, rampdata.length(), UT_ISTREAM_ASCII);
612  v->load(istr);
613  }
614  else v.reset();
615  }
618  loadData(is, data);
619  if (data.isstring())
620  {
621  // Find the data type.
622  char *colon = UT_StringWrap(data).findChar(':');
623  if (colon)
624  {
625  int typelen = colon - data.buffer();
627  type.strncpy(data.buffer(), typelen);
628  UT_IStream istr(((const char *) data) + typelen + 1, data.length() - (typelen + 1), UT_ISTREAM_BINARY);
629 
630  v = PRM_DataFactory::parseBinary(type.buffer(), istr);
631  }
632  }
633  else v.reset();
634  }
635 
636  static void saveData(std::ostream &os, int64 v)
637  { UTwrite(os, &v); }
638  static void saveData(std::ostream &os, bool v)
639  { int64 iv = v; UTwrite(os, &iv); }
640  static void saveData(std::ostream &os, fpreal64 v)
641  { UTwrite<fpreal64>(os, &v); }
642  static void saveData(std::ostream &os, UT_Vector2D v)
643  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y()); }
644  static void saveData(std::ostream &os, UT_Vector3D v)
645  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
646  UTwrite<fpreal64>(os, &v.z()); }
647  static void saveData(std::ostream &os, UT_Vector4D v)
648  { UTwrite<fpreal64>(os, &v.x()); UTwrite<fpreal64>(os, &v.y());
649  UTwrite<fpreal64>(os, &v.z()); UTwrite<fpreal64>(os, &v.w()); }
650  static void saveData(std::ostream &os, UT_Matrix2D v)
652  static void saveData(std::ostream &os, UT_Matrix3D v)
654  static void saveData(std::ostream &os, UT_Matrix4D v)
656  static void saveData(std::ostream &os, UT_StringHolder s)
657  { UT_StringWrap(s).saveBinary(os); }
658  static void saveData(std::ostream &os, UT_SharedPtr<UT_Ramp> s)
659  { UT_StringHolder result;
660  UT_OStringStream ostr;
661  if (s) s->save(ostr);
662  result = ostr.str();
663  saveData(os, result);
664  }
665  static void saveData(std::ostream &os, PRM_DataItemHandle s)
666  { UT_StringHolder result;
667  UT_OStringStream ostr;
668  if (s)
669  {
670  ostr << s->getDataTypeToken();
671  ostr << ":";
672  s->saveBinary(ostr);
673  }
674  result = ostr.str();
675  saveData(os, result);
676  }
677 
678 
679  void save(std::ostream &os) const
680  {
681  int32 v = version();
682  UTwrite(os, &v);
683  saveData(os, myPrevpos);
684  saveData(os, myDisableSelfAttr);
685  saveData(os, myDisableExternalAttr);
686  saveData(os, myWeldAttr);
687  saveData(os, myThickness);
688  saveData(os, myDoSelf);
689  saveData(os, myDoTet);
690  saveData(os, myUpdateDisable);
691  saveData(os, myResetDetangledPoints);
692  saveData(os, myDoMark);
693  saveData(os, myMarkAttr);
694  saveData(os, myDoresolve);
695  saveData(os, myMaxWeight);
696  saveData(os, myCapDisplace);
697  saveData(os, myMaxDisplace);
698  saveData(os, myResolveAll);
699  saveData(os, myResolveAllMax);
700  saveData(os, myResolveFreeEdges);
701  saveData(os, myLayerAttr);
702  saveData(os, myLayerShock);
703  saveData(os, myExternalFriction);
704  saveData(os, mySelfFriction);
705  saveData(os, myStaticThreshold);
706  saveData(os, myKineticScale);
707  saveData(os, myConstantCollisionTopology);
708  saveData(os, mySharedCache);
709  saveData(os, myResetKey);
710  saveData(os, myUpdateOverlap);
711 
712  }
713 
714  bool load(UT_IStream &is)
715  {
716  int32 v;
717  is.bread(&v, 1);
718  if (version() != v)
719  {
720  // Fail incompatible versions
721  return false;
722  }
723  loadData(is, myPrevpos);
724  loadData(is, myDisableSelfAttr);
725  loadData(is, myDisableExternalAttr);
726  loadData(is, myWeldAttr);
727  loadData(is, myThickness);
728  loadData(is, myDoSelf);
729  loadData(is, myDoTet);
730  loadData(is, myUpdateDisable);
731  loadData(is, myResetDetangledPoints);
732  loadData(is, myDoMark);
733  loadData(is, myMarkAttr);
734  loadData(is, myDoresolve);
735  loadData(is, myMaxWeight);
736  loadData(is, myCapDisplace);
737  loadData(is, myMaxDisplace);
738  loadData(is, myResolveAll);
739  loadData(is, myResolveAllMax);
740  loadData(is, myResolveFreeEdges);
741  loadData(is, myLayerAttr);
742  loadData(is, myLayerShock);
743  loadData(is, myExternalFriction);
744  loadData(is, mySelfFriction);
745  loadData(is, myStaticThreshold);
746  loadData(is, myKineticScale);
747  loadData(is, myConstantCollisionTopology);
748  loadData(is, mySharedCache);
749  loadData(is, myResetKey);
750  loadData(is, myUpdateOverlap);
751 
752  return true;
753  }
754 
755  const UT_StringHolder & getPrevpos() const { return myPrevpos; }
756  void setPrevpos(const UT_StringHolder & val) { myPrevpos = val; }
758  {
759  SOP_Node *thissop = cookparms.getNode();
760  if (!thissop) return getPrevpos();
761  UT_StringHolder result;
762  OP_Utils::evalOpParm(result, thissop, "prevpos", cookparms.getCookTime(), 0);
763  return result;
764  }
765  const UT_StringHolder & getDisableSelfAttr() const { return myDisableSelfAttr; }
766  void setDisableSelfAttr(const UT_StringHolder & val) { myDisableSelfAttr = val; }
768  {
769  SOP_Node *thissop = cookparms.getNode();
770  if (!thissop) return getDisableSelfAttr();
771  UT_StringHolder result;
772  OP_Utils::evalOpParm(result, thissop, "disableselfattr", cookparms.getCookTime(), 0);
773  return result;
774  }
775  const UT_StringHolder & getDisableExternalAttr() const { return myDisableExternalAttr; }
776  void setDisableExternalAttr(const UT_StringHolder & val) { myDisableExternalAttr = val; }
778  {
779  SOP_Node *thissop = cookparms.getNode();
780  if (!thissop) return getDisableExternalAttr();
781  UT_StringHolder result;
782  OP_Utils::evalOpParm(result, thissop, "disableexternalattr", cookparms.getCookTime(), 0);
783  return result;
784  }
785  const UT_StringHolder & getWeldAttr() const { return myWeldAttr; }
786  void setWeldAttr(const UT_StringHolder & val) { myWeldAttr = val; }
788  {
789  SOP_Node *thissop = cookparms.getNode();
790  if (!thissop) return getWeldAttr();
791  UT_StringHolder result;
792  OP_Utils::evalOpParm(result, thissop, "weldattr", cookparms.getCookTime(), 0);
793  return result;
794  }
795  fpreal64 getThickness() const { return myThickness; }
796  void setThickness(fpreal64 val) { myThickness = val; }
798  {
799  SOP_Node *thissop = cookparms.getNode();
800  if (!thissop) return getThickness();
801  fpreal64 result;
802  OP_Utils::evalOpParm(result, thissop, "thickness", cookparms.getCookTime(), 0);
803  return result;
804  }
805  bool getDoSelf() const { return myDoSelf; }
806  void setDoSelf(bool val) { myDoSelf = val; }
807  bool opDoSelf(const SOP_NodeVerb::CookParms &cookparms) const
808  {
809  SOP_Node *thissop = cookparms.getNode();
810  if (!thissop) return getDoSelf();
811  bool result;
812  OP_Utils::evalOpParm(result, thissop, "doself", cookparms.getCookTime(), 0);
813  return result;
814  }
815  bool getDoTet() const { return myDoTet; }
816  void setDoTet(bool val) { myDoTet = val; }
817  bool opDoTet(const SOP_NodeVerb::CookParms &cookparms) const
818  {
819  SOP_Node *thissop = cookparms.getNode();
820  if (!thissop) return getDoTet();
821  bool result;
822  OP_Utils::evalOpParm(result, thissop, "dotet", cookparms.getCookTime(), 0);
823  return result;
824  }
825  bool getUpdateDisable() const { return myUpdateDisable; }
826  void setUpdateDisable(bool val) { myUpdateDisable = val; }
827  bool opUpdateDisable(const SOP_NodeVerb::CookParms &cookparms) const
828  {
829  SOP_Node *thissop = cookparms.getNode();
830  if (!thissop) return getUpdateDisable();
831  bool result;
832  OP_Utils::evalOpParm(result, thissop, "updatedisable", cookparms.getCookTime(), 0);
833  return result;
834  }
835  bool getResetDetangledPoints() const { return myResetDetangledPoints; }
836  void setResetDetangledPoints(bool val) { myResetDetangledPoints = val; }
837  bool opResetDetangledPoints(const SOP_NodeVerb::CookParms &cookparms) const
838  {
839  SOP_Node *thissop = cookparms.getNode();
840  if (!thissop) return getResetDetangledPoints();
841  bool result;
842  OP_Utils::evalOpParm(result, thissop, "resetdetangled", cookparms.getCookTime(), 0);
843  return result;
844  }
845  bool getDoMark() const { return myDoMark; }
846  void setDoMark(bool val) { myDoMark = val; }
847  bool opDoMark(const SOP_NodeVerb::CookParms &cookparms) const
848  {
849  SOP_Node *thissop = cookparms.getNode();
850  if (!thissop) return getDoMark();
851  bool result;
852  OP_Utils::evalOpParm(result, thissop, "domark", cookparms.getCookTime(), 0);
853  return result;
854  }
855  const UT_StringHolder & getMarkAttr() const { return myMarkAttr; }
856  void setMarkAttr(const UT_StringHolder & val) { myMarkAttr = val; }
858  {
859  SOP_Node *thissop = cookparms.getNode();
860  if (!thissop) return getMarkAttr();
861  UT_StringHolder result;
862  OP_Utils::evalOpParm(result, thissop, "markattr", cookparms.getCookTime(), 0);
863  return result;
864  }
865  bool getDoresolve() const { return myDoresolve; }
866  void setDoresolve(bool val) { myDoresolve = val; }
867  bool opDoresolve(const SOP_NodeVerb::CookParms &cookparms) const
868  {
869  SOP_Node *thissop = cookparms.getNode();
870  if (!thissop) return getDoresolve();
871  bool result;
872  OP_Utils::evalOpParm(result, thissop, "doresolve", cookparms.getCookTime(), 0);
873  return result;
874  }
875  fpreal64 getMaxWeight() const { return myMaxWeight; }
876  void setMaxWeight(fpreal64 val) { myMaxWeight = val; }
878  {
879  SOP_Node *thissop = cookparms.getNode();
880  if (!thissop) return getMaxWeight();
881  fpreal64 result;
882  OP_Utils::evalOpParm(result, thissop, "maxweight", cookparms.getCookTime(), 0);
883  return result;
884  }
885  bool getCapDisplace() const { return myCapDisplace; }
886  void setCapDisplace(bool val) { myCapDisplace = val; }
887  bool opCapDisplace(const SOP_NodeVerb::CookParms &cookparms) const
888  {
889  SOP_Node *thissop = cookparms.getNode();
890  if (!thissop) return getCapDisplace();
891  bool result;
892  OP_Utils::evalOpParm(result, thissop, "capdisplace", cookparms.getCookTime(), 0);
893  return result;
894  }
895  fpreal64 getMaxDisplace() const { return myMaxDisplace; }
896  void setMaxDisplace(fpreal64 val) { myMaxDisplace = val; }
898  {
899  SOP_Node *thissop = cookparms.getNode();
900  if (!thissop) return getMaxDisplace();
901  fpreal64 result;
902  OP_Utils::evalOpParm(result, thissop, "maxdisplace", cookparms.getCookTime(), 0);
903  return result;
904  }
905  bool getResolveAll() const { return myResolveAll; }
906  void setResolveAll(bool val) { myResolveAll = val; }
907  bool opResolveAll(const SOP_NodeVerb::CookParms &cookparms) const
908  {
909  SOP_Node *thissop = cookparms.getNode();
910  if (!thissop) return getResolveAll();
911  bool result;
912  OP_Utils::evalOpParm(result, thissop, "resolveall", cookparms.getCookTime(), 0);
913  return result;
914  }
915  int64 getResolveAllMax() const { return myResolveAllMax; }
916  void setResolveAllMax(int64 val) { myResolveAllMax = val; }
918  {
919  SOP_Node *thissop = cookparms.getNode();
920  if (!thissop) return getResolveAllMax();
921  int64 result;
922  OP_Utils::evalOpParm(result, thissop, "resolveallmax", cookparms.getCookTime(), 0);
923  return result;
924  }
925  bool getResolveFreeEdges() const { return myResolveFreeEdges; }
926  void setResolveFreeEdges(bool val) { myResolveFreeEdges = val; }
927  bool opResolveFreeEdges(const SOP_NodeVerb::CookParms &cookparms) const
928  {
929  SOP_Node *thissop = cookparms.getNode();
930  if (!thissop) return getResolveFreeEdges();
931  bool result;
932  OP_Utils::evalOpParm(result, thissop, "resolvealledges", cookparms.getCookTime(), 0);
933  return result;
934  }
935  const UT_StringHolder & getLayerAttr() const { return myLayerAttr; }
936  void setLayerAttr(const UT_StringHolder & val) { myLayerAttr = val; }
938  {
939  SOP_Node *thissop = cookparms.getNode();
940  if (!thissop) return getLayerAttr();
941  UT_StringHolder result;
942  OP_Utils::evalOpParm(result, thissop, "layerattr", cookparms.getCookTime(), 0);
943  return result;
944  }
945  fpreal64 getLayerShock() const { return myLayerShock; }
946  void setLayerShock(fpreal64 val) { myLayerShock = val; }
948  {
949  SOP_Node *thissop = cookparms.getNode();
950  if (!thissop) return getLayerShock();
951  fpreal64 result;
952  OP_Utils::evalOpParm(result, thissop, "layershock", cookparms.getCookTime(), 0);
953  return result;
954  }
955  fpreal64 getExternalFriction() const { return myExternalFriction; }
956  void setExternalFriction(fpreal64 val) { myExternalFriction = val; }
958  {
959  SOP_Node *thissop = cookparms.getNode();
960  if (!thissop) return getExternalFriction();
961  fpreal64 result;
962  OP_Utils::evalOpParm(result, thissop, "externalfriction", cookparms.getCookTime(), 0);
963  return result;
964  }
965  fpreal64 getSelfFriction() const { return mySelfFriction; }
966  void setSelfFriction(fpreal64 val) { mySelfFriction = val; }
968  {
969  SOP_Node *thissop = cookparms.getNode();
970  if (!thissop) return getSelfFriction();
971  fpreal64 result;
972  OP_Utils::evalOpParm(result, thissop, "selffriction", cookparms.getCookTime(), 0);
973  return result;
974  }
975  fpreal64 getStaticThreshold() const { return myStaticThreshold; }
976  void setStaticThreshold(fpreal64 val) { myStaticThreshold = val; }
978  {
979  SOP_Node *thissop = cookparms.getNode();
980  if (!thissop) return getStaticThreshold();
981  fpreal64 result;
982  OP_Utils::evalOpParm(result, thissop, "static_threshold", cookparms.getCookTime(), 0);
983  return result;
984  }
985  fpreal64 getKineticScale() const { return myKineticScale; }
986  void setKineticScale(fpreal64 val) { myKineticScale = val; }
988  {
989  SOP_Node *thissop = cookparms.getNode();
990  if (!thissop) return getKineticScale();
991  fpreal64 result;
992  OP_Utils::evalOpParm(result, thissop, "kinetic_scale", cookparms.getCookTime(), 0);
993  return result;
994  }
995  bool getConstantCollisionTopology() const { return myConstantCollisionTopology; }
996  void setConstantCollisionTopology(bool val) { myConstantCollisionTopology = val; }
998  {
999  SOP_Node *thissop = cookparms.getNode();
1000  if (!thissop) return getConstantCollisionTopology();
1001  bool result;
1002  OP_Utils::evalOpParm(result, thissop, "constantcollisiontopology", cookparms.getCookTime(), 0);
1003  return result;
1004  }
1005  const UT_StringHolder & getSharedCache() const { return mySharedCache; }
1006  void setSharedCache(const UT_StringHolder & val) { mySharedCache = val; }
1008  {
1009  SOP_Node *thissop = cookparms.getNode();
1010  if (!thissop) return getSharedCache();
1011  UT_StringHolder result;
1012  OP_Utils::evalOpParm(result, thissop, "sharedcache", cookparms.getCookTime(), 0);
1013  return result;
1014  }
1015  fpreal64 getResetKey() const { return myResetKey; }
1016  void setResetKey(fpreal64 val) { myResetKey = val; }
1018  {
1019  SOP_Node *thissop = cookparms.getNode();
1020  if (!thissop) return getResetKey();
1021  fpreal64 result;
1022  OP_Utils::evalOpParm(result, thissop, "resetkey", cookparms.getCookTime(), 0);
1023  return result;
1024  }
1025  bool getUpdateOverlap() const { return myUpdateOverlap; }
1026  void setUpdateOverlap(bool val) { myUpdateOverlap = val; }
1027  bool opUpdateOverlap(const SOP_NodeVerb::CookParms &cookparms) const
1028  {
1029  SOP_Node *thissop = cookparms.getNode();
1030  if (!thissop) return getUpdateOverlap();
1031  bool result;
1032  OP_Utils::evalOpParm(result, thissop, "updateoverlap", cookparms.getCookTime(), 0);
1033  return result;
1034  }
1035 
1036 private:
1037  UT_StringHolder myPrevpos;
1038  UT_StringHolder myDisableSelfAttr;
1039  UT_StringHolder myDisableExternalAttr;
1040  UT_StringHolder myWeldAttr;
1041  fpreal64 myThickness;
1042  bool myDoSelf;
1043  bool myDoTet;
1044  bool myUpdateDisable;
1045  bool myResetDetangledPoints;
1046  bool myDoMark;
1047  UT_StringHolder myMarkAttr;
1048  bool myDoresolve;
1049  fpreal64 myMaxWeight;
1050  bool myCapDisplace;
1051  fpreal64 myMaxDisplace;
1052  bool myResolveAll;
1053  int64 myResolveAllMax;
1054  bool myResolveFreeEdges;
1055  UT_StringHolder myLayerAttr;
1056  fpreal64 myLayerShock;
1057  fpreal64 myExternalFriction;
1058  fpreal64 mySelfFriction;
1059  fpreal64 myStaticThreshold;
1060  fpreal64 myKineticScale;
1061  bool myConstantCollisionTopology;
1062  UT_StringHolder mySharedCache;
1063  fpreal64 myResetKey;
1064  bool myUpdateOverlap;
1065 
1066 };
bool operator!=(const SOP_DetangleParms &src) const
static void saveData(std::ostream &os, PRM_DataItemHandle s)
static void loadData(UT_IStream &is, UT_Vector3D &v)
fpreal64 getResetKey() const
void getParmValue(exint idx, UT_Matrix2D &value) const
void getParmValue(exint idx, UT_Vector2D &value) const
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
void getParmValue(exint idx, UT_Vector4D &value) const
static void saveData(std::ostream &os, int64 v)
SOP_Node * getNode() const
Definition: SOP_NodeVerb.h:494
UT_StringHolder opWeldAttr(const SOP_NodeVerb::CookParms &cookparms) const
T & z(void)
Definition: UT_Vector4.h:379
void setSelfFriction(fpreal64 val)
bool getDoSelf() const
bool operator==(const SOP_DetangleParms &src) const
static void saveData(std::ostream &os, fpreal64 v)
fpreal64 getMaxDisplace() const
void getParmValue(exint idx, PRM_DataItemHandle &value) const
void setDoTet(bool val)
void setMarkAttr(const UT_StringHolder &val)
exint bread(int32 *buffer, exint asize=1)
GT_API const UT_StringHolder time
fpreal getTime() const
Definition: OP_Context.h:60
void setThickness(fpreal64 val)
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
const GLdouble * v
Definition: glcorearb.h:836
void setKineticScale(fpreal64 val)
bool getResolveFreeEdges() const
void setResolveFreeEdges(bool val)
fpreal64 getSelfFriction() const
static void saveData(std::ostream &os, UT_StringHolder s)
void getParmValue(exint idx, exint &value) const
fpreal64 getExternalFriction() const
SYS_FORCE_INLINE const char * buffer() const
T & x(void)
Definition: UT_Vector2.h:285
bool getDoTet() const
const UT_StringHolder & getPrevpos() const
An output stream object that owns its own string buffer storage.
void setLayerAttr(const UT_StringHolder &val)
fpreal64 opStaticThreshold(const SOP_NodeVerb::CookParms &cookparms) const
bool getConstantCollisionTopology() const
void setMaxWeight(fpreal64 val)
void setSharedCache(const UT_StringHolder &val)
void setExternalFriction(fpreal64 val)
static void saveData(std::ostream &os, bool v)
UT_StringHolder opDisableSelfAttr(const SOP_NodeVerb::CookParms &cookparms) const
const UT_WorkBuffer & str() const
Returns a read-only reference to the underlying UT_WorkBuffer.
void getParmValue(exint idx, UT_Matrix4D &value) const
void setMaxDisplace(fpreal64 val)
SYS_FORCE_INLINE T & x(void)
Definition: UT_Vector3.h:498
void getParmValue(exint idx, UT_Vector3D &value) const
fpreal64 getKineticScale() const
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
const UT_StringHolder & getDisableSelfAttr() const
static void loadData(UT_IStream &is, UT_Vector3I &v)
void setWeldAttr(const UT_StringHolder &val)
void setDisableSelfAttr(const UT_StringHolder &val)
const UT_StringHolder & getMarkAttr() const
virtual void copyFrom(const SOP_NodeParms *src)
bool getResolveAll() const
bool getUpdateOverlap() const
bool opDoresolve(const SOP_NodeVerb::CookParms &cookparms) const
bool opCapDisplace(const SOP_NodeVerb::CookParms &cookparms) const
void doGetParmValue(exint idx, T &value) const
SYS_FORCE_INLINE T & z(void)
Definition: UT_Vector3.h:502
void doSetParmValue(exint idx, const T &value)
fpreal64 opExternalFriction(const SOP_NodeVerb::CookParms &cookparms) const
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Definition: Dimensions.h:137
long long int64
Definition: SYS_Types.h:107
int64 opResolveAllMax(const SOP_NodeVerb::CookParms &cookparms) const
bool opDoMark(const SOP_NodeVerb::CookParms &cookparms) const
void setDoSelf(bool val)
static void saveData(std::ostream &os, UT_Vector4D v)
UT_StringHolder opSharedCache(const SOP_NodeVerb::CookParms &cookparms) const
bool opResolveAll(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Matrix2D &v)
void setResetKey(fpreal64 val)
exint length() const
char * findChar(int c) const
Find first occurrance of character. Returns NULL upon failure.
Definition: UT_String.h:550
const UT_StringHolder & getWeldAttr() const
fpreal64 getLayerShock() const
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
Definition: UT_SharedPtr.h:28
void setUpdateDisable(bool val)
void setParmValue(exint idx, const UT_Matrix4D &value)
int64 exint
Definition: SYS_Types.h:116
void setResetDetangledPoints(bool val)
static void loadData(UT_IStream &is, int64 &v)
const OP_Node * node() const
Definition: SOP_NodeVerb.h:104
double fpreal64
Definition: SYS_Types.h:192
void setPrevpos(const UT_StringHolder &val)
fpreal64 getStaticThreshold() const
void setParmValue(exint idx, const UT_StringHolder &value)
virtual ~SOP_DetangleParms()
fpreal64 opKineticScale(const SOP_NodeVerb::CookParms &cookparms) const
const UT_StringHolder & getLayerAttr() const
void setParmValue(exint idx, const UT_Vector2D &value)
static void saveData(std::ostream &os, UT_Matrix2D v)
fpreal64 opThickness(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix3D v)
void getParmValue(exint idx, fpreal &value) const
GLboolean * data
Definition: glcorearb.h:130
void setDoresolve(bool val)
bool getResetDetangledPoints() const
static void loadData(UT_IStream &is, UT_Vector2D &v)
int int32
Definition: SYS_Types.h:35
T & y(void)
Definition: UT_Vector4.h:377
int64 getResolveAllMax() const
fpreal64 opMaxDisplace(const SOP_NodeVerb::CookParms &cookparms) const
void buildFromOp(const OP_Node *node, fpreal time, DEP_MicroNode *depnode)
fpreal64 getThickness() const
void setUpdateOverlap(bool val)
void saveBinary(std::ostream &os) const
Save string to binary stream.
Definition: UT_String.h:294
UT_StringHolder opPrevpos(const SOP_NodeVerb::CookParms &cookparms) const
GT_API const UT_StringHolder version
DEP_MicroNode * depnode() const
Definition: SOP_NodeVerb.h:111
void setParmValue(exint idx, const exint &value)
void getParmValue(exint idx, UT_SharedPtr< UT_Ramp > &value) const
fpreal64 opLayerShock(const SOP_NodeVerb::CookParms &cookparms) const
bool getCapDisplace() const
static void loadData(UT_IStream &is, UT_Vector2I &v)
void save(std::ostream &os) const
SYS_FORCE_INLINE T & y(void)
Definition: UT_Vector3.h:500
virtual void loadFromOpSubclass(const LoadParms &loadparms)
GLsizei const GLfloat * value
Definition: glcorearb.h:823
double fpreal
Definition: SYS_Types.h:270
void setParmValue(exint idx, const UT_SharedPtr< UT_Ramp > &value)
static void loadData(UT_IStream &is, UT_Vector4D &v)
fpreal64 opMaxWeight(const SOP_NodeVerb::CookParms &cookparms) const
void setParmValue(exint idx, const UT_Vector4D &value)
fpreal64 opSelfFriction(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Matrix4D v)
void setCapDisplace(bool val)
void setParmValue(exint idx, const PRM_DataItemHandle &value)
bool getDoresolve() const
void setResolveAllMax(int64 val)
static void loadData(UT_IStream &is, fpreal64 &v)
void setParmValue(exint idx, const UT_Matrix2D &value)
static void loadData(UT_IStream &is, UT_Matrix4D &v)
Utility class for containing a color ramp.
Definition: UT_Ramp.h:84
static void saveData(std::ostream &os, UT_Vector3D v)
GLuint GLfloat * val
Definition: glcorearb.h:1607
const UT_StringHolder & getDisableExternalAttr() const
#define SOP_API
Definition: SOP_API.h:10
UT_StringHolder opDisableExternalAttr(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
bool opUpdateDisable(const SOP_NodeVerb::CookParms &cookparms) const
static void saveData(std::ostream &os, UT_Vector2D v)
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
fpreal getCookTime() const
Definition: SOP_NodeVerb.h:501
void getParmValue(exint idx, UT_StringHolder &value) const
bool opConstantCollisionTopology(const SOP_NodeVerb::CookParms &cookparms) const
T & x(void)
Definition: UT_Vector4.h:375
bool opDoSelf(const SOP_NodeVerb::CookParms &cookparms) const
virtual exint getNumParms() const
T & y(void)
Definition: UT_Vector2.h:287
void getParmValue(exint idx, UT_Matrix3D &value) const
void setStaticThreshold(fpreal64 val)
bool opDoTet(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Matrix3D &v)
void setParmValue(exint idx, const UT_Vector3D &value)
GLboolean r
Definition: glcorearb.h:1221
bool opResetDetangledPoints(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, bool &v)
static void loadData(UT_IStream &is, UT_StringHolder &v)
bool opResolveFreeEdges(const SOP_NodeVerb::CookParms &cookparms) const
UT_StringHolder opMarkAttr(const SOP_NodeVerb::CookParms &cookparms) const
T & w(void)
Definition: UT_Vector4.h:381
void setDoMark(bool val)
virtual ParmType getParmType(exint fieldnum) const
void setParmValue(exint idx, const fpreal &value)
bool load(UT_IStream &is)
void setConstantCollisionTopology(bool val)
fpreal64 opResetKey(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector4I &v)
bool getUpdateDisable() const
void setParmValue(exint idx, const UT_Matrix3D &value)
bool getDoMark() const
const OP_Context & context() const
Definition: SOP_NodeVerb.h:109
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
Definition: PRM_Parm.h:88
virtual const char * getParmName(exint fieldnum) const
SYS_FORCE_INLINE bool isstring() const
const UT_StringHolder & getSharedCache() const
bool opUpdateOverlap(const SOP_NodeVerb::CookParms &cookparms) const
void setDisableExternalAttr(const UT_StringHolder &val)
void setResolveAll(bool val)
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
UT_StringHolder opLayerAttr(const SOP_NodeVerb::CookParms &cookparms) const
void setLayerShock(fpreal64 val)
fpreal64 getMaxWeight() const
GLenum src
Definition: glcorearb.h:1792