HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
PRM_Template.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: PRM_Template.h (Parameter Library)
7  *
8  * COMMENTS:
9  * PRM_Template is the class which contains all the static data
10  * relating to a parameter. It encapsulates the characteristics
11  * of the parameter, such as type, default values, range, etc.
12  * A PRM_Template is used in conjunction with a PRM_Instance to
13  * define a PRM_Parm. A PRM_Instance is to a PRM_Template as
14  * an object is to a class in C++.
15  */
16 
17 #ifndef __PRM_Template__
18 #define __PRM_Template__
19 
20 #include "PRM_API.h"
21 #include "PRM_Callback.h"
22 #include "PRM_ConditionalType.h"
23 #include "PRM_Name.h"
24 #include "PRM_Type.h"
25 #include <UT/UT_Assert.h>
26 #include <UT/UT_IntArray.h>
27 #include <UT/UT_String.h>
28 #include <UT/UT_StringHolder.h>
29 #include <UT/UT_UniquePtr.h>
30 #include <UT/UT_ValArray.h>
31 #include <SYS/SYS_Types.h>
32 
33 #define PRM_TYPE_IS_SWITCHER(type) (type.isSwitcher())
34 #define PRM_IS_JOIN(parm) (parm.getTypeExtended() == PRM_TYPE_TOGGLE_JOIN || \
35  parm.getTypeExtended() == PRM_TYPE_JOIN_PAIR)
36 
37 class UT_WorkBuffer;
38 class PRM_ChoiceList;
39 class PRM_Conditional;
41 class PRM_Range;
42 class PRM_Default;
43 class PRM_Template;
44 class PRM_SpareData;
45 
47 
49 {
50 public:
51  // An export level is a hint to say if a parm should be displayed or not.
52  // By default, all parms have minimum export level, which means that
53  // they are only displayed if someone asks for a dialog with the minimum
54  // export level. Creating a dialog with a higher export level will only
55  // contain those parameters with higher export levels.
57  {
61  PRM_EXPORT_TBX // for toolboxes
62  };
63 
64  enum
65  {
66  // This is maximum vector size for parameters. This is because we keep
67  // per component flags in uint32 variables. For myAutoScopeField, we
68  // use the high-bit to keep track of whether it's initialized so the
69  // actual limit is 31, not 32.
70  MAX_VECTOR_SIZE = 31
71  };
72 
73  // No extended type given and no export level given.
75  int thevectorsize = 1,
76  PRM_Name *thenameptr = 0,
77  PRM_Default *thedefaults = 0,
78  PRM_ChoiceList *thechoicelistptr = 0,
79  PRM_Range *therangeptr = 0,
80  PRM_Callback thecallbackfunc = 0,
81  PRM_SpareData *thespareptr = 0,
82  int theparmgroup = 1,
83  const char *thehelptext = 0,
84  PRM_ConditionalBase *thecondptr = 0);
85 
86  // No extended type given but export level given.
87  PRM_Template(PRM_Type thetype,
88  PRM_Export theexportlevel,
89  int thevectorsize = 1,
90  PRM_Name *thenameptr = 0,
91  PRM_Default *thedefaults = 0,
92  PRM_ChoiceList *thechoicelistptr = 0,
93  PRM_Range *therangeptr = 0,
94  PRM_Callback thecallbackfunc = 0,
95  PRM_SpareData *thespareptr = 0,
96  int theparmgroup = 1,
97  const char *thehelptext = 0,
98  PRM_ConditionalBase *thecondptr = 0);
99 
100  // Extended type given but no export level given.
101  PRM_Template(PRM_Type thetype,
102  PRM_TypeExtended thetype_ext,
103  int thevectorsize = 1,
104  PRM_Name *thenameptr = 0,
105  PRM_Default *thedefaults = 0,
106  PRM_ChoiceList *thechoicelistptr = 0,
107  PRM_Range *therangeptr = 0,
108  PRM_Callback thecallbackfunc = 0,
109  PRM_SpareData *thespareptr = 0,
110  int theparmgroup = 1,
111  const char *thehelptext = 0,
112  PRM_ConditionalBase *thecondptr = 0);
113 
114  // Extended type given and export level given.
115  PRM_Template(PRM_Type thetype,
116  PRM_TypeExtended thetype_ext,
117  PRM_Export theexportlevel,
118  int thevectorsize = 1,
119  PRM_Name *thenameptr = 0,
120  PRM_Default *thedefaults = 0,
121  PRM_ChoiceList *thechoicelistptr = 0,
122  PRM_Range *therangeptr = 0,
123  PRM_Callback thecallbackfunc = 0,
124  PRM_SpareData *thespareptr = 0,
125  int theparmgroup = 1,
126  const char *thehelptext = 0,
127  PRM_ConditionalBase *thecondptr = 0);
128 
129  // Dynamic multi-parm type contructors:
130 
131  // Notes: - the export level cannot be PRM_EXPORT_TBX (they won't fit)
132  // - the vector size is the number of shown instances (Scroll type)
133  // or the number of instances per tab (Switcher type).
134  // - the default is the number of default instances (int)
135  // - the range is the allowable range of instances, min zero.
136  // - the template list is a list of templates to use as a guide
137  // to create new instances (a template, but I didn't want to use
138  // that word again). Names will have a number suffixed to them
139  // depending on the instance number ("foo1") or %d may be used to
140  // specify where the number is put ("foo%dbar"). The template list
141  // otherwise should look exactly the same as a normal list.
142  // - the start offset is where we start counting our instances,
143  // by default from 1.
144  PRM_Template(PRM_MultiType thetype,
145  PRM_Template *thetemplates,
146  PRM_Export theexportlevel,
147  fpreal multisize,
148  PRM_Name *thenameptr,
149  PRM_Default *thedefaultsize = 0,
150  PRM_Range *thedefaultrange = 0,
151  PRM_SpareData *thespareptr = 0,
152  const char *thehelptext = 0,
153  PRM_ConditionalBase *thecondptr = 0,
154  PRM_Callback thecallbackfunc = 0);
155  // no export option.
156  PRM_Template(PRM_MultiType thetype,
157  PRM_Template *thetemplates,
158  fpreal multisize,
159  PRM_Name *thenameptr,
160  PRM_Default *thedefaultsize = 0,
161  PRM_Range *thedefaultrange = 0,
162  PRM_SpareData *thespareptr = 0,
163  const char *thehelptext = 0,
164  PRM_ConditionalBase *thecondptr = 0,
165  PRM_Callback thecallbackfunc = 0);
166 
167  PRM_Template(const PRM_Template &src);
168  ~PRM_Template();
169 
170  int64 getMemoryUsage(bool inclusive) const;
171 
172  const PRM_Template &operator=(const PRM_Template &src);
173 
174  void initialize(PRM_Type thetype,
175  PRM_TypeExtended thetype_ext,
176  PRM_Export theexportlevel,
177  int thevectorsize,
178  PRM_Name *thenameptr,
179  PRM_Default *thedefaults,
180  PRM_ChoiceList *thechoicelistptr,
181  PRM_Range *therangeptr,
182  PRM_Callback thecallbackfunc,
183  PRM_SpareData *thespareptr,
184  int theparmgroup,
185  const char *thehelptext,
186  PRM_ConditionalBase *thecondptr);
187 
188  void initMulti(PRM_MultiType thetype,
189  PRM_Template *thetemplates,
190  PRM_Export theexportlevel,
191  fpreal multisize,
192  PRM_Name *thenameptr,
193  PRM_Default *thedefaultsize,
194  PRM_Range *thedefaultrange,
195  PRM_Callback thecallbackfunc,
196  PRM_SpareData *thespareptr,
197  const char *thehelptext,
198  PRM_ConditionalBase *thecondptr);
199 
200  // This method is effectively an assignment operator which copies everything
201  // from the source except for the vector size and defaults.
202  void assign(const PRM_Template &src, int thevectorsize,
203  PRM_Default *thedefaults);
204 
205  const PRM_Type &getType() const { return myType; }
206  PRM_MultiType getMultiType() const { return myMultiType; }
207  bool isMultiType() const;
208  bool isRampType() const;
209  bool isRampTypeColor() const;
210  PRM_TypeExtended getTypeExtended() const { return myTypeExtended; }
211  int getVectorSize() const { return myVectorSize; }
212  fpreal getMultiSize() const { return myMultiSize; }
213  void setNamePtr(PRM_Name *name) { myNamePtr = name; }
214  PRM_Name *getNamePtr() { return myNamePtr; }
215  const PRM_Name *getNamePtr() const { return myNamePtr; }
216  PRM_SpareData *getSparePtr() { return mySparePtr; }
217  const PRM_SpareData *getSparePtr() const { return mySparePtr; }
218  PRM_SpareData *getOrCreateSparePtr();
220  { mySparePtr = spare; }
221  PRM_Conditional *getConditionalPtr(PRM_ConditionalType type);
222  const PRM_Conditional *getConditionalPtr(PRM_ConditionalType type) const;
224  { return myConditionalPtr; }
226  { return myConditionalPtr; }
228  { myConditionalPtr = conditional; return *this; }
229 
231  { return getConditionalPtr(PRM_CONDTYPE_DISABLE); }
233  { return getConditionalPtr(PRM_CONDTYPE_DISABLE); }
235  {
236  const PRM_ChoiceList *list;
237  if (!myChoiceListPtr &&
238  (myType & PRM_TYPE_ORDINAL) &&
239  (myType & PRM_TYPE_TOGGLE))
240  list = &PRMtoggleMenu;
241  else
242  list = myChoiceListPtr;
243  return list;
244  }
246  {
247  PRM_ChoiceList *list;
248  if (myChoiceListPtr == nullptr
249  && myType.isOrdinalType()
250  && myType.hasOrdinalType(
252  list = &PRMtoggleMenu;
253  else
254  list = myChoiceListPtr;
255  return list;
256  }
258  {
259  myChoiceListPtr = list;
260  }
261  const PRM_Range *getRangePtr() const { return myRangePtr; }
262  PRM_Range *getRangePtr() { return myRangePtr; }
263  PRM_Callback getCallback() const { return myCallbackFunc; }
264  void setCallback(PRM_Callback callback)
265  { myCallbackFunc = callback; }
266  const UT_StringHolder &getHelpText() const { return myHelpText; }
267  unsigned int getAutoScopeField()
268  {
269  if (myAutoScopeField & (1<<(unsigned)myVectorSize))
270  setAutoScopeField();
271  return myAutoScopeField;
272  }
273 
275  { return myMultiParmTemplate; }
277  { return myMultiParmTemplate; }
279  {
280  UT_ASSERT(!tplate || !tplate->isRampType());
281  myMultiParmTemplate = tplate;
282  }
283  int getMultiStartOffset() const;
284 
285  /// matchMultiInstance() tests the given name and returns true if it
286  /// might be an instance parm of the multiparm token (with # characters).
287  /// - If the result is true, then the parsed instance index (relative to
288  /// start_offset) is returned.
289  /// - If the index in the name is less that start_offset, then it will be
290  /// rejected.
291  /// - For nested multiparms, the instance_index array contains an array of
292  /// the parent multiparm instance indices that you want to match against.
293  /// If it is nullptr, then those checks will be skipped.
294  static bool matchMultiInstance(const char *name,
295  const char *multi_name,
296  int start_offset,
297  int &index,
298  const UT_IntArray *instance_index);
299 
301  {
302  return (myDefaults
303  && index >= 0 && index < myVectorSize)
304  ? myDefaults[index].get() : nullptr;
305  }
306  const PRM_Default *getDefault(int index) const
307  {
308  return (myDefaults
309  && index >= 0 && index < myVectorSize)
310  ? myDefaults[index].get() : nullptr;
311  }
313  {
314  return myFactoryDefaults;
315  }
317  {
318  myFactoryDefaults = defaults;
319  }
320  void restoreFactoryDefaults();
321  void setFloatDefault(int index, fpreal v);
322  void setOrdinalDefault(int index, int v);
323  void setStringDefault(int index, const char *v);
324  void setDefault(int index, const PRM_Default &d);
325 
326  // This function sets the PRM_TYPE_NORESIM flag on an existing parameter.
327  // This is an odd operation because it is changing the type of a parameter
328  // when it already exists. But setting this flag doesn't really change
329  // the fundamental type of the parameter. This capability is used in
330  // DOP_Table.C for marking parameters related to guide geometry as not
331  // requiring a refresh.
332  void setNoResim(bool noresim);
333  void setNoCook(bool nocook);
334  /// Set the no-cook flag based on the "cook_dependent" spare data. If the
335  /// force flag is set, the no-cook flag will be set to true if the spare
336  /// data doesn't exist.
337  /// @return The value of the nocook flag
338  bool setNoCook(const PRM_SpareData *spare,
339  bool force=false);
340  void setBaseParm(bool baseparm);
341  void setInvisible(bool invisible);
342  bool getInvisible() const
343  { return (myType & PRM_TYPE_INVISIBLE) != 0; }
344  void setJoinNext(bool joinnext);
345  bool getJoinNext() const
346  { return (myType & PRM_TYPE_JOIN_NEXT) != 0; }
347  void setLabelNone(bool labelnone);
348  bool getLabelNone() const
349  { return (myType & PRM_TYPE_LABEL_NONE) != 0; }
350 
352  { myTypeExtended = type_ext; }
353 
355  { return (PRM_Export)myExportLevel; }
357  { myExportLevel = (unsigned char)level; }
358  int getParmGroup() const { return (int)myParmGroup; }
359 
360  // findSubIndex returns -1 if no parameter is found
361  int findSubIndex(const UT_StringRef &thechannelname) const
362  {
363  if (!myChannelNames)
364  buildChannelNames();
365 
366  for (int i = 0; i < myVectorSize; i++)
367  {
368  if (myChannelNames[i] == thechannelname)
369  return i;
370  }
371  return -1;
372  }
373 
375  {
376  if (!myChannelNames)
377  buildChannelNames();
378  return myChannelNames.get();
379  }
380  void getChannelToken(UT_String &s, int vi) const
381  {
382  if (!myChannelNames)
383  buildChannelNames();
384 
385  if (vi >= 0 && vi < myVectorSize)
386  {
387  s = myChannelNames[vi].buffer();
388  }
389  else
390  {
391  UT_ASSERT(!"ERROR: Out of range");
392  s = "";
393  }
394  }
395 
396  const UT_StringHolder &getChannelToken(int vi) const
397  {
398  if (!myChannelNames)
399  buildChannelNames();
400 
401  if (vi >= 0 && vi < myVectorSize)
402  return myChannelNames[vi];
403 
404  UT_ASSERT(!"ERROR: Out of range");
406  }
407 
408  bool hasChannelToken(const UT_StringRef &s, int vi) const
409  {
410  if (!myChannelNames)
411  buildChannelNames();
412 
413  UT_ASSERT_P(vi >= 0 && vi < myVectorSize);
414  return myChannelNames[vi] == s;
415  }
416  void getChannelLabel(UT_String &thestrref,
417  int theindex) const;
418  void getToken(UT_String &thestrref) const
419  {
420  thestrref = myNamePtr->getToken();
421  }
422  void getLabel(UT_String &thestrref) const
423  {
424  thestrref = myNamePtr->getLabel();
425  }
426 
427  int getExpressionFlag() const
428  {
429  return myNamePtr->getExpressionFlag();
430  }
431 
432  //
433  // Retrieve as strings instead of UT_Strings.
434  const char *getToken() const
435  {
436  return myNamePtr->getToken();
437  }
438  const UT_StringRef &getTokenRef() const
439  {
440  return myNamePtr->getTokenRef();
441  }
442  const char *getLabel() const
443  {
444  return myNamePtr->getLabel();
445  }
446  unsigned getTokenHash() const
447  {
448  return myNamePtr->getHash();
449  }
450 
451  // A utility function to count the number of templates in a list. When
452  // counting a list for inclusion into a switcher, nested switchers (and all
453  // their templates) only count as a single template. When for_switcher is
454  // true, the count will include switchers (and all their nested templates)
455  // as a single entity. When for_switcher is false, the function will
456  // return the total size of the template. Similarly for toggle joins &
457  // parm joins with 'for_join'.
458  static int countTemplates(
459  const PRM_Template *templates,
460  bool for_switcher = false,
461  bool for_joins = false,
462  bool for_rows = false);
463  // Finds an index of a template that matches a given token. Returns -1 if
464  // not found.
465  static int getTemplateIndexByToken(
466  const PRM_Template *templates,
467  const char * token);
468 
469  // Returns a pointer to the template right after the PRM_SWITCHER
470  // template that is passed in.
471  static const PRM_Template *getEndOfSwitcher(
472  const PRM_Template *templates);
473  // Returns the number of switcher and non-switcher parms contained
474  // within another switcher.
475  static void getSwitcherStats(
476  const PRM_Template *templates,
477  UT_IntArray &numswitchersonpages,
478  UT_IntArray &numnonswitchersonpages);
479 
480  static bool getEnclosingSwitcherFolder(
481  const PRM_Template *tplates,
482  const int index,
483  int &switcher, int &folder);
484 
485  // Returns the highest export level for any template in the list.
486  static PRM_Export getHighestExportLevel(
487  const PRM_Template *tplates);
488 
489  // Return whether our choicelist is the one used automatically when none
490  // is specified by the user.
491  bool isAutomaticallyGeneratedChoiceList() const;
492 
493  // Find the first folder, if any, with the specified label in a switcher
494  // template. Returns -1 if none exists.
495  int findSwitcherFolderWithLabel(
496  const char *label) const;
497 
498  unsigned int getAutoSelectField()
499  {
500  if (myAutoSelectField & (1<<(unsigned)myVectorSize))
501  setAutoSelectField();
502  return myAutoSelectField;
503  }
504 private:
505  void clearOurData();
506  void buildChannelNames() const;
507  void setAutoScopeField();
508  void setAutoSelectField();
509 
510  using PRM_DefaultPtr = UT_UniquePtr<PRM_Default>;
511 
512  PRM_Type myType;
513  PRM_MultiType myMultiType;
514  PRM_TypeExtended myTypeExtended;
515  int myVectorSize;
516  PRM_Name *myNamePtr;
518  PRM_Default *myFactoryDefaults;
519  PRM_ChoiceList *myChoiceListPtr;
520  PRM_Range *myRangePtr;
521  PRM_Callback myCallbackFunc;
522  PRM_SpareData *mySparePtr;
523  PRM_ConditionalBase *myConditionalPtr;
524  unsigned char myExportLevel;
525  unsigned char myParmGroup;
526  unsigned char myChoiceListOwnedByMe;
527  unsigned int myAutoScopeField;
528  unsigned int myAutoSelectField;
529  PRM_Template *myMultiParmTemplate;
530  fpreal myMultiSize;
531  UT_StringHolder myHelpText;
533  myChannelNames; // just a cache
534 };
535 
536 #endif
PRM_Default * getFactoryDefaults() const
Definition: PRM_Template.h:312
const char * getToken() const
Definition: PRM_Template.h:434
PRM_ChoiceList * getChoiceListPtr()
Definition: PRM_Template.h:245
PRM_Default * getDefault(int index)
Definition: PRM_Template.h:300
PRM_Template * getMultiParmTemplate()
Definition: PRM_Template.h:276
const PRM_Type & getType() const
Definition: PRM_Template.h:205
unsigned getTokenHash() const
Definition: PRM_Template.h:446
GLuint GLsizei const GLchar * label
Definition: glcorearb.h:2544
#define SYS_DEPRECATED(__V__)
bool hasChannelToken(const UT_StringRef &s, int vi) const
Definition: PRM_Template.h:408
PRM_Callback getCallback() const
Definition: PRM_Template.h:263
const UT_StringRef & getTokenRef() const
Definition: PRM_Template.h:438
PRM_SpareData * getSparePtr()
Definition: PRM_Template.h:216
const GLdouble * v
Definition: glcorearb.h:836
const PRM_Template * getMultiParmTemplate() const
Definition: PRM_Template.h:274
void setNamePtr(PRM_Name *name)
Definition: PRM_Template.h:213
PRM_Template & setConditionalBasePtr(PRM_ConditionalBase *conditional)
Definition: PRM_Template.h:227
const PRM_Conditional * getDisablePtr() const
Definition: PRM_Template.h:232
GLint level
Definition: glcorearb.h:107
unsigned int getAutoSelectField()
Definition: PRM_Template.h:498
png_uint_32 i
Definition: png.h:2877
void setExportLevel(PRM_Export level)
Definition: PRM_Template.h:356
PRM_API const PRM_Type PRM_TYPE_TOGGLE
void setCallback(PRM_Callback callback)
Definition: PRM_Template.h:264
const UT_StringHolder & getChannelToken(int vi) const
Definition: PRM_Template.h:396
PRM_Range * getRangePtr()
Definition: PRM_Template.h:262
long long int64
Definition: SYS_Types.h:107
const char * buffer() const
Definition: UT_String.h:503
void setSparePtr(PRM_SpareData *spare)
Definition: PRM_Template.h:219
const UT_StringHolder & getHelpText() const
Definition: PRM_Template.h:266
int getExpressionFlag() const
Definition: PRM_Template.h:427
bool getJoinNext() const
Definition: PRM_Template.h:345
void getChannelToken(UT_String &s, int vi) const
Definition: PRM_Template.h:380
const PRM_Range * getRangePtr() const
Definition: PRM_Template.h:261
unsigned int getAutoScopeField()
Definition: PRM_Template.h:267
#define UT_ASSERT_P(ZZ)
Definition: UT_Assert.h:125
static const UT_StringHolder theEmptyString
bool getInvisible() const
Definition: PRM_Template.h:342
const char * getLabel() const
Definition: PRM_Template.h:442
bool getLabelNone() const
Definition: PRM_Template.h:348
OPENVDB_API void initialize()
Global registration of basic types.
Definition: logging.h:318
GLuint const GLchar * name
Definition: glcorearb.h:785
PRM_API const PRM_Type PRM_TYPE_LABEL_NONE
void getToken(UT_String &thestrref) const
Definition: PRM_Template.h:418
void setFactoryDefaults(PRM_Default *defaults)
Definition: PRM_Template.h:316
PRM_MultiType getMultiType() const
Definition: PRM_Template.h:206
int getVectorSize() const
Definition: PRM_Template.h:211
PRM_TypeExtended getTypeExtended() const
Definition: PRM_Template.h:210
PRM_Conditional * getDisablePtr()
Definition: PRM_Template.h:230
const PRM_ConditionalBase * getConditionalBasePtr() const
Definition: PRM_Template.h:225
PRM_API const PRM_Type PRM_LIST_TERMINATOR
int findSubIndex(const UT_StringRef &thechannelname) const
Definition: PRM_Template.h:361
double fpreal
Definition: SYS_Types.h:270
const PRM_Name * getNamePtr() const
Definition: PRM_Template.h:215
PRM_ConditionalType
PRM_TypeExtended
Definition: PRM_Type.h:506
fpreal getMultiSize() const
Definition: PRM_Template.h:212
PRM_Export exportLevel() const
Definition: PRM_Template.h:354
PRM_API const PRM_Type PRM_TYPE_JOIN_NEXT
void setChoiceListPtr(PRM_ChoiceList *list)
Definition: PRM_Template.h:257
A smart pointer for unique ownership of dynamically allocated objects.
Definition: UT_UniquePtr.h:47
PRM_API const PRM_Type PRM_TYPE_ORDINAL
GLuint index
Definition: glcorearb.h:785
void setMultiParmTemplate(PRM_Template *tplate)
Definition: PRM_Template.h:278
GLint GLint GLsizei GLint GLenum GLenum type
Definition: glcorearb.h:107
const UT_StringHolder * getChannelTokens() const
Definition: PRM_Template.h:374
bool isRampType() const
const PRM_ChoiceList * getChoiceListPtr() const
Definition: PRM_Template.h:234
#define UT_ASSERT(ZZ)
Definition: UT_Assert.h:126
const PRM_SpareData * getSparePtr() const
Definition: PRM_Template.h:217
PRM_API const PRM_Type PRM_TYPE_INVISIBLE
int getParmGroup() const
Definition: PRM_Template.h:358
PRM_ConditionalBase * getConditionalBasePtr()
Definition: PRM_Template.h:223
#define PRM_API
Definition: PRM_API.h:10
void setTypeExtended(PRM_TypeExtended type_ext)
Definition: PRM_Template.h:351
void getLabel(UT_String &thestrref) const
Definition: PRM_Template.h:422
PRM_Name * getNamePtr()
Definition: PRM_Template.h:214
PRM_API PRM_ChoiceList PRMtoggleMenu
PRM_MultiType
This type enum defines the different types of multi (dynamic) parameters.
Definition: PRM_Type.h:417
GLenum src
Definition: glcorearb.h:1792
const PRM_Default * getDefault(int index) const
Definition: PRM_Template.h:306