HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CH_Segment.h
Go to the documentation of this file.
1 /*
2  * PROPRIETARY INFORMATION. This software is proprietary to
3  * Side Effects Software Inc., and is not to be reproduced,
4  * transmitted, or disclosed in any way without written permission.
5  *
6  * NAME: Channel Library (C++)
7  *
8  * COMMENTS: This is the class definition for a segment.
9  *
10 */
11 
12 #ifndef __CH_Segment_h__
13 #define __CH_Segment_h__
14 
15 #include "CH_API.h"
16 #include "CH_ExprLanguage.h"
17 #include "CH_Manager.h"
18 #include "CH_Support.h"
19 #include "CH_Types.h"
20 
21 #include <CL/CL_SimpleChannel.h>
22 #include <UT/UT_Vector3.h>
23 #include <SYS/SYS_Math.h> // for SYSsqrt() etc
24 #include <SYS/SYS_StaticAssert.h>
25 #include <SYS/SYS_Types.h>
26 
27 #include <iosfwd>
28 
29 
30 #define CH_EXPRESSION_CONSTANT "constant()"
31 #define CH_EXPRESSION_BEZIER "bezier()"
32 #define CH_EXPRESSION_LINEAR "linear()"
33 #define CH_EXPRESSION_CUBIC "cubic()"
34 #define CH_EXPRESSION_EASE "ease()"
35 #define CH_EXPRESSION_EASEIN "easein()"
36 #define CH_EXPRESSION_EASEOUT "easeout()"
37 #define CH_EXPRESSION_SPLINE "spline()"
38 #define CH_EXPRESSION_QLINEAR "qlinear()"
39 #define CH_EXPRESSION_QCUBIC "qcubic()"
40 #define CH_EXPRESSION_QUINTIC "quintic()"
41 
42 #define CH_SEGMENT_MINIMUM_LENGTH 0.000001F
43 
44 class CH_Channel;
45 class CH_Expression;
46 class CH_Manager;
47 class CH_Segment;
48 class CH_TimeGroup;
49 
50 class UT_DeepString;
51 class UT_String;
52 
53 enum
54 {
55  CH_STRETCH_IN = 0x01,
57 };
58 
60 {
61 public:
63  {
64  setDefaults();
65  }
66  void save(std::ostream &os, int binary) const;
67  bool load(UT_IStream &is);
68 
69  void setDefaults();
70  bool isDefault() const;
71 
72  void display();
73 
74  unsigned isConstant:1,
75  isBezier:1,
76  isLinear:1,
77  isCubic:1,
78  isEase:1,
79  isEaseIn:1,
80  isEaseOut:1,
81  isLocked:1,
82  isSpline:1,
83  modified:1,
84  tieOutAccel:1,
85  tieInAccel:1,
86  tieOutSlope:1,
87  tieInSlope:1,
88  tieOutValue:1,
89  tieInValue:1,
90  lockEnd:1,
91  lockStart:1,
92  lockLength:1,
93  isCooking:1,
94  isQLinear:1,
95  isQCubic:1,
96  autoInSlope:1,
97  autoOutSlope:1,
98  modifyingAccel:1,
99  isChop:1,
100  isQuintic:1;
101 };
102 
103 #define CH_MAX_SLOPE 1e8
104 #define CH_MAX_ACCEL 1e8
105 
107 {
108 public:
109 
110  // Minimal constructor with no expression
111  CH_Segment(CH_Channel *mom);
112 
113  // Default constructor creates an expression with which returns the
114  // default value
115  CH_Segment(fpreal def_val, CH_Channel *mom, fpreal len = 0);
116 
117  // Copy constructor.
118  CH_Segment(const CH_Segment &from);
119  CH_Segment(const CL_SimpleSegment &from, CH_Channel *mom,
120  const char *expr, CH_ExprLanguage language);
121 
122  // Constructor for an expression segment. By default, there is
123  // no callback function and no raw array
124  CH_Segment(const char *expr, CH_ExprLanguage language, CH_Channel *mom,
125  fpreal len = 0);
126 
127  ~CH_Segment();
128 
129  int64 getMemoryUsage(bool inclusive) const;
130 
131  CH_Manager *getManager() const;
132  fpreal getTolerance() const;
133 
134  void save(std::ostream &os, int binary, bool compiled,
135  bool disabled) const;
136  template <typename FPREAL_TYPE>
137  bool load(UT_IStream &is, bool disabled,
138  bool reload=false);
139 
140  // Now we define some operators so that we can use these objects
141  // in the UT_Array of channels
142  CH_Segment &operator= (const CH_Segment &from);
143  int operator==(const CH_Segment &) { return 0; }
144 
145  // Evaluate this segment using the current global time in CH_EvalContext
146  fpreal evaluate(int thread);
147  void evaluateString(UT_String &result, int thread);
148 
149  // Clears and reparses the expression:
150  void unresolveLocalVars(int thread);
151 
152  CH_Channel *getChannel() const { return myParent; }
153  void setChannel(CH_Channel *chp) { myParent = chp; }
154 
155  void setExprLanguage(CH_ExprLanguage language);
156  CH_ExprLanguage getExprLanguage() const;
157 
158  // If we were to ask for the value of the segment as a string, this
159  // function returns what the meaning of that string would be (either a
160  // literal or expression in some language).
161  CH_StringMeaning getStringMeaning();
162 
163  int isMatchFunction() const;
164  int isLockedSegment() const { return myFlags.isLocked; }
165  int isChopSegment() const { return myFlags.isChop; }
166 
167  CH_SegmentFlags getFlags() const { return myFlags; }
168  void lockLength(int onoff) { myFlags.lockLength = onoff; }
169  void lockStart(int onoff) { myFlags.lockStart = onoff; }
170  void lockEnd(int onoff) { myFlags.lockEnd = onoff; }
171  void tieInValue(int onoff, bool dotie = true);
172  void tieOutValue(int onoff, bool dotie = true);
173  void tieInSlope(int onoff, bool dotie = true,
174  fpreal ar = 0.0 );
175  void tieOutSlope(int onoff, bool dotie = true,
176  fpreal ar = 0.0 );
177  void tieInAccel(int onoff, bool dotie = true);
178  void tieOutAccel(int onoff, bool dotie = true);
179 
180  void autoInSlope(int onoff);
181  void autoOutSlope(int onoff);
182 
183  // Turn cooking on and set the sample array size or turn cooking off...
184  void cook(int state, int unused = 0);
185 
186  int isCooking() const { return myFlags.isCooking; }
187  int isLengthLocked() const { return myFlags.lockLength; }
188  int isStartLocked() const { return myFlags.lockStart; }
189  int isEndLocked() const { return myFlags.lockEnd; }
190  int isInValueTied() const { return myFlags.tieInValue; }
191  int isOutValueTied() const { return myFlags.tieOutValue; }
192  int isInSlopeTied() const { return myFlags.tieInSlope; }
193  int isOutSlopeTied() const { return myFlags.tieOutSlope; }
194  int isInAccelTied() const { return myFlags.tieInAccel; }
195  int isOutAccelTied() const { return myFlags.tieOutAccel; }
196  int isConstant() const { return myFlags.isConstant; }
197  int isCubic() const { return myFlags.isCubic; }
198  int isQuintic() const { return myFlags.isQuintic; }
199  int isBezier() const { return myFlags.isBezier; }
200  int isLinear() const { return myFlags.isLinear; }
201  int isQLinear() const { return myFlags.isQLinear; }
202  int isQCubic() const { return myFlags.isQCubic; }
203  int isEase() const { return myFlags.isEase; }
204  int isEaseIn() const { return myFlags.isEaseIn; }
205  int isEaseOut() const { return myFlags.isEaseOut; }
206 
207  int isQuaternion() const
208  { return isQLinear() || isQCubic(); }
209  bool isStandard() const
210  { return myFlags.isBezier ||
211  myFlags.isLinear || myFlags.isQLinear ||
212  myFlags.isConstant ||
213  myFlags.isCubic || myFlags.isQCubic ||
214  myFlags.isEase ||
215  myFlags.isEaseIn ||
216  myFlags.isEaseOut; }
217  // when drawing past channel ends, should "extend" be treated
218  // the same as "hold"?
219  bool treatExtendAsHold() const
220  { return isStandard() || myFlags.isQuintic; }
221 
222  bool hasFakeSlopeHandles() const
223  { return myFlags.isLinear || myFlags.isQLinear ||
224  myFlags.isEase ||
225  myFlags.isEaseIn ||
226  myFlags.isEaseOut; }
227 
228  // currently, all segment functions that have fake slope handles can have fake accel handles as well
229  bool hasFakeAccelHandles() const
230  { return hasFakeSlopeHandles() && getManager()->shouldShowFakeAccelHandles(); }
231 
232  int isInSlopeAuto() const { return myFlags.autoInSlope; }
233  int isOutSlopeAuto() const { return myFlags.autoOutSlope; }
234  // Setting force to true ignores whether the slope is auto or not
235  bool isInSlopeFixed(bool force) const;
236  bool isOutSlopeFixed(bool force) const;
237 
238  int isInValueUsed(); // These methods query the
239  int isOutValueUsed(); // expression to find out
240  int isInSlopeUsed();
241  int isOutSlopeUsed();
242  int isInAccelUsed();
243  int isOutAccelUsed();
244  int isSplineUsed();
245 
246  // For simple functions that CH_SegmentFlags supports, return the
247  // CH_Support.h user flags for whether the value/slope/accels are used
248  // without needing to evaluate the expression. Returns false if all of the
249  // CH_SegmentFlags::isCubic, isBezier, etc. are false.
250  bool getFunctionKeyUserFlags(int thread, unsigned &flags);
251 
252  // Does a quick check to see if this segment is time dependent, using the
253  // flags set from the last evaluation. Returns false if we're not a special
254  // case function, or if result was computed as a special case, else false.
255  bool computeFastTimeDep(bool &is_special) const;
256 
257  // Does a quick check to see if this segment is time dependent, using the
258  // flags set from the last evaluation. If it can't find out, then it will
259  // conservatively return true.
260  bool isTimeDependent() const
261  {
262  bool is_special;
263  return computeFastTimeDep(is_special);
264  }
265 
266  // This function will return if the value is time dependent, and, if
267  // it's not, the value argument will be set. This way, you can compare
268  // adjacent values between segments to quickly check for time dependencies.
269  // This function will evaluate the expression if it's not already flagged
270  // as time dependent.
271  // This is a helper for CH_Channel::isTimeDependentSlowImpl().
272  inline bool isTimeDependentAndGetValue(
273  fpreal &value, int thread) const;
274  inline bool isTimeDependentAndGetValue(
275  UT_DeepString &value, int thread) const;
276 
277  bool hasNonIntegerKeys() const;
278  unsigned isDataDependent() const;
279 
280  // The following methods are used to change the segment times
281  // (start, end, duration), and also for checking whether the
282  // segment can be changed.
283  int canChange(fpreal start, fpreal end) const;
284  void changeLength(fpreal len,
286  bool accel_ratio = true);
287  void changeTimes(fpreal s, fpreal e);
288 
289  // This method should only be called by CH_Channel - hands off.
290  void stretch(fpreal scale, int adjust_slopes,
291  int adjust_accel);
292 
293  // Some query methods
294  const char *getExpression() const;
295  const CH_Expression *getCHExpr() const { return myExpression; }
296  CH_Expression *getCHExpr() { return myExpression; }
297 
298  bool isEndSegment() const
299  {
300  return myLength == CONST_FPREAL(0);
301  }
302  fpreal getInValue() const { return myInValue; }
303  fpreal getOutValue() const { return myOutValue; }
304  fpreal getInSlope() const { return myInSlope; }
305  fpreal getOutSlope() const { return myOutSlope; }
306  fpreal getInAccel() const { return myInAccel; }
307  fpreal getOutAccel() const { return myOutAccel; }
309  {
310  return getAccelRatio(myInSlope, myInAccel,
311  myLength);
312  }
314  {
315  return getAccelRatio(myOutSlope, myOutAccel,
316  myLength);
317  }
318  static fpreal getAccelRatio(fpreal slope, fpreal accel,
319  fpreal length);
320  static fpreal getAccelFromRatio(fpreal slope, fpreal ratio,
321  fpreal length)
322  {
323  if( length==0.0 )
324  length = 1.0;
325  return length * ratio * SYSsqrt( slope*slope + 1 );
326  }
327  static fpreal getAccelX(fpreal slope, fpreal accel);
328 
329  CH_Segment *getNext() { return myNext; }
330  const CH_Segment *getNext() const { return myNext; }
331  void setNext(CH_Segment *segp)
332  { myNext = segp; }
333  CH_Segment *getPrev() { return myPrev; }
334  const CH_Segment *getPrev() const { return myPrev; }
335  void setPrev(CH_Segment *segp)
336  { myPrev = segp; }
337 
338  fpreal getLength() const { return myLength; }
339  fpreal getILength() const { return myInverseLength; }
340 
341  fpreal getStart() const { return myStart; }
342  fpreal getEnd() const { return myEnd; }
343 
345  {
346  return (t - myStart) * myInverseLength;
347  }
348 
349  void changeExpression(const char *expr, CH_ExprLanguage language,
350  bool convert_accels, bool post_process=true);
351  void changeExpression(const char *expr,
352  CH_ExprLanguage language);
353  void changeExpressionToBezierOrCubic();
354 
355  // Return whether or not an expression is a call to an animation function.
356  // Note that such expressions are compatible between different languages.
357  // The static method is for an arbitrary expression string and the
358  // non-static is for this segment.
359  static bool expressionIsAnimationFunctionCall(
360  const char *expression);
361  bool expressionIsAnimationFunctionCall();
362 
363  // When an application calls the following methods to set in/out values,
364  // they should leave the doTie as 1, it's only used internally.
365  void setInValue(fpreal v, bool dotie = true);
366  void setOutValue(fpreal v, bool dotie = true);
367  void setInSlope(fpreal v, bool dotie = true, fpreal ar = 0.0);
368  void setOutSlope(fpreal v, bool dotie = true, fpreal ar = 0.0);
369  void setInAccel(fpreal v, bool dotie = true);
370  void setOutAccel(fpreal v, bool dotie = true);
371  void setInAccelRatio(fpreal ratio, bool dotie = true)
372  {
373  fpreal v = getAccelFromRatio(myInSlope, ratio,
374  myLength);
375  setInAccel( v, dotie );
376  }
377  void setOutAccelRatio(fpreal ratio, bool dotie = true )
378  {
379  fpreal v = getAccelFromRatio(myOutSlope, ratio,
380  myLength);
381  setOutAccel( v, dotie );
382  }
383  void clampInAccel();
384  void clampOutAccel();
385  void normalizeAccels();
386  void postProcessFakeSlopeAccelHandles();
387  void postProcessHybridSlopes();
388 
389  // Does nothing for segments that are not cubic or bezier
390  void makeMonotone(bool do_prev=false, bool do_next=false);
391  // Returns false for segments that are not cubic or bezier
392  bool isMonotone() const;
393  /// For segments that are not cubic or bezier, sets range to the entire
394  /// slope interval, (-CH_MAX_SLOPE, CH_MAX_SLOPE), and returns false
395  bool getMonotoneInterval(UT_IntervalR &range, bool lock_in);
396 
398  {
399  myPrev = p;
400  myNext = n;
401  }
402 
403  // Sorry, you can only flag a segment as being changed, it's got it's
404  // own internal mechanism for flagging this
405  void setChanged();
406 
407  // Only the CH_Channel class should call the following method(s)
408  void reverse();
409 
410  // Op dependencies
411  void buildOpDependencies(void *ref_id, int thread);
412  int changeOpRef(const char *new_fullpath,
413  const char *old_fullpath,
414  const char *old_cwd,
415  const char *chan_name,
416  const char *old_chan_name,
417  int thread);
418 
419  int findString(const char *str, bool fullword,
420  bool usewildcards) const;
421  int changeString(const char *from, const char *to,
422  bool fullword, int thread);
423 
424  void transferGroup(CH_Segment &from);
425 
426  bool wasModified() const { return (myFlags.modified != 0); }
427  void setModified(bool on_off);
428 
429  void dirtyExprCache();
430 
431  fpreal getValue(bool left, CH_ValueTypes t) const;
432  void setValue(bool left, CH_ValueTypes t, fpreal value);
433  bool getValueValid(bool left, CH_ValueTypes t);
434  bool getValueTied(bool left, CH_ValueTypes t) const;
435  void setValueTied(bool left, CH_ValueTypes t, bool on_off);
436  bool getValueAuto(bool left, CH_ValueTypes t) const;
437  void setValueAuto(bool left, CH_ValueTypes t, bool on_off);
438 
439  void display();
440 
441  CH_TimeGroup *getTimeGroup() const { return myTimeGroup; }
442 
443  CL_SimpleSegmentType getSimpleType() const;
444 
445  static const char *getExpressionFromSimpleType(CL_SimpleSegmentType type);
446 
447  CL_SegmentValues getSegmentValues() const;
448 private:
449  void setTimeGroup(CH_TimeGroup *g, bool refresh=true);
450 
451  void setExpression(const CH_Expression *newexpr);
452  void checkExpression();
453  void constructorInit(); // Initialize all values
454  void isCooking(int state) // Toggle state during cook
455  { myFlags.isCooking = state; }
456  bool loadTimeGroups(UT_IStream &is);
457  void saveTimeGroups(std::ostream &is, int binary) const;
458 
459  void holdLastKey(fpreal v, bool dotie);
460 
461  void updateExprFlags();
462 
463 
464  static constexpr unsigned
465  TIMEDEPFLAGS = (CH_EXPRTIME | CH_EXPRCHAN |
468 
469  bool isExprTimeDep() const;
470 
471  // the member variables marked with (*) should be removed as they are
472  // actually useless
473 
474  CH_SegmentFlags myFlags;
475 
476  // Here is the local context information for the segment. It is
477  // be used for evaluation of the segment.
478  //
479  // All times and lengths of time are in the channel local time.
480  CH_Expression *myExpression;
481 
482  fpreal myInValue, myOutValue;
483  fpreal myInSlope, myOutSlope;
484  fpreal myInAccel, myOutAccel;
485 
486  CH_TimeGroup *myTimeGroup;
487 
488  // (*) we shouldn't store length, just use getNext()->myStart - myStart
489  // storing inverse length is acceptable
490  fpreal myLength;
491  fpreal myInverseLength; // Inverse stored for speed
492 
493  // (*) myEnd is redundant, and is not really that much more efficient
494  fpreal myStart, myEnd; // Redundant; for efficiency
495 
496  CH_Channel *myParent; // Our channel.
497 
498  // (**) ideally we would store segments in a ref array, in which case
499  // getNext could ideally be (this+1), ditto for prev, but there are some
500  // boundary cases of course where this gets weird
501  CH_Segment *myPrev, *myNext; // For easy reference
502 
503  friend class CH_TimeGroup;
504 };
505 
506 inline bool
507 CH_Segment::computeFastTimeDep(bool &is_special) const
508 {
509  // Constant segments are never time dependent
510  if (myFlags.isConstant)
511  {
512  is_special = true;
513  return false;
514  }
515 
516  if (isEndSegment())
517  {
518  // For end segments, the out value/slopes are not used so all of these
519  // expressions on them are NOT time dependent
520  if (treatExtendAsHold())
521  {
522  is_special = true;
523  return false;
524  }
525  }
526  else
527  {
528  if (myFlags.isBezier || myFlags.isCubic || myFlags.isQuintic)
529  {
530  is_special = true;
531  return (myInValue != myOutValue) || myInSlope || myOutSlope;
532  }
533 
534  if (myFlags.isLinear || myFlags.isEase ||
535  myFlags.isEaseIn || myFlags.isEaseOut)
536  {
537  is_special = true;
538  return myInValue != myOutValue;
539  }
540  }
541 
542  // If the expression is already flagged as time-dependent, we don't
543  // need to do any evaluation.
544  is_special = false;
545  return isExprTimeDep();
546 }
547 
548 
549 
550 #endif
CH_Channel * getChannel() const
Definition: CH_Segment.h:152
void setOutAccelRatio(fpreal ratio, bool dotie=true)
Definition: CH_Segment.h:377
void setPrev(CH_Segment *segp)
Definition: CH_Segment.h:335
GLbitfield flags
Definition: glcorearb.h:1596
fpreal getInAccelRatio() const
Definition: CH_Segment.h:308
PXL_API void reload()
Reload the configuration.
GLenum GLint * range
Definition: glcorearb.h:1925
fpreal relativeTime(fpreal t) const
Definition: CH_Segment.h:344
int isInValueTied() const
Definition: CH_Segment.h:190
unsigned isLinear
Definition: CH_Segment.h:74
int isEase() const
Definition: CH_Segment.h:203
GA_API const UT_StringHolder accel
bool isEndSegment() const
Definition: CH_Segment.h:298
CH_ExprLanguage
GLint left
Definition: glcorearb.h:2005
CH_StringMeaning
unsigned isBezier
Definition: CH_Segment.h:74
const GLdouble * v
Definition: glcorearb.h:837
CH_Expression * getCHExpr()
Definition: CH_Segment.h:296
unsigned isConstant
Definition: CH_Segment.h:74
int isQLinear() const
Definition: CH_Segment.h:201
#define CH_EXPRACCEL
Definition: CH_Support.h:36
GLuint start
Definition: glcorearb.h:475
const GLuint GLenum const void * binary
Definition: glcorearb.h:1924
GLboolean GLboolean g
Definition: glcorearb.h:1222
void reverse(I begin, I end)
Definition: pugixml.cpp:7190
GLdouble s
Definition: glad.h:3009
fpreal getInValue() const
Definition: CH_Segment.h:302
GLuint GLsizei GLsizei * length
Definition: glcorearb.h:795
bool isStandard() const
Definition: CH_Segment.h:209
int isEaseIn() const
Definition: CH_Segment.h:204
**But if you need a result
Definition: thread.h:613
int isLengthLocked() const
Definition: CH_Segment.h:187
__hostdev__ void setValue(uint32_t offset, bool v)
Definition: NanoVDB.h:5750
bool wasModified() const
Definition: CH_Segment.h:426
#define CH_EXPRSLOPE
Definition: CH_Support.h:34
static fpreal getAccelFromRatio(fpreal slope, fpreal ratio, fpreal length)
Definition: CH_Segment.h:320
int isCubic() const
Definition: CH_Segment.h:197
int isEndLocked() const
Definition: CH_Segment.h:189
int isQuaternion() const
Definition: CH_Segment.h:207
CH_TimeGroup * getTimeGroup() const
Definition: CH_Segment.h:441
bool shouldShowFakeAccelHandles() const
Definition: CH_Manager.h:554
fpreal getInSlope() const
Definition: CH_Segment.h:304
fpreal getOutValue() const
Definition: CH_Segment.h:303
int isOutSlopeTied() const
Definition: CH_Segment.h:193
int isStartLocked() const
Definition: CH_Segment.h:188
__hostdev__ float getValue(uint32_t i) const
Definition: NanoVDB.h:5578
bool isTimeDependent() const
Definition: CH_Segment.h:260
CL_SimpleSegmentType
bool treatExtendAsHold() const
Definition: CH_Segment.h:219
GA_API const UT_StringHolder scale
GLdouble n
Definition: glcorearb.h:2008
int isInAccelTied() const
Definition: CH_Segment.h:194
int isLockedSegment() const
Definition: CH_Segment.h:164
int isConstant() const
Definition: CH_Segment.h:196
int isOutAccelTied() const
Definition: CH_Segment.h:195
fpreal getStart() const
Definition: CH_Segment.h:341
#define CONST_FPREAL(c)
Definition: SYS_Types.h:327
bool computeFastTimeDep(bool &is_special) const
Definition: CH_Segment.h:507
GLuint GLuint end
Definition: glcorearb.h:475
int isCooking() const
Definition: CH_Segment.h:186
bool hasFakeAccelHandles() const
Definition: CH_Segment.h:229
unsigned isEaseIn
Definition: CH_Segment.h:74
unsigned isCubic
Definition: CH_Segment.h:74
bool hasFakeSlopeHandles() const
Definition: CH_Segment.h:222
long long int64
Definition: SYS_Types.h:116
int isLinear() const
Definition: CH_Segment.h:200
int isOutValueTied() const
Definition: CH_Segment.h:191
CH_Segment * getPrev()
Definition: CH_Segment.h:333
void lockLength(int onoff)
Definition: CH_Segment.h:168
const CH_Expression * getCHExpr() const
Definition: CH_Segment.h:295
unsigned isQuintic
Definition: CH_Segment.h:74
const CH_Segment * getPrev() const
Definition: CH_Segment.h:334
int isInSlopeTied() const
Definition: CH_Segment.h:192
void lockStart(int onoff)
Definition: CH_Segment.h:169
unsigned isEaseOut
Definition: CH_Segment.h:74
void setNext(CH_Segment *segp)
Definition: CH_Segment.h:331
GLdouble t
Definition: glad.h:2397
fpreal getLength() const
Definition: CH_Segment.h:338
#define CH_EXPRKNOTS
Definition: CH_Support.h:37
unsigned isEase
Definition: CH_Segment.h:74
int isInSlopeAuto() const
Definition: CH_Segment.h:232
int isBezier() const
Definition: CH_Segment.h:199
**Note that the tasks the is the thread number *for the or if it s being executed by a non pool thread(this *can happen in cases where the whole pool is occupied and the calling *thread contributes to running the work load).**Thread pool.Have fun
int operator==(const CH_Segment &)
Definition: CH_Segment.h:143
CH_ValueTypes
Definition: CH_Types.h:113
SIM_API const UT_StringHolder force
void setPrevNext(CH_Segment *p, CH_Segment *n)
Definition: CH_Segment.h:397
fpreal64 fpreal
Definition: SYS_Types.h:277
#define CH_API
Definition: CH_API.h:10
int isChopSegment() const
Definition: CH_Segment.h:165
fpreal getILength() const
Definition: CH_Segment.h:339
LeafData & operator=(const LeafData &)=delete
int isQCubic() const
Definition: CH_Segment.h:202
fpreal getOutSlope() const
Definition: CH_Segment.h:305
#define CH_EXPRCHAN
Definition: CH_Support.h:31
CH_SegmentScale
Definition: CH_Types.h:107
#define CH_EXPRVALUE
Definition: CH_Support.h:41
CH_Segment * getNext()
Definition: CH_Segment.h:329
fpreal getOutAccel() const
Definition: CH_Segment.h:307
fpreal getInAccel() const
Definition: CH_Segment.h:306
Definition: core.h:1131
void lockEnd(int onoff)
Definition: CH_Segment.h:170
fpreal getOutAccelRatio() const
Definition: CH_Segment.h:313
CH_SegmentFlags getFlags() const
Definition: CH_Segment.h:167
const CH_Segment * getNext() const
Definition: CH_Segment.h:330
int isOutSlopeAuto() const
Definition: CH_Segment.h:233
type
Definition: core.h:1059
int isEaseOut() const
Definition: CH_Segment.h:205
void setChannel(CH_Channel *chp)
Definition: CH_Segment.h:153
int isQuintic() const
Definition: CH_Segment.h:198
void setInAccelRatio(fpreal ratio, bool dotie=true)
Definition: CH_Segment.h:371
fpreal getEnd() const
Definition: CH_Segment.h:342
#define CH_EXPRTIME
Definition: CH_Support.h:30