Namespaces
namespace	Application
	Contains information about the application that is using DDImage.
namespace	HashFile
	Includes functions to generate and check a hash for a given file.
Classes
class	Attribute
	General Attribute class. More...
class	AxisOp
	AxisOp is the base class for all the 3D objects. It simply contains a transform matrix. More...
class	Black
class	BlockAllocator
class	Blur
class	Box
	Describes a rectangle with integer boundaries. More...
class	Box3
	3D Box More...
class	BufferIop
	Base class for Iops which buffer the output of another Iop into an image plane. More...
class	BufferIopTile
class	CameraOp
class	ChannelMap
class	ChannelSet
class	ColorLookup
class	Colorspace_KnobI
class	ComplexLightOp
struct	ConvolveArray
class	Convolve
class	DeepAccumPixelOp
class	DeepFilterOp
class	DeepInfo
class	DeepOp
class	DeepPixel
class	DeepOutputPixel
class	DeepPlane
class	DeepOutPixel
class	DeepOutputPlane
class	DeepInPlaceOutputPlane
class	DeepReader
class	DeepSample
	helper class representing a small float vector, one for each channel in a set More...
class	DeepSampleVector
class	DeepWriterOwner
class	DeepWriter
class	DepthMapRender
	Depth map rendering for a shadow buffer. More...
class	License
class	Description
class	DirectGeneralTile
class	DownRez
class	DrawIop
class	EngineContext
class	Enumeration_KnobI
class	Executable
	Class to wrap up node graph execution. More...
class	Execute
class	File_KnobI
class	FileOp
class	FileRead
class	FileReader
class	FileSet
class	FileWriter
class	Filter
class	Format
	Describes the size and shape of an image. More...
class	FrameExtentProviderI
class	FrameRangeControls
	Class used to standardise frame range controls throughout NUKE. More...
class	GeneralInfo
	Base class for defining a time bounded region. More...
class	GeneralTile
class	AttribContext
struct	GeoInfoRenderState
class	GeoInfo
	Contains a list of points and geometric primitives. More...
class	GeometryList
class	GeoOp
class	GeoReader
class	GeoDescription
class	GeoWriter
class	GPUContext
class	Hash
class	HConvolve
class	HeapAllocator
class	Histogram_Data
class	IllumShader
	This subclass of Material provides some convienence functions so that it is easier to write a lighting surface shader. More...
class	ImageCacheReadI
	Holder of temporary data to read files from cache: More...
class	ImageCacheWriteI
	Holder of temporary data to write files to cache: More...
class	Image_Cache
class	ImageTileReadOnlyPtr
class	ImagePlane
class	ImagePlaneDescriptor
class	Info2D
class	InterestRatchet
class	Interest
class	IopInfoOwner
	IopInfo holder. More...
class	Iop
	Iop is the base class for all the image operators. More...
class	IopInfo
class	Knob
class	KnobChangeGroup
class	KnobChangedObserverI
struct	IRange
class	LightContext
class	LightOp
	LightOp defines a 3D light. More...
class	LinkableKnobInfo
class	LinkableI
class	LookAt
	Helper class that adds LookAt functionality. More...
struct	CurveDescription
class	LookupCurves
class	LookupCurves_KnobI
class	LUT
class	Linear
class	Material
class	SolidShader
	Default solid vertex shader. More...
class	WireframeShader
	Default wireframe shader. More...
class	Matrix3
	A 3x3 transformation matrix. More...
class	Matrix4
	A 4x4 transformation matrix. More...
class	MatrixArray
class	Memory
class	MemoryHolder
class	Menu
class	Mesh
class	ModifyGeo
class	MultiArray_KnobI
class	MultiTileIop
class	NoIop
class	NukeWrapper
class	NullGeo
class	PreValidateContext
class	Op
	Base class of all the things that can be created by Nuke nodes. More...
class	OpMessage
	This class encapsulates a text message to the user produced by an op. More...
class	OpMessageHandler
	This component of an op handles its messages to the user. More...
class	OpMessageObserver
class	OpTimer
class	OpTree
class	OpTreeHandler
	This component of an op handles the manipulations of its trees: adding to, removing from, checking statuses, etc. More...
class	OrderedMap
class	OutputContext
class	ParticleSystem
class	ParticleNodeState
class	ParticleNodeStateFactory
class	Random
	A random number generator for the use of ParticleOps. More...
class	ParticleOp
class	ParticleBehaviour
class	ParticleRender
class	Particles
struct	Sprite
class	ParticlesSprite
class	SpriteGenerator
class	MBSceneSpriteGenerator
class	MBParticleSpriteGenerator
class	Pixel
class	PixelIop
class	PlanarI
class	PlanarIop
class	Plane
class	Point
class	Polygon
class	PolygonPrimitive
class	PolyMesh
	PolyMesh is a connected series of polygons comprising a contiguous surface. More...
class	PositionVector_KnobI
	The interface for position vector knobs. More...
class	Primitive
class	PrimitiveContext
struct	AllocTrackingInfo
	A structure holding information about a tracked object's memory allocation. More...
class	AllocationTracker
	A class for checkpoint tracking of memory allocations allocated by the HeapAllocator. More...
class	ProfileEvent
class	AutoProfileEvent
class	InternalOCIOOp
	Helper class to enable Readers and Writers to use internal OCIOColorpace Ops. More...
class	LUTInfo
class	RandomBoxes
	Vector of boxes with member functions. More...
class	ReaderImpl
	Private, hidden implementation for DD::Image::Reader objects. More...
class	ReadImpl
	Private, hidden implementation for DD::Image::Read objects. More...
class	ShutdownBroadcaster
class	ShutDownListener
class	TimelineReadInternals
	A used by TimelineRead to hide internal implementations that we don't want to expose in the public DDImage API. More...
class	WriterImpl
	Private, hidden implementation for DD::Image::Writer objects. More...
class	ProxyContext
class	Box2f
struct	QuadtreeNode
class	Quadtree
class	Quaternion
	A implementation of a way of representing rotations that avoid a lot of the problems that the standard rotation about the axis methods have. More...
class	Radio_KnobI
class	RawGeneralTile
struct	Ray
class	PrimitiveTestCache
class	BasicGrid
class	ReadFileKnobOwner
class	Read
class	Reader
class	DataInfo
	Class that provides information about component types. More...
class	GenericImagePlaneDescriptor
class	GenericImagePlane
	Class to wrap up an image plane of arbitrary type. This is used by the readers to return image data with the minimal amount of conversion needed. More...
class	BaseHandle
class	Handle
	Standard handle, which allocates via DD Images memory pool. More...
class	PlanarReadInfo
	Information about a generic image plane, as opposed to a scan line, and how it can be read and decoded. More...
class	ReadGeo
class	RefCountedFloatBuffer
class	RefCountedObject
class	RefCountedPtr
class	Render
	Base class for rendering a 3D scene to an image. More...
class	RenderScene
	3D image renderer parent class More...
class	RequestOutput
class	Row
class	RowCacheTile
class	rPoint
class	rPrimitive
	This is the base class of anything renderable! We use this class to handle renderable objects that can have simple geometry such as triangles, spheres, etc. More...
class	rTriangle
class	Scene
class	SceneView_KnobI
class	ShapeKnob
class	ShutterControls
class	SmallBlockDefinition
class	SourceGeo
class	Text_KnobI
class	TextureFilter
class	Lock
class	SignalLock
class	ReadWriteLock
class	RecursiveLock
class	ReadGuard
class	WriteGuard
class	TryWriteGuard
class	BaseLockGuard
class	Guard
class	SpinGuard
class	Thread
class	TimelineRead
	Sub-class of DD::Image::Read used by NukeStudio/Hiero for timeline reads. More...
class	ToBuffer
	Takes the output of an image tree and put it into an 8-bit buffer. More...
class	Transform
class	TransformGeo
	Operator that transforms geometric points. More...
class	TransformJack_ClientI
class	TransformReceiverI
class	Triangle
class	UpRez
class	ValueStuffI
	Container for values. More...
class	VConvolve
class	Vector2
class	Vector3
class	Vector4
class	Version
class	VArray
class	VertexContext
class	ViewerCache
	Image cache for the viewer. More...
struct	Draw_Handle_Callback
class	ViewerContext
class	ViewFrustum
class	Write
class	WriteGeo
class	Writer
struct	ObjectCell
Typedefs
typedef Knob_Closure &	Knob_Callback
typedef RefCountedPtr< Attribute >	AttributePtr
typedef void(*	callback_change_knobs )(void *v, Knob_Callback f)
typedef int	FrameRange [2]
typedef RefCountedPtr< PointList >	PointListPtr
typedef RefCountedPtr < PrimitiveList >	PrimitiveListPtr
typedef unsigned	GeometryMask
typedef std::vector < AttribContext >	AttribContextList
typedef std::vector< float >	VertexSelection
typedef std::vector< float >	FaceSelection
typedef std::map < DD::Image::Hash, Image_Cache_Entry >	Cache_Entry_Map
typedef void(*	TimeoutHandler )(void *)
typedef unsigned long long	Flags
typedef unsigned int	ParticleChannelSet
typedef Read	ReaderOwner
typedef RefCountedPtr< BaseHandle >	HandlePtr
typedef std::pair< std::string, int >	StlStringIntPair
typedef pthread_t	ThreadId
typedef SignalLock	SlowSignalLock
typedef DD::Image::RawGeneralTile	Tile
	typedef for our preferred Tele type
typedef void(*	DrawHandleCallbackFunc )(void , ViewerContext )
typedef unsigned int	DrawHandleTypeMask
typedef Foundry::Base::ThreadLocalStorage < RequestCount, kMaxThreadGrowth >	ThreadLocalRequestCount
typedef PlanarI::PlaneID	PlaneID
typedef RefCountedPtr< ObjectGrid >	ObjectGridPtr
typedef bool(*	plugin_interpret_callback )(const char *name)
typedef pthread_t	ThreadID
Enumerations
enum	AttribType { INVALID_ATTRIB, FLOAT_ATTRIB, VECTOR2_ATTRIB, VECTOR3_ATTRIB, VECTOR4_ATTRIB, NORMAL_ATTRIB, INT_ATTRIB, STRING_ATTRIB, STD_STRING_ATTRIB, POINTER_ATTRIB, MATRIX3_ATTRIB, MATRIX4_ATTRIB }
enum	Channel { Chan_Black, Chan_Red, Chan_Green, Chan_Blue, Chan_Alpha, Chan_Z, Chan_U, Chan_V, Chan_Backward_U, Chan_Backward_V, Chan_Stereo_Disp_Left_X, Chan_Stereo_Disp_Left_Y, Chan_Stereo_Disp_Right_X, Chan_Stereo_Disp_Right_Y, Chan_Mask, Chan_RotoPaint_Mask, Chan_DeepFront, Chan_DeepBack, Chan_Mask_PlanarTrack, Chan_Mask_SplineWarp, Chan_Unused }
enum	ChannelSetInit { Mask_None, Mask_Red, Mask_Green, Mask_Blue, Mask_Alpha, Mask_Z, Mask_DeepBack, Mask_DeepFront, Mask_Deep, Mask_U, Mask_V, Mask_Backward_U, Mask_Backward_V, Mask_Stereo_Disp_Left_X, Mask_Stereo_Disp_Left_Y, Mask_Stereo_Disp_Right_X, Mask_Stereo_Disp_Right_Y, Mask_RGB, Mask_RGBA, Mask_UV, Mask_MoVecForward, Mask_MoVecBackward, Mask_MoVec, Mask_Stereo_Disp_Left, Mask_Stereo_Disp_Right, Mask_Stereo_Disp, Mask_Mask, Mask_RotoPaint_Mask, Mask_PlanarTrack, Mask_SplineWarp, Mask_Builtin, Mask_All }
enum	{ Chan_Px, Chan_Py, Chan_Pz, Chan_Pw, Chan_UVx, Chan_UVy, Chan_UVz, Chan_UVw, Chan_Nx, Chan_Ny, Chan_Nz, Chan_PLx, Chan_PLy, Chan_PLz, Chan_PWx, Chan_PWy, Chan_PWz, Chan_MBx, Chan_MBy, Chan_MBz, Chan_VELx, Chan_VELy, Chan_VELz, Chan_P_, Chan_UV_, Chan_N_, Chan_PL_, Chan_PW_, Chan_MB_, Chan_VEL_ }
enum	ChannelSet3DInit { Mask_Px, Mask_Py, Mask_Pz, Mask_Pw, Mask_UVx, Mask_UVy, Mask_UVz, Mask_UVw, Mask_Nx, Mask_Ny, Mask_Nz, Mask_PLx, Mask_PLy, Mask_PLz, Mask_PWx, Mask_PWy, Mask_PWz, Mask_MBx, Mask_MBy, Mask_MBz, Mask_VELx, Mask_VELy, Mask_VELz, Mask_CF_, Mask_P_, Mask_UV_, Mask_N_, Mask_PL_, Mask_PW_, Mask_MB_, Mask_VEL_ }
enum	GroupType { Group_None, Group_Primitives, Group_Vertices, Group_Points, Group_Object, Group_Matrix, Group_Attributes, Group_Last }
enum	{ Mask_No_Geometry, Mask_Primitives, Mask_Vertices, Mask_Points, Mask_Geometry, Mask_Object, Mask_Matrix, Mask_Attributes, Mask_All_Geometry }
enum	RenderMode { RENDER_OFF, RENDER_WIREFRAME, RENDER_SOLID, RENDER_SOLID_LINES, RENDER_TEXTURED, RENDER_TEXTURED_LINES, RENDER_UNCHANGED }
enum	Display3DMode { DISPLAY_OFF, DISPLAY_WIREFRAME, DISPLAY_SOLID, DISPLAY_SOLID_LINES, DISPLAY_TEXTURED, DISPLAY_TEXTURED_LINES, DISPLAY_UNCHANGED }
enum	{ XY, XZ, YZ, YX, ZX, ZY }
enum	FileKnob_Type { Normal_File, Read_File_Proxy, Write_File_Proxy, Geo_File, Write_File_Normal, Script_File, Read_File_Cached, Read_File_NoProxy, OCIO_File, Particle_Cache_File, Cube_File }
enum	{ TRANSFORM, POSITIONER, TO_PROXY, NO_SCALE, NO_UNIFORM_SCALE, NO_SKEW, NO_CENTER, T2D_GAUGE, T2D_INVERT }
enum	LookupCurvesType { eLookupCurvesTypeTime, eLookupCurvesTypePlot, eLookupCurvesTypeRGBLut, eLookupCurvesTypeYLut, eLookupCurvesTypeALut, eLookupCurvesTypeHue1, eLookupCurvesTypeHue2 }
enum	{ LOCAL_SPACE, WORLD_SPACE, EYE_SPACE, CLIP_SPACE, SCREEN_SPACE }
enum	{ OBJECT_MATRIX, OBJECT_iMATRIX, CAMERA_MATRIX, CAMERA_iMATRIX, PROJECTION_MATRIX, PROJECTION_iMATRIX, FORMAT_MATRIX, FORMAT_iMATRIX }
enum	{ PLANE_XY, PLANE_YZ, PLANE_ZX }
enum	MeshSubdivisionMethod { ROWS, COLUMNS, ROWS_COLUMNS, QUADS, TRIANGLES_A, TRIANGLES_B, ALT_TRIANGLES }
enum	ViewerWorldCoordinate { eViewerWorldCoordinateYUp, eViewerWorldCoordinateZUp, eViewerWorldCoordinateCount }
enum	{ eAlignNone, eAlignSpin, eAlignVelocity }
enum	{ eBlendNone, eBlendModulate }
enum	FrameAdvance { eFrameAdvanceConstant, eFrameAdvanceStep, eFrameAdvanceRandom }
enum	PrimitiveType { eUnknownPrimitive, eTriangle, ePolygon, eMesh, ePoint, eParticles, eParticlesSprite, ePolyMesh, ePrimitiveTypeCount }
enum	ColorCurveEnum { eColorCurveLinear, eColorCurveSRGB, eColorCurveRec709, eColorCurveLog, eColorCurveGamma18, eColorCurveGamma22, eColorCurveGamma24, eColorCurveGamma26, eColorCurvePanalog, eColorCurveREDLog, eColorCurveViperLog, eColorCurveAlexaV3LogC, eColorCurvePLogLin, eColorCurveSLog, eColorCurveSLog1, eColorCurveSLog2, eColorCurveSLog3, eColorCurveCLog, eColorCurveLog3G10, eColorCurveLog3G12, eColorCurveHybridLogGamma, eColorCurveProtune, eColorCurveBT1886, eColorCurveHDR2084, eColorCurveUnknown }
	Enum to label standard lookup curves applied to colours.
enum	DataTypeEnum { eDataTypeNone, eDataTypeUInt8, eDataTypeUInt16, eDataTypeUInt32, eDataTypeFloat16, eDataTypeFloat32, eDataTypeUInt32_10bit }
	Enumeration for data types that DataInfo supports.
enum	RippleType { eRippleOff, eRippleAll, eRippleFromStart, eRippleToEnd, eRippleRange }
enum	MotionVectorType { eDisableMotionVector, eClassicMotionVector, eVelocityMotionVector, eDistanceMotionVector }
	Scene motion vector types. More...
enum	StoreType { DoublePtr, FloatPtr, StringPtr, IntPtr, UnsignedIntPtr, BoolPtr, ConvolveArrayPtr, ChannelSetPtr, ChannelPtr, FormatPairPtr, MatrixPtr, LookupCurvesPtr, IntSetPtr, IntIntMapPtr, IntPairPtr, StringVecVecPtr, StlStringPtr, StlStringIntPairPtr, StlStringVecPtr, Custom }
enum	StringExpandFlags { eStringExpandNoFlags, eStringExpandFilename, eStringExpandFileNumber }
enum	DrawHandleType { eDrawHandleAlways, eDrawHandleVertexSelection, eDrawHandleEdgeSelection, eDrawHandleFaceSelection, eDrawHandleObjectSelection, eDrawHandleNodeSelection }
enum	ViewerConnected { NOT_CONNECTED, CONNECTED, SHOW_OBJECT, SHOW_PUSHED_OBJECT }
enum	ViewerMode { VIEWER_2D, VIEWER_PERSP, VIEWER_RSIDE, VIEWER_LSIDE, VIEWER_TOP, VIEWER_BOTTOM, VIEWER_FRONT, VIEWER_BACK, VIEWER_MODE_COUNT }
enum	ViewerEvent { NO_EVENT, DRAW_OPAQUE, DRAW_TRANSPARENT, DRAW_STIPPLED, DRAW_SHADOW, DRAW_LINES, MOVE, PUSH, DRAG, RELEASE, KEY, KEYUP, DROP, DROP_CHECK, ENTER_VIEWER, EXIT_VIEWER, CURSOR, HOVER_ENTER, HOVER_MOVE, HOVER_LEAVE, DRAG_SELECT, DRAG_SELECT_FINISHED, FIRST_MENU }
enum	CameraLockMode { CAMERA_LOCKMODE_UNLOCKED, CAMERA_LOCKMODE_LOCKED, CAMERA_LOCKMODE_INTERACTIVE, CAMERA_LOCKMODE_COUNT }
enum	SelectionMode3D { eSelect3DNode, eSelect3DVertex, eSelect3DFace, eSelect3DObject, eNumberOfSelectionModes3D }
enum	SelectionOptions3D { eOptionDisableOcclusionTesting }
enum	Select3DAction { eSelectReplace, eSelectAdd, eSelectRemove, eSelectDrag }
enum	{ SHOW_POINT_HANDLES, SHOW_POINT_NUM, SHOW_POINT_INFO, SHOW_POINT_UVS, SHOW_POINT_NORMALS, SHOW_VERTEX_NUM, SHOW_VERTEX_UVS, SHOW_VERTEX_NORMALS, SHOW_PRIMITIVE_NUM, SHOW_PRIMITIVE_NORMAL, SHOW_BBOX, SHOW_TRANSPARENCY, SHOW_LIGHTING, SHOW_WIREFRAME_IF_NOT_PANEL_VISIBLE }
enum	{ LeftButton, MiddleButton, RightButton, SpaceKey, PlusKey, MinusKey, BackSpaceKey, TabKey, ClearKey, ReturnKey, PauseKey, ScrollLockKey, EscapeKey, HomeKey, LeftKey, UpKey, RightKey, DownKey, PageUpKey, PageDownKey, EndKey, PrintKey, InsertKey, MenuKey, HelpKey, NumLockKey, KeypadEnter, F0Key, F1Key, F2Key, F3Key, F4Key, F5Key, F6Key, F7Key, F8Key, F9Key, F10Key, F11Key, F12Key, LastFunctionKey, LeftShiftKey, RightShiftKey, LeftControlKey, RightControlKey, CapsLockKey, LeftMetaKey, RightMetaKey, LeftAltKey, RightAltKey, DeleteKey }
enum	{ SHIFT, CAPSLOCK, CTRL, ALT, KEYPAD, META, COMMAND, OPTION, SCROLLLOCK, ALL_MODIFIERS, KEY_MASK }
enum	{ eUnknown, ePen, eCursor, eEraser }
enum	FrustumPlane { eNear, eFar, eLeft, eRight, eTop, eBottom, eMax }
	Frustum planes enumerations.
enum	FrustumVisibility { eNotVisible, eFullVisible, ePartialVisible }
	Frustum visibility result. More...
enum	SampleType { eFront, eBack, eBoth }
enum	ShowMessagesOption { eSMO_DoNotShowMessages, eSMO_ShowMessages }
enum	AttributeType { kAttrTypeInvalid, kAttrTypeFloat, kAttrTypeFloat2, kAttrTypeFloat3, kAttrTypeFloat4, kAttrTypeNormal, kAttrTypeInt32, kAttrTypeString, kAttrTypeStdString, kAttrTypePointer, kAttrTypeFloat3x3, kAttrTypeFloat4x4, kAttrTypeBoolean, kAttrTypeDouble, kAttrTypeUInt32, kAttrTypeQuaternion, kAttrTypeSource, kAttrTypeBounceInfo, kAttrTypeFrameAdvance, kAttrTypeChannelSet }
enum	{ eNoDomain, eSphereDomain, eBoxDomain, eHalfSpaceDomain, eCylinderDomain, eMaxDomain }
Functions
	mFnCreateGlobalSTLAllocator (STL3DAllocator, Allocators::g3DAllocator)
	mFnCreateGlobalSTLAllocator (STLNodeAllocator, Allocators::gNodeAllocator)
	mFnCreateGlobalSTLAllocator (STLOpAllocator, Allocators::gOpAllocator)
	mFnCreateGlobalSTLAllocator (STLKnobAllocator, Allocators::gKnobAllocator)
void	SetValueProvider (Knob_Callback f, ArrayKnobI::ValueProvider *valueProvider)
	mFnCreateInstanceSTLAllocator (STLBlockAllcoator, BlockAllocator)
	Create STL allocator class using macro.
void	incr (Channel &c)
std::ostream &	operator<< (std::ostream &, Channel)
Channel	getChannel (const char *name, bool sort=true)
size_t	getChannelCount ()
Channel	findChannel (const char *name)
const char *	getName (Channel)
const char *	getLayerName (Channel)
unsigned	colourIndex (Channel, const char *layer=0)
Channel	brother (Channel, unsigned index)
bool	compareChannels (Channel a, Channel b)
ChannelSetInit	operator\| (ChannelSetInit a, ChannelSetInit b)
ChannelSetInit	operator& (ChannelSetInit a, ChannelSetInit b)
ChannelSetInit	operator& (ChannelSetInit a, Channel b)
bool	intersect (const ChannelSet &m, const ChannelSet &c)
bool	intersect (const ChannelSet &m, ChannelSetInit c)
bool	intersect (const ChannelSet &m, Channel z)
bool	turn_off (const ChannelSet &c, const ChannelSet &m)
bool	turn_off (ChannelSetInit c, const ChannelSet &m)
bool	turn_off (Channel c, const ChannelSet &m)
ChannelSetInit	depth2mask (int d)
void	mask2array (Channel array, unsigned n, ChannelMask mask, const char layer)
ChannelSet	array2mask (const Channel *array, int n)
Channel	mask (Channel c)
const Version &	version ()
const Version &	applicationVersion ()
double	scriptVersion ()
void	CombineOverlappingSamples (const ChannelMap &channels, const DeepPixel &deepPixel, DeepSampleVector &pixels)
void	CombineOverlappingSamples (const ChannelMap &channels, const DeepSampleVector &deepPixel, DeepSampleVector &pixels)
void	CombineOverlappingSamples (const ChannelMap &channels, const DeepPixel &deepPixel, DeepOutPixel &pixels)
void	CompositeSamples (const DeepPixel &samples, const ChannelSet &chans, Row &row, int x, float Zpix, float Zfrontpix)
	composite the samples together. Samples can be a DeepPixel or a DeepSampleVector.
void	CompositeSamples (const DeepSampleVector &samples, const ChannelSet &chans, Row &row, int x, float Zpix, float Zfrontpix)
void	CompositeSamples (const DeepPixel &samples, const ChannelSet &chans, Row &row, int x, float Zpix, float Zfrontpix, float *Zbackpix)
	composite the samples together. Samples can be a DeepPixel or a DeepSampleVector.
void	CompositeSamples (const DeepSampleVector &samples, const ChannelSet &chans, Row &row, int x, float Zpix, float Zfrontpix, float *Zbackpix)
bool	DetectOverlappingSamples (const DeepSampleVector &t)
	check whether any samples overlap. Samples can be a DeepPixel or a DeepSampleVector.
bool	DetectOverlappingSamples (const DeepPixel &t)
bool	RenameTempToFinal (const char lpTempName, const char lpFinalName, Op *lpOp)
std::string	RemapPath (const std::string &path)
	Apply path remapping configured in Nuke's preferences to a path, and return the result.
template<class T , class V >
bool	IsEqualFloat (T val1, T val2)
	Accepts float or double.
bool	IsEqual (float val1, float val2)
bool	IsEqual (double val1, double val2)
bool	IsNonZero (float val1)
bool	IsNonZero (double val1)
const AttribContext *	GetGeoInfoAttribContext (const GeoInfo info, const char attribName, AttribType attribType)
GeoSelection &	GetGeometrySelection ()
void	glColor (unsigned)
void	glColor4 (unsigned)
void	glColor4fvLUT (const float *)
void	gl_text (const char *str)
void	gl_text (const char *str, int n)
void	gl_text (const char *str, float x, float y, float z=0)
void	gl_text (const char *str, int n, float x, float y, float z=0)
void	gl_text (const char *str, int x, int y, int z=0)
void	gl_text (const char *str, int n, int x, int y, int z=0)
void	gl_text (const char *str, double x, double y, double z=0)
void	gl_text (const char *str, int n, double x, double y, double z=0)
void	gl_enable_line_smoothing (float width)
void	gl_disable_line_smoothing ()
void	gl_circlef (float x, float y, float z, float diam, int plane, bool filled=false, float normal=1.0f)
void	gl_circlefAsTris (float x, float y, float z, float diam, float lineWidth, int plane, bool filled=false, float normal=1.0f)
void	gl_cylinderf (float x, float y, float z, float width, float diam1, float diam2, int plane, bool capped=true, bool filled=false)
void	gl_conef (float x, float y, float z, float length, float diam, int plane)
void	gl_sphere (float radius=0.5)
void	gl_planef (float x, float y, float z, float width, float height, int plane)
void	gl_gridf (float x, float y, float z, int numW, int numH, int plane)
void	gl_quadi (int x, int y, int r, int t)
void	gl_rectangle (float x, float y, float r, float t)
void	gl_rectangle (int x, int y, int r, int t)
void	gl_circle (float x, float y, float radius, float intervalDegrees)
void	gl_ellipse (float x, float y, float xradius, float yradius, unsigned nPoints)
void	gl_bracket (float x, float y, float r, float t, float sx, float sy)
void	gl_crossf (float x, float y, float z, float size, int plane)
void	gl_crossi (int x, int y, int z, int size, int plane)
void	gl_axis ()
void	gl_axis_label ()
void	gl_boxf (float x, float y, float n, float r, float t, float f, bool filled=false)
void	gl_cubef (float x, float y, float z, float width)
void	gl_bezierf (float x, float y, float x1, float y1, float x2, float y2, float x3, float y3, float scale=1)
void	gl_polygon (const DD::Image::Vector2 *points, size_t nPoints, DD::Image::Vector2 offset=DD::Image::Vector2())
void	gl_drawTextTopLeftOrthogonal (const std::string &text, DD::Image::ViewerContext *ctx, bool redColour=true)
const char *	gl_errorstring (int errorcode)
int	glGetErrors (const char *message=0)
bool	GLProject (float x, float y, float z, const DD::Image::Matrix4 &m, const DD::Image::Box &vp, float winx, float winy, float *winz)
bool	GLUnproject (float wx, float wy, float wz, const DD::Image::Matrix4 &m, const DD::Image::Box &vp, float objx, float objy, float *objz)
DD::Image::Box	GLProjectCube (const DD::Image::Box3 &cube, const DD::Image::Matrix4 &m, const DD::Image::Box &vp)
void	GLZOffsetProjection (float offsetAmount)
void	cacheglBegin (unsigned int mode)
void	cacheglEnd ()
void	cacheglVertex2f (float x, float y)
void	cacheglVertex2fv (const float *v)
void	cacheglVertex2d (double x, double y)
void	cacheglVertex3f (float x, float y, float z)
void	cacheglVertex3fv (const float *c)
void	cacheglNormal3f (float nx, float ny, float nz)
void	cacheglColor3f (float r, float g, float b)
void	cacheglColor4fv (const float *c)
void	cacheglLineWidth (float width)
void	cacheglLineStipple (int factor, short pattern)
void	cacheglPushAttrib (unsigned int mask)
void	cacheglPopAttrib ()
void	cacheglPushMatrix ()
void	cacheglPopMatrix ()
void	cacheglMatrixMode (unsigned int mode)
void	cacheglLoadIdentity ()
void	cacheglEnable (unsigned int cap)
void	cacheglDisable (unsigned int cap)
void	cacheglHint (unsigned int target, unsigned int mode)
void	cacheglLoadName (unsigned int name)
void	cacheglLoadMatrixf (const float *m)
void	cacheglStoreColor (float *c)
void	cacheglRestoreColor (float *c)
void	cacheglPointSize (float size)
void	cacheglTranslatef (float tx, float ty, float tz)
void	cacheglScaled (double sx, double sy, double sz)
void	cacheglAlphaFunc (unsigned int func, float ref)
void	cacheglBlendFunc (unsigned int sfactor, unsigned int dfactor)
void	cacheglDepthMask (bool flag)
void	cacheglClear (unsigned long mask)
void	cacheglDepthFunc (unsigned int func)
void	cacheglFlush ()
void	cacheglPolygonMode (unsigned int face, unsigned int mode)
void	cacheglColor4f (float r, float g, float b, float a)
void	cacheglTexCoord2f (float s, float t)
void	cacheglVertex2i (int x, int y)
void	cacheglScalef (float sx, float sy, float sz)
void	cacheglRectf (float x1, float y1, float x2, float y2)
void	cacheglOrtho (double left, double right, double bottom, double top, double zNear, double zFar)
void	cacheglRotatef (float angle, float x, float y, float z)
void	cacheglRotated (double angle, double x, double y, double z)
void	cacheuglColor (unsigned int color)
void	cacheuglText (const char *str, float x, float y, float z=0.0f)
void	cacheuglZOffsetProjection (float offsetAmount)
void	cacheuglBezierf (float x, float y, float x1, float y1, float x2, float y2, float x3, float y3, float scale=1.0f)
void	cacheuglProjectionMatrix ()
void	cacheuglRectangle (float x, float y, float r, float t)
void	cacheuglEllipse (float center_x, float center_y, float xradius, float yradius, unsigned nPoints)
void	cacheuglPolygon (const DD::Image::Vector2 *points, size_t nPoints, DD::Image::Vector2 offset=DD::Image::Vector2())
template<class T >
U64	getHashValue (const T s)
	mFnCreateInstanceSTLAllocator (STLHeapAllocator, HeapAllocator)
	Create STL allocator class using macro.
bool	RGBtoHSV (float r, float g, float b, float &h, float &s, float &v)
void	HSVtoRGB (float h, float s, float v, float &r, float &g, float &b)
bool	RGBtoHSL (float r, float g, float b, float &H, float &S, float &L)
void	HSLtoRGB (float H, float S, float L, float &r, float &g, float &b)
void	HSVtoHSL (float h, float s, float v, float &H, float &S, float &L)
void	HSLtoHSV (float H, float S, float L, float &h, float &s, float &v)
std::ostream &	operator<< (std::ostream &o, const Knob::cstring &c)
std::ostream &	operator<< (std::ostream &o, const Knob::Indent *)
std::string	escape (const char *s)
void	Tooltip (Knob_Callback f, const char *)
void	Tooltip (Knob_Callback f, const std::string &text)
void	SetFlags (Knob_Callback f, Knob::FlagMask n)
void	ClearFlags (Knob_Callback f, Knob::FlagMask n)
void	SetRange (Knob_Callback f, double minimum, double maximum)
Knob *	Obsolete_knob (Knob_Callback f, const char linkto, NAME name, const char script)
Knob *	Obsolete_knob (Knob_Callback f, NAME name, const char *script)
Knob *	Op_knob (Knob_Callback f, Op *op, NAME name)
Knob *	String_knob (Knob_Callback f, const char **p, NAME n, LABEL l=0)
Knob *	Password_knob (Knob_Callback f, const char **p, NAME n, LABEL l=0)
Knob *	String_knob (Knob_Callback f, std::string *p, NAME n, LABEL l=0)
Knob *	String_knob (Knob_Callback f, NAME n, LABEL l=0)
Knob *	File_knob (Knob_Callback f, const char **p, NAME n, LABEL l=0, FileKnob_Type type=Normal_File)
Knob *	Read_File_knob (ReadFileKnobOwner ptr, Knob_Callback f, const char *p, NAME n, LABEL l=0)
Knob *	Read_File_knob (ReadFileKnobOwner ptr, Knob_Callback f, std::string p, NAME n, LABEL l=0)
Knob *	Cached_File_knob (Knob_Callback f, const char **p, NAME n, LABEL l=0, FileKnob_Type type=Normal_File)
Knob *	Write_File_knob (Knob_Callback f, const char **p, NAME n, LABEL l=0)
Knob *	Write_File_knob (Knob_Callback f, std::string *p, NAME n, LABEL l=0)
Knob *	Proxyless_Read_File_knob (ReadFileKnobOwner ptr, Knob_Callback f, const char *p, NAME n, LABEL l=0)
Knob *	Int_knob (Knob_Callback f, int *p, NAME n, LABEL l=0)
Knob *	Enumeration_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=0)
Knob *	CascadingEnumeration_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=0)
Knob *	Colorspace_knob (Knob_Callback f, int p, const char e, NAME n, LABEL l=0)
Knob *	SceneView_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=0)
Knob *	SceneView_knob (Knob_Callback f, SceneView_KnobI::ItemList *p, NAME n, LABEL l=0)
Knob *	FreeTypeFont_knob (Knob_Callback f, StlStringIntPair *p, NAME n, LABEL l=0)
Knob *	OneView_knob (Knob_Callback f, int p, NAME n, LABEL l=0, const char defcaption=0)
Knob *	ViewPair_knob (Knob_Callback f, std::pair< int, int > *p, NAME n, LABEL l=0)
Knob *	MetaData_knob (Knob_Callback f, NAME n, LABEL l=0)
Knob *	MultiView_knob (Knob_Callback f, std::set< int > *p, NAME n, LABEL l=0)
Knob *	ViewView_knob (Knob_Callback f, std::map< int, int > p, NAME n, std::pair< std::string, std::string > headings, LABEL l=0)
Knob *	Bitmask_knob (Knob_Callback f, unsigned int *p, ENUM_LABELS e, NAME n, LABEL l=0)
Knob *	Dynamic_Bitmask_knob (Knob_Callback f, unsigned int p, std::map< int, std::string > e, NAME n, LABEL l=0)
Knob *	Bool_knob (Knob_Callback f, bool *p, NAME n, LABEL l=0)
Knob *	Float_knob (Knob_Callback f, double *p, NAME n, LABEL l=0)
Knob *	Float_knob (Knob_Callback f, float *p, NAME n, LABEL l=0)
Knob *	Frame_knob (Knob_Callback f, float *p, NAME n, LABEL l=0)
Knob *	Deep_knob (Knob_Callback f, float *p, NAME n, LABEL l=0)
Knob *	MultiFloat_knob (Knob_Callback f, double *p, int dim, NAME n, LABEL l=0)
Knob *	MultiFloat_knob (Knob_Callback f, float *p, int dim, NAME n, LABEL l=0)
Knob *	MultiInt_knob (Knob_Callback f, int *p, int dim, NAME n, LABEL l=0)
Knob *	PixelAspect_knob (Knob_Callback f, double *p, NAME n, LABEL l=0)
Knob *	Array_knob (Knob_Callback f, ConvolveArray *p, int width, int height, NAME n, LABEL l=0, bool defaultData=false)
Knob *	ResizableArray_knob (Knob_Callback f, ConvolveArray *p, int width, int height, NAME n, LABEL l=0, bool defaultData=false)
Knob *	ChannelSet_knob (Knob_Callback f, ChannelSet *p, NAME n, LABEL l=0)
Knob *	Input_ChannelSet_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=0)
Knob *	InputOnly_ChannelSet_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=0)
Knob *	Channel_knob (Knob_Callback f, Channel *p, int count, NAME n, LABEL l=0)
Knob *	Input_Channel_knob (Knob_Callback f, Channel *p, int count, int input, NAME n, LABEL l=0)
Knob *	InputOnly_Channel_knob (Knob_Callback f, Channel *p, int count, int input, NAME n, LABEL l=0)
Knob *	XY_knob (Knob_Callback f, double p, NAME n, LABEL l, Knob parent=0)
Knob *	XY_knob (Knob_Callback f, double p, NAME n, Knob parent=0)
Knob *	XY_knob (Knob_Callback f, float p, NAME n, LABEL l, Knob parent=0)
Knob *	XY_knob (Knob_Callback f, float p, NAME n, Knob parent=0)
Knob *	XYZ_knob (Knob_Callback f, float p, NAME n, LABEL l=0, Knob parent=0)
Knob *	UV_knob (Knob_Callback f, double *p, NAME n, LABEL l=0)
Knob *	UV_knob (Knob_Callback f, float *p, NAME n, LABEL l=0)
Knob *	CP_knob (Knob_Callback f, float *p, int dim, NAME n, LABEL l=0)
Knob *	WH_knob (Knob_Callback f, double *p, NAME n, LABEL l=0)
Knob *	WH_knob (Knob_Callback f, float *p, NAME n, LABEL l=0)
Knob *	BBox_knob (Knob_Callback f, double p, NAME n, LABEL l=0, Knob parent=0)
Knob *	BBox_knob (Knob_Callback f, float p, NAME n, LABEL l=0, Knob parent=0)
Knob *	Format_knob (Knob_Callback f, FormatPair *p, NAME n, LABEL l=0)
Knob *	Color_knob (Knob_Callback f, float *p, NAME n, LABEL l=0)
Knob *	Color_knob (Knob_Callback f, double *p, NAME n, LABEL l=0)
Knob *	AColor_knob (Knob_Callback f, float *p, NAME n, LABEL l=0)
Knob *	AColor_knob (Knob_Callback f, double *p, NAME n, LABEL l=0)
Knob *	Eyedropper_knob (Knob_Callback f, float *p, NAME n, LABEL l=0)
Knob *	Range_knob (Knob_Callback f, double *p, int np, NAME n, LABEL l=0)
Knob *	Range_knob (Knob_Callback f, float *p, int np, NAME n, LABEL l=0)
void	FrameRange_knob (Knob_Callback f, FrameRange p, const std::string &n, LABEL l=0)
Knob *	Transform2d_knob (Knob_Callback f, Matrix4 *p, NAME n, int type=0)
Knob *	Transform2d_knob (Knob_Callback f, Matrix4 *p, NAME n, LABEL l, int type=0)
Knob *	LookupCurves_knob (Knob_Callback f, LookupCurves *p, DD::Image::LookupCurvesType type, NAME n, LABEL l=0)
Knob *	LookupCurves_knob (Knob_Callback f, LookupCurves *p, NAME n, LABEL l=0)
Knob *	Axis_knob (Knob_Callback f, Matrix4 *p, NAME n, LABEL l=0)
Knob *	PositionVector_knob (Knob_Callback f, float *p, NAME n, LABEL l=0)
Knob *	Box3_knob (Knob_Callback f, float *p, NAME n, LABEL l=0)
Knob *	Histogram_knob (Knob_Callback f, Histogram_Data *p, NAME n, LABEL l=0)
Knob *	Keyer_knob (Knob_Callback f, double *p, NAME n, LABEL l=0)
Knob *	ColorChip_knob (Knob_Callback f, unsigned *p, NAME n, LABEL l=0)
Knob *	Tab_knob (Knob_Callback f, LABEL label)
Knob *	MultiArray_knob (Knob_Callback f, NAME n, LABEL l=0)
Knob *	BeginGroup (Knob_Callback f, NAME name, LABEL label=0)
Knob *	BeginClosedGroup (Knob_Callback f, NAME name, LABEL label=0)
Knob *	EndGroup (Knob_Callback f)
Knob *	BeginToolbar (Knob_Callback f, NAME name, LABEL label=0, int position=Knob::TOOLBAR_TOP)
Knob *	EndToolbar (Knob_Callback f)
Knob *	BeginTabGroup (Knob_Callback f, NAME name, LABEL label=0)
Knob *	EndTabGroup (Knob_Callback f)
Knob *	BeginExoGroup (Knob_Callback f, NAME name, LABEL label=0)
Knob *	EndExoGroup (Knob_Callback f)
Knob *	Text_knob (Knob_Callback f, LABEL text)
Knob *	Text_knob (Knob_Callback f, LABEL label, LABEL text)
Knob *	Named_Text_knob (Knob_Callback f, LABEL name, LABEL text)
Knob *	Newline (Knob_Callback f, LABEL label=" ")
Knob *	Divider (Knob_Callback f, LABEL label=0)
Knob *	Spacer (Knob_Callback f, int spaceInPixels)
Knob *	VSpacer (Knob_Callback f, int spaceInPixels)
Knob *	Icon_knob (Knob_Callback f, const char *icon)
Knob *	Help_knob (Knob_Callback f, LABEL text)
Knob *	Help_knob (Knob_Callback f, LABEL label, LABEL text)
Knob *	Button (Knob_Callback f, NAME n, LABEL l=0)
Knob *	Script_knob (Knob_Callback f, NAME command, NAME n, LABEL l=0)
Knob *	PyScript_knob (Knob_Callback f, NAME command, NAME n, LABEL l=0)
Knob *	CancelExecution_knob (Knob_Callback f, NAME n, LABEL l=0)
Knob *	Menu_knob (Knob_Callback f, const char *menuName, NAME name, LABEL label=NULL)
Knob *	Python_knob (Knob_Callback f, NAME command, NAME n, LABEL l=0)
Knob *	Pulldown_knob (Knob_Callback f, ENUM_LABELS e, NAME n, LABEL l=0)
Knob *	PyPulldown_knob (Knob_Callback f, ENUM_LABELS e, NAME n, LABEL l=0)
Knob *	Multiline_String_knob (Knob_Callback f, const char **p, NAME n, LABEL l=0, int lines=5)
Knob *	RangeStuff (Knob_Callback f, Knob *knob, const IRange &r)
Knob *	Int_knob (Knob_Callback f, int *p, const IRange &r, NAME n, LABEL l=0)
Knob *	Double_knob (Knob_Callback f, double *p, NAME n, LABEL l=0)
Knob *	Double_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=0)
Knob *	Float_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=0)
Knob *	Float_knob (Knob_Callback f, float *p, const IRange &r, NAME n, LABEL l=0)
Knob *	ChannelMask_knob (Knob_Callback f, ChannelSet *p, NAME n, LABEL l=0)
Knob *	Input_ChannelMask_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=0)
Knob *	InputOnly_ChannelMask_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=0)
Knob *	WH_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=0)
Knob *	Scale_knob (Knob_Callback f, double *p, NAME n, LABEL l=0)
Knob *	Scale_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=0)
Knob *	Color_knob (Knob_Callback f, float *p, const IRange &r, NAME n, LABEL l=0)
Knob *	AColor_knob (Knob_Callback f, float *p, const IRange &r, NAME n, LABEL l=0)
Knob *	List_knob (Knob_Callback f, std::vector< std::vector< std::string > > *p, NAME n, LABEL l=0)
Knob *	Table_knob (Knob_Callback f, NAME n, LABEL l=0)
Knob *	Range_knob (Knob_Callback f, double *p, int np, int ixp, NAME n, LABEL l=0, double min=0.0, double max=1.0)
Knob *	Tab_knob (Knob_Callback f, int level, LABEL label)
Knob *	Link_knob (Knob_Callback f, const char *linkto, NAME name, LABEL label=0)
Knob *	Multiline_Eval_String_knob (Knob_Callback f, const char **p, NAME n, LABEL l=0, int lines=5)
Knob *	Eval_String_knob (Knob_Callback f, const char **p, NAME n, LABEL l=0)
Knob *	TextEditor_knob (Knob_Callback f, const char **p, NAME n, LABEL l=0, int lines=5)
Knob *	Toolbox_knob (Knob_Callback f, int *p, bool expanded, ENUM_LABELS e, NAME n, LABEL l=0, bool changeOnClick=false)
Knob *	GeoSelect_knob (DD::Image::Knob_Callback f, const char *name)
Knob *	ControlPointCollection_knob (Knob_Callback f, NAME n, LABEL l=0)
Knob *	MetaKeyFrame_knob (Knob_Callback f, NAME n, LABEL l=0, const DD::Image::MetaKeyFrameOptions &options=DD::Image::MetaKeyFrameOptions())
Knob *	TransformJack_knob (Knob_Callback f, NAME n)
Knob *	Ripple_knob (Knob_Callback f, NAME n, LABEL l=0)
Knob *	Disable_knob (Knob_Callback f, bool *p, NAME n, LABEL l=0)
Knob *	FrameExtent_knob (Knob_Callback f, DD::Image::FrameExtentProviderI *prov, NAME n, LABEL l=0)
Knob *	Radio_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=0)
std::ostream &	operator<< (std::ostream &o, const Matrix4 &matrix)
std::vector< double >	Matrix4ToVector (const Matrix4 &matrix)
Matrix4	VectorToMatrix4 (const std::vector< double > &matrix)
void	Matrix4ToArray (Matrix4 &matrix, double *arr)
void	Matrix3x4ToArray (Matrix4 &matrix, double *arr)
std::ostream &	operator<< (std::ostream &o, const Memory::bytes &c)
double	noise (double x)
double	noise (double x, double y)
double	noise (double x, double y, double z)
double	fBm (double x, double y, double z, int octaves, double lacunarity, double gain)
double	turbulence (double x, double y, double z, int octaves, double lacunarity, double gain)
double	p_random (int x)
double	p_random (int x, int y)
double	p_random (int x, int y, int z)
double	p_random (double x)
double	p_random (double x, double y)
double	p_random (double x, double y, double z)
template<class T >
T	op_cast (Op *op)
	Cast an op to a known subclass. This is cheaper than dynamic_cast, as well as being safer over module boundaries.
template<>
Iop *	*op_cast< Iop >** (Op *op)
template<>
GeoOp *	*op_cast< GeoOp >** (Op *op)
template<>
ParticleOp *	*op_cast< ParticleOp >** (Op *op)
template<>
DeepOnlyOp *	*op_cast< DeepOnlyOp >** (Op *op)
template<typename Function >
void	ParallelFor (unsigned int numItems, Function f, unsigned int maxThreads=0, unsigned int minItems=1000)
template<typename Function >
void	ParallelForRange (unsigned int numItems, Function f, unsigned int maxThreads=0, unsigned int minItems=1000)
int	plugin_count ()
const char *	plugin_name ()
const char *	plugin_name (int n)
const char *	plugin_find (const char name, const char const *extensions=0)
const char *	plugin_load (const char name, const char altname=NULL)
	load a plugin with the basename 'name' (or 'altname' if specified and nothing by name can be found)
void *	plugin_load (const char name, void (test)(const char ), const char arg, const char symbol=0)
const char *	plugin_load_all (const char *name)
const char *	plugin_load_one (const char *name)
const char *	plugin_path (int n)
void	plugin_addpath (const char *)
void	plugin_appendpath (const char *)
const char *	plugin_error ()
void	plugin_error (const char *)
void *	plugin_binary (const char name, const char symbol=0)
const char *const	plugin_default_extensions ()
const std::vector< const char * > &	plugin_path_list (int n)
void	setPluginHashCheck (bool lEnabled)
const std::vector< const char * > &	getPluginPath ()
	Returns the entire plugin path as a vector.
void	setPluginInstallPaths (const std::vector< std::string > &paths)
const std::vector< std::string > &	getPluginInstallPaths ()
const char *	getApplicationPluginPath ()
void	RemoveRendererFromSceneLights (DD::Image::Scene pScene, DD::Image::Render depthMapCandidate)
void	PostAbortTeardown ()
void	InitialiseThread ()
void	GetScreenToWorldRay (ViewerContext *ctx, int screenX, int screenY, Ray &ray)
size_t	DataTypeSizeInBytes (DataTypeEnum dataType)
Particles *	MakeRenderParticles (Point::RenderMode renderMode, unsigned points, unsigned start, bool haveNormals, float particleSize)
float	GetRenderParticlesPointSize (const Primitive *prim)
void	createRIPContext ()
void	destroyRIPContext ()
	mFnCreateGlobalSTLAllocator (STLAllocator, DefaultAllocator::getInstance())
void	TextureMipSample (const Vector2 &center, const Vector2 &dU, const Vector2 &dV, TextureFilter filter, Iop *mip, Pixel &out)
void	SleepMS (int ms)
void	sleepFor (double seconds)
void	setThreadGUIMode (bool guiMode)
	Threading needs to know whether the GUI is active for priority settings.
std::ostream &	VersionStreamPut (std::ostream &s, const DD::Image::Version &v)
	put to a stream. Doesn't persist the date yet
std::istream &	VersionStreamGet (std::istream &s, DD::Image::Version &v)
	get from a stream. The thing should be in the regex format above. Doesn't persist the date yet
bool	VersionLessThan (const Version &a, const Version &b)
bool	VersionCompare (const Version &a, const Version &b)
bool	style_needs_wireframe (int x)
template<class T , class Out >
void	CombineOverlappingSamplesT (const ChannelMap &channels, const T &deepPixel, Out &pixels)
GeoSelection &	DefaultGetGeometrySelection ()
void	initCachedGLFunctionsTable ()
void	internalglBegin ()
void	internalglEnd ()
void	internalglVertex2f ()
void	internalglVertex2fv ()
void	internalglVertex3f ()
void	internalglVertex3fv ()
void	internalglNormal3f ()
void	internalglColor3f ()
void	internalglColor4fv ()
void	internalglColor4ub ()
void	internalglLineWidth ()
void	internalglLineStipple ()
void	internalglPushAttrib ()
void	internalglPopAttrib ()
void	internalglPushMatrix ()
void	internalglPopMatrix ()
void	internalglMatrixMode ()
void	internalglLoadIdentity ()
void	internalglEnable ()
void	internalglDisable ()
void	internalglHint ()
void	internalglLoadName ()
void	internalglLoadMatrix ()
void	internalStoreColor ()
void	internalRestoreColor ()
void	internalPointSize ()
void	internalglTranslatef ()
void	internalglScaled ()
void	internalglAlphaFunc ()
void	internalglBlendFunc ()
void	internalglDepthMask ()
void	internalglClear ()
void	internalglDepthFunc ()
void	internalglFlush ()
void	internalglPolygonMode ()
void	internalglColor4f ()
void	internalglTexCoord2f ()
void	internalglVertex2i ()
void	internalglOrtho ()
void	internalglVertex2d ()
void	internalglScalef ()
void	internalglRotatef ()
void	internalglRotated ()
void	internalRectf ()
void	internaluglColor ()
void	internaluglText ()
void	internaluglRectangle ()
void	internaluglEllipse ()
void	internaluglPolygon ()
template<int stride>
void	fillSpan (float *dst, float value, size_t len)
template<int stride>
void	copySpan (float dst, const float src, size_t len)
void	PrintKnobChangedInValidateWarning (Knob *k)
void	FnLicensingShutdown ()
std::string	reformatTime (const std::string &timestamp)
bool	DefaultGetBoolPreference (const char *name)
unsigned int	DefaultGetUIntPreference (const char *name)
int	DefaultGetIntPreference (const char *name)
float	DefaultGetFloatPreference (const char *name)
double	DefaultGetDoublePreference (const char *name)
std::string	DefaultGetStringPreference (const char *)
std::string	DefaultGetLocalisationPath ()
std::vector< Op * >	GetAllConnectedOps (Op *lpRoot)
	Returns a vector of all ops connected to the given one (including the original)
std::string	GetOpText (const Op *lpOp, ShowMessagesOption lShowMsgs=eSMO_ShowMessages)
	Returns text describing the op, or an appropriate valid string if null.
std::string	GetOpTreeText (const OpTree *lpTree)
	Returns text describing the op tree, or an appropriate valid string if null.
bool	RecursiveGetStepsPerFrame (ParticleOp op, std::set< ParticleOp > &ops, bool &gotStepsFrame, int &stepsFrame)
int	RecursivePushParticleOps (ParticleOp lPop, std::vector< ParticleOp > &ops, std::vector< unsigned > &masks, int &nextBit)
void	RecursiveGetStartFrame (ParticleOp op, std::set< ParticleOp > &ops, double &startFrame)
void	RecursiveUseFilesystem (ParticleRender op, std::set< ParticleRender > &ops, bool &useFilesystem, bool &filesystemReadOnly, bool &renderingCache)
	Searches Particle tree for a ParticleCache node and retrieves settings. Called on each ParticleOp in tree.
	static_assert (sizeof(fake_bool)==sizeof(bool),"")
	mFnAssertStatic (sizeof(ParticleSystem::Source)==sizeof(Particle::DiskSource))
	mFnAssertStatic (sizeof(Node *)==sizeof(long long))
	mFnAssertStatic (sizeof(int)==sizeof(ParticleBehaviour::FalloffType))
	mDefineAccessors (Vector3, _initialPosition, particleInitialPosition) mDefineAccessors(Vector3
particlePosition	mDefineAccessors (Vector3, _lastPosition, particleLastPosition) mDefineAccessors(Vector3
particlePosition particleVelocity	mDefineAccessors (Vector3, _size, particleSize) mDefineAccessors(Vector4
particlePosition particleVelocity particleColor	mDefineAccessors (Quaternion, _orientation, particleOrientation) mDefineAccessors(Vector3
particlePosition particleVelocity particleColor particleRotationAxis	mDefineAccessors (float, _rotationAngle, particleRotationAngle) mDefineAccessors(float
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity	mDefineAccessors (float, _mass, particleMass) mDefineAccessors(float
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife	mDefineAccessors (float, _expirationChance, particleExpirationChance) mDefineAccessors(float
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleT	mDefineAccessors (float, _startTime, particleStartTime) mDefineAccessors(int
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleT particleId	mDefineAccessors (ParticleChannelSet, _channels, particleChannels) mDefineAccessors(unsigned int
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleT particleId particlePathMask	mDefineAccessors (bool, _active, particleActive) mDefineAccessors(ParticleSystem
ChannelSet	MaskRequestedChannelsForPlane (const Iop *iop, const ChannelSet &planeChannels)
std::set< ChannelSet >	MaskRequestedChannelsForPlaneSet (const Iop *iop, const std::set< ChannelSet > &planeChannels)
const char *	plugin_is_loaded (const char *name)
bool	ParseDDImageAbiVersionFromDLErrorMessage (const char *dlErrorMessage, int &majorVersion, int &minorVersion)
bool	ParseBlinkLibraryAbiVersionFromDLErrorMessage (const char *dlErrorMessage, int &majorVersion, int &minorVersion)
float	MyClamp (float in)
bool	test_small_block_allocator ()
void	PolygonTriangulate (const Primitive poly, const int face, const PointList pointList, std::vector< unsigned > &triangles)
AddOp
Adds an op and its connected input ops to the specified trees
void	AddOpToTrees (Op lpOp, const std::vector< OpTree > &lrTrees)
void	AddOpToTree (Op lpOp, OpTree lpTree)
RemoveOp
Removes an op and its connected input ops from the specified trees
void	RemoveOpFromTrees (Op lpOp, const std::vector< OpTree > &lrTrees)
void	RemoveOpFromTree (Op lpOp, OpTree lpTree)
Variables
const Version	gVersion
const Version *	gApplicationVersion
double	gScriptVersion
bool(*	scriptExec )(const char *, bool)
bool(*	scriptEval )(const char *)
bool(*	scriptSingle )(const char *)
void(*	showScriptErrorPopup )()
const char *const	group_names []
const char *const	render_modes []
const char *const	render_modes_source []
const size_t	kInterestImplReserveSize
const char	INVISIBLE []
	FN_MEMORYHOLDERFACTORY_SPECIALIZATION
	FN_MEMORYREGISTRANT_SPECIALIZATION
const char *const	plane_orientation_modes []
const char *const	subdivision_modes []
const char *	kViewerBGColor
const char *	kViewerFGColor
const char *	kViewerBGColor3D
const char *	kViewerFGColor3D
const char *	kViewerSelColor3D
const char *	kUIHighlightColor
const char *	kUIHighlightedTextColor
const char *	kUIFontSize
const char *	kViewerWorldCoordinateSystem
const char *	kViewerHandleSize
const char *	kViewerHandlePickSize
const char *	kViewerHandleSize3D
const char *	kViewerHandlePickSize3D
const char *	kChannelWarningThreshold
bool(*	GetBoolPreference )(const char *name)
unsigned int(*	GetUIntPreference )(const char *name)
int(*	GetIntPreference )(const char *name)
float(*	GetFloatPreference )(const char *name)
double(*	GetDoublePreference )(const char *name)
std::string(*	GetStringPreference )(const char *name)
std::string(*	GetLocalisationPath )()
float(*	root_real_fps )()
OpManager	gOpManager
	Global singleton-style manager object - not a true singleton due to compiler and module issues.
bool	plugin_verbose
bool	plugin_safe_mode
bool(*	plugin_interpret_tcl )(const char *name)
bool(*	plugin_interpret_py )(const char *name)
const char *	plugin_ext
	! The standard extension used for plugins on this platform (e.g. ".so" or ".dll")
DD::Image::ViewerEvent(*	context_menu )(ViewerContext , Menu )
void(*	menu_add )(Menu , const char , int shortcut, int event)
void(*	menu_stuff )(Menu *, int command, int event)
void(*	menu_set_data )(Menu , int event, MenuItemData data)
const MenuItemData (	menu_get_data )(Menu *, int event)
bool(*	evaluateString )(const char string, int expandFlags, NodeI node, const OutputContext &oc, std::string &expandedString)
std::string(*	getClipboardContents )()
void(*	setClipboardContents )(std::string &text)
const char *const	display3d_names []
const char *const	display3d_names_source []
const ViewerContext (	activeViewerContext )()
void(*	setSelectionMode3D )(SelectionMode3D newMode)
void(*	setSelection3D )(const DD::Image::GeoSelection &newSelection)
const DD::Image::GeoSelection (	getSelection3D )()
void(*	viewThroughCamera )(const CameraOp *camOp, CameraLockMode lockMode)
bool	_createdAllocators
Lock	_AllocatorLock
bool(*	isColourSamplingFromCache )(const Hash &hash)
Callbacks *	gCallbacks
Channel(*	pGetChannel )(const char *, bool)
size_t(*	pGetChannelCount )()
Channel(*	pFindChannel )(const char *)
const char (	pGetName )(Channel)
const char (	pGetLayerName )(Channel)
unsigned(*	pColourIndex )(Channel, const char *layer)
Channel(*	pBrother )(Channel, unsigned)
bool(*	pCompareChannels )(Channel, Channel)
const int	gMaxPixelValueSize
void (	profileRequestEventPointer )(const std::string &name, const uint32_t &color)
void(*	profileEventPointerComplete )(void *&)
void(*	profileEventStart )(void *&)
void(*	profileEventStop )(void *&)
std::string(*	path_remap )(const std::string &)=0
void(*	set_knob_disallowed_to_edit )(const Knob *const)
GeoSelection &(*	get_geometry_selection )()
void(*	gl_text_cb )(const char *, int)
const unsigned int	kCacheGlVertex3f
const unsigned int	kCacheGlBegin
const unsigned int	kCacheGlEnd
const unsigned int	kCacheGlVertex2f
const unsigned int	kCacheGlVertex2fv
const unsigned int	kCacheGlColor3f
const unsigned int	kCacheGlColor4fv
const unsigned int	kCacheGlColor4ub
const unsigned int	kCacheGlLineWidth
const unsigned int	kCacheGlLineStipple
const unsigned int	kCacheGlPushAttrib
const unsigned int	kCacheGlPopAttrib
const unsigned int	kCacheGlPushMatrix
const unsigned int	kCacheGlEnable
const unsigned int	kCacheGlDisable
const unsigned int	kCacheGlHint
const unsigned int	kCacheGlLoadName
const unsigned int	kCacheGlLoadMatrix
const unsigned int	kCacheGlPopMatrix
const unsigned int	kCacheGlMatrixMode
const unsigned int	kCacheGlLoadIdentity
const unsigned int	kCacheGlPointSize
const unsigned int	kCacheGlNormal3f
const unsigned int	kCacheGlTranslate3f
const unsigned int	kCacheGlScaled
const unsigned int	kCacheGlAlphaFunc
const unsigned int	kCacheGlBlendFunc
const unsigned int	kCacheGlDepthMask
const unsigned int	kCacheGlClear
const unsigned int	kCacheGlDepthFunc
const unsigned int	kCacheGlFlush
const unsigned int	kCacheUglColor
const unsigned int	kCacheUglStoreColor
const unsigned int	kCacheUglRestoreColor
const unsigned int	kCacheUglText
const unsigned int	kCacheGlPolygonMode
const unsigned int	kCacheGlColor4f
const unsigned int	kCacheGlTextCoord2f
const unsigned int	kCacheGlVertex2i
const unsigned int	kCacheGlOrtho
const unsigned int	kCacheGlVertex2d
const unsigned int	kCacheGlScalef
const unsigned int	kCacheGlRectf
const unsigned int	kCacheGlVertex3fv
const unsigned int	kCacheGlRotatef
const unsigned int	kCacheGlRotated
const unsigned int	kCacheUglRectangle
const unsigned int	kCacheUglEllipse
const unsigned int	kCacheUglPolygon
const unsigned int	kCacheEnd
const unsigned int	kCacheFunctions
const unsigned int	kInitCacheSize
const float	kCacheGrowDelta
const unsigned int	kInvalidPass
std::array < detail::CacheFunction, kCacheFunctions >	cacheTable
Iop (	iop_default_input )(const Iop *thisIop, const OutputContext &)
bool(*	iop_set_texturemap )(Iop , ViewerContext , bool)
void(*	Description_callback )(Description , void(f)(Description *), Description::NodeBuilder nodeBuilder)
const OutputContext &(*	node_uiContext )(Node *)
const Format &(*	node_input_format )(Node *)
void(*	knob_make_handle )(Knob knob, Knob::HandleContext command, ViewerContext ctx, Knob::Handle cb, Knob::HandleBatch cbBatched, int index, const DD::Image::Vector3 &pos, ViewerContext::Cursor cursor)
void(*	knob_begin_handle )(Knob knob, Knob::HandleContext command, ViewerContext ctx, Knob::Handle cb, Knob::HandleBatch cbBatched, int index, const DD::Image::Vector3 &pos, ViewerContext::Cursor cursor)
void(*	knob_end_handle )(ViewerContext *ctx)
int(*	node_replace_knobs )(Node , Knob afterthis, int n, void(f)(void , Knob_Callback), void , const char fileExt)
bool(*	knob_is_selected )(const Knob , ViewerContext , Knob::Handle , Knob::HandleBatch , int)
void(*	knob_get_selected_indices )(const Knob , Knob::Handle , Knob::SelectedIndexVector &allIndices)
bool(*	knob_clear_selected )(Knob , ViewerContext )
bool(*	knob_toggle_selected )(Knob , ViewerContext , Knob::Handle , Knob::HandleBatch , int)
bool(*	knob_is_focused )(Knob , ViewerContext , Knob::Handle , Knob::HandleBatch , int)
int(*	knob_selection_size )(Knob , ViewerContext )
void(*	script_list_create )(const char , int , const char ***)
void(*	script_list_free )(char *)
Knob (	node_knob )(Node , const char )
Knob (	node_knob_index )(Node *, int)
Op (	knob_op )(const Knob *)
bool(*	node_disabled )(Node *)
bool(*	node_is_unlicensed )(Node *)
bool(*	knob_is_disallowed_to_edit )(Node , const Knob const)
void(*	node_set_unlicensed )(Node *)
bool(*	node_panel_visible )(Node *)
bool(*	node_selected )(Node *)
std::string(*	node_class )(Node *)
unsigned(*	node_gl_color )(Node *)
bool(*	knob_to_double )(Knob , const char , double &)
void(*	knob_new_undo )(Knob , const void , const std::string &)
void(*	knob_extra_undo )(Knob *)
void(*	knob_add_to_undo )(Knob *)
void(*	knob_stop_add_to_undo )(Knob *)
bool(*	knob_doing_undo_redo )()
void(*	knob_changed )(Knob *)
void(*	knob_enabled )(Knob *)
void(*	knob_disabled )(Knob *)
void(*	knob_hidden )(Knob *)
void(*	knob_shown )(Knob *)
void(*	knob_relabelled )(Knob *)
void(*	knob_tooltip_changed )(Knob *)
void(*	knob_undo )(Knob *)
void(*	knob_redo )(Knob *)
void(*	knob_redraw )(Knob *)
void(*	knob_undoless )(Knob *, bool undoless)
void(*	knob_renamed )(Knob *)
void(*	knob_deleting )(Knob *)
VersionNumbers (	knob_version )(const Knob *)
bool(*	execPythonKnob )(const char , Knob )
bool(*	validateFilename )(const char , Node )
void(*	node_asapUpdate )(Node , const Box , int)
std::string(*	getFullyQualifiedName )(const Knob *, int idx)
LUTMapper (	NukeLUTMapperFactoryFuncPointer )(Op *pOp)
Op (	node_get_firstop )(const Node *node)
int(*	op_node_inputs )(const Op *)
Op (	op_node_input )(const Op , int, Op::GenerateType, const DD::Image::OutputContext outputContext)
void(*	op_update_handles )(const Op *)
Hash(*	knob_curve_hash )(const Op *op)=0
bool(*	knob_op_current )(const Op *op)=0
void(*	op_begin_handle )(Op op, Op::HandleType command, ViewerContext ctx, Op::EventCallback *cb, int index, float x, float y, float z, ViewerContext::Cursor cursor)
void(*	op_end_handle )(ViewerContext *ctx)
Op::NodeContext(*	op_node_context )(const Node *)
DD::Image::NodeI (	convertNodeToInterface )(Node *)
Op (	op_root )(const Op *)
bool(*	node_script_command )(Node , const char , bool py, bool eval)
bool(*	node_script_expand )(Node , const char , int)
const char (	node_script_result )()
const char (	node_script_result_py )()
void(*	node_script_unlock )()
int(*	op_message_vf )(char, const char *, va_list)
void(*	op_add_timeout )(float t, TimeoutHandler, void *)
void(*	op_repeat_timeout )(float t, TimeoutHandler, void *)
bool(*	op_has_timeout )(TimeoutHandler, void *)
void(*	op_remove_timeout )(TimeoutHandler, void *)
bool(*	op_pushed )(const Op *)
void(*	op_add_input_handle )(const Op , int, ViewerContext )
Op::HandlesMode(*	op_any_input_handle )(const Op , ViewerContext )
Op (	op_get )(const Op , const Op::Description )
void(*	op_setKnobsToContext )(Op *, const OutputContext &)=0
void(*	op_gotoContext )(Op *, const OutputContext &, bool)=0
double(*	evaluate )(const Animation *, double t)
bool	gTimingEnabled
bool	gParticleCacheDebugMessages
	_position
particlePosition	_velocity
particlePosition particleVelocity	_color
particlePosition particleVelocity particleColor	_rotationAxis
particlePosition particleVelocity particleColor particleRotationAxis	_rotationVelocity
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity	_life
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife	_t
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleT	_id
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleT particleId	_pathMask
bool	plugin_unapproved
const char *	ddimage_program_name
const char *	first_in_plugin_path
const int	kAveragePointsPerCell
const unsigned int	kMaxGridSize
Foundry::Type::AtomicCount32	gNextRayID
RIP::Compute::ContextIP	gRipContext
bool(*	ShapeKnob_keys )(ShapeKnob *, int, float)
bool(*	ShapeKnob_handle )(ShapeKnob *, int, double)
Knob (	ShapeKnob_constructor )(Knob_Closure , ShapeKnob , const char , const char )
float(*	ShapeKnob_time )(const ShapeKnob *, int)
float(*	ShapeKnob_shape )(const ShapeKnob *, double)
bool	gShowTransformPreview
void(*	doInitCache )()

Detailed Description

All functions and classes that are used for image processing by Nuke Plugins are in this namespace. Some utility and cross-platform compatibility functions are not in this namespace.

Typedef Documentation

typedef unsigned DD::Image::GeometryMask

Geometry part mask. Each bit represents a logical geometric component.

typedef SignalLock DD::Image::SlowSignalLock

This is for back compatibility only

Enumeration Type Documentation

enum DD::Image::AttribType

Attribute data type enumerations.

Enumerator:

INVALID_ATTRIB	Data type not set.
FLOAT_ATTRIB	1 float
VECTOR2_ATTRIB	Vector2(2 floats)
VECTOR3_ATTRIB	Vector3(3 floats)
VECTOR4_ATTRIB	Vector4(4 floats)
NORMAL_ATTRIB	Normal vector - Vector3(3 floats)
INT_ATTRIB	Int.
STRING_ATTRIB	Char*.
STD_STRING_ATTRIB	std::string. Variable size
POINTER_ATTRIB	Void*.
MATRIX3_ATTRIB	Matrix3 (9 floats)
MATRIX4_ATTRIB	Matrix4 (16 floats)

enum DD::Image::Channel

Channel ID numbers. These are used to index arrays of pixel data, such as in the DD::Image::Row object.

A plugin can use these pre-defined ones. Nuke will also create new ones that are outside this set. DD::Image::getName() will return a string name of these.

A plugin can create channels by using DD::Image::getChannel(). DD::Image::findChannel() looks up channels by name but without creating them.

See also the class DD::Image::ChannelSet.

Enumerator:

Chan_U	used mostly for 2d ops, 1/distance (so, 0 = infinitely far away)
Chan_DeepBack	used mostly for deep ops, distance to front of sample (0=at camera, inf=infinitely far away)
Chan_Mask_PlanarTrack	used mostly for deep ops, distance to front of sample (0=at camera, inf=infinitely far away)

enum DD::Image::ChannelSetInit

Bitmasks of various combinations of the predefined Channel numbers. These values can be used in most places a ChannelSet is expected. They will be cast to ChannelSet or used directly by the code.

Enumerator:

Mask_All

Special value that makes the ChannelSet contain all possible channels.

enum DD::Image::ChannelSet3DInit

Enumerator:

Mask_Px	Point x.
Mask_Py	Point y.
Mask_Pz	Point z.
Mask_Pw	Point w.
Mask_UVx	UV x.
Mask_UVy	UV y.
Mask_UVz	UV z.
Mask_UVw	UV w.
Mask_Nx	Normal x.
Mask_Ny	Normal y.
Mask_Nz	Normal z.
Mask_PLx	Local-space point x.
Mask_PLy	Local-space point y.
Mask_PLz	Local-space point z.
Mask_PWx	World-space point x.
Mask_PWy	World-space point y.
Mask_PWz	World-space point z.
Mask_MBx	Motion-blur x.
Mask_MBy	Motion-blur y.
Mask_MBz	Motion-blur z.
Mask_VELx	Point velocity vector x.
Mask_VELy	Point velocity vector y.
Mask_VELz	Point velocity vector z.

enum DD::Image::GroupType

Geometry part groups.

anonymous enum

Geometry part mask flags.

Enumerator:

Mask_Primitives	Primitive list.
Mask_Vertices	Vertex group.
Mask_Points	Point list.
Mask_Object	The Object.
Mask_Matrix	Local->World Transform Matrix.
Mask_Attributes	Attribute list.

enum DD::Image::RenderMode

Value for render_mode.

enum Display3DMode [related, inherited]

Value for GeoOp::display3d() and ViewerContext::display3d()

enum DD::Image::LookupCurvesType

Type for the lookup curves editor. Mostly affects background and framing. On the hue types the first and last keyframes will be synchronised.

anonymous enum

Transform-space enumerations for shaders. These numbers are used by the MatrixArray class to index the in/out space parameters.

Enumerator:

LOCAL_SPACE	Point in locally defined space.
WORLD_SPACE	Object transform applied.
EYE_SPACE	Inverse camera transform applied(camera becomes 0,0,0)
CLIP_SPACE	Camera projection applied, homogeneous-space.
SCREEN_SPACE	Homogeneous-space scaled to pixel coordinates.

enum DD::Image::FrameAdvance

Enumerator:

eFrameAdvanceStep	do not advance frame
eFrameAdvanceRandom	advance a frame each frame

enum DD::Image::MotionVectorType

Scene motion vector types.

Enumerator:

eDisableMotionVector	the motion vector is disable
eClassicMotionVector	classic and old way to do motion vector
eVelocityMotionVector	store velocity in motion vector channel
eDistanceMotionVector	store distance in motion vector channel

enum DD::Image::StringExpandFlags

"expand" the string by replacing tcl portions of the string with the final text. Returns true if successful, false otherwise.

This function is not thread-safe.

"[command]" is replaced with the result of executing that command, and "$variable" is replaced with the tcl variable.

The flags controls what is replaced. The following substitutions are done:

If the flag eStringExpandFilename is set, a leading "~/" is replaced by the value of $env(HOME), and a leading "~foo" is replaced by a guess of the user foo's home directory done by replacing the end of $env(HOME) (nuke does not bother with the passwd file). And the result is passed through filename_fix, if the command is defined.

If the flag eStringExpandFileNumber is set, a nd and ### sequences are replaced by the frame number from the ScriptContext argument, and V and v are replaced with the name and initial of the view.

"\x" (where x is any character including backslash) is replaced by "x". However the backslash prevents x from being interpreted in any way, so you can get square brackets or %% or other characters into the output.

enum DD::Image::DrawHandleType

The types of drawing handle that Nuke recognises. Geometry handles are always drawn, regardless of the selection mode; all other types are only drawn when the Nuke viewer is in the appropriate selection mode. The default mode is node selection, which corresponds to the original Nuke behaviour.

enum ViewerConnected [related, inherited]

Values for ViewerContext::connected()

Enumerator:

NOT_CONNECTED	There is no connection.
CONNECTED	There is a connection from here to viewer input.
SHOW_OBJECT	Connected, draw an object.
SHOW_PUSHED_OBJECT	Connected, draw object if node is pushed()

enum ViewerMode [related, inherited]

Value for ViewerContext::viewer_mode()

Enumerator:

VIEWER_2D	orthographic 2D
VIEWER_PERSP	perspective 3D
VIEWER_RSIDE	ortho 3D down -x axis
VIEWER_LSIDE	ortho 3D down +x axis
VIEWER_TOP	ortho 3D down -y axis
VIEWER_BOTTOM	ortho 3D down +y axis
VIEWER_FRONT	ortho 3D down -z axis
VIEWER_BACK	ortho 3D down +z axis

enum ViewerEvent [related, inherited]

Value for ViewerContext::event().

Enumerator:

NO_EVENT	only call menu(), otherwise ignore
DRAW_OPAQUE	solid objects/texture maps
DRAW_TRANSPARENT	transparent (below alpha threshold) 3D pass
DRAW_STIPPLED	draw things hidden behind solid objects
DRAW_SHADOW	shadows under lines in the 2D pass
DRAW_LINES	lines in 3D, and the entire 2D pass
MOVE	draw_handles() is being called to find tooltip
PUSH	user just pushed the mouse down, hit detection. Any handle callback which returns true for this event should also return true for DRAG and RELEASE
DRAG	user is dragging mouse, region selection hit detection. Any handle callback which returns true for this event should also return true for PUSH and RELEASE
RELEASE	user released the mouse. Any handle callback which returns true for this event should also return true for PUSH and DRAG
KEY	user hit a key
KEYUP	user let go of key
DROP	user dropped some data in a drag'n'drop operation
DROP_CHECK	user is dragging data over a handle
ENTER_VIEWER	the mouse has entered the viewer
EXIT_VIEWER	the mouse has exited the viewer
CURSOR	hit-detecting for a handle cursor
HOVER_ENTER	the hover was entered
HOVER_MOVE	user is hovering
HOVER_LEAVE	user has left hovering
DRAG_SELECT	user is drag-selecting handles
DRAG_SELECT_FINISHED	drag selection of handles has finished
FIRST_MENU	recommended start of Menu events

enum CameraLockMode [related, inherited]

Value for camera lock mode

enum DD::Image::SelectionMode3D

The selection modes for the 3d viewer. The default is eSelect3DNode, in which an entire node will be selected if you click on any part of it in the 3d viewer (the old Nuke behaviour). eSelect3DVertex will select individual vertices;

enum DD::Image::SelectionOptions3D

Selection options for the 3D viewer. These options appear in the same menu as the Selection modes above, so it's important that the first option's ID is

anonymous enum [related, inherited]

Value for ViewerContext::what_to_draw(). This is a bunch of checkmarks on the viewer. The viewer will implement some of these (such as transparency or lighting) by initializing the OpenGL state, but it may still be useful to check if they are off.

Enumerator:

SHOW_POINT_NORMALS	draw point normals
SHOW_VERTEX_NUM	draw vertex normals
SHOW_VERTEX_NORMALS	draw vertex normals
SHOW_PRIMITIVE_NUM	draw primitive number
SHOW_PRIMITIVE_NORMAL	draw primitive normal
SHOW_BBOX	draw bounding box around things
SHOW_TRANSPARENCY	transparency checkmark from viewer
SHOW_LIGHTING	lighting checkmark from viewer

anonymous enum [related, inherited]

Values for ViewerContext::key() and ViewerContext::is_down(). Same values as Qt. Use lowercase 'x' or the unshifted symbol for the printing character keys.

anonymous enum [related, inherited]

Values for ViewerContext::state(). On the Macintosh, the Command key gives CTRL and the Ctrl key gives META.

anonymous enum [related, inherited]

Values for ViewerContext::pointer_type(). Valid for pen types when used with a tablet

enum DD::Image::FrustumVisibility

Frustum visibility result.

Enumerator:

eNotVisible	the primitive is completely outside the view frustum
eFullVisible	the primitive is completely inside the view frustum
ePartialVisible	part of the primitive is inside the view frustum

Function Documentation

void DD::Image::SetValueProvider	(	Knob_Callback	f,
		ArrayKnobI::ValueProvider *	valueProvider
	)

set the valueProvider on the most recently made Knob. if f.makeKnobs() is not true, or the that knob is not an ArrayKnobI, is a no-op. For calling from knobs(Knob_Callback) like calls to SetFlags()

void DD::Image::incr ( Channel & c ) [inline]

Adds one to the Channel and returns it.

Referenced by DD::Image::Row::offset().

std::ostream & DD::Image::operator<<	(	std::ostream &	o,
		Channel	channel
	)

This prints getName(channel), but prints the number if the name is null.

References getName().

Channel DD::Image::getChannel	(	const char *	name,
		bool	sort = `true`
	)

Find or create a channel with this name. Plugins can call this to get the number for any channels they want to output.

For instance if you output something called "shadow" for each pixel, you may want to call this with "shadow" as an argument in order to get what channel to write to. All calls to get "shadow" will return the same number. If you output an xyz triplet called "position" you may want to call this with "position.x", "position.y", and "position.z".

Text before the last period is used to create or find the layer. If there is no period, it makes a layer called "other" (this may change in future versions). If sort is true, then the channel is insertion-sorted into the layer so that r,g,b,a are first and then the rest of the channels are in alphabetical order. If sort is false then the channel is appended to the end of the layer. (this sorting was needed because the exr library produces the channels in a random order due to the use of a hash table).

Referenced by DD::Image::Iop::channel().

size_t DD::Image::getChannelCount ( )

Get the number of channels currently registered.

Channel DD::Image::findChannel ( const char * name )

Find a channel with this name. Plugins can call this to get the number for any channels they want to output.

const char * DD::Image::getName ( Channel channel )

Returns a string name to print for the channel, or NULL if it cannot figure it out. This is a full "layer.chan" name.

Referenced by DD::Image::Iop::channel_name(), operator<<(), and DD::Image::Memory::register_allocator().

const char * DD::Image::getLayerName ( Channel channel )

Returns the name of the layer this channel belongs to, or NULL if it can't find a layer.

unsigned DD::Image::colourIndex	(	Channel	channel,
		const char *	layer = `0`
	)

Returns 0 if this channel is "red", 1 if it is "green", 2 if it is "blue", and 3 for all other possibilities.

Referenced by DD::Image::DrawIop::pixel_engine().

Channel DD::Image::brother	(	Channel	channel,
		unsigned	index
	)

Return a channel such that colourIndex(n) returns the given index, and it belongs to the same layer as channel. This is used to find the related colours. You can also use this to find all the channels in a layer by incrementing the index until this returns Chan_Black.

Returns Chan_Black if no such channel exists.

Also see DD::Image::ChannelSet::addBrothers().

bool DD::Image::compareChannels	(	Channel	a,
		Channel	b
	)

Compares two channels to determine ordering based on purpose. For example, a channel with purpose Chan_Red will order before one with purpose Chan_Green, regardless of the actual channel map ordering.

const Version& DD::Image::version ( ) [inline]

Returns a structure that you can query to get the DDImage version in various forms, such as text or numbers.

Referenced by DD::Image::GeoOp::synchronize_cache().

const Version& DD::Image::applicationVersion ( ) [inline]

Returns a structure that you can query to get the Nuke version in various forms. This does not work if DDImage is not being used by Nuke.

double DD::Image::scriptVersion ( ) [inline]

This is a version of Nuke that was used to write the currently loading script, encoded as M.mr where M is the major number and m is the minor, and r is a revision. If a script is not being currently loaded this is set to applicationVersion().majorMinorReleaseDouble() which is the number that will be saved when a script is written. This can be used to preset back-compatibility knobs in an Op.

void DD::Image::CombineOverlappingSamples	(	const ChannelMap &	channels,
		const DeepPixel &	deepPixel,
		DeepSampleVector &	pixels
	)

combines overlapping samples from within /deepPixel/ into a number of non-overlapping samples, output in /pixels/ will omit any samples after a sample with alpha 1.

bool DD::Image::RenameTempToFinal	(	const char *	lpTempName,
		const char *	lpFinalName,
		Op *	lpOp
	)

Renames a temporary file to its final name. On failure, it sets an appropriate error message on the supplied op.

Returns:: True iff the rename succeeded. If false, an error message will be set.

References DD::Image::Op::critical().

Referenced by DD::Image::DeepWriter::closeFile().

const AttribContext* DD::Image::GetGeoInfoAttribContext	(	const GeoInfo *	info,
		const char *	attribName,
		AttribType	attribType
	)		`[inline]`

Get a valid and not empty attribute context from GeoInfo

References DD::Image::AttribContext::name, and DD::Image::AttribContext::type.

void DD::Image::glColor ( unsigned c )

Set the current OpenGL color to a color specified by the bytes of the unsigned value. The highest byte is red, the next green, then blue, then alpha. For instance 0xff00ff00 is purple (red+blue). This is the same form the Nuke and fltk use to identify GUI colors. Currently the alpha value is ignored.

Referenced by DD::Image::Transform::draw_handle(), DD::Image::LightOp::draw_handle(), DD::Image::ComplexLightOp::draw_handle(), DD::Image::CameraOp::draw_handle(), DD::Image::AxisOp::draw_handle(), gl_axis(), and gl_axis_label().

void DD::Image::gl_text ( const char * str )

Draw the null-terminated string, appending it to the previous string or at the last call to glRasterPos.

Referenced by DD::Image::LightOp::draw_handle(), DD::Image::ComplexLightOp::draw_handle(), DD::Image::CameraOp::draw_handle(), DD::Image::AxisOp::draw_handle(), DD::Image::Primitive::draw_primitive_num(), DD::Image::Primitive::draw_vertex_num(), DD::Image::Primitive::draw_vertex_uvs(), gl_axis_label(), gl_drawTextTopLeftOrthogonal(), and gl_text().

void DD::Image::gl_text	(	const char *	str,
		int	n
	)

Draw the first n bytes of the string, appending them to the previous string or last call to glRasterPos.

void DD::Image::gl_text	(	const char *	str,
		float	x,
		float	y,
		float	z = `0`
	)

Draw the null-terminated string, at position x,y,z. The font is controlled by the current glListBase(), Nuke will have preset this and it is probably best to leave it alone.

References gl_text().

void DD::Image::gl_text	(	const char *	str,
		int	n,
		float	x,
		float	y,
		float	z = `0`
	)

Draw the first n bytes of the string at position x,y,z

void DD::Image::gl_text	(	const char *	str,
		int	x,
		int	y,
		int	z = `0`
	)

Draw the null-terminated string, at position x,y,z. The font is controlled by the current glListBase(), Nuke will have preset this and it is probably best to leave it alone.

References gl_text().

void DD::Image::gl_text	(	const char *	str,
		int	n,
		int	x,
		int	y,
		int	z = `0`
	)

Draw the first n bytes of the string at position x,y,z

void DD::Image::gl_circlef	(	float	x,
		float	y,
		float	z,
		float	diam,
		int	plane,
		bool	filled = `false`,
		float	normal = `1.0f`
	)

gl_circle: Draw a circle or disc. Uses a precalculated cosine table of 51 entries encompassing 360degs. x, y, z = position of center of circle diam = diameter of circle plane = which plane to draw on: XY, YZ, XZ - Provided for convenience filled = whether to make them polygons

Referenced by gl_cylinderf(), and gl_sphere().

void DD::Image::gl_circlefAsTris	(	float	x,
		float	y,
		float	z,
		float	diam,
		float	lineWidth,
		int	plane,
		bool	filled = `false`,
		float	normal = `1.0f`
	)

gl_circlefAsTris: Draw a circle or disc using a tristrip. Uses a precalculated cosine table of 51 entries encompassing 360degs. x, y, z = position of center of circle diam = diameter of circle lineWidth = width of the circle border plane = which plane to draw on: XY, YZ, XZ - Provided for convenience filled = whether to make them polygons

void DD::Image::gl_cylinderf	(	float	x,
		float	y,
		float	z,
		float	width,
		float	diam1,
		float	diam2,
		int	plane,
		bool	capped = `true`,
		bool	filled = `false`
	)

gl_cylinder: Draw two connected discs forming a cylinder. Uses a precalculated cosine table of 51 entries encompassing 360degs. x, y, z = position of center of cylinder diam1 = diameter of endcap 1 diam2 = diameter of endcap 2 plane = which plane to draw in: XY, YZ, XZ - Provided for convenience filled = whether to make them polygons

References gl_circlef().

Referenced by DD::Image::CameraOp::draw_handle().

void DD::Image::gl_conef	(	float	x,
		float	y,
		float	z,
		float	length,
		float	diam,
		int	plane
	)

gl_cone: Draw a open or closed cone. Uses a precalculated cosine table of 51 entries encompassing 360degs. x, y, z = position of tip length = length of cone diam = diameter of cone plane = which plane to draw on: XY, YZ, XZ - Provided for convenience

Referenced by gl_axis().

void DD::Image::gl_sphere ( float radius = 0.5 )

Draw a wireframe sphere around 0,0,0

References gl_circlef().

Referenced by DD::Image::LightOp::draw_handle(), and DD::Image::ComplexLightOp::draw_handle().

void DD::Image::gl_planef	(	float	x,
		float	y,
		float	z,
		float	width,
		float	height,
		int	plane
	)

Draw a flat plane in any of the three basic planes

void DD::Image::gl_axis ( )

Draw a 3-D T with each beam 1 unit long

References gl_conef(), and glColor().

void DD::Image::gl_axis_label ( )

Draw labels at the ends of the T drawn by gl_axis()

References gl_text(), and glColor().

void DD::Image::gl_bezierf	(	float	x,
		float	y,
		float	x1,
		float	y1,
		float	x2,
		float	y2,
		float	x3,
		float	y3,
		float	scale = `1`
	)

Call glVertex2f with points on a 2-D bezier curve. x,y are the initial point, which is not drawn (this is done so several curves join together, you should draw the point yourself for the first curve in the sequence. The curve goes to x3,y3. x1,y1 and x2,y2 are the bezier handles.

Enough points are drawn so that the error of the curve is less than one pixel anywhere and the straight edges should not be visible. To to this it needs to know how big one unit is in pixels, this can be passed as scale.

This should not be used for curves that are way bigger than the viewport. The algorithim would normally divide the line into millions of pieces and waste a huge amount of time drawing the clipped pieces. This version does a maximum of 100 segments, so the machine does not lock up, but the result is then inaccurate.

void DD::Image::gl_drawTextTopLeftOrthogonal	(	const std::string &	text,
		DD::Image::ViewerContext *	ctx,
		bool	redColour = `true`
	)

draws text in the top left of the ViewerWindow tied to the ViewerContext. By default draws it in red text, if you want another colour, set redColour to false and set the colour before calling this then pop the attribute after calling this.

References gl_text(), DD::Image::Box::h(), DD::Image::Box::t(), DD::Image::ViewerContext::viewport(), DD::Image::ViewerContext::visibleViewportArea(), DD::Image::Box::w(), and DD::Image::Box::x().

const char * DD::Image::gl_errorstring ( int errorcode )

Print GL errors - reasonably emulates gluErrorString

Referenced by glGetErrors().

int DD::Image::glGetErrors ( const char * message = 0 )

Clear accumulated OpenGL errors. If FN_DEBUG is on, it prints them to stderr, prefixed with message. Returns number of errors found.

References gl_errorstring().

bool DD::Image::GLProject	(	float	x,
		float	y,
		float	z,
		const Matrix4 &	m,
		const Box &	vp,
		float *	winx,
		float *	winy,
		float *	winz
	)

Given a point x,y,z in world coordinates, project it into screen coordinates. The projection matrix and viewport dimensions are passed in as the parameters m and vp respectively.

I copied this from Viewer.cpp (where it's called gl_project).

References DD::Image::Box::h(), DD::Image::Box::w(), DD::Image::Box::x(), and DD::Image::Box::y().

Referenced by DD::Image::ViewerContext::getScreenBoundingBox().

std::string DD::Image::escape ( const char * w )

as operator<<(ostream&), but returns a string, and doesn't do any of the quotation mark stuff, which should be supplied by the caller if needed

References DD::Image::Knob::cstring::needQuotes().

void DD::Image::Tooltip	(	Knob_Callback	f,
		const char *	text
	)

This one avoids the overhead of converting a character pointer to a std::string if the value is not actually used.

Referenced by DD::Image::Transform::filter_knobs(), DD::Image::Executable::frameRangeKnobs(), DD::Image::DrawIop::input_knobs(), DD::Image::Transform::knobs(), DD::Image::ShutterControls::knobs(), DD::Image::NukeWrapper::knobs(), DD::Image::LookAt::knobs(), DD::Image::FrameRangeControls::knobs(), DD::Image::Filter::knobs(), and DD::Image::Transform::motionblur_knobs().

void DD::Image::Tooltip	(	Knob_Callback	f,
		const std::string &	text
	)

In an Op::knobs() function, this sets the tooltip of the previous knob.

void DD::Image::SetFlags	(	Knob_Callback	f,
		Knob::FlagMask	n
	)

In an Op::knobs() function, this turns on some flags on the previous knob. The initial setting of the flags is done by the knob-creating function, depending on the type of knob and the arguments to that function, but you can modify it with this. Warning: not all flag combinations are supported!

Values that work for any knob:

Knob::DISABLED Set by disable(), cleared by enable().
Knob::NO_ANIMATION Prevent the value from being animated. This removes any animation or view buttons, and it stops tcl expressions from being evaluated in string knobs, and may make it ignore attempts to set expressions or key frames (nyi).
Knob::HIDE_ANIMATION_AND_VIEWS Prevent animation and view buttons from being displayed. Animation is still possible, unless NO_ANIMATION is specified of course.
Knob::DO_NOT_WRITE Don't ever save this knob to a script (including copy & paste!)
Knob::INVISIBLE The knob does not appear in the panels. No widgets are created. This is not the same as hide(), and show() will not undo it!
Knob::RESIZABLE The knob can stretch in the panel so that it fills up all the remaining space in the line. Defaults to true for most of the complex knobs, but off for buttons, checkmarks, and pulldown lists.
Knob::STARTLINE This knob starts a new row in the panel. The default is true unless a zero-length (not NULL) string is passed as the label. Currently the default is false for checkmarks and buttons but this may change in future versions.
Knob::ENDLINE This knob will end a row, acts exactly like STARTLINE was set on the next knob. Set true for divider lines.
Knob::NO_RERENDER This knob does not contribute to the hash value for the op. This should be used on knobs that have no effect on the op's output.
Knob::NO_HANDLES Don't draw anything in the viewer, this is useful if the Op draws it's own indicators.
Knob::HANDLES_ANYWAY makes the handles appear in the viewer when the panel is open even if a different tab is selected.
Knob::HIDDEN Set by hide(), cleared by show().
Knob::NO_UNDO Don't undo/redo any changes to this knob. May be replaced with "output knob" in the future.
Knob::NO_KNOB_CHANGED: Don't bother calling Op::knob_changed() with this knob. This is turned on automatically if the knob_changed() returns false.
Knob::KNOB_CHANGED_ALWAYS will call node()->knob_changed() every time the value of the knob changes. Normally it is only called if the user changes the value with the panel open. This allows you to track all changes to the value. Be careful as knob_changed() will be called without storing the new values into your structure.
Knob::ALWAYS_SAVE save the knob to a script even if not_default() returns false. Deprecated, instead override not_default() and make it return true!
Knob::NODE_KNOB is used by Nuke internally for controls on the DAG appearance such as xpos and ypos.
Knob::MODIFIES_GEOMETRY should be set for any knob that modifies geometry, either by affecting the internal geometry directly or by changing its transform

Values that work for knobs that store numbers:

Knob::MAGNITUDE If there are several numbers, this enables a button to only show a single number, and all are set equal to this number. Default is true for WH_knob() and Color_knob().
Knob::SLIDER Turns on the slider. Currently this only works if the size is 1 or MAGNITUDE is enabled and it is set to single numbers. Defaults to on for most non-integer numerical controls.
Knob::LOG_SLIDER Tick marks on the slider (if enabled with SLIDER) are spaced logarithmically. This is turned on for WH_knob() and Color_knob(), and if the range has both ends greater than zero. If you turn this on and the range passes through zero, the scale is actually the cube root of the number, not the logarithim.
Knob::TINY_SLIDER Modifies SLIDER. The slider is shown as a thin strip underneath the LineEdit/SpinBox.
Knob::STORE_INTEGER Only integer values should be displayed or stored.
Knob::FORCE_RANGE Clamps the value to the range when storing.
Knob::ANGLE Turn on a little widget depicting this number as an angle.
Knob::NO_PROXYSCALE disables proxy scaling for XY or WH knobs. Useful if you just want two numbers called "x" and "y" that are not really a position. You probably also want to do NO_HANDLES.

Values that work for Enumeration_knob():

Knob::SAVE_MENU writes the contents of the menu to the saved script. Useful if your plugin modifies the list of items.

Values that work for BeginGroup():

Knob::CLOSED True for a BeginGroup knob that is closed

Values that work for ChanneSet_knob() and Channel_knob():

Knob::NO_CHECKMARKS Get rid of the individual channel checkmarks.
Knob::NO_ALPHA_PULLDOWN Get rid of the extra pulldown that lets you set the 4th channel to an arbitrary different layer than the first 3.

Values that work for Format_knob():

Knob::PROXY_DEFAULT makes the default value be the root.proxy_format rather than the root.format.

Referenced by DD::Image::Transform::filter_knobs(), DD::Image::DrawIop::input_knobs(), DD::Image::Transform::knobs(), DD::Image::ShutterControls::knobs(), DD::Image::NukeWrapper::knobs(), DD::Image::FrameRangeControls::knobs(), DD::Image::Transform::motionblur_knobs(), and DD::Image::DrawIop::output_knobs().

void DD::Image::ClearFlags	(	Knob_Callback	f,
		Knob::FlagMask	n
	)

In an Op::knobs() function, this turns off some flags on the previous knob. The initial setting of the flags is done by the knob-creating function, depending on the type of knob and the arguments to that function, but you can modify it with this. See DD::Image::SetFlags for a list of flags.

void DD::Image::SetRange	(	Knob_Callback	f,
		double	minimum,
		double	maximum
	)

In an Op::knobs() function, this sets the numeric range on the previous knob. The range if you don't do this is determined by the knob but in almost all cases it is 0-1.

Referenced by Deep_knob().

Knob* DD::Image::Obsolete_knob	(	Knob_Callback	f,
		const char *	linkto,
		NAME	name,
		const char *	script
	)		`[inline]`

Obsolete_Knob is used to throw away the values saved in scripts for knobs that are no longer in use. This knob will not be listed in lists of knobs or saved to files. But if you know it's name, scripting language or loading files can still set the knob or query it's value.

linkto, if not null, is the name of a knob to link to. Attempts to set or get information from the knob will instead act on this linked knob. If this is null only from_script() will work, all other calls will produce errors. This is very similar to Link_knob().

script, if this is not null, is a tcl script that is called instead of calling from_script() on the linked-to knob. This script is executed in the context of the node, and the text attempting to be stored into the knob is put in $value.

If both are null then the knob is ignored, attempts to set it are thrown away without any error.

Be careful with the argument order. It is set up to match the Link_knob() arguments and there is some back-compatibility problems.

Referenced by DD::Image::DrawIop::input_knobs(), DD::Image::Transform::knobs(), DD::Image::ShutterControls::knobs(), DD::Image::NukeWrapper::knobs(), and DD::Image::DrawIop::output_knobs().

Knob* DD::Image::Obsolete_knob	(	Knob_Callback	f,
		NAME	name,
		const char *	script
	)		`[inline]`

Back-compatibility of Obsolete_knob(), equivalent to passing null for the linketo knob.

Knob * DD::Image::Op_knob	(	Knob_Callback	f,
		Op *	op,
		NAME	name
	)

Produce the knob named name for op. This can be used to insert knobs from a child Op into your control panel. This is done by calling knobs() on the child with a special callback that looks for the name and if found it calls f with it.

References DD::Image::Op::knobs().

Knob* DD::Image::String_knob	(	Knob_Callback	f,
		const char **	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Store a string that is edited by the user. Nuke will manage the memory used by the string, do not free it in your destructor.

Knob* DD::Image::Password_knob	(	Knob_Callback	f,
		const char **	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Create a Password input field

Knob* DD::Image::String_knob	(	Knob_Callback	f,
		std::string *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Store a string that is edited by the user. Uses an STL string so no worries about memory ownership.

Knob* DD::Image::File_knob	(	Knob_Callback	f,
		const char **	p,
		NAME	n,
		LABEL	l = `0`,
		FileKnob_Type	type = `Normal_File`
	)		`[inline]`

Same as String_knob() but Nuke adds a file chooser, and the string is passed through the filename_fix scripting function before being stored.

Knob* DD::Image::Read_File_knob	(	ReadFileKnobOwner *	ptr,
		Knob_Callback	f,
		const char **	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Special knob for use by the ReadFileKnobOwners. Ops must implement that interface to include this knob.

Knob* DD::Image::Read_File_knob	(	ReadFileKnobOwner *	ptr,
		Knob_Callback	f,
		std::string *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Special knob for use by the ReadFileKnobOwners. Ops must implement that interface to include this knob.

Knob* DD::Image::Cached_File_knob	(	Knob_Callback	f,
		const char **	p,
		NAME	n,
		LABEL	l = `0`,
		FileKnob_Type	type = `Normal_File`
	)		`[inline]`

It allows for local file caching to be enabled on the node

Knob* DD::Image::Write_File_knob	(	Knob_Callback	f,
		const char **	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Special knob for use by the Write. This will present the user with two strings for full-size and proxy, and will store the string for the current setting. This may be usable by ops other than Write.

Knob* DD::Image::Write_File_knob	(	Knob_Callback	f,
		std::string *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Special knob for use by the Write. This will present the user with two strings for full-size and proxy, and will store the string for the current setting. This may be usable by ops other than Write.

Knob* DD::Image::Proxyless_Read_File_knob	(	ReadFileKnobOwner *	ptr,
		Knob_Callback	f,
		const char **	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Special knob for use by the Read Op only. It stores several other values in other fields of Read. Do not use except for the Read Op.

Knob* DD::Image::Int_knob	(	Knob_Callback	f,
		int *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Controls a single integer value.

Referenced by DD::Image::Executable::frameRangeKnobs(), and DD::Image::FileOp::Reload_Button().

Knob* DD::Image::Enumeration_knob	(	Knob_Callback	f,
		int *	p,
		ENUM_LABELS	e,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Controls an integer enumeration. The array of labels e will produce a pop-up list the user can choose from. The index into this list is stored. The first item will store a zero, etc. You can assume that only legal values are stored.

Referenced by DD::Image::ParticleBehaviour::Falloff_knob(), DD::Image::DrawIop::input_knobs(), DD::Image::ShutterControls::knobs(), DD::Image::LookAt::knobs(), DD::Image::FrameRangeControls::knobs(), DD::Image::Filter::knobs(), and DD::Image::DrawIop::output_knobs().

Knob* DD::Image::Bitmask_knob	(	Knob_Callback	f,
		unsigned int *	p,
		ENUM_LABELS	e,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Produces a set of labelled checkmarks. Each checkmark will set one bit in the output integer. The first one sets 1, the next 2, the next one 4, etc.

Knob* DD::Image::Bool_knob	(	Knob_Callback	f,
		bool *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

A single checkmark that controls a bool

Referenced by DD::Image::Transform::filter_knobs(), DD::Image::Executable::frameRangeKnobs(), DD::Image::DrawIop::input_knobs(), DD::Image::Transform::knobs(), DD::Image::NukeWrapper::knobs(), and DD::Image::LookAt::knobs().

Knob* DD::Image::Float_knob	(	Knob_Callback	f,
		double *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Controls a single number stored as a double

Referenced by DD::Image::DrawIop::input_knobs(), DD::Image::NukeWrapper::knobs(), and DD::Image::Transform::motionblur_knobs().

Knob* DD::Image::Float_knob	(	Knob_Callback	f,
		float *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Controls a single number stored as a float

Knob* DD::Image::Frame_knob	(	Knob_Callback	f,
		float *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Controls a single frame number stored as a float

DD::Image::Knob * DD::Image::Deep_knob	(	Knob_Callback	f,
		float *	p,
		NAME	n,
		LABEL	l = `0`
	)

Controls a single number stored as a float, representing a Deep value

References SetRange().

Knob* DD::Image::MultiFloat_knob	(	Knob_Callback	f,
		double *	p,
		int	dim,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Controls dim doubles in an array

Knob* DD::Image::MultiFloat_knob	(	Knob_Callback	f,
		float *	p,
		int	dim,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Controls dim floats in an array

Knob* DD::Image::MultiInt_knob	(	Knob_Callback	f,
		int *	p,
		int	dim,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Controls dim integers in an array

Knob* DD::Image::PixelAspect_knob	(	Knob_Callback	f,
		double *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Controls a single float value, which is a pixel aspect ratio.

Knob* DD::Image::Array_knob	(	Knob_Callback	f,
		ConvolveArray *	p,
		int	width,
		int	height,
		NAME	n,
		LABEL	l = `0`,
		bool	defaultData = `false`
	)		`[inline]`

Sets a matrix as used by the Convolve operator. Currently the user interface is limited to fixed-size arrays but the tcl script can change the array size.

Knob* DD::Image::ChannelSet_knob	(	Knob_Callback	f,
		ChannelSet *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Store a ChannelSet. The UI looks almost identical to Channel_knob, but the user can select many more channels, including "all".

Referenced by DD::Image::DrawIop::input_knobs().

Knob* DD::Image::Input_ChannelSet_knob	(	Knob_Callback	f,
		ChannelSet *	p,
		int	input,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Same as ChannelSet_knob, but the UI menu puts all channels not returned by Op::node_input(input) into a sub menu called "Other Layers"

Knob* DD::Image::InputOnly_ChannelSet_knob	(	Knob_Callback	f,
		ChannelSet *	p,
		int	input,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Same as ChannelSet_knob, but the UI menu only shows channels returned by Op::node_input(input).

Knob* DD::Image::Channel_knob	(	Knob_Callback	f,
		Channel *	p,
		int	count,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Store count channel numbers for your operator to write to. The user selects it from a popup list that has all the layers, a "new" item that lets them define a new layer, and "none" which stores zero into all the numbers (attemts to write to the zero channel will write to a junk buffer that is thrown away. If a layer with more than one channel is selected the user gets checkmarks to turn the individual layers off (storing zero instead of the channel number).

Knob* DD::Image::Input_Channel_knob	(	Knob_Callback	f,
		Channel *	p,
		int	count,
		int	input,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Same as Channel_knob but the popup menu lacks the "new" option. Also only layers that exist in the input Iop (and RGB, RGBA and Alpha) are listed in the top level UI menu. All other channels are listed in the "other" submenu (and if this input is not connected to an Iop then all layers are listed). This is used to store channel numbers that your operator will read from.

Referenced by DD::Image::DrawIop::input_knobs(), DD::Image::NukeWrapper::knobs(), and DD::Image::IllumShader::knobs().

Knob* DD::Image::InputOnly_Channel_knob	(	Knob_Callback	f,
		Channel *	p,
		int	count,
		int	input,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Same as Input_Channel_knob but the popup menu only shows layers that exist in the input Iop. If this input is not connected to an Iop then all layers are listed. This is used to store channel numbers that your operator will read from.

Knob* DD::Image::XY_knob	(	Knob_Callback	f,
		double *	p,
		NAME	n,
		LABEL	l,
		Knob *	parent = `0`
	)		`[inline]`

Stores an x and y position. Draws a square dot in the viewer that the user can drag around.

The parent is an optional XY_knob() return value. The stored values are then relative to the point stored by that knob, and this draws a vector from this point to the parent point, and moving the parent moves this one with it.

Referenced by DD::Image::DrawIop::output_knobs().

Knob* DD::Image::XYZ_knob	(	Knob_Callback	f,
		float *	p,
		NAME	n,
		LABEL	l = `0`,
		Knob *	parent = `0`
	)		`[inline]`

Stores an xyz position and draws a square dot on the 3D viewer that the user can drag around.

The parent is an optional XYZ_knob() return value. The stored values are then relative to the point stored by that knob, and this draws a vector from this point to the parent point, and moving the parent moves this one with it.

Knob* DD::Image::UV_knob	(	Knob_Callback	f,
		double *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Makes two numbers called 'u' and 'v'.

Knob* DD::Image::CP_knob	(	Knob_Callback	f,
		float *	p,
		int	dim,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

It's used to store a collection of control points

Knob* DD::Image::WH_knob	(	Knob_Callback	f,
		double *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Stores a width and height. The user can change the slider to two input fields so they can make the width and height different. When stored the horizontal value (the first one) is divided by the incoming format's pixel aspect ratio, so if the user sees equal values the result is square in the viewer. The sizes are also scaled to account for the difference between the full size and proxy formats.

Knob* DD::Image::BBox_knob	(	Knob_Callback	f,
		double *	p,
		NAME	n,
		LABEL	l = `0`,
		Knob *	parent = `0`
	)		`[inline]`

Stores four numbers representing the x, y, right, and top of a rectangle selected by the user. The values are scaled by the current proxy settings. Draws this rectangle on the viewer that the user can manipulate.

The parent is an optional XY_knob() return value. The stored values are then relative to the point stored by that knob, and moving the XY_knob will move the box with it.

Knob* DD::Image::Format_knob	(	Knob_Callback	f,
		FormatPair *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

User chooses a format, which is stored in p.full_size_format. Also the current proxy scaling is used to produce another format that is stored in p.format.

Normally you should use p.format for any calculations. However since the bottom and top values are rounded to the nearest integer, you may want to use outputContext().to_proxy() on the full_size_format values to get exact vertical positions.

The FormatPair structure also contains space for making the p.format if necessary.

Knob* DD::Image::Color_knob	(	Knob_Callback	f,
		float *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Stores 3 floating-point numbers that represent a rgb color selected by the user.

Knob* DD::Image::AColor_knob	(	Knob_Callback	f,
		float *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Stores 4 floating-point numbers that represent a rgb color and an alpha value selected by the user.

Referenced by DD::Image::DrawIop::output_knobs().

Knob* DD::Image::Eyedropper_knob	(	Knob_Callback	f,
		float *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

This knob provides an interface to sample an average color from a viewer. It also provides the position and size of the sampled area

Knob* DD::Image::Range_knob	(	Knob_Callback	f,
		double *	p,
		int	np,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Store np numbers, but show a single slider with multiple moving slider handles. Values will always be in sorted because the user cannnot move the sliders through each other.

Knob* DD::Image::Transform2d_knob	(	Knob_Callback	f,
		Matrix4 *	p,
		NAME	n,
		int	type = `0`
	)		`[inline]`

This knob stores into a Matrix4 a 2-D transformation (although a Matrix4 is 4x4, this will only set 6 a00,a01,a03,a10,a11,a13 to values other than the identity). The user is presented with a "transform jack" in the viewer.

This creates named child knobs. If the name of the knob ends with "_" then these names are instead appended to this overall name, which allows more than one of these to be used in a node.

type modifies how the transform knob works. Known types are:

TRANSFORM (0) = Used by Transform operator. Initializes to the identity and initializes the center to put itself in the middle of the image. The stored matrix will transform pixel positions.

TO_PROXY = Same as TRANSFORM but when it calculates the matrix when Nuke is in proxy mode, it also stores the conversion from full-size to proxy format. This can be used by a knob like the Bezier that wants to store a set of x/y positions specified by the user.

POSITIONER = Used to place objects, such as Text, where location 0,0 is of some importance to the user. Hides the "center" control from the user (though the user can still move it with ctrl+drag) The passed matrix is used to initialize the transform. Currently only scale and translate is deduced from it.

POSITIONER|TO_PROXY = Does both.

T2D_GAUGE adds a little angular handle that outputs a value between 0 and 1 in bottom right corner of the matrix. Be sure to reset this value to 1 before using the matrix! Example use is transparency in the 'wipe' UI of the viewer.

Knob* DD::Image::LookupCurves_knob	(	Knob_Callback	f,
		LookupCurves *	p,
		DD::Image::LookupCurvesType	type,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

A set of lookup curves is stored and the user is presented with an editor in which they can manipulate them. See the LookupCurves class for more information.

Knob* DD::Image::LookupCurves_knob	(	Knob_Callback	f,
		LookupCurves *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

A set of lookup curves is stored and the user is presented with an editor in which they can manipulate them. See the LookupCurves class for more information.

Knob* DD::Image::Axis_knob	(	Knob_Callback	f,
		Matrix4 *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

This knob stores into a Matrix4 a 3-D transformation. A 3-D transform jack is presented to the user in the 3D viewer.

This creates named child knobs. If the name of the knob ends with "_" then these names are instead appended to this overall name, which allows more than one of these to be used in a node.

Knob* DD::Image::PositionVector_knob	(	Knob_Callback	f,
		float *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

A knob which represents a vector as an arrow joining two X,Y,Z positions.

The parameter p is a pointer to a pair of x, y, z points (6 floats) which are used to set the default start and end position of the arrow.

Knob* DD::Image::Box3_knob	(	Knob_Callback	f,
		float *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Stores 2 x,y,z points(6 floats) describing a 3D volume.

Knob* DD::Image::Histogram_knob	(	Knob_Callback	f,
		Histogram_Data *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

A histogram knob displays a histogram and lets the user choose 5 mapping parameters

Knob* DD::Image::Keyer_knob	(	Knob_Callback	f,
		double *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

obsolete

Knob* DD::Image::ColorChip_knob	(	Knob_Callback	f,
		unsigned *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Stores an unsigned value representing a color for use in coloring in the GUI. The stored bytes are rrggbb00. If you want the floating point equivalents you can use from_sRGB() on these.

Knob* DD::Image::Tab_knob	(	Knob_Callback	f,
		LABEL	label
	)		`[inline]`

Starts a new tab on the control panel and resets the BeginGroup() hierarchy level to zero.

Referenced by DD::Image::LookAt::knobs(), and DD::Image::DrawIop::output_knobs().

Knob* DD::Image::BeginGroup	(	Knob_Callback	f,
		NAME	name,
		LABEL	label = `0`
	)		`[inline]`

Starts a new hierarchy level. This produces a line with an open/close icon on the left, which causes all knobs between this and the matching EndGroup() to show/hide.

The name can be used to look this up so you can call Knob::open() and Knob::close() on it from a knob_changed() method.

Knob* DD::Image::BeginClosedGroup	(	Knob_Callback	f,
		NAME	name,
		LABEL	label = `0`
	)		`[inline]`

Same as BeginGroup() except the group is closed by default. This has to be passed to the constructor (rather than set afterwards by SetFlags so that the default can be remembered and scripts written with the settings that way.

Knob* DD::Image::EndGroup ( Knob_Callback f ) [inline]

Ends a hierarchy level.

Knob* DD::Image::BeginToolbar	(	Knob_Callback	f,
		NAME	name,
		LABEL	label = `0`,
		int	position = `Knob::TOOLBAR_TOP`
	)		`[inline]`

Starts a new viewer toolbar. This produces a toolbar which appears along a edge of each viewer. Use EndToolbar to finish the toolbar.

Knob* DD::Image::EndToolbar ( Knob_Callback f ) [inline]

Ends a toolbar.

Knob* DD::Image::BeginTabGroup	(	Knob_Callback	f,
		NAME	name,
		LABEL	label = `0`
	)		`[inline]`

Starts a new tabbed group. Use EndTabGroup to finish the group and TabKnob to add new tabs to the group.

Knob* DD::Image::EndTabGroup ( Knob_Callback f ) [inline]

Ends a tabbed group.

Knob* DD::Image::BeginExoGroup	(	Knob_Callback	f,
		NAME	name,
		LABEL	label = `0`
	)		`[inline]`

Starts a new group outside of any tabs Use EndExogroup to finish the group

Knob* DD::Image::EndExoGroup ( Knob_Callback f ) [inline]

Ends a extratabular group.

Knob* DD::Image::Text_knob	(	Knob_Callback	f,
		LABEL	text
	)		`[inline]`

Displays some text. This can be placed between any knobs if you do ClearFlags(f,Knob::STARTLINE) on the next knob.

Knob* DD::Image::Text_knob	(	Knob_Callback	f,
		LABEL	label,
		LABEL	text
	)		`[inline]`

Deprecated, do not use. Same as Newline(f,label) followed by Text_knob(f,text).

Knob* DD::Image::Named_Text_knob	(	Knob_Callback	f,
		LABEL	name,
		LABEL	text
	)		`[inline]`

Same as Text_knob() but the knob has a name. This is necessary if you want to find the knob again in order to hide/show it.

Knob* DD::Image::Newline	(	Knob_Callback	f,
		LABEL	label = `" "`
	)		`[inline]`

Start a new line in the panel. The label, if provided, is put on the left.

Referenced by DD::Image::DrawIop::input_knobs(), DD::Image::NukeWrapper::knobs(), and DD::Image::LookAt::knobs().

Knob* DD::Image::Divider	(	Knob_Callback	f,
		LABEL	label = `0`
	)		`[inline]`

Horizontal divider line. The label, if provided, is put to the left of it.

Referenced by DD::Image::DrawIop::input_knobs(), and DD::Image::SourceGeo::knobs().

Knob* DD::Image::Spacer	(	Knob_Callback	f,
		int	spaceInPixels
	)		`[inline]`

Horizontal gap between knobs. Be sure to ClearFlags(f,Knob::STARTLINE) on the next knob.

Knob* DD::Image::VSpacer	(	Knob_Callback	f,
		int	spaceInPixels
	)		`[inline]`

Vertical gap between knobs.

Knob* DD::Image::Icon_knob	(	Knob_Callback	f,
		const char *	icon
	)		`[inline]`

A non-interactive icon

Knob* DD::Image::Help_knob	(	Knob_Callback	f,
		LABEL	text
	)		`[inline]`

Displays a questionmark button, when the user clicks it a popup window appears displaying a block of text.

Knob* DD::Image::Help_knob	(	Knob_Callback	f,
		LABEL	label,
		LABEL	text
	)		`[inline]`

You can put other symbols on the questionmark button with this.

Knob* DD::Image::Button	(	Knob_Callback	f,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Produces a button that when the user presses it it will call the Op::knob_changed() method.

Knob* DD::Image::Script_knob	(	Knob_Callback	f,
		NAME	command,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Produces a button that when the user presses it it will execute in Nuke scripting language the passed command, with this knob as "context" so that relative names work. Also does knob_callback().

Referenced by DD::Image::FrameRangeControls::knobs(), and DD::Image::FileOp::Reload_Button().

Knob* DD::Image::PyScript_knob	(	Knob_Callback	f,
		NAME	command,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Produces a button that when the user presses it it will execute in Nuke Python the passed command, with this knob as "context" so that relative names work. Also does knob_callback().

Knob* DD::Image::CancelExecution_knob	(	Knob_Callback	f,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Produces a button that when the user presses it it will cancel and abort the current Op tree. It effectively simulates pressing "Cancel" in the progress dialog.

Knob* DD::Image::Python_knob	(	Knob_Callback	f,
		NAME	command,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Produces a custom Python knob. This is a knob which will execute Python code to produce its UI.

Knob* DD::Image::Pulldown_knob	(	Knob_Callback	f,
		ENUM_LABELS	e,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Produces a pulldown menu with multiple items that will execute in Nuke scripting language the passed command, with this knob as "context" so that relative names work.

Knob* DD::Image::PyPulldown_knob	(	Knob_Callback	f,
		ENUM_LABELS	e,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Produces a pulldown menu with multiple items that will execute in Nuke scripting language the passed command, with this knob as "context" so that relative names work.

Knob* DD::Image::Multiline_String_knob	(	Knob_Callback	f,
		const char **	p,
		NAME	n,
		LABEL	l = `0`,
		int	lines = `5`
	)		`[inline]`

Multi-line text editor.

Referenced by Eval_String_knob().

Knob* DD::Image::Eval_String_knob	(	Knob_Callback	f,
		const char **	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

Creates a new String knob that may contain an expression.

References Multiline_String_knob().

Knob* DD::Image::Toolbox_knob	(	Knob_Callback	f,
		int *	p,
		bool	expanded,
		ENUM_LABELS	e,
		NAME	n,
		LABEL	l = `0`,
		bool	changeOnClick = `false`
	)		`[inline]`

Controls an integer enumeration. The array of labels e will produce a pop-up list the user can choose from. The index into this list is stored. The first item will store a zero, etc. You can assume that only legal values are stored.

Knob* DD::Image::Disable_knob	(	Knob_Callback	f,
		bool *	p,
		NAME	n,
		LABEL	l = `0`
	)		`[inline]`

A knob managing the logic for disabling nodes

ostream & DD::Image::operator<<	(	std::ostream &	o,
		const Matrix4 &	matrix
	)

Writes it in nuke/tcl notation, with nested curly braces

std::vector<double> DD::Image::Matrix4ToVector ( const Matrix4 & matrix ) [inline]

convert a DD::Image::Matrix4 to a std::vector<double> transposes from column-major to row-major

Matrix4 DD::Image::VectorToMatrix4 ( const std::vector< double > & matrix ) [inline]

convert a std::vector<double> to a DD::Image::Matrix4 transposes from row-major to column-major

void DD::Image::Matrix4ToArray	(	Matrix4 &	matrix,
		double *	arr
	)		`[inline]`

convert a DD::Image::Matrix4 to an array of doubles transposes from column-major to row-major

References DD::Image::Matrix4::array(), and DD::Image::Matrix4::transpose().

void DD::Image::Matrix3x4ToArray	(	Matrix4 &	matrix,
		double *	arr
	)		`[inline]`

convert a DD::Image::Matrix4 to an array of doubles ignores 3rd row transposes from column-major to row-major

References DD::Image::Matrix4::array(), and DD::Image::Matrix4::transpose().

double DD::Image::noise ( double arg )

Same as noise(arg,0,0) but faster

Referenced by fBm(), and turbulence().

double DD::Image::noise	(	double	arg0,
		double	arg1
	)

Same as noise(arg0,arg1,0) but faster

double DD::Image::noise	(	double	x,
		double	y,
		double	z
	)

3D Perlin noise function.

Unlike some shader libraries, this produces a signed range centered on zero. The absolute maximum range is from -1.0 to 1.0. Doing (noise(x,y,z)+1)/2 will return values that are used by some other libraries. This produces zero at all integers, so you should rotate the coordinates somewhat (add a fraction of y and z to x, etc) if you want to use this for random number generation.

This uses a compiled random table and thus will produce exactly the same results on all platforms for the same xyz values.

Losely based on principles described by Perlin http://www.mrl.nyu.edu/~perlin/doc/oscar.html coherent noise function over 1, 2 or 3 dimensions (copyright Ken Perlin)

Modified by information in Perlin's paper at Siggraph 2002 on "Improving Noise"

double DD::Image::fBm	(	double	x,
		double	y,
		double	z,
		int	octaves,
		double	lacunarity,
		double	gain
	)

Fractional Brownian Motion. This is the sum of octaves calls to noise(). For each of them the input point is multiplied by pow(lacunarity,i) and the result is multiplied by pow(gain,i). For normal use lacunarity should be greater than 1 and gain should be less than 1.

References noise().

double DD::Image::turbulence	(	double	x,
		double	y,
		double	z,
		int	octaves,
		double	lacunarity,
		double	gain
	)

This is the same as fBm() except the absolute value of the noise() function is used.

References noise().

double DD::Image::p_random ( int x )

Return a repeatable pseudo random-number in the range 0-1. The same value is returned each time this is called with a given x.

This is a function that I randomly made up. I hope that this will give a decent random number with the help of the main table. (I know, cryptographers will call me naive. Matthias) The most important part is that this function will return the same value on any OS and processor.

Referenced by DD::Image::RenderScene::inputContext(), DD::Image::Transform::motionBlurSample(), and p_random().

double DD::Image::p_random	(	int	x,
		int	y
	)

Return a repeatable pseudo-random in the range 0-1 for each different combination of x and y.

double DD::Image::p_random	(	int	x,
		int	y,
		int	z
	)

Return a repeatable pseudo-random in the range 0-1 for each different combination of x and y and z.

double DD::Image::p_random ( double x )

1D pseudo random number space. Same as the integer version at integers, does smooth interpolation between the values between the integers.

Note that due to the smooth interpolation the returned values may go outside the 0-1 range. The actual range is -.25 to 1.25.

References p_random().

double DD::Image::p_random	(	double	x,
		double	y
	)

2D pseudo random number space. Same as the integer version at integers, does smooth interpolation between the values between the integers.

References p_random().

double DD::Image::p_random	(	double	x,
		double	y,
		double	z
	)

3D pseudo random number space. Same as the integer version at integers, does smooth interpolation between the values between the integers.

References p_random().

template<typename Function >

void DD::Image::ParallelFor	(	unsigned int	numItems,
		Function	f,
		unsigned int	maxThreads = `0`,
		unsigned int	minItems = `1000`
	)

Loop through the given number of items, calling the supplied function for each item with the index as the parameter. If maxThreads != 1, this will spawn multiple threads. If maxThreads == 0 (the default), it will use as many threads as are available. If there are less than minItems, it won't spawn any threads to avoid the overhead of thread spawning. It may be worth reducing this for expensive per-item operations.

template<typename Function >

void DD::Image::ParallelForRange	(	unsigned int	numItems,
		Function	f,
		unsigned int	maxThreads = `0`,
		unsigned int	minItems = `1000`
	)

Sometimes you need to set up a cache or other state which requires per-thread storage, in which case parallel_for won't help. parallel_for_range takes one step back and lets your function do the looping. All it does is divide the items into ranges and then calls the supplied function for each range. If you have N threads in the thread pool, the items will be divided into N ranges, and the function called once for each range. If threading is turned off, this is just the same as calling f(0, numItems);

int DD::Image::plugin_count ( )

Return how many plugins have been loaded. This is incremented by every successful plugin_find().

const char * DD::Image::plugin_name ( )

Return the name of the plugin being currently loaded. This is set when reading binary or tcl plugins. A blank string is returned if no such plugin is currently being loaded. The directory of this name will affect the locations searched by plugin_find().

Referenced by plugin_find(), and plugin_load().

const char * DD::Image::plugin_name ( int n )

Return the filename of the Nth plugin that was found.

const char * DD::Image::plugin_find	(	const char *	name,
		const char const	extensions = `0`
	)

Find and return the filename of a plugin. If the file is found, the full filename is copied to permanent storage and that permanent copy is returned. If the file is not found zero is returned.

If name contains any slashes, then it is expanded relative to the directory that is in plugin_name(), and that single filename (with any possible extensions) is checked. Note that only forward slashes work.

Otherwise every single directory in getPluginPath() is looked into.

extensions is an optional null-terminated list of filename extensions to try. These should start with a period. Each of them is added to the filename in each directory and the first match is returned. This is *only* done if name does not contain a period after the last slash. If you need to know which one was used, look at the end of the returned string (I don't return the index in order to force calling code to check extensions that are supplied in the plugin name).

The extension ".osx.bundle" is handled specially, if it is matched a whole lot more data is tacked on in order to produce the actual name of the shared object file that the plugin really is in.

References getPluginPath(), plugin_name(), DD::Image::FileSet::reload(), and strlcpy().

Referenced by plugin_load(), and plugin_load_one().

const char * DD::Image::plugin_load	(	const char *	name,
		const char *	altname = `NULL`
	)

load a plugin with the basename 'name' (or 'altname' if specified and nothing by name can be found)

Try to load a shared-object or tcl plugin.

plugin_find() is done with the passed name. This means that if the name does not have any slashes in it, it is looked for in every directory in getPluginPath(). If it does have a slash in it, it is tried in one location, relative the the location of the current plugin if it does not start with slash.

If there is no period in the name after the last slash, then it tries the following extensions:

".$plugin_ext" (".so", ".dylib", ".dll" etc depending on platform). This is a compiled plugin. These extensions allow plugins compiled for different platforms to coexist in the same directory.
".tcl" and ".gizmo". Extensions for interpreted nuke scripts

If the plugin is found, it is loaded. If the resulting filename ends in ".tcl" or ".gizmo" then plugin_interpret() is called. Otherwise plugin_binary() is called. The filename found is returned. If the plugin fails to load due to some error you can retrieve the error message with plugin_error().

If no matching filename is found, null is returned. plugin_error() is set to an appropriate error message.

References plugin_find(), and snprintf().

Referenced by DD::Image::Writer::Description::find(), DD::Image::GeoWriter::Description::find(), DD::Image::Reader::Description::find(), DD::Image::DeepWriter::Description::find(), DD::Image::Op::find_description(), and plugin_load().

void * DD::Image::plugin_load	(	const char *	name,
		void ()(const char *)	test,
		const char *	arg,
		const char *	symbol = `0`
	)

Load a plugin and make sure it defines some object (such as a script command). The function test(arg) should search for the desired object. arg is typically the name of the object.

This calls test(arg) first and if it returns non-zero that is returned.

It then tries plugin_load(name). If that fails null is returned.

If the plugin does load, test(arg) is called again. If it returns non-zero it returns that value. This will happen if some constructor exectued by loading the plugin added the new object to the correct tables.

If test(arg) fails after loading the plugin, plugin_error() is set to a message with the filename of the plugin saying the plugin did not define symbol. If symbol is null then name is used.

Thus when this returns, either a pointer to the desired object is returned, or null is returned and a useful error message is in plugin_error().

References plugin_load(), plugin_name(), and snprintf().

const char * DD::Image::plugin_load_all ( const char * name )

Load the plugin from every directory in getPluginPath(). This may load several plugins, only the name of the last one is returned. The directories in getPluginPath() are tried in backwards order, so that "earlier" plugins may override later ones.

This is used by Nuke to load the init.py and menu.py plugins.

The name of the last plugin found is returned, or NULL if no plugin was found.

The last error produced by any of the plugins is reported by plugin_error(). However if no matching plugin was found this is not considered an error.

References getPluginPath(), and strlcpy().

const char * DD::Image::plugin_load_one ( const char * name )

Similar to plugin_load, except that plugin_addpath calls insert paths instead of adding them, like plugin_load_all.

References plugin_find(), and snprintf().

const char * DD::Image::plugin_path ( int n )

Old iterator for accessing items in getPluginPath(). Returns NULL if n is greater or equal to the size().

References getPluginPath().

Referenced by DD::Image::FileOp::file_types().

void DD::Image::plugin_addpath ( const char * name )

Add a directory to getPluginPath(). Nothing is done if the directory is already in the path (this is done with simple strcmp so an exact match is needed). name is copied to our own storage.

Normally the new directory is added to the start of the path, ie the most recently added directory is searched first.

However if we are currently inside a plugin_load_all/one() call the directory is inserted before the directory we are currently reading from. In addition if the filename does not start with a slash (or letter, colon, slash on NT) then it is appended to the current directory. This allows an init.tcl file to "plugin_addpath ./subdir" and make subdir be searched without knowing the current directory name. If there is an init.tcl in the subdirectory it will be sourced as well.

References strlcpy().

Referenced by plugin_appendpath().

void DD::Image::plugin_appendpath ( const char * name )

Add a directory to the end of getPluginPath(), if not already in it. See plugin_addpath().

References plugin_addpath().

const char * DD::Image::plugin_error ( )

Return any error reported by the last call to plugin_load(), or return NULL if none. The returned value points at a static buffer that is overwritten on each call.

Referenced by DD::Image::Write::execute(), DD::Image::Op::find_description(), DD::Image::WriteGeo::set_file_type_from_filename(), and DD::Image::Write::set_file_type_from_filename().

void DD::Image::plugin_error ( const char * s )

Set an error message for the current plugin.

References strlcpy().

void * DD::Image::plugin_binary	(	const char *	name,
		const char *	symbol = `0`
	)

plugin_load() calls this for a binary plugin. You can call it yourself to load dynamic objects in a portable way.

This returns zero and sets plugin_error() if there is any problem loading the file as a plugin.

If symbol is non-zero, it locates that symbol in the plugin and returns a pointer to it. If the symbol is not found this returns zero and sets plugin_error().

If symbol is zero, this just returns a non-zero value if the plugin successfully loads. Stuff in the init portions of the object will be executed, this is how all DDImage plugins initialize themselves.

References DD::Image::Application::GetProductName(), ParseBlinkLibraryAbiVersionFromDLErrorMessage(), ParseDDImageAbiVersionFromDLErrorMessage(), plugin_verbose, and snprintf().

const std::vector< const char * > & DD::Image::plugin_path_list ( int n )

Return the list of files in entry n in getPluginPath(). n must be less than the size of the path.

References getPluginPath(), and DD::Image::FileSet::list().

Referenced by DD::Image::FileOp::file_types().

const std::vector< const char * > & DD::Image::getPluginPath ( )

Returns the entire plugin path as a vector.

Returns a vector of the directories Nuke will look in to get the plugins. This is initially $HOME/.nuke, $NUKE_PATH, and directory(NukeExecutableName)/plugins.

Referenced by plugin_find(), plugin_load_all(), plugin_path(), and plugin_path_list().

void DD::Image::setPluginInstallPaths ( const std::vector< std::string > & paths )

Sets system-specific locations that Nuke will look in for third-party plugins. Called during initialisation.

const std::vector< std::string > & DD::Image::getPluginInstallPaths ( )

Gets system-specific locations that Nuke will look in for third-party plugins.

const char * DD::Image::getApplicationPluginPath ( )

Return the plugin path of the application

void DD::Image::PostAbortTeardown ( )

! PostAbortTeardown Should be called after the op-tree abort has been called during global teardown.

References DD::Image::ShutdownBroadcaster::Destroy().

void DD::Image::InitialiseThread ( )

Initialises DDImage threading Should be called from the MainThread.

void DD::Image::createRIPContext ( )

create and register the DDImage RIP Context with RIP

References gRipContext, and DD::Image::Thread::numCPUs.

void DD::Image::destroyRIPContext ( )

Destroy the DDImage RIP Context

References gRipContext.

void DD::Image::TextureMipSample	(	const Vector2 &	center,
		const Vector2 &	dU,
		const Vector2 &	dV,
		TextureFilter *	filter,
		Iop **	mip,
		Pixel &	out
	)

Sample a parallelogram of an iop with a mipmap technique.

void DD::Image::SleepMS ( int ms )

Make this thread sleep for the given number of milliseconds (1/1000 of a second).

If you pass 0 or negative then it will sleep for the very shortest period of time (doing sched_yield() on Linux and SwitchToThread() on Windows).

Referenced by sleepFor().

void DD::Image::sleepFor ( double seconds ) [inline]

Make this thread sleep for the given number of seconds. This is done by rounding to the nearest millisecond and calling SleepMS().

References SleepMS().

bool DD::Image::style_needs_wireframe ( int x ) [inline]

Test to see if you should draw lines

Referenced by DD::Image::Transform::draw_handle(), and DD::Image::CameraOp::draw_handle().

template<int stride>

void DD::Image::fillSpan	(	float *	dst,
		float	value,
		size_t	len
	)

Helper function to fill a span, with stride. Templated so loop will be optimised.

template<int stride>

void DD::Image::copySpan	(	float *	dst,
		const float *	src,
		size_t	len
	)

Helper function to copy a span, with stride. Templated so loop will be optimised.

void DD::Image::PrintKnobChangedInValidateWarning ( Knob * k )

Print a warning if a knob has been changed inside validate() unless the node has been whitelisted

References DD::Image::Knob::op(), and DD::Image::Op::warning().

Referenced by DD::Image::Knob::changed().

bool DD::Image::ParseDDImageAbiVersionFromDLErrorMessage	(	const char *	dlErrorMessage,
		int &	majorVersion,
		int &	minorVersion
	)

Try to parse the error given by dlopen() - if the message is about DDImage ABI version, parse the major and minor versions the plugin was compiled for

References ParseDDImageAbiVersionFromDLErrorMessage().

Referenced by ParseDDImageAbiVersionFromDLErrorMessage(), and plugin_binary().

bool DD::Image::ParseBlinkLibraryAbiVersionFromDLErrorMessage	(	const char *	dlErrorMessage,
		int &	majorVersion,
		int &	minorVersion
	)

Try to parse the error given by dlopen() - if the message is about BlinkLibrary ABI version, parse the major and minor versions the plugin was compiled for

References ParseBlinkLibraryAbiVersionFromDLErrorMessage().

Referenced by ParseBlinkLibraryAbiVersionFromDLErrorMessage(), and plugin_binary().

Variable Documentation

const char *const DD::Image::group_names

Group name strings.

Referenced by DD::Image::AttribContext::print_info().

const char *const DD::Image::render_modes

Name text array for render_mode enumeration knob

const char *const DD::Image::render_modes_source

Same as render_modes, except missing the "unchanged" entry

const char DD::Image::INVISIBLE

In Op::knobs() use this to label knobs you don't want the user to see. This is the string "INVISIBLE" but the pointer is recognized and it causes Knob::hidden() to return true.

Referenced by DD::Image::NukeWrapper::knobs(), and DD::Image::FileOp::Reload_Button().

float(* DD::Image::root_real_fps)()

Return the current global setting for frames per second.

Referenced by DD::Image::Read::append().

bool DD::Image::plugin_verbose

If this is set to true then it prints messages to stdout when it loads plugins.

Referenced by plugin_binary().

bool DD::Image::plugin_safe_mode

If this is set to true then it skips loading plugins (and menus) from ~/.nuke and NUKE_PATH. It also skips loading any Ofx plugins

std::string(* DD::Image::getClipboardContents)()

Return the contents of the clipboard

void(* DD::Image::setClipboardContents)(std::string &text)