12 #ifndef __ROP_Node_h__
13 #define __ROP_Node_h__
29 class ROP_ExecuteContext;
82 #define FLT_PARM(name, vi, t) \
83 { return evalFloat(name, vi, t); }
84 #define FLT_SET(name, vi, t, val) \
85 { setFloat(name, vi, t, val); }
86 #define INT_SET(name, vi, t, val) \
87 { setInt(name, vi, t, val); }
89 #define INT_PARM(name, vi, t) \
90 { return evalInt(name, vi, t); }
92 #define INT_SET(name, vi, t, val) \
93 { setInt(name, vi, t, val); }
95 #define STR_PARM(name, vi, t) \
96 { evalString(str, name, vi, t); }
100 class ROP_SohoOutput;
126 virtual ROP_IFD *castToROPIFD();
127 virtual ROP_IFDBase *castToROPIFDBase();
128 virtual ROP_SohoOp *castToROPSoho();
129 virtual ROP_OpenGL *castToROPOpenGL();
131 virtual bool hasImageOutput();
134 virtual bool detectIfExistingOutputFiles();
136 virtual void deleteExistingOutputFiles();
147 static void initSimulationOPs();
160 const char *relative_path = NULL)
override;
166 ROP_SohoOutput *out=0,
167 bool generate=
false);
183 { myExecuteOverride =
f;
184 myExecuteOverrideData = d;
187 { myPreExecuteOverride =
f;
188 myPreExecuteOverrideData = d;
191 { myPostExecuteOverride =
f;
192 myPostExecuteOverrideData = d;
212 void setRenderResX(
int x);
213 void setRenderResY(
int y);
216 void setRenderAspect(
float aspect);
217 float getRenderAspect();
223 {
INT_SET(
"trange", 0, 0, val) }
226 if(myOverrideFrameRangeFlag)
229 return myCachedDoRange;
234 if(myOverrideFrameRangeFlag)
235 return myOverrideStartFrame;
237 return myCachedStart;
241 if(myOverrideFrameRangeFlag)
242 return myOverrideEndFrame;
249 if(myOverrideFrameRangeFlag)
250 return myOverrideFrameInc;
256 static int doRenderCback(
void *
data,
int index,
260 static int doRenderBackgroundCback(
void *
data,
int index,
263 static int doRenderDialog(
void *
data,
int index,
272 bool executePreRenderScript(
fpreal ttime);
273 bool executePreFrameScript(
fpreal ttime);
274 bool executePostFrameScript(
fpreal ttime);
275 bool executePostWriteScript(
fpreal ttime);
276 bool executePostRenderScript(
fpreal ttime);
277 bool executeIPRStopScript(
fpreal ttime);
279 static void buildRibVersionMenu(
PRM_Name *menu,
int max,
280 bool for_archive=
false);
294 virtual void initRenderDependencies();
295 virtual void cleanupRenderDependencies();
297 void addJobFrames(
const char *job_name,
298 const char *frame_string);
300 static void setDependencyRenderFlag(
bool f);
301 static bool getDependencyRenderFlag();
303 static void setFrameByFrameFlag(
bool f);
304 static bool getFrameByFrameFlag();
306 static void setRenderScriptFlag(
bool enable);
307 static bool getRenderScriptFlag();
309 static void setOutputResolutionScale(
fpreal xscale,
fpreal yscale);
310 static void getOutputResolutionScale(
float &xs,
float &ys);
313 { x = y = 0;
return false; }
317 static void setRenderQuality(
int quality);
318 int getRenderQuality();
321 void overrideFrameRange(
bool enable,
328 {
return myOverrideOutputFlag; }
332 virtual void overrideOutput(
bool enable,
const char *fname=0);
336 bool getOutputOverride(
339 bool expand =
true)
const;
349 bool getOutputOverrideEx(
352 const char *output_parm_name,
353 const char *mkdir_parm_name);
355 virtual void overrideDevice(
bool enable,
bool interactive=
false,
356 const char *devicestr=0);
358 bool expand =
true)
const;
376 { myForceBackgroundRender =
f; }
378 {
return myForceBackgroundRender; }
382 { myTemporaryInputs =
in; }
400 {
return myLastRenderItem; }
404 virtual bool isRenderDependentOnNode(
ROP_Node *node,
407 static void setColorCorrectionIPGamma(
bool enable,
fpreal gamma);
408 static fpreal getColorCorrectionIPGamma();
409 static void setColorCorrectionIPLUT(
bool enable,
const char *lut);
410 static const char *getColorCorrectionIPLUT();
412 static void setColorCorrectionEnvVariables(
bool set);
413 static void setFPSVariable(
bool do_set = 0,
fpreal frame_inc = 1);
425 int &copied_input)
override;
447 virtual int startRender(
int nframes,
fpreal tstart,
454 TAKE_Take *applyRenderTake(
const char *take);
455 void restorePreviousTake(
TAKE_Take *take);
457 void initRenderDependencyVars(
fpreal t);
458 virtual void doInitRenderDependencyVars(
fpreal t);
462 virtual void buildInputRenderDependencies(
465 bool matchingLastRenderParms(
468 { myLastRenderItem = item; }
469 void clearLastRenderDep();
482 {
INT_SET(
"trange", 0, 0, val); }
501 {
return myVerbose; }
503 {
return myVerbose.getStream(); }
505 {
return myVerbose.getAlfred(); }
534 {
return myTemporaryInputs.entries(); }
537 {
return myTemporaryInputs(i); }
558 static void resetSimulation(
OP_Node* node);
560 ROP_ExecuteContext *myEContext;
563 void *myExecuteOverrideData;
565 void *myPreExecuteOverrideData;
567 void *myPostExecuteOverrideData;
569 bool myForceBackgroundRender;
571 bool myOverrideFrameRangeFlag;
572 fpreal myOverrideStartFrame;
573 fpreal myOverrideEndFrame;
574 fpreal myOverrideFrameInc;
576 bool myOverrideOutputFlag;
579 bool myOverrideDeviceFlag;
587 bool executeParmScript(
const char *parm_name,
589 bool executeParmScripts(
const char *parm_name,
595 static void installCommands();
608 myFullFrameInc(0.0
f),
613 myIgnoreBypass(true),
614 myIgnoreLocks(false),
619 myFirstFrameFlag(true) { }
638 { myFullStart =
start; myFullEnd =
end; myFullFrameInc = finc; }
640 { myStart =
start; myEnd =
end; myFrameInc = finc; }
652 fpreal finc = myFullFrameInc;
679 myIgnoreBypass = ignore_bypass;
680 myIgnoreLocks = ignore_locks;
687 { myRenderSerial = render_serial; }
692 { myDepParent = dep_parent; }
703 myOrder = copy.myOrder;
704 myDepParent = copy.myDepParent;
705 myTopLevelRop = copy.myTopLevelRop;
706 myFullStart = copy.myFullStart;
707 myFullEnd = copy.myFullEnd;
708 myFullFrameInc = copy.myFullFrameInc;
709 myStart = copy.myStart;
711 myFrameInc = copy.myFrameInc;
712 myRenderSerial = copy.myRenderSerial;
713 myDoInputs = copy.myDoInputs;
714 myIgnoreBypass = copy.myIgnoreBypass;
715 myIgnoreLocks = copy.myIgnoreLocks;
716 myFrameMerge = copy.myFrameMerge;
717 myFirstFrameFlag = copy.myFirstFrameFlag;
722 return (myFullStart == copy.myFullStart &&
723 myFullEnd == copy.myFullEnd &&
724 myFullFrameInc == copy.myFullFrameInc &&
725 myStart == copy.myStart &&
726 myEnd == copy.myEnd &&
727 myFrameInc == copy.myFrameInc &&
728 myDoInputs == copy.myDoInputs &&
729 myIgnoreBypass == copy.myIgnoreBypass &&
730 myIgnoreLocks == copy.myIgnoreLocks &&
731 myFrameMerge == copy.myFrameMerge &&
732 myRenderSerial == copy.myRenderSerial);
750 bool myFirstFrameFlag;
virtual int saveCookedData(std::ostream &os, OP_Context &, int binary=0)=0
bool isOutputOverridden() const
fpreal getFullFrameInc() const
virtual bool updateParmsFlags()
void setDepParent(const ROP_RenderItemHandle &dep_parent)
void setOrder(ROP_RenderList &order)
static const char * theChildTableName
fpreal getH() const override
Node position/scale is used by the UI.
virtual void getOutputFile(UT_String &)
fpreal getW() const override
Node position/scale is used by the UI.
GLuint GLdouble GLdouble GLint GLint order
void addMessage(int code, const char *msg=0)
virtual void FSTART_SET(fpreal val)
void setFullFrameRange(fpreal start, fpreal end, fpreal finc)
#define SYS_VISIBILITY_EXPORT
virtual void FINC_SET(fpreal val)
GT_API const UT_StringHolder time
virtual void FEND_SET(fpreal val)
const GLuint GLenum const void * binary
void setExecuteOverride(ROP_ExecuteOverride f, void *d)
GLsizei const GLchar *const * path
void addSystemError(const char *msg=0)
bool isFirstFrame() const
Parameters for OP_Node::getInfoText()/OP_Node::getNodeSpecificInfoText()
OP_VERSION myCachedVersion
bool evalVariableValue(UT_String &v, int index, int thread) override
ROP_RenderItemHandle getLastRenderDepItem() const
GLuint const GLchar * name
void clearTemporaryInputs()
virtual void getNodeSpecificInfoText(OP_Context &context, OP_NodeInfoParms &parms)
virtual void SETDORANGE(int val)
virtual OP_ERROR cookMe(OP_Context &context)=0
void setRenderSerial(int render_serial)
fpreal getFullEnd() const
std::ostream * getVerbose() const
void setFirstFrame(bool first)
void setDoInputsFlag(bool do_inputs)
const ROP_RenderDepParms & operator=(const ROP_RenderDepParms ©)
void setLastRenderDepItem(ROP_RenderItemHandle item)
ROP_RenderDepParms(const ROP_RenderDepParms ©)
ROP_RenderMode getRenderMode()
virtual const char * getInteractiveImageDevice() const
virtual void DORANGE_SET(int val)
virtual void RENDER_TAKE(UT_String &take)
void forceBackgroundRender(bool f=true)
ROP_Node * getTopLevelRop() const
void evalString(UT_String &val, int pi, int vi, fpreal t) const
virtual void * getCookedData(OP_Context &)
ImageBuf OIIO_API max(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
void setFullAscendingFrameRange(ROP_Node &rop)
virtual bool getOutputResolution(int &x, int &y)
bool getForceBackgroundRender() const
void addWarning(int code, const char *msg=0)
#define FLT_SET(name, vi, t, val)
ROP_Node * getTemporaryInputs(int i) const
void copyErrorsInto(UT_ErrorManager &error_manager)
void addError(int code, const char *msg=0)
void(* ROP_ExecuteOverride)(ROP_Node *me, fpreal time, void *data)
#define INT_SET(name, vi, t, val)
virtual bool referenceSingleParameter(OP_Parameters *from, int parm_idx, const char *relative_path=NULL)
fpreal getFrameInc() const
const ROP_RenderItemHandle & getDepParent() const
virtual OP_DataType getCookedDataType() const =0
bool operator==(const ROP_RenderDepParms ©)
virtual OP_OpTypeId getOpTypeID() const
int getNumTemporaryInputs() const
void setFrameRange(fpreal start, fpreal end, fpreal finc)
void setTemporaryInputs(const UT_ValArray< ROP_Node * > &in)
void setPreExecuteOverride(ROP_ExecuteOverride f, void *d)
int stealErrors(UT_ErrorManager &victim, int rangestart=0, int rangeend=-1, UT_ErrorSeverity severity=UT_ERROR_NONE, bool borrow_only=false)
fpreal getFullStart() const
virtual const char * getChildType() const
**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
void setExecuteContext(ROP_ExecuteContext *c)
bool getIgnoreBypass() const
virtual const char * getFileExtension(int binary) const =0
Parameters for OP_Node::fillInfoTree()/OP_Node::fillInfoTreeNodeSpecific()
void setIgnoreFlags(bool ignore_bypass, bool ignore_locks)
virtual void fillInfoTreeNodeSpecific(UT_InfoTree &tree, const OP_NodeInfoTreeParms &parms)
ROP_RenderList & getOrder() const
void copyErrorsFrom(UT_ErrorManager &error_manager)
File options for manipulating image data on load or save. This class allows you to modify the incomin...
void setFrameMerge(bool merge)
OIIO_API bool copy(string_view from, string_view to, std::string &err)
virtual const char * getOpType() const
void(* ROP_RenderButtonCB)(ROP_Node *, ROP_RenderMode)
ROP_ExecuteContext * getExecuteContext()
ROP_RenderMode myRenderMode
A global error manager scope.
virtual OP_OpTypeId getChildTypeID() const =0
**If you just want to fire and args
virtual bool evalVariableValue(UT_String &val, int index, int thread)
void setTopLevelRop(ROP_Node *rop)
bool getIgnoreLocks() const
ROP_Verbose & getRopVerbose()
void inputConnectChanged(int which) override
bool getFrameMerge() const
void setRenderMode(ROP_RenderMode mode)
virtual bool isPreviewAllowed()
Override if preview is supported by rendering to 'ip'.
SYS_VISIBILITY_EXPORT void newDriverOperator(OP_OperatorTable *table)
virtual bool getGeometryHandle(const char *path, fpreal t, GU_DetailHandle &gdh, UT_DMatrix4 &world_xform)
virtual OP_ERROR bypassMe(OP_Context &context, int &copied_input)=0
UT_LockedRawPtr< UT_ErrorManager, OP_Lock > getLockedErrorManager()
GLenum GLsizei GLenum GLenum const void * table
void setPostExecuteOverride(ROP_ExecuteOverride f, void *d)
virtual void onCreated()
Overriden in VOPs.
int getRenderSerial() const
virtual void deleteCookedData()=0