HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
SHOP_Node.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: SHOP_Node.h ( SHOP Library, C++)
7  *
8  * COMMENTS: Shader OPs. These are nodes which collect all shading
9  * information for nodes into a nice compact encapsulation.
10  */
11 
12 #ifndef __SHOP_Node__
13 #define __SHOP_Node__
14 
15 #include "SHOP_API.h"
16 
17 #include "SHOP_ClerkCache.h"
18 #include "SHOP_Error.h"
19 
20 #include <OP/OP_Network.h>
21 #include <OP/OP_OperatorPair.h>
22 #include <IMG/IMG_Raster.h>
23 #include <UT/UT_Map.h>
24 
25 class UT_Options;
26 class OP_Operator;
27 class OP_OperatorTable;
28 class CH_LocalVariable;
29 class VOP_Language;
30 class SHOP_ReData;
31 class SHOP_Node;
32 class SHOP_Clerk;
34 
35 extern "C" {
37 }
38 
39 // Sub-class variables should start their local variables at SHOP_VAR_MAX_BASE
40 enum {
44 };
45 
46 #include "SHOP_NodeTypes.h"
47 
48 #define SHOP_RENDERTYPE_OPTION "rendertype"
49 #define SHOP_FPRECISION_OPTION "soho_precision"
50 #define SHOP_DEFAULT_CLERK "VMantra"
51 
53 {
54 public:
55  SHOP_Node(OP_Network *dad, const char *name,
56  OP_Operator *entry, SHOP_TYPE shader_type=SHOP_SURFACE);
57  ~SHOP_Node() override;
58 
60  static CH_LocalVariable myVariableList[];
61 
62  /// Returns the list of obsolete parameters.
63  static PRM_Template *getObsolete(SHOP_TYPE type);
64 
65  const UT_String &getRenderMask() const { return myRenderMask; }
66 
67  virtual int getFirstParameter();
68  virtual int getLastParameter();
69 
70  bool runCreateScript() override;
71  void onCreated() override;
72 
73  // The options may contain:
74  // rendertype: The the shader for a specific renderer
75  virtual SHOP_Node *findShader(SHOP_TYPE shop_type, fpreal now,
76  const UT_Options *options);
77 
78  /// Returns true if the shop node provides a shader for a given shop_type.
79  virtual bool matchesShaderType(SHOP_TYPE shop_type);
80 
81  // Collect all shaders of the specific type which are hooked up.
82  // The return code is the number of shaders in the list.
83  virtual int collectShaders(UT_ValArray<SHOP_Node *>&list,
84  SHOP_TYPE shop_type,
85  fpreal now, const UT_Options *options);
86 
87  /// Returns true if co-shader parameters may have corresponding node inputs.
88  bool canHaveInputsForCoshaderParms() const;
89 
90  /// Returns the langauge used by this shop.
91  const VOP_Language *getLanguage() const;
92 
93  /// Collect all coshader parameter names on this node.
94  /// If is_coshader_array is not null, the bits are set for parms
95  /// that are coshader arrays (rather than just a co-shader).
96  void gatherCoShaderParmNames(UT_StringArray& coshaderparms,
97  UT_BitArray *is_coshader_array);
98 
99  /// Gets the input node corresponding to the given co-shader parameter.
100  SHOP_Node * getCoShaderInputNode(const char* parm_name);
101 
102  /// Obtain the coshader node(s) specified by the given parameter.
103  /// If there is an input node wired to the connector corresponding to
104  /// this parm, then it is used for constructing the list, otherwise,
105  /// parameter is evaluated and the op path is used for the list.
106  /// For parameters representing a single co-shader, the list will
107  /// contain zero or one entries (ie, the input node or node in parm path),
108  /// but for parameters representing co-shader arrays, the list may contain
109  /// more than one entry (eg, merge shop input would build a larger array).
110  void getCoShaderNodes(UT_ValArray<SHOP_Node *>&list,
111  const char* parm_name,
112  fpreal now, const UT_Options *options);
113 
114  /// Represents this shop as a coshader list. Usually just a single entry,
115  /// but some shops add several entries (eg, merge co-shaders shop).
116  virtual void representAsCoShader(UT_ValArray<SHOP_Node *>&list);
117 
118  /// Collect coshader nodes for this shop's shader of a given type.
119  virtual void gatherCoShaderNodes(UT_ValArray<SHOP_Node *>&list,
120  SHOP_TYPE main_shader_type,
121  fpreal now, const UT_Options *options);
122 
123  virtual int getInputTileLOD() const;
124  virtual int getOutputTileLOD() const;
125  virtual bool isInputVisible(int idx) const;
126  virtual bool isOutputVisible(int idx) const;
127 
128  virtual SHOP_Node *getOutputNode() const;
129  void getInputName(UT_String &name, int idx) const override;
130  int getInputFromName(const UT_String &in) const override;
131  virtual SHOP_TYPE getInputType(int idx) const;
132  void getOutputName(UT_String &name, int idx) const override;
133  int getOutputFromName(const UT_String &out) const override;
134  virtual SHOP_TYPE getOutputType(int idx) const;
135 
136  void saveDialogScriptExtraInfo(std::ostream &os) override;
137  void createGalleryEntry(OP_GalleryEntry &entry) override;
138 
140  { return myVisibleInputs; }
142  { return myVisibleOutputs; }
143 
144  // This is only called from a Clerk to find out the shader name (when
145  // building the render data). Note that the returned pointer may become
146  // invalidated, so make a copy of the data if it must be kept around.
147  virtual UT_StringHolder
148  getShaderName(bool forvex, SHOP_TYPE shoptype) const;
149  virtual SHOP_TYPE getShaderType() const;
150  bool evalVariableValue(fpreal &v, int idx,
151  int thread) override
152  { return OP_Network::evalVariableValue(v, idx, thread); }
153  bool evalVariableValue(UT_String &str, int idx,
154  int thread) override;
155 
158  const CH_ChannelList &channels) override;
161  PRM_ParmNameMap &nmap,
162  UT_String &errors) override;
163 
164  static void pushCallers(OP_Node *obj, OP_Node *sop);
165  static void popCallers();
166 
167  /// Obtain a clerk that matches the shop type of this node and the render
168  /// type. If the shop type of this node is multi-type, then the method
169  /// argument is used to interpret the multi type as a specific shop type,
170  /// which is then used to match the clerk.
171  SHOP_Clerk *getClerk(const char *rendertype,
172  SHOP_TYPE interpret_type = SHOP_INVALID );
173  SHOP_Clerk *getAnyClerk(bool only_string_generators);
174 
176  fpreal t,
177  OP_Node *parent,
178  UT_Map<int, bool> *visitlist) override;
180  fpreal t,
181  DEP_MicroNode *depnode,
182  UT_Map<int, bool> *visitlist) override;
183 
184  virtual bool buildShaderString(UT_String &result, fpreal now,
185  const UT_Options *options, OP_Node *obj=0, OP_Node *sop=0,
186  SHOP_TYPE interpret_type = SHOP_INVALID);
187  virtual bool buildShaderHandle(UT_String &result, fpreal now,
188  const UT_Options *options, OP_Node *obj=0, OP_Node *sop=0,
189  SHOP_TYPE interpret_type = SHOP_INVALID);
190  virtual bool buildShaderLanguage(UT_String &result, fpreal now,
191  const UT_Options *options, OP_Node *obj=0, OP_Node *sop=0,
192  SHOP_TYPE interpret_type = SHOP_INVALID);
193  virtual bool buildShaderData(SHOP_ReData &data, fpreal now,
194  const UT_Options *options, OP_Node *obj=0, OP_Node *sop=0,
195  SHOP_TYPE interpret_type = SHOP_INVALID);
196  virtual bool buildShaderBounds(UT_BoundingBox &box, fpreal now,
197  const UT_Options *options, OP_Node *obj=0, OP_Node *sop=0,
198  SHOP_TYPE interpret_type = SHOP_INVALID);
199  virtual bool buildCoShaderStrings(UT_StringArray &result,OP_NodeList &shops,
200  fpreal now, const UT_Options *options,
201  OP_Node *obj=0, OP_Node *sop=0,
202  SHOP_TYPE interpret_type = SHOP_INVALID);
203  virtual bool buildCoShaderHandles(UT_StringArray &result, fpreal now,
204  const UT_Options *options, OP_Node *obj=0, OP_Node *sop=0,
205  SHOP_TYPE interpret_type = SHOP_INVALID);
206  virtual bool buildCoShaderLanguages(UT_StringArray &result, fpreal now,
207  const UT_Options *options, OP_Node *obj=0, OP_Node *sop=0,
208  SHOP_TYPE interpret_type = SHOP_INVALID);
209 
210  /// Build a shader string for a VOP node. If the VOP isn't a code creator,
211  /// the code creator parent of the VOP will have its string generated.
212  virtual bool buildVopShaderString(VOP_Node *vop,
213  UT_String &result, fpreal now,
214  const UT_Options *options,
215  OP_Node *obj, OP_Node *sop,
216  SHOP_TYPE interpret_type = SHOP_INVALID);
217 
218  /// Returns the shader types this shop outputs.
219  virtual void getOutputShaderTypes(UT_Array<SHOP_TYPE> & types);
220 
221  static void buildShaderTable(OP_OperatorTable &table);
222  static void initializeExpressions();
223  static OP_Operator *getManagementOperator();
224  static OP_Operator *getMaterialManagementOperator();
225 
226  // Convenience error methods
227  void addError(int code, const char *msg = 0)
228  { UTaddError("SHOP", code, msg);}
229  void addMessage(SHOP_ErrorCode code, const char *msg = 0)
230  { UTaddMessage("SHOP", code, msg);}
231  void addWarning(SHOP_ErrorCode code, const char *msg = 0)
232  { UTaddWarning("SHOP", code, msg);}
233  void addFatal(SHOP_ErrorCode code, const char *msg = 0)
234  { UTaddFatal("SHOP", code, msg);}
235  void addSystemError(const char *msg = 0)
236  { UTaddSystemError(msg);}
237  void addCommonError(UT_CommonErrorCode what, const char *msg = 0)
238  { UTaddCommonError(what, msg);}
239 
240  bool containsShopType(SHOP_TYPE type) const;
241  void bumpContainedType(SHOP_TYPE type, int dir);
242 
243  int getOGLScriptCacheState() const { return myOGLScriptCache; }
245  const char *vtxsrc, const char *geomsrc,
246  const char *fragsrc)
247  { myOGLScriptCache = val;
248  myOGLVtxSource.harden(vtxsrc);
249  myOGLGeomSource.harden(geomsrc);
250  myOGLFragSource.harden(fragsrc);
251  myOGLProgram.clear();
252  }
254  const char *program_file)
255  { myOGLScriptCache = enable ? 1 : -1;
256  myOGLVtxSource.clear();
257  myOGLGeomSource.clear();
258  myOGLFragSource.clear();
259  myOGLProgram.harden(program_file);
260  }
261  const char *getOGLVtxSource() const
262  { return (const char *) myOGLVtxSource; }
263  const char *getOGLGeomSource() const
264  { return (const char *) myOGLGeomSource; }
265  const char *getOGLFragSource() const
266  { return (const char *) myOGLFragSource; }
267 
268  const char *getOGLShaderProgram() const
269  { return (const char *) myOGLProgram; }
270 
271  // The following evaluator will evaluate the string parameter. However, it
272  // will also perform any bundle pattern expansion, or matrix evaluation
273  // based on the PRM_SpareData.
274  // The quoted bool returns whether the result should be considered to be a
275  // string (or whether it's another data type).
276  void evalStringParm(UT_String &result,
277  const char *parm_name,
278  int vector_index, fpreal now,
279  const PRM_Template *tplate,
280  bool &quoted,
281  const char *rtype, int fprecision);
282 
283  // Standard OP Network methods
284  static const char *theChildTableName;
285  const char *getChildType() const override;
286  const char *getOpType() const override;
287 
288  OP_OpTypeId getChildTypeID() const override;
289  OP_OpTypeId getOpTypeID() const override;
290 
291  // Absolute Width
292  fpreal getW() const override;
293  // Absolute Height
294  fpreal getH() const override;
295 
296  // SHOP Parameter Evaluation with options.
297  bool evalShopParameter(const char *name, int vec_idx,
298  fpreal now, int &value,
299  const UT_Options *options,
300  bool add_cook_dependency=false);
301  bool evalShopParameter(const char *name, int vec_idx,
302  fpreal now, fpreal &value,
303  const UT_Options *options,
304  bool add_cook_dependency=false);
305  bool evalShopParameter(const char *name, int vec_idx,
306  fpreal now, UT_String &value,
307  const UT_Options *options,
308  bool add_cook_dependency=false);
309 
310  // Overrides of OP_Node methods specific to materials
312  { return &myMaterialIconFilename; }
313  void setMaterialIconFilename(const char *icon_file) override
314  { myMaterialIconFilename.harden(icon_file); }
315 
317  { return &myMaterialIconImage; }
318 
320  { return myAllowIconRegeneration; }
321  void setMaterialIconAllowRegenerateFlag(bool allow) override
322  { myAllowIconRegeneration = allow; }
323 
324  virtual SHOP_TYPE getNamedInputType(
325  const OP_ConnectorId& input_name) const;
326  virtual SHOP_TYPE getNamedOutputType(
327  const OP_ConnectorId& output_name) const;
328 
329  /// Returns a procedural shader node of a given type, if the shop
330  /// indeed has such a node. Returns NULL otherwise.
331  virtual VOP_Node * getProcedural(VOP_Type type);
332 
333 protected:
334  const PRM_Template *getShaderParmTemplates() override;
335 
336  // Standard OP Node methods
337  int getDataClass() const override;
338  OP_ERROR cookMe(OP_Context &) override;
339  OP_ERROR bypassMe(OP_Context &, int &) override;
340  const char *getFileExtension(int binary) const override;
341 
342  OP_DataType getCookedDataType() const override;
343  void deleteCookedData() override;
344  int saveCookedData(const char *, OP_Context &) override;
345  int saveCookedData(std::ostream &, OP_Context &,
346  int) override;
347 
348  bool cookedDataUsesAllParameters() const override
349  { return true; }
350  bool cookedDataNeedsErrors() const override
351  { return true; }
352 
353  /// Disable parms whose corresponding input connectors are wired in.
354  bool updateParmsFlags() override;
355 
356  // Regenerates the visible inputs and outputs arrays.
357  virtual void updateVisibleInputsAndOutputs();
358 
359  // This method will expand the pattern specified, possibly generating a
360  // bundle for expansion.
361  void resolveParmBundle(const char *parm_name,
362  int vector_index,
364  OP_Network *creator,
365  const char *filter,
366  bool expand_fullpath = false);
367 
368  // Instead of simply getting the node wired into the input specified, we
369  // also get the output number which it's wired from.
370  SHOP_Node *getFullInput(int input_idx, int &output_idx) const;
371 
372  void setShaderType(SHOP_TYPE t);
373 
374  /// Checks if the options specify a render mask that limit
375  /// the types of nodes that can be returned by findShader().
376  /// Returns this object if no clerk name is specified or if
377  /// the node maches the specified clerk. Otherwise, returns NULL.
378  SHOP_Node * checkRenderMask( const UT_Options *options);
379 
380  bool renderMatch(const char *rendertype) const;
381  bool renderMatch(const SHOP_Clerk &clerk) const;
382 
383  int myContainedShops[SHOP_MAX_TYPES];
385 
391 
394 
398 
399 private:
400  // This is overriden to selectively save nodes for compiled assets.
401  bool getAllowSavingChild(OP_Node *node,
402  const OP_SaveFlags &flags) override;
403 
404  static void installCommands();
405 
406  SHOP_TYPE myShaderType;
407 };
408 
409 // ============================================================================
411 {
412 public:
414  : myObject(obj)
415  , mySop(sop)
416  {
417  if (myObject || mySop)
418  SHOP_Node::pushCallers(obj, sop);
419  }
421  {
422  if (myObject || mySop)
424  }
425 
426 private:
427  OP_Node *myObject;
428  OP_Node *mySop;
429 };
430 
431 // ============================================================================
432 /// Filter used by material vop containers.
434 {
435 public:
436  void setContextName(const UT_StringHolder &context);
437  bool allowOperatorAsChild(OP_Operator *op) override;
438 
439 private:
440  UT_StringHolder myContextName;
441 };
442 
443 
444 #endif
virtual int saveCookedData(std::ostream &os, OP_Context &, int binary=0)=0
Reprsents a language for which VOPs can generate source code.
Definition: VOP_Language.h:27
void addCommonError(UT_CommonErrorCode what, const char *msg=0)
Definition: SHOP_Node.h:237
virtual void createGalleryEntry(OP_GalleryEntry &entry)
int getOGLScriptCacheState() const
Definition: SHOP_Node.h:243
static void pushCallers(OP_Node *obj, OP_Node *sop)
virtual void buildVexScript(UT_String &script, fpreal t, OP_Node *owner, UT_Map< int, bool > *visitlist=0)
GT_API const UT_StringHolder selection
virtual bool updateParmsFlags()
void addWarning(SHOP_ErrorCode code, const char *msg=0)
Definition: SHOP_Node.h:231
fpreal getH() const override
Node position/scale is used by the UI.
void setMaterialIconAllowRegenerateFlag(bool allow) override
Definition: SHOP_Node.h:321
fpreal getW() const override
Node position/scale is used by the UI.
virtual void getInputName(UT_String &in, int idx) const
GLuint const GLchar * name
Definition: glew.h:1814
Unsorted map container.
Definition: UT_Map.h:83
#define SYS_VISIBILITY_EXPORT
GLuint const GLfloat * val
Definition: glew.h:2794
SHOP_AutoPushCallers(OP_Node *obj, OP_Node *sop)
Definition: SHOP_Node.h:413
virtual OP_OpTypeId getOpTypeID() const =0
virtual bool createSpareParametersForLoad(UT_StringArray &, PRM_ParmNameMap &, UT_String &)
UT_API UT_ErrorSeverity UTaddFatal(const char *type, int code, const char *msg=0, const UT_SourceLocation *loc=0)
GLenum GLsizei GLenum GLenum const void * table
Definition: glew.h:4940
GLenum GLsizei GLsizei GLsizei GLsizei GLbitfield flags
Definition: glew.h:2864
static const char * theChildTableName
Definition: SHOP_Node.h:284
UT_String myOGLGeomSource
Definition: SHOP_Node.h:388
Filter used by material vop containers.
Definition: SHOP_Node.h:433
const UT_IntArray & getVisibleOutputs() const
Definition: SHOP_Node.h:141
bool cookedDataUsesAllParameters() const override
Definition: SHOP_Node.h:348
UT_ErrorSeverity
Definition: UT_Error.h:25
const char * getOGLGeomSource() const
Definition: SHOP_Node.h:263
virtual int getDataClass() const
const GLdouble * v
Definition: glew.h:1391
GLhandleARB obj
Definition: glew.h:6236
void addMessage(SHOP_ErrorCode code, const char *msg=0)
Definition: SHOP_Node.h:229
UT_IntArray myVisibleInputs
Definition: SHOP_Node.h:392
UT_API UT_ErrorSeverity UTaddMessage(const char *type, int code, const char *msg=0, const UT_SourceLocation *loc=0)
SYS_VISIBILITY_EXPORT void newShopOperator(OP_OperatorTable *)
UT_API UT_ErrorSeverity UTaddSystemError(const char *msg=0)
virtual OP_ERROR cookMe(OP_Context &context)=0
virtual bool getAllowSavingChild(OP_Node *node, const OP_SaveFlags &flags)
Returns true if the child at node can should be saved, false otherwise.
Definition: OP_Network.h:902
bool cookedDataNeedsErrors() const override
Definition: SHOP_Node.h:350
GLsizei GLenum GLenum * types
Definition: glew.h:3954
UT_String myOGLFragSource
Definition: SHOP_Node.h:389
virtual void saveDialogScriptExtraInfo(std::ostream &os)
#define SHOP_API
Definition: SHOP_API.h:10
UT_IntArray myVisibleOutputs
Definition: SHOP_Node.h:393
GLint GLint GLint GLint GLint GLint GLint GLbitfield GLenum filter
Definition: glew.h:2981
virtual const char * getOpType() const =0
const char * getOGLShaderProgram() const
Definition: SHOP_Node.h:268
GLuint in
Definition: glew.h:11510
void setMaterialIconFilename(const char *icon_file) override
Definition: SHOP_Node.h:313
GLint GLenum GLsizei GLint GLsizei const void * data
Definition: glew.h:1379
int myOGLScriptCache
Definition: SHOP_Node.h:386
SHOP_ErrorCode
Definition: SHOP_Error.h:14
SHOP_TYPE
const GLuint GLenum const void * binary
Definition: glew.h:3502
UT_String myMaterialIconFilename
Definition: SHOP_Node.h:395
GLuint const GLuint * names
Definition: glew.h:2690
virtual int getOutputFromName(const UT_String &out) const
UT_String * getMaterialIconFilename() override
Definition: SHOP_Node.h:311
OP_OpTypeId
Definition: OP_OpTypeId.h:18
*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
UT_String myOGLVtxSource
Definition: SHOP_Node.h:387
const char * getOGLVtxSource() const
Definition: SHOP_Node.h:261
GLuint GLuint GLsizei GLenum type
Definition: glew.h:1253
virtual OP_DataType getCookedDataType() const =0
bool myAllowIconRegeneration
Definition: SHOP_Node.h:397
UT_API UT_ErrorSeverity UTaddCommonError(UT_CommonErrorCode what, const char *msg=0)
virtual bool createSpareParametersFromChannels(UT_BitArray &selection, const CH_ChannelList &channels)
IMG_Raster * getMaterialIconImage() override
Definition: SHOP_Node.h:316
void addSystemError(const char *msg=0)
Definition: SHOP_Node.h:235
UT_CommonErrorCode
Definition: UT_Error.h:42
virtual const char * getChildType() const
A map of string to various well defined value types.
Definition: UT_Options.h:84
virtual const char * getFileExtension(int binary) const =0
const UT_IntArray & getVisibleInputs() const
Definition: SHOP_Node.h:139
UT_String myOGLProgram
Definition: SHOP_Node.h:390
fpreal64 fpreal
Definition: SYS_Types.h:277
bool evalVariableValue(fpreal &v, int idx, int thread) override
Definition: SHOP_Node.h:150
UT_String myRenderMask
Definition: SHOP_Node.h:384
UT_API UT_ErrorSeverity UTaddWarning(const char *type, int code, const char *msg=0, const UT_SourceLocation *loc=0)
virtual bool allowOperatorAsChild(OP_Operator *)
Definition: OP_Network.h:112
virtual int getInputFromName(const UT_String &in) const
VOP_Type
Definition: VOP_Types.h:24
OP_DataType
Definition: OP_DataTypes.h:28
virtual OP_OpTypeId getChildTypeID() const =0
virtual bool runCreateScript()
virtual bool evalVariableValue(UT_String &val, int index, int thread)
void setOGLScriptCache(int val, const char *vtxsrc, const char *geomsrc, const char *fragsrc)
Definition: SHOP_Node.h:244
GLuint64EXT * result
Definition: glew.h:14007
static void popCallers()
bool getMaterialIconAllowRegenerateFlag() override
Definition: SHOP_Node.h:319
virtual void getOutputName(UT_String &out, int idx) const
void setOGLShaderProgram(bool enable, const char *program_file)
Definition: SHOP_Node.h:253
GLubyte * pattern
Definition: glew.h:5711
const char * getOGLFragSource() const
Definition: SHOP_Node.h:265
void addFatal(SHOP_ErrorCode code, const char *msg=0)
Definition: SHOP_Node.h:233
GLsizei const GLfloat * value
Definition: glew.h:1849
void addError(int code, const char *msg=0)
Definition: SHOP_Node.h:227
virtual OP_ERROR bypassMe(OP_Context &context, int &copied_input)=0
GLboolean enable
Definition: glew.h:2745
GLdouble GLdouble t
Definition: glew.h:1398
static OP_VariablePair myVariablePair
Definition: SHOP_Node.h:59
virtual const PRM_Template * getShaderParmTemplates()
const UT_String & getRenderMask() const
Definition: SHOP_Node.h:65
UT_API UT_ErrorSeverity UTaddError(const char *type, int code, const char *msg=0, const UT_SourceLocation *loc=0)
ImageBuf OIIO_API channels(const ImageBuf &src, int nchannels, cspan< int > channelorder, cspan< float > channelvalues={}, cspan< std::string > newchannelnames={}, bool shuffle_channel_names=false, int nthreads=0)
virtual void onCreated()
Overriden in VOPs.
Definition: OP_Node.h:2982
virtual void deleteCookedData()=0
IMG_Raster myMaterialIconImage
Definition: SHOP_Node.h:396