20 using namespace UT::Literal;
23 namespace SOP_UVLayout_2_0Enums
52 myPackBetween =
false;
53 myAdditionalSeams =
""_sh;
57 myPaddingBoundary =
false;
58 myPackInCavities =
true;
61 myCorrectAreas =
false;
62 myAxisAlignIslands =
true;
67 myUvTolerance = 1e-05;
68 myScaleTolerance = 0.005;
78 if (myUvAttr != src.myUvAttr)
return false;
79 if (myGroup != src.myGroup)
return false;
80 if (myPackBetween != src.myPackBetween)
return false;
81 if (myAdditionalSeams != src.myAdditionalSeams)
return false;
82 if (myPacking != src.myPacking)
return false;
83 if (myScale != src.myScale)
return false;
84 if (myPadding != src.myPadding)
return false;
85 if (myPaddingBoundary != src.myPaddingBoundary)
return false;
86 if (myPackInCavities != src.myPackInCavities)
return false;
87 if (myBboxCenter != src.myBboxCenter)
return false;
88 if (myBboxSize != src.myBboxSize)
return false;
89 if (myCorrectAreas != src.myCorrectAreas)
return false;
90 if (myAxisAlignIslands != src.myAxisAlignIslands)
return false;
91 if (myRotations != src.myRotations)
return false;
92 if (myIterations != src.myIterations)
return false;
93 if (myRandSeed != src.myRandSeed)
return false;
94 if (myResolution != src.myResolution)
return false;
95 if (myUvTolerance != src.myUvTolerance)
return false;
96 if (myScaleTolerance != src.myScaleTolerance)
return false;
113 graph->
evalOpParm(myUvAttr, nodeidx,
"uvattr", time, 0);
116 graph->
evalOpParm(myGroup, nodeidx,
"group", time, 0);
117 myPackBetween =
false;
119 graph->
evalOpParm(myPackBetween, nodeidx,
"packbetween", time, 0);
120 myAdditionalSeams =
""_sh;
122 graph->
evalOpParm(myAdditionalSeams, nodeidx,
"additionalseams", time, 0);
125 graph->
evalOpParm(myPacking, nodeidx,
"packing", time, 0);
127 if (
true && ( (!(((
int64(getPacking())!=1)))) ) )
128 graph->
evalOpParm(myScale, nodeidx,
"scale", time, 0);
131 graph->
evalOpParm(myPadding, nodeidx,
"padding", time, 0);
132 myPaddingBoundary =
false;
134 graph->
evalOpParm(myPaddingBoundary, nodeidx,
"paddingboundary", time, 0);
135 myPackInCavities =
true;
137 graph->
evalOpParm(myPackInCavities, nodeidx,
"packincavities", time, 0);
139 if (
true && ( (!(((
int64(getPacking())!=0)))) ) )
140 graph->
evalOpParm(myBboxCenter, nodeidx,
"bboxcenter", time, 0);
142 if (
true && ( (!(((
int64(getPacking())!=0)))) ) )
143 graph->
evalOpParm(myBboxSize, nodeidx,
"bboxsize", time, 0);
144 myCorrectAreas =
false;
146 graph->
evalOpParm(myCorrectAreas, nodeidx,
"correctareas", time, 0);
147 myAxisAlignIslands =
true;
149 graph->
evalOpParm(myAxisAlignIslands, nodeidx,
"axisalignislands", time, 0);
152 graph->
evalOpParm(myRotations, nodeidx,
"rotations", time, 0);
155 graph->
evalOpParm(myIterations, nodeidx,
"iterations", time, 0);
157 if (
true && ( (!(((
int64(getIterations())==1)))) ) )
158 graph->
evalOpParm(myRandSeed, nodeidx,
"randseed", time, 0);
161 graph->
evalOpParm(myResolution, nodeidx,
"resolution", time, 0);
162 myUvTolerance = 1e-05;
164 graph->
evalOpParm(myUvTolerance, nodeidx,
"uvtolerance", time, 0);
165 myScaleTolerance = 0.005;
166 if (
true && ( (!(((
int64(getPacking())==1)))) ) )
167 graph->
evalOpParm(myScaleTolerance, nodeidx,
"scaletolerance", time, 0);
183 template <
typename T>
190 if (idx.
size() != instance.
size()+1)
195 coerceValue(value, myUvAttr);
198 coerceValue(value, myGroup);
201 coerceValue(value, myPackBetween);
204 coerceValue(value, myAdditionalSeams);
207 coerceValue(value, myPacking);
210 coerceValue(value, myScale);
213 coerceValue(value, myPadding);
216 coerceValue(value, myPaddingBoundary);
219 coerceValue(value, myPackInCavities);
222 coerceValue(value, myBboxCenter);
225 coerceValue(value, myBboxSize);
228 coerceValue(value, myCorrectAreas);
231 coerceValue(value, myAxisAlignIslands);
234 coerceValue(value, myRotations);
237 coerceValue(value, myIterations);
240 coerceValue(value, myRandSeed);
243 coerceValue(value, myResolution);
246 coerceValue(value, myUvTolerance);
249 coerceValue(value, myScaleTolerance);
256 { doGetParmValue(idx, instance, value); }
258 { doGetParmValue(idx, instance, value); }
260 { doGetParmValue(idx, instance, value); }
262 { doGetParmValue(idx, instance, value); }
264 { doGetParmValue(idx, instance, value); }
266 { doGetParmValue(idx, instance, value); }
268 { doGetParmValue(idx, instance, value); }
270 { doGetParmValue(idx, instance, value); }
272 { doGetParmValue(idx, instance, value); }
274 { doGetParmValue(idx, instance, value); }
276 { doGetParmValue(idx, instance, value); }
278 template <
typename T>
285 if (idx.
size() != instance.
size()+1)
290 coerceValue(myUvAttr, value);
293 coerceValue(myGroup, value);
296 coerceValue(myPackBetween, value);
299 coerceValue(myAdditionalSeams, value);
302 coerceValue(myPacking, value);
305 coerceValue(myScale, value);
308 coerceValue(myPadding, value);
311 coerceValue(myPaddingBoundary, value);
314 coerceValue(myPackInCavities, value);
317 coerceValue(myBboxCenter, value);
320 coerceValue(myBboxSize, value);
323 coerceValue(myCorrectAreas, value);
326 coerceValue(myAxisAlignIslands, value);
329 coerceValue(myRotations, value);
332 coerceValue(myIterations, value);
335 coerceValue(myRandSeed, value);
338 coerceValue(myResolution, value);
341 coerceValue(myUvTolerance, value);
344 coerceValue(myScaleTolerance, value);
351 { doSetParmValue(idx, instance, value); }
353 { doSetParmValue(idx, instance, value); }
355 { doSetParmValue(idx, instance, value); }
357 { doSetParmValue(idx, instance, value); }
359 { doSetParmValue(idx, instance, value); }
361 { doSetParmValue(idx, instance, value); }
363 { doSetParmValue(idx, instance, value); }
365 { doSetParmValue(idx, instance, value); }
367 { doSetParmValue(idx, instance, value); }
369 { doSetParmValue(idx, instance, value); }
371 { doSetParmValue(idx, instance, value); }
387 if (fieldnum.
size() < 1)
396 return "packbetween";
398 return "additionalseams";
406 return "paddingboundary";
408 return "packincavities";
414 return "correctareas";
416 return "axisalignislands";
426 return "uvtolerance";
428 return "scaletolerance";
436 if (fieldnum.
size() < 1)
437 return PARM_UNSUPPORTED;
480 return PARM_UNSUPPORTED;
516 loadData(is, rampdata);
534 int typelen = colon - data.
buffer();
548 {
int64 iv =
v; UTwrite(os, &iv); }
550 { UTwrite<fpreal64>(os, &
v); }
552 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y()); }
554 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
555 UTwrite<fpreal64>(os, &v.
z()); }
557 { UTwrite<fpreal64>(os, &v.
x()); UTwrite<fpreal64>(os, &v.
y());
558 UTwrite<fpreal64>(os, &v.
z()); UTwrite<fpreal64>(os, &v.
w()); }
570 if (s) s->save(ostr);
572 saveData(os, result);
579 ostr << s->getDataTypeToken();
584 saveData(os, result);
588 void save(std::ostream &os)
const
592 saveData(os, myUvAttr);
593 saveData(os, myGroup);
594 saveData(os, myPackBetween);
595 saveData(os, myAdditionalSeams);
596 saveData(os, myPacking);
597 saveData(os, myScale);
598 saveData(os, myPadding);
599 saveData(os, myPaddingBoundary);
600 saveData(os, myPackInCavities);
601 saveData(os, myBboxCenter);
602 saveData(os, myBboxSize);
603 saveData(os, myCorrectAreas);
604 saveData(os, myAxisAlignIslands);
605 saveData(os, myRotations);
606 saveData(os, myIterations);
607 saveData(os, myRandSeed);
608 saveData(os, myResolution);
609 saveData(os, myUvTolerance);
610 saveData(os, myScaleTolerance);
623 loadData(is, myUvAttr);
624 loadData(is, myGroup);
625 loadData(is, myPackBetween);
626 loadData(is, myAdditionalSeams);
627 loadData(is, myPacking);
628 loadData(is, myScale);
629 loadData(is, myPadding);
630 loadData(is, myPaddingBoundary);
631 loadData(is, myPackInCavities);
632 loadData(is, myBboxCenter);
633 loadData(is, myBboxSize);
634 loadData(is, myCorrectAreas);
635 loadData(is, myAxisAlignIslands);
636 loadData(is, myRotations);
637 loadData(is, myIterations);
638 loadData(is, myRandSeed);
639 loadData(is, myResolution);
640 loadData(is, myUvTolerance);
641 loadData(is, myScaleTolerance);
651 if (!thissop)
return getUvAttr();
653 OP_Utils::evalOpParm(result, thissop,
"uvattr", cookparms.
getCookTime(), 0);
661 if (!thissop)
return getGroup();
663 OP_Utils::evalOpParm(result, thissop,
"group", cookparms.
getCookTime(), 0);
671 if (!thissop)
return getPackBetween();
673 OP_Utils::evalOpParm(result, thissop,
"packbetween", cookparms.
getCookTime(), 0);
681 if (!thissop)
return getAdditionalSeams();
683 OP_Utils::evalOpParm(result, thissop,
"additionalseams", cookparms.
getCookTime(), 0);
691 if (!thissop)
return getPacking();
693 OP_Utils::evalOpParm(result, thissop,
"packing", cookparms.
getCookTime(), 0);
703 OP_Utils::evalOpParm(result, thissop,
"scale", cookparms.
getCookTime(), 0);
711 if (!thissop)
return getPadding();
713 OP_Utils::evalOpParm(result, thissop,
"padding", cookparms.
getCookTime(), 0);
721 if (!thissop)
return getPaddingBoundary();
723 OP_Utils::evalOpParm(result, thissop,
"paddingboundary", cookparms.
getCookTime(), 0);
731 if (!thissop)
return getPackInCavities();
733 OP_Utils::evalOpParm(result, thissop,
"packincavities", cookparms.
getCookTime(), 0);
741 if (!thissop)
return getBboxCenter();
743 OP_Utils::evalOpParm(result, thissop,
"bboxcenter", cookparms.
getCookTime(), 0);
751 if (!thissop)
return getBboxSize();
753 OP_Utils::evalOpParm(result, thissop,
"bboxsize", cookparms.
getCookTime(), 0);
761 if (!thissop)
return getCorrectAreas();
763 OP_Utils::evalOpParm(result, thissop,
"correctareas", cookparms.
getCookTime(), 0);
771 if (!thissop)
return getAxisAlignIslands();
773 OP_Utils::evalOpParm(result, thissop,
"axisalignislands", cookparms.
getCookTime(), 0);
781 if (!thissop)
return getRotations();
783 OP_Utils::evalOpParm(result, thissop,
"rotations", cookparms.
getCookTime(), 0);
791 if (!thissop)
return getIterations();
793 OP_Utils::evalOpParm(result, thissop,
"iterations", cookparms.
getCookTime(), 0);
801 if (!thissop)
return getRandSeed();
803 OP_Utils::evalOpParm(result, thissop,
"randseed", cookparms.
getCookTime(), 0);
811 if (!thissop)
return getResolution();
813 OP_Utils::evalOpParm(result, thissop,
"resolution", cookparms.
getCookTime(), 0);
821 if (!thissop)
return getUvTolerance();
823 OP_Utils::evalOpParm(result, thissop,
"uvtolerance", cookparms.
getCookTime(), 0);
831 if (!thissop)
return getScaleTolerance();
833 OP_Utils::evalOpParm(result, thissop,
"scaletolerance", cookparms.
getCookTime(), 0);
845 bool myPaddingBoundary;
846 bool myPackInCavities;
850 bool myAxisAlignIslands;
void getNestParmValue(TempIndex idx, TempIndex instance, exint &value) const override
static void loadData(UT_IStream &is, UT_Matrix3D &v)
Packing getPacking() const
int64 opPadding(const SOP_NodeVerb::CookParms &cookparms) const
bool getPackInCavities() const
void setGroup(const UT_StringHolder &val)
bool operator!=(const SOP_UVLayout_2_0Parms &src) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix3D &value) const override
static void loadData(UT_IStream &is, UT_Matrix2D &v)
fpreal64 getUvTolerance() const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_StringHolder &value) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix4D &value) override
bool opPaddingBoundary(const SOP_NodeVerb::CookParms &cookparms) const
SOP_Node * getNode() const
static void loadData(UT_IStream &is, fpreal64 &v)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector2D &value) const override
static void saveData(std::ostream &os, UT_StringHolder s)
void setPackBetween(bool val)
UT_StringHolder opAdditionalSeams(const SOP_NodeVerb::CookParms &cookparms) const
exint bread(int32 *buffer, exint asize=1)
GT_API const UT_StringHolder time
int64 opRandSeed(const SOP_NodeVerb::CookParms &cookparms) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix4D &value) const override
UT_Vector2T< fpreal64 > UT_Vector2D
int64 getRandSeed() const
static void saveData(std::ostream &os, UT_Matrix2D v)
GLuint const GLfloat * val
void save(std::ostream &os) const
bool getPaddingBoundary() const
static void loadData(UT_IStream &is, UT_Vector2D &v)
static void loadData(UT_IStream &is, UT_StringHolder &v)
fpreal64 getScale() const
void setPackInCavities(bool val)
static void saveData(std::ostream &os, UT_Matrix3D v)
void getNestParmValue(TempIndex idx, TempIndex instance, PRM_DataItemHandle &value) const override
Resolution getResolution() const
SYS_FORCE_INLINE const char * buffer() const
const SOP_GraphProxy * graph() const
An output stream object that owns its own string buffer storage.
fpreal64 getScaleTolerance() const
UT_Vector2D getBboxSize() const
bool opPackInCavities(const SOP_NodeVerb::CookParms &cookparms) const
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_SharedPtr< UT_Ramp > &value) override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector4D &value) override
void setAdditionalSeams(const UT_StringHolder &val)
void doSetParmValue(TempIndex idx, TempIndex instance, const T &value)
static PRM_DataItemHandle parseBinary(const char *type, UT_IStream &is)
const UT_WorkBuffer & str()
Returns a read-only reference to the underlying UT_WorkBuffer.
void setResolution(Resolution val)
bool getAxisAlignIslands() const
void setUvTolerance(fpreal64 val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix2D &value) override
static void loadData(UT_IStream &is, PRM_DataItemHandle &v)
bool operator==(const BaseDimensions< T > &a, const BaseDimensions< Y > &b)
Packing opPacking(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_SharedPtr< UT_Ramp > &v)
static void saveData(std::ostream &os, UT_Vector2D v)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_StringHolder &value) override
static void saveData(std::ostream &os, PRM_DataItemHandle s)
void setNestParmValue(TempIndex idx, TempIndex instance, const fpreal &value) override
SYS_FORCE_INLINE const char * buffer() const
std::shared_ptr< T > UT_SharedPtr
Wrapper around std::shared_ptr.
~SOP_UVLayout_2_0Parms() override
GLint GLenum GLsizei GLint GLsizei const void * data
void setAxisAlignIslands(bool val)
const UT_StringHolder & getUvAttr() const
bool operator==(const SOP_UVLayout_2_0Parms &src) const
void setRandSeed(int64 val)
void getNestParmValue(TempIndex idx, TempIndex instance, fpreal &value) const override
const UT_StringHolder & getGroup() const
static void saveData(std::ostream &os, fpreal64 v)
void setUvAttr(const UT_StringHolder &val)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_SharedPtr< UT_Ramp > &value) const override
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector4D &value) const override
UT_StringHolder opUvAttr(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Matrix4D &v)
void setIterations(int64 val)
void doGetParmValue(TempIndex idx, TempIndex instance, T &value) const
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Vector3D &value) const override
void setPadding(int64 val)
Resolution opResolution(const SOP_NodeVerb::CookParms &cookparms) const
void copyFrom(const SOP_NodeParms *src) override
void saveBinary(std::ostream &os) const
Save string to binary stream.
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector3D &value) override
bool getCorrectAreas() const
GT_API const UT_StringHolder version
fpreal64 opScale(const SOP_NodeVerb::CookParms &cookparms) const
DEP_MicroNode * depnode() const
static void saveData(std::ostream &os, UT_Vector3D v)
void setNestParmValue(TempIndex idx, TempIndex instance, const exint &value) override
int64 opIterations(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, bool &v)
bool opAxisAlignIslands(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, int64 &v)
void setPaddingBoundary(bool val)
void setScaleTolerance(fpreal64 val)
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Matrix3D &value) override
static void saveData(std::ostream &os, UT_SharedPtr< UT_Ramp > s)
static void loadData(UT_IStream &is, UT_Vector4D &v)
static void saveData(std::ostream &os, bool v)
void buildFromOp(const SOP_GraphProxy *graph, exint nodeidx, fpreal time, DEP_MicroNode *depnode)
Utility class for containing a color ramp.
static void loadData(UT_IStream &is, UT_Vector3D &v)
const UT_StringHolder & getAdditionalSeams() const
void setCorrectAreas(bool val)
GLdouble GLdouble GLdouble r
Vec3< typename MatType::value_type > getScale(const MatType &mat)
Return a Vec3 representing the lengths of the passed matrix's upper 3×3's rows.
int64 opRotations(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector2D getBboxCenter() const
virtual void evalOpParm(int64 &v, NodeIdx node, const char *parmname, fpreal time, DEP_MicroNode *depnode) const =0
UT_StringHolder opGroup(const SOP_NodeVerb::CookParms &cookparms) const
static void loadData(UT_IStream &is, UT_Vector3I &v)
fpreal getCookTime() const
static void saveData(std::ostream &os, UT_Matrix4D v)
exint getNestNumParms(TempIndex idx) const override
void setNestParmValue(TempIndex idx, TempIndex instance, const UT_Vector2D &value) override
void setNestParmValue(TempIndex idx, TempIndex instance, const PRM_DataItemHandle &value) override
void setScale(fpreal64 val)
const char * findChar(int c) const
void setBboxCenter(UT_Vector2D val)
const char * getNestParmName(TempIndex fieldnum) const override
ParmType getNestParmType(TempIndex fieldnum) const override
static void loadData(UT_IStream &is, UT_Vector2I &v)
fpreal64 opScaleTolerance(const SOP_NodeVerb::CookParms &cookparms) const
bool getPackBetween() const
fpreal64 opUvTolerance(const SOP_NodeVerb::CookParms &cookparms) const
bool opCorrectAreas(const SOP_NodeVerb::CookParms &cookparms) const
UT_Vector2D opBboxCenter(const SOP_NodeVerb::CookParms &cookparms) const
GLsizei const GLfloat * value
static void saveData(std::ostream &os, UT_Vector4D v)
int64 getRotations() const
const OP_Context & context() const
UT_SharedPtr< const PRM_DataItem > PRM_DataItemHandle
int64 getIterations() const
static void loadData(UT_IStream &is, UT_Vector4I &v)
void setPacking(Packing val)
SYS_FORCE_INLINE bool isstring() const
static void saveData(std::ostream &os, int64 v)
void setRotations(int64 val)
SYS_FORCE_INLINE void strncpy(const char *src, exint maxlen)
void loadFromOpSubclass(const LoadParms &loadparms) override
UT_Vector2D opBboxSize(const SOP_NodeVerb::CookParms &cookparms) const
bool opPackBetween(const SOP_NodeVerb::CookParms &cookparms) const
bool load(UT_IStream &is)
void getNestParmValue(TempIndex idx, TempIndex instance, UT_Matrix2D &value) const override
void setBboxSize(UT_Vector2D val)