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