12 #ifndef __ROP_Node_h__
13 #define __ROP_Node_h__
29 class ROP_ExecuteContext;
97 #define FLT_PARM(name, vi, t) \
98 { return evalFloat(name, vi, t); }
99 #define FLT_SET(name, vi, t, val) \
100 { setFloat(name, vi, t, val); }
101 #define INT_SET(name, vi, t, val) \
102 { setInt(name, vi, t, val); }
104 #define INT_PARM(name, vi, t) \
105 { return evalInt(name, vi, t); }
107 #define INT_SET(name, vi, t, val) \
108 { setInt(name, vi, t, val); }
110 #define STR_PARM(name, vi, t) \
111 { evalString(str, name, vi, t); }
115 class ROP_SohoOutput;
141 virtual ROP_IFD *castToROPIFD();
142 virtual ROP_IFDBase *castToROPIFDBase();
143 virtual ROP_SohoOp *castToROPSoho();
144 virtual ROP_OpenGL *castToROPOpenGL();
146 virtual bool hasImageOutput();
149 virtual bool detectIfExistingOutputFiles();
151 virtual void deleteExistingOutputFiles();
162 static void initSimulationOPs();
175 const char *relative_path = NULL)
override;
181 ROP_SohoOutput *out=0,
182 bool generate=
false);
198 { myExecuteOverride =
f;
199 myExecuteOverrideData = d;
202 { myPreExecuteOverride =
f;
203 myPreExecuteOverrideData = d;
206 { myPostExecuteOverride =
f;
207 myPostExecuteOverrideData = d;
227 void setRenderResX(
int x);
228 void setRenderResY(
int y);
231 void setRenderAspect(
float aspect);
232 float getRenderAspect();
238 {
INT_SET(
"trange", 0, 0, val) }
241 if(myOverrideFrameRangeFlag)
244 return myCachedDoRange;
249 if(myOverrideFrameRangeFlag)
250 return myOverrideStartFrame;
252 return myCachedStart;
256 if(myOverrideFrameRangeFlag)
257 return myOverrideEndFrame;
264 if(myOverrideFrameRangeFlag)
265 return myOverrideFrameInc;
269 virtual bool SETROPCOOK();
272 static int doRenderCback(
void *
data,
int index,
276 static int doRenderBackgroundCback(
void *
data,
int index,
279 static int doRenderDialog(
void *
data,
int index,
288 bool executePreRenderScript(
fpreal ttime);
289 bool executePreFrameScript(
fpreal ttime);
290 bool executePostFrameScript(
fpreal ttime);
291 bool executePostWriteScript(
fpreal ttime);
292 bool executePostRenderScript(
fpreal ttime);
293 bool executeIPRStopScript(
fpreal ttime);
295 static void buildRibVersionMenu(
PRM_Name *menu,
int max,
296 bool for_archive=
false);
310 virtual void initRenderDependencies();
311 virtual void cleanupRenderDependencies();
313 void addJobFrames(
const char *job_name,
314 const char *frame_string);
316 static void setDependencyRenderFlag(
bool f);
317 static bool getDependencyRenderFlag();
319 static void setFrameByFrameFlag(
bool f);
320 static bool getFrameByFrameFlag();
322 static void setRenderScriptFlag(
bool enable);
323 static bool getRenderScriptFlag();
325 static void setOutputResolutionScale(
fpreal xscale,
fpreal yscale);
326 static void getOutputResolutionScale(
float &xs,
float &ys);
329 { x = y = 0;
return false; }
333 static void setRenderQuality(
int quality);
334 int getRenderQuality();
337 void overrideFrameRange(
bool enable,
344 {
return myOverrideOutputFlag; }
348 virtual void overrideOutput(
bool enable,
const char *fname=0);
352 bool getOutputOverride(
355 bool expand =
true)
const;
365 bool getOutputOverrideEx(
368 const char *output_parm_name,
369 const char *mkdir_parm_name);
371 virtual void overrideDevice(
bool enable,
bool interactive=
false,
372 const char *devicestr=0);
374 bool expand =
true)
const;
392 { myForceBackgroundRender =
f; }
394 {
return myForceBackgroundRender; }
398 { myTemporaryInputs = in; }
416 {
return myLastRenderItem; }
420 virtual bool isRenderDependentOnNode(
ROP_Node *node,
425 void addRenderEventCallback(
428 bool run_before_script);
431 void removeRenderEventCallback(
435 static void setColorCorrectionIPGamma(
bool enable,
fpreal gamma);
436 static fpreal getColorCorrectionIPGamma();
437 static void setColorCorrectionIPLUT(
bool enable,
const char *lut);
438 static const char *getColorCorrectionIPLUT();
440 static void setColorCorrectionEnvVariables(
bool set);
441 static void setFPSVariable(
bool do_set = 0,
fpreal frame_inc = 1);
453 int &copied_input)
override;
475 virtual int startRender(
int nframes,
fpreal tstart,
482 TAKE_Take *applyRenderTake(
const char *take);
483 void restorePreviousTake(
TAKE_Take *take);
485 void initRenderDependencyVars(
fpreal t);
486 virtual void doInitRenderDependencyVars(
fpreal t);
490 virtual void buildInputRenderDependencies(
493 bool matchingLastRenderParms(
496 { myLastRenderItem = item; }
497 void clearLastRenderDep();
510 {
INT_SET(
"trange", 0, 0, val); }
529 {
return myVerbose; }
531 {
return myVerbose.getStream(); }
533 {
return myVerbose.getAlfred(); }
562 {
return myTemporaryInputs.entries(); }
565 {
return myTemporaryInputs(i); }
584 struct EventCallbackEntry
588 bool myRunBeforeScript;
593 static void resetSimulation(
OP_Node* node);
595 ROP_ExecuteContext *myEContext;
598 void *myExecuteOverrideData;
600 void *myPreExecuteOverrideData;
602 void *myPostExecuteOverrideData;
604 bool myForceBackgroundRender;
606 bool myOverrideFrameRangeFlag;
607 fpreal myOverrideStartFrame;
608 fpreal myOverrideEndFrame;
609 fpreal myOverrideFrameInc;
611 bool myOverrideOutputFlag;
614 bool myOverrideDeviceFlag;
624 bool executeCallback(
fpreal ttime,
627 bool executeParmScript(
const char *parm_name,
630 bool executeParmScripts(
const char *parm_name,
637 static void installCommands();
650 myFullFrameInc(0.0
f),
655 myIgnoreBypass(true),
656 myIgnoreLocks(false),
661 myFirstFrameFlag(true) { }
680 { myFullStart =
start; myFullEnd =
end; myFullFrameInc = finc; }
682 { myStart =
start; myEnd =
end; myFrameInc = finc; }
694 fpreal finc = myFullFrameInc;
721 myIgnoreBypass = ignore_bypass;
722 myIgnoreLocks = ignore_locks;
729 { myRenderSerial = render_serial; }
734 { myDepParent = dep_parent; }
745 myOrder = copy.myOrder;
746 myDepParent = copy.myDepParent;
747 myTopLevelRop = copy.myTopLevelRop;
748 myFullStart = copy.myFullStart;
749 myFullEnd = copy.myFullEnd;
750 myFullFrameInc = copy.myFullFrameInc;
751 myStart = copy.myStart;
753 myFrameInc = copy.myFrameInc;
754 myRenderSerial = copy.myRenderSerial;
755 myDoInputs = copy.myDoInputs;
756 myIgnoreBypass = copy.myIgnoreBypass;
757 myIgnoreLocks = copy.myIgnoreLocks;
758 myFrameMerge = copy.myFrameMerge;
759 myFirstFrameFlag = copy.myFirstFrameFlag;
764 return (myFullStart == copy.myFullStart &&
765 myFullEnd == copy.myFullEnd &&
766 myFullFrameInc == copy.myFullFrameInc &&
767 myStart == copy.myStart &&
768 myEnd == copy.myEnd &&
769 myFrameInc == copy.myFrameInc &&
770 myDoInputs == copy.myDoInputs &&
771 myIgnoreBypass == copy.myIgnoreBypass &&
772 myIgnoreLocks == copy.myIgnoreLocks &&
773 myFrameMerge == copy.myFrameMerge &&
774 myRenderSerial == copy.myRenderSerial);
792 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.
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
OIIO_UTIL_API bool copy(string_view from, string_view to, std::string &err)
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
**But if you need a result
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 &)
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)
GLdouble GLdouble GLint GLint order
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)
GLuint const GLchar * name
fpreal getFrameInc() const
const ROP_RenderItemHandle & getDepParent() const
virtual OP_DataType getCookedDataType() const =0
bool operator==(const ROP_RenderDepParms ©)
GLenum GLenum GLsizei void * table
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)
virtual const char * getOpType() const
void(* ROP_RenderButtonCB)(ROP_Node *, ROP_RenderMode)
ROP_ExecuteContext * getExecuteContext()
ImageBuf OIIO_API max(Image_or_Const A, Image_or_Const B, ROI roi={}, int nthreads=0)
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(* ROP_RenderEventCallback)(ROP_Node *node, ROP_RenderEventType event, fpreal time, void *data)
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()
void setPostExecuteOverride(ROP_ExecuteOverride f, void *d)
virtual void onCreated()
Overriden in VOPs.
int getRenderSerial() const
virtual void deleteCookedData()=0