Namespaces
	Application
	Contains information about the application that is using DDImage.

	HashFile
	Includes functions to generate and check a hash for a given file.

Classes
class	AllocationTracker
	A class for checkpoint tracking of memory allocations allocated by the HeapAllocator. More...

struct	AllocTrackingInfo
	A structure holding information about a tracked object's memory allocation. More...

class	AttribContext

class	Attribute
	General Attribute class. More...

class	AudioReaderI

struct	AudioReadInfo

class	AutoProfileEvent

class	AxisOp
	AxisOp is the base class for all the 3D objects. It simply contains a transform matrix. More...

class	BaseHandle

class	BaseLockGuard

class	BaseReadWriteGuard
	Base class for Read/Write Guard classes. More...

class	BasicGrid

class	Black

class	BlockAllocator

class	Blur

class	Box
	Describes a rectangle with integer boundaries. More...

class	Box2f

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	ChannelSetIterator

class	CodecHandler

class	CodecOp

class	ColorLookup

class	Colorspace_KnobI

class	ComplexLightOp

class	ConvertibleToIop
	Helper class for converting non Iop based classes to Iop. More...

class	Convolve

struct	ConvolveArray

struct	CurveDescription

class	DataInfo
	Class that provides information about component types. More...

class	DebugTopDownGraphObserver
	An observer class for tracking topdown rendering events and logging them to standard output. More...

class	DeepAccumPixelOp

class	DeepFilterOp

class	DeepInfo

class	DeepInPlaceOutputPlane

class	DeepLightSample
	helper class representing a small float vector, one for each channel in a set More...

class	DeepOnlyOp

class	DeepOp

class	DeepOutPixel

class	DeepOutputPixel

class	DeepOutputPlane

class	DeepPixel

class	DeepPixelOp
	DeepPixelOp is a base class that provides similar functionality to the combination of NukeWrapper and PixelOp. More...

class	DeepPlane

class	DeepReader

class	DeepSample
	helper class representing a small float vector, one for each channel in a set More...

class	DeepSampleVector

class	DeepWriter

class	DeepWriterOwner

class	DepthMapRender
	Depth map rendering for a shadow buffer. More...

class	Description

class	DirectGeneralTile

class	DownRez

struct	Draw_Handle_Callback

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	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	GenericImagePlaneDescriptor

class	GeoDescription

class	GeoInfo
	Contains a list of points and geometric primitives. More...

struct	GeoInfoRenderState

class	GeometryList

class	GeoOp

class	GeoReader

class	GeoWriter

class	GPUContext

class	Guard

class	Handle
	Standard handle, which allocates via DD Images memory pool. More...

class	Hash

class	HConvolve

class	HeapAllocator

class	Histogram_Data

class	IAllocator
	Allocator interface. More...

class	IllumShader
	This subclass of Material provides some convienence functions so that it is easier to write a lighting surface shader. More...

class	Image_Cache

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	ImagePlane

class	ImagePlaneDescriptor

class	Info2D

class	Interest

class	InterestRatchet

class	InternalOCIOOp
	Helper class to enable Readers and Writers to use internal OCIOColorpace Ops. More...

class	Iop
	Iop is the base class for all the image operators. More...

class	IopInfo

class	IopInfoOwner
	IopInfo holder. More...

struct	IRange

class	Knob

class	KnobChangedObserverI

class	KnobChangeGroup

class	LayerI

class	License

class	LightContext

class	LightOp
	LightOp defines a 3D light. More...

class	Linear

class	LinkableI

class	LinkableKnobInfo

class	Lock

class	LookAt
	Helper class that adds LookAt functionality. More...

class	LookupCurves

class	LookupCurves_KnobI

class	LUT

class	LUTInfo

class	Material

class	Matrix3
	A 3x3 transformation matrix. More...

class	Matrix4
	A 4x4 transformation matrix. More...

class	MatrixArray

class	MBParticleSpriteGenerator

class	MBSceneSpriteGenerator

class	Memory

class	MemoryHolder

class	Menu

class	Mesh

class	ModifyGeo

class	MultiArray_KnobI

class	MultiTileIop

class	NoIop

class	NukeWrapper

class	NullGeo

struct	ObjectCell

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	OpTask

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	ParticleBehaviour

class	ParticleNodeState

class	ParticleNodeStateFactory

class	ParticleOp

class	ParticleRender

class	Particles

class	ParticlesSprite

class	ParticleSystem

class	Pixel

class	PixelIop

class	PlanarI

class	PlanarIop

class	PlanarReadInfo
	Information about a generic image plane, as opposed to a scan line, and how it can be read and decoded. More...

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	PreValidateContext

class	Primitive

class	PrimitiveContext

class	PrimitiveTestCache

class	ProfileEvent

class	ProxyContext

class	Quadtree

struct	QuadtreeNode

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	Random
	A random number generator for the use of ParticleOps. More...

class	RandomBoxes
	Vector of boxes with member functions. More...

class	RawGeneralTile

struct	Ray

class	Read

class	Reader

class	ReaderDescription
	Base class for Reader plugin descriptions. More...

class	ReaderImpl
	Private, hidden implementation for DD::Image::Reader objects. More...

class	ReadFileKnobOwner

class	ReadGeo

class	ReadGuard

class	ReadImpl
	Private, hidden implementation for DD::Image::Read objects. More...

class	ReadWriteLock
	Read/Write Lock for shared access. More...

class	RecursiveLock

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

struct	SamplePosition

class	Sampler

class	Scene

class	SceneGraph_KnobI

class	SceneView_KnobI

class	ShapeKnob

class	ShutdownBroadcaster

class	ShutDownListener

class	ShutterControls

class	SignalLock

class	SmallBlockDefinition

class	SolidShader
	Default solid vertex shader. More...

class	SourceGeo

class	SpinGuard

struct	Sprite

class	SpriteGenerator

class	Text_KnobI

class	TextureFilter

class	Thread

class	ThreadProfileEvent

class	TimelineRead
	Sub-class of DD::Image::Read used by NukeStudio/Hiero for timeline reads. More...

class	TimelineReadInternals
	A used by TimelineRead to hide internal implementations that we don't want to expose in the public DDImage API. More...

class	ToBuffer
	Takes the output of an image tree and put it into an 8-bit buffer. More...

class	TopDownGraphEvaluator

class	TopDownGraphNotifier

class	TopDownGraphObserver

class	TopDownPImpl
	Helper functions used by the top-down graph evaluator's private implementation. More...

class	Transform

class	TransformGeo
	Operator that transforms geometric points. More...

class	TransformJack_ClientI

class	TransformReceiverI

class	Triangle

class	TryWriteGuard

class	UpRez

class	ValueStuffI
	Container for values. More...

class	VArray

class	VConvolve

class	Vector2

class	Vector3

class	Vector4

class	Version

class	VertexContext

class	ViewerCache
	Image cache for the viewer. More...

class	ViewerContext

class	ViewFrustum

class	WireframeShader
	Default wireframe shader. More...

class	Write

class	WriteGeo

class	WriteGuard

class	Writer

class	WriterImpl
	Private, hidden implementation for DD::Image::Writer objects. More...

Typedefs
typedef Knob_Closure &	Knob_Callback

typedef RefCountedPtr< Attribute >	AttributePtr

using	CombineFunc = DeepSample(*)(const DD::Image::ChannelMap &channels, DeepSample sampleA, DeepSample sampleB)

using	CombineOperation = DeepLightSample(*)(const DD::Image::ChannelMap &channels, const DeepLightSample &sampleA, const DeepLightSample &sampleB)

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

using	ObjectSelections = std::vector< float >

using	SelectionWeights = std::vector< float >

using	VertexSelection = ObjectSelections

using	FaceSelection = ObjectSelections

using	VertexWeights = SelectionWeights

using	FaceWeights = SelectionWeights

typedef std::map< DD::Image::Hash, Image_Cache_Entry >	Cache_Entry_Map

using	ImageTilePtr = PtrStridedIterator< float >

using	ImageTileReadOnlyPtr = PtrStridedIterator< const float >

typedef void(*	TimeoutHandler) (void *)

typedef unsigned long long	Flags

typedef unsigned int	ParticleChannelSet

using	PluginUnloadedFunc = void()(const char )

using	OpTasks = std::map< Op , OpTask >

using	Quaternion = TQuaternion< double >

using	Quaternion4d = TQuaternion< double >

using	Quaternion4f = TQuaternion< float >

using	ClipTestFunc = bool(*)(const Box &box)

typedef Read	ReaderOwner

typedef RefCountedPtr< BaseHandle >	HandlePtr

typedef std::vector< SceneItem >	SceneItems

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 PlanarI::PlaneID	PlaneID

template<SampleFunction function>
using	ReturnType = typename std::conditional< function==SampleFunction::eDoSampleShadowMap, float, void >::type

template<SampleFunction function>
using	ArgType = typename std::conditional< function==SampleFunction::eDoEngine, TransformI, Iop >::type

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

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	OpHints { OpHints::eDefault, OpHints::eChainable, OpHints::eIgnore, OpHints::eIgnoreInputs, OpHints::eSingleThread, OpHints::eInternalMultithreaded, OpHints::eUnsupportedTerminal }

enum	{ eAlignNone, eAlignSpin, eAlignVelocity }

enum	{ eBlendNone, eBlendModulate }

enum	FrameAdvance : unsigned char { eFrameAdvanceConstant, eFrameAdvanceStep, eFrameAdvanceRandom }

enum	PrimitiveType { eUnknownPrimitive, eTriangle, ePolygon, eMesh, ePoint, eParticles, eParticlesSprite, ePolyMesh, ePrimitiveTypeCount }

enum	SelectionPrecedence : uint8_t { TransformHandle, PointHighest, PointLowest }

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, eColorCurveST2084, eColorCurveBMfilmgen5, 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	ImageDirection { eIncreasingY, eDecreasingY }

enum	RippleType { eRippleOff, eRippleAll, eRippleFromStart, eRippleToEnd, eRippleRange }

enum	MotionVectorType { eDisableMotionVector, eClassicMotionVector, eVelocityMotionVector, eDistanceMotionVector }
	Scene motion vector types. More...

enum	SceneNodeType : unsigned int { eInvalid, eGeometry, eCamera, eAxis }

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

enum	TransformSpace : uint8_t

enum	ViewerMode

enum	ViewerEvent

enum	CameraLockMode

enum	SelectionMode3D { eSelect3DNode, eSelect3DVertex, eSelect3DFace, eSelect3DObject, eNumberOfSelectionModes3D }

enum	SelectionOptions3D { eOptionDisableOcclusionTesting }

enum	Select3DAction { eSelectReplace, eSelectAdd, eSelectRemove, eSelectDrag }

enum

enum

enum

enum

enum	FrustumPlane { eNear, eFar, eLeft, eRight, eTop, eBottom, eMax }
	Frustum planes enumerations.

enum	FrustumVisibility { eNotVisible, eFullVisible, ePartialVisible }
	Frustum visibility result. More...

enum	SampleType : unsigned int { eBoth, eFront, eBack }

enum	SampleFunction { eDoSample, eDoEngine, eDoSampleShadowMap }

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

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

	mFnCreateInstanceSTLAllocator (STLBlockAllcoator, BlockAllocator) template< typename T > inline T *BlockAllocator
	Create STL allocator class using macro.

bool	operator== (const DD::Image::Box &b1, const DD::Image::Box &b2)
	equality of boxes

bool	operator!= (const DD::Image::Box &b1, const DD::Image::Box &b2)
	inequality of boxes

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=nullptr)

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)

ChannelSetIterator	begin (const ChannelSet &channels)
	Implementation of begin() needed to support ranged-for loops.

ChannelSetIterator	end (const ChannelSet &channels)
	Implementation of end() needed to support ranged-for loops.

const Version &	version ()

const Version &	applicationVersion ()

double	scriptVersion ()

	mFnDeprecatedInNuke13 ("PlusSamples(const ChannelMap&, DeepSample, DeepSample) has been deprecated.") DeepSample PlusSamples(const ChannelMap &chanMap

	mFnDeprecatedInNuke13 ("MergeSamples(const ChannelMap&, DeepSample, DeepSample) has been deprecated.") DeepSample MergeSamples(const ChannelMap &chanMap

DeepLightSample	PlusOperation (const ChannelMap &chanMap, const DeepLightSample &sampleA, const DeepLightSample &sampleB)

DeepLightSample	MergeOperation (const ChannelMap &chanMap, const DeepLightSample &sampleA, const DeepLightSample &sampleB)

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)

	mFnDeprecatedInNuke13 ("DeoverlapSamples(const ChannelMap&, const DeepPixel&, DeepOutPixel&) has been deprecated.") void DeoverlapSamples(const ChannelMap &channels
	These functions together work similarly to CombineOVerlapping Samples to make a deep image tidy.

DeepOutPixel	MergeOverlappingPixelSamples (const DD::Image::ChannelSet &channels, const DeepPixel &in_pixel, CombineOperation f)

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 bottomCapDiameter, float topCapDiameter, 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 right, int top)
	gl_quadi Draws a filled quad (int version). More...

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=nullptr)

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	cacheglNormal3fv (const float *n)

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) template< typename T > inline T *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=nullptr)

Knob *	Password_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr)

Knob *	String_knob (Knob_Callback f, std::string *p, NAME n, LABEL l=nullptr)

Knob *	String_knob (Knob_Callback f, NAME n, LABEL l=nullptr)

Knob *	File_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr, FileKnob_Type type=Normal_File)

Knob *	Read_File_knob (ReadFileKnobOwner ptr, Knob_Callback f, const char *p, NAME n, LABEL l=nullptr)

Knob *	Read_File_knob (ReadFileKnobOwner ptr, Knob_Callback f, std::string p, NAME n, LABEL l=nullptr)

Knob *	Cached_File_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr, FileKnob_Type type=Normal_File)

Knob *	Write_File_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr)

Knob *	Write_File_knob (Knob_Callback f, std::string *p, NAME n, LABEL l=nullptr)

Knob *	Proxyless_Read_File_knob (ReadFileKnobOwner ptr, Knob_Callback f, const char *p, NAME n, LABEL l=nullptr)

Knob *	Int_knob (Knob_Callback f, int *p, NAME n, LABEL l=nullptr)

Knob *	Enumeration_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=nullptr)

Knob *	CascadingEnumeration_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=nullptr)

Knob *	Colorspace_knob (Knob_Callback f, int p, const char e, NAME n, LABEL l=nullptr)

Knob *	SceneGraph_knob (Knob_Callback f, int p, std::vector< SceneItem > e, NAME n, LABEL l=nullptr)

Knob *	SceneView_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=nullptr)

Knob *	SceneView_knob (Knob_Callback f, SceneView_KnobI::ItemList *p, NAME n, LABEL l=nullptr)

Knob *	FreeTypeFont_knob (Knob_Callback f, StlStringIntPair *p, NAME n, LABEL l=nullptr)

Knob *	OneView_knob (Knob_Callback f, int p, NAME n, LABEL l=nullptr, const char defcaption=nullptr)

Knob *	ViewPair_knob (Knob_Callback f, std::pair< int, int > *p, NAME n, LABEL l=nullptr)

Knob *	MetaData_knob (Knob_Callback f, NAME n, LABEL l=nullptr)

Knob *	MultiView_knob (Knob_Callback f, std::set< int > *p, NAME n, LABEL l=nullptr)

Knob *	ViewView_knob (Knob_Callback f, std::map< int, int > p, NAME n, std::pair< std::string, std::string > headings, LABEL l=nullptr)

Knob *	ParticleChannels_knob (Knob_Callback f, unsigned int *p, NAME n, LABEL l=nullptr)

Knob *	Bitmask_knob (Knob_Callback f, unsigned int *p, ENUM_LABELS e, NAME n, LABEL l=nullptr)

Knob *	Dynamic_Bitmask_knob (Knob_Callback f, unsigned int p, std::map< int, std::string > e, NAME n, LABEL l=nullptr)

Knob *	Bool_knob (Knob_Callback f, bool *p, NAME n, LABEL l=nullptr)

Knob *	Float_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)

Knob *	Float_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)

Knob *	Frame_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)

Knob *	Deep_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)

Knob *	MultiFloat_knob (Knob_Callback f, double *p, int dim, NAME n, LABEL l=nullptr)

Knob *	MultiFloat_knob (Knob_Callback f, float *p, int dim, NAME n, LABEL l=nullptr)

Knob *	MultiInt_knob (Knob_Callback f, int *p, int dim, NAME n, LABEL l=nullptr)

Knob *	PixelAspect_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)

Knob *	Array_knob (Knob_Callback f, ConvolveArray *p, int width, int height, NAME n, LABEL l=nullptr, bool defaultData=false)

Knob *	ResizableArray_knob (Knob_Callback f, ConvolveArray *p, int width, int height, NAME n, LABEL l=nullptr, bool defaultData=false)

Knob *	ChannelSet_knob (Knob_Callback f, ChannelSet *p, NAME n, LABEL l=nullptr)

Knob *	Input_ChannelSet_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=nullptr)

Knob *	InputOnly_ChannelSet_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=nullptr)

Knob *	Channel_knob (Knob_Callback f, Channel *p, int count, NAME n, LABEL l=nullptr)

Knob *	Input_Channel_knob (Knob_Callback f, Channel *p, int count, int input, NAME n, LABEL l=nullptr)

Knob *	InputOnly_Channel_knob (Knob_Callback f, Channel *p, int count, int input, NAME n, LABEL l=nullptr)

Knob *	XY_knob (Knob_Callback f, double p, NAME n, LABEL l, Knob parent=nullptr)

Knob *	XY_knob (Knob_Callback f, double p, NAME n, Knob parent=nullptr)

Knob *	XY_knob (Knob_Callback f, float p, NAME n, LABEL l, Knob parent=nullptr)

Knob *	XY_knob (Knob_Callback f, float p, NAME n, Knob parent=nullptr)

Knob *	XYZ_knob (Knob_Callback f, float p, NAME n, LABEL l=nullptr, Knob parent=nullptr)

Knob *	UV_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)

Knob *	UV_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)

Knob *	CP_knob (Knob_Callback f, float *p, int dim, NAME n, LABEL l=nullptr)

Knob *	WH_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)

Knob *	WH_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)

Knob *	BBox_knob (Knob_Callback f, double p, NAME n, LABEL l=nullptr, Knob parent=nullptr)

Knob *	BBox_knob (Knob_Callback f, float p, NAME n, LABEL l=nullptr, Knob parent=nullptr)

Knob *	Format_knob (Knob_Callback f, FormatPair *p, NAME n, LABEL l=nullptr)

Knob *	Color_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)

Knob *	Color_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)

Knob *	AColor_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)

Knob *	AColor_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)

Knob *	Eyedropper_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)

Knob *	Range_knob (Knob_Callback f, double *p, int np, NAME n, LABEL l=nullptr)

Knob *	Range_knob (Knob_Callback f, float *p, int np, NAME n, LABEL l=nullptr)

void	FrameRange_knob (Knob_Callback f, FrameRange p, const std::string &n, LABEL l=nullptr)

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=nullptr)

Knob *	LookupCurves_knob (Knob_Callback f, LookupCurves *p, NAME n, LABEL l=nullptr)

Knob *	Axis_knob (Knob_Callback f, Matrix4 *p, NAME n, LABEL l=nullptr)

Knob *	PositionVector_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)

Knob *	Box3_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)

Knob *	Histogram_knob (Knob_Callback f, Histogram_Data *p, NAME n, LABEL l=nullptr)

Knob *	Keyer_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)

Knob *	ColorChip_knob (Knob_Callback f, unsigned *p, NAME n, LABEL l=nullptr)

Knob *	Tab_knob (Knob_Callback f, LABEL label)

Knob *	MultiArray_knob (Knob_Callback f, NAME n, LABEL l=nullptr)

Knob *	BeginGroup (Knob_Callback f, NAME name, LABEL label=nullptr)

Knob *	BeginClosedGroup (Knob_Callback f, NAME name, LABEL label=nullptr)

Knob *	EndGroup (Knob_Callback f)

Knob *	BeginToolbar (Knob_Callback f, NAME name, LABEL label=nullptr, int position=Knob::TOOLBAR_TOP)

Knob *	EndToolbar (Knob_Callback f)

Knob *	BeginTabGroup (Knob_Callback f, NAME name, LABEL label=nullptr)

Knob *	EndTabGroup (Knob_Callback f)

Knob *	BeginExoGroup (Knob_Callback f, NAME name, LABEL label=nullptr)

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 *	Named_Text_knob (Knob_Callback f, LABEL name, LABEL label, LABEL text)

Knob *	Newline (Knob_Callback f, LABEL label=" ")

Knob *	Divider (Knob_Callback f, LABEL label=nullptr)

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=nullptr)

Knob *	Script_knob (Knob_Callback f, NAME command, NAME n, LABEL l=nullptr)

Knob *	PyScript_knob (Knob_Callback f, NAME command, NAME n, LABEL l=nullptr)

Knob *	CancelExecution_knob (Knob_Callback f, NAME n, LABEL l=nullptr)

Knob *	Menu_knob (Knob_Callback f, const char *menuName, NAME name, LABEL label=nullptr)

Knob *	Python_knob (Knob_Callback f, NAME command, NAME n, LABEL l=nullptr)

Knob *	Pulldown_knob (Knob_Callback f, ENUM_LABELS e, NAME n, LABEL l=nullptr)

Knob *	PyPulldown_knob (Knob_Callback f, ENUM_LABELS e, NAME n, LABEL l=nullptr)

Knob *	Multiline_String_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr, 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=nullptr)

Knob *	Double_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)

Knob *	Double_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=nullptr)

Knob *	Float_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=nullptr)

Knob *	Float_knob (Knob_Callback f, float *p, const IRange &r, NAME n, LABEL l=nullptr)

Knob *	ChannelMask_knob (Knob_Callback f, ChannelSet *p, NAME n, LABEL l=nullptr)

Knob *	Input_ChannelMask_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=nullptr)

Knob *	InputOnly_ChannelMask_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=nullptr)

Knob *	WH_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=nullptr)

Knob *	Scale_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)

Knob *	Scale_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=nullptr)

Knob *	Color_knob (Knob_Callback f, float *p, const IRange &r, NAME n, LABEL l=nullptr)

Knob *	Color_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=nullptr)

Knob *	AColor_knob (Knob_Callback f, float *p, const IRange &r, NAME n, LABEL l=nullptr)

Knob *	List_knob (Knob_Callback f, std::vector< std::vector< std::string > > *p, NAME n, LABEL l=nullptr)

Knob *	Table_knob (Knob_Callback f, NAME n, LABEL l=nullptr)

Knob *	Range_knob (Knob_Callback f, double *p, int np, int ixp, NAME n, LABEL l=nullptr, 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=nullptr)

Knob *	Multiline_Eval_String_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr, int lines=5)

Knob *	Eval_String_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr)

Knob *	TextEditor_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr, int lines=5)

Knob *	Toolbox_knob (Knob_Callback f, int *p, bool expanded, ENUM_LABELS e, NAME n, LABEL l=nullptr, bool changeOnClick=false)

Knob *	GeoSelect_knob (DD::Image::Knob_Callback f, const char *name)

Knob *	ControlPointCollection_knob (Knob_Callback f, NAME n, LABEL l=nullptr)

Knob *	MetaKeyFrame_knob (Knob_Callback f, NAME n, LABEL l=nullptr, 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=nullptr)

Knob *	Disable_knob (Knob_Callback f, bool *p, NAME n, LABEL l=nullptr)

Knob *	FrameExtent_knob (Knob_Callback f, DD::Image::FrameExtentProviderI *prov, NAME n, LABEL l=nullptr)

Knob *	Radio_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=nullptr)

LayerI *	GetLayer (const std::string &name)
	Returns a pointer to a layer instance based on the layer name.

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)

constexpr OpHints	operator\| (OpHints lhs, OpHints rhs)

OpHints &	operator\|= (OpHints &lhs, OpHints rhs)

constexpr OpHints	operator& (OpHints lhs, OpHints rhs)

OpHints &	operator&= (OpHints &lhs, OpHints rhs)

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=nullptr)

const char *	plugin_load (const char name, const char altname=nullptr)
	load a plugin with the basename 'name' (or 'altname' if specified and nothing by name can be found) More...

void *	plugin_load (const char name, void (test)(const char ), const char arg, const char symbol=nullptr)

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=nullptr)

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. More...

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

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

const char *	getApplicationPluginPath ()

void	setPluginUnloadedCallback (PluginUnloadedFunc f)

void	FnLicensingShutdown ()

std::string	GetNukeHomeDir ()

OpHints	opHints (Op *op)
	Return a mask of hints used to control how the specified op should be rendered by the top-down system.

bool	cacheOpInputs (Op *op)
	Support functions used during top-down task graph construction and execution.

bool	isPlanarOp (Op *op)

bool	isMultiThreadableOp (Op *op)

bool	ignoreOp (Op *op)

bool	ignoreOpInputs (Op *op)

bool	isUnsupportedTerminalOp (Op *op)

bool	isInternalMultithreadedOp (Op *op)

void	RemoveRendererFromSceneLights (DD::Image::Scene pScene, DD::Image::Render depthMapCandidate)

void	PostAbortTeardown ()

void	InitialiseThread ()

bool	Encrypt (const unsigned int vendorID, const std::string &message, std::string &encryptedMessage)

bool	Encrypt (const unsigned char *publicKeyData, const size_t publicKeyDataSize, const std::string &message, std::string &encryptedMessage)

bool	Decrypt (const unsigned char *privateKeyData, const size_t privateKeyDataSize, const std::string &encryptedMessage, std::string &decryptedMessage)

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 ()

std::ostream &	operator<< (std::ostream &os, const DD::Image::SceneItem &item)

bool	operator< (const SceneItem &a, const SceneItem &b)

	mFnCreateGlobalSTLAllocator (STLAllocator, DefaultAllocator::getInstance()) template< class T > class STL

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 &chanMap, const T &deepPixel, Out &pixels)

decltype(auto)	SplitVolume (const ChannelMap &cm, const DeepLightSample &openSample, float zSplit)

DeepSample	MergeSamples (const ChannelMap &chanMap, DeepSample sample_a, DeepSample sample_b)

DeepSample	PlusSamples (const ChannelMap &chanMap, DeepSample sample_a, DeepSample sample_b)

void	DeoverlapSamples (const ChannelMap &channelMap, const DeepPixel &deepPixel, DeepOutPixel &pixels)

DeepOutPixel	DeoverlapPixelSamples (const ChannelMap &channelMap, const DeepPixel &deepPixel)

void	MergeOverlappingSamples (const DD::Image::ChannelSet &channels, const DeepPixel &in_pixel, DeepOutPixel &out_pixel, CombineFunc func)

GeoSelection &	DefaultGetGeometrySelection ()

void	initCachedGLFunctionsTable ()

CacheBlock &	operator<< (CacheBlock &, bool)

CacheBlock &	operator<< (CacheBlock &, unsigned char)

CacheBlock &	operator<< (CacheBlock &, short)

CacheBlock &	operator<< (CacheBlock &, int)

CacheBlock &	operator<< (CacheBlock &, float)

CacheBlock &	operator<< (CacheBlock &, double)

CacheBlock &	operator<< (CacheBlock &, char *)

CacheBlock &	operator>> (CacheBlock &, bool &)

CacheBlock &	operator>> (CacheBlock &, unsigned char &)

CacheBlock &	operator>> (CacheBlock &, int &)

CacheBlock &	operator>> (CacheBlock &, short &)

CacheBlock &	operator>> (CacheBlock &, unsigned int &)

CacheBlock &	operator>> (CacheBlock &, unsigned long &)

CacheBlock &	operator>> (CacheBlock &, float &)

CacheBlock &	operator>> (CacheBlock &, double &)

CacheBlock &	operator>> (CacheBlock &, const char *&)

void	internalglBegin ()

void	internalglEnd ()

void	internalglVertex2f ()

void	internalglVertex2fv ()

void	internalglVertex3f ()

void	internalglVertex3fv ()

void	internalglNormal3f ()

void	internalglNormal3fv ()

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 ()

void	PrintKnobChangedInValidateWarning (Knob *k)

std::string	reformatTime (const std::string &timestamp)

template<SampleFunction function, typename... Ts>
ReturnType< function >	MultiTileCall (ArgType< function > &self, Iop &checkIfPlanar, Ts &&...args)

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.

	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 (Quaternion4f, _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 particleStartTime	mDefineAccessors (int, _id, particleId) mDefineAccessors(ParticleChannelSet

particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels	mDefineAccessors (unsigned int, _pathMask, particlePathMask) mDefineAccessors(bool

particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive	mDefineAccessors (ParticleSystem::Source, _source, particleSource) mDefineAccessors(float

particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive particleRepresentationFrame	mDefineAccessors (int, _representationFirstFrame, particleRepresentationFirstFrame) mDefineAccessors(int

particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive particleRepresentationFrame particleRepresentationLastFrame	mDefineAccessors (FrameAdvance, _frameAdvance, particleFrameAdvance) mDefineAccessors(float

particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive particleRepresentationFrame particleRepresentationLastFrame particleDeltaT	mDefineAccessors (ParticleSystem::BounceInfo, _bounceInfo, particleBounceInfo) int 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)

std::string	GenerateRandomString (const size_t length)

bool	IsPluginAuthoredByPermittedVendor (void handle, const char filename)

bool	IsWhiteListedPlugin (const char *filename)

void	pluginCleanup (const char *filename)

template<typename ValueType >
ostream &	operator<< (ostream &o, const TQuaternion< ValueType > &q)

float	MyClamp (float in)

enum SceneGraphNodeType unsigned int bool	DoNothing (const char fileName, SceneGraph_KnobI , const SceneItems &items)

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 )()

DeepSample	sampleA

DeepSample DeepSample	sampleB

const DeepPixel &	deepPixel

const DeepPixel DeepOutPixel &	pixels

mFnDeprecatedInNuke13("MergeOverlappingSamples(const DD::Image::ChannelSet&, const DeepPixel&, DeepOutPixel&, CombineFunc) has been deprecated.") void MergeOverlappingSamples(const DD DeepOutPixel	DeoverlapPixelSamples (const ChannelMap &channels, const DeepPixel &deepPixel)

const char *const	group_names []

const char *const	render_modes []

const char *const	render_modes_source []

const char	INVISIBLE []

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 *	kViewerMinSelColor3D

const char *	kUIHighlightColor

const char *	kUIHighlightedTextColor

const char *	kUIFontSize

const char *	kViewerWorldCoordinateSystem

const char *	kViewerHandleSize

const char *	kViewerHandlePickSize

const char *	kViewerHandleSize3D

const char *	kViewerTransformHandleSize3D

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")

Callbacks *	gCallbacks

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)

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 &)

void(*	set_knob_disallowed_to_edit )(const Knob *const)

GeoSelection &(*	get_geometry_selection )()

constexpr uint32_t	kAxisColorRed

constexpr uint32_t	kAxisColorGreen

constexpr uint32_t	kAxisColorBlue

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	kCacheGlNormal3fv

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)

Iop::TextureImage(*	iop_get_texturemap )(Iop , ViewerContext )

void(*	Description_callback )(Description , void(f)(Description *), Description::NodeBuilder nodeBuilder)=default_ctor

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_force_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)

LayerI (	pGetLayer )(const std::string &)

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)

bool(*	knob_op_current )(const Op *op)

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 &)

void(*	op_gotoContext )(Op *, const OutputContext &, bool)

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	_startTime

particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime	_channels

particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels	_active

particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive	_representationFrame

particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive particleRepresentationFrame	_representationLastFrame

particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive particleRepresentationFrame particleRepresentationLastFrame	_deltaT

bool	plugin_unapproved

const char *	ddimage_program_name

const char *	first_in_plugin_path

const int	kAveragePointsPerCell

const unsigned int	kMaxGridSize

RIP::Compute::ContextIP	gRipContext

bool(*	create_scene_graph_browser )(const char fileName, DD::Image::SceneGraph_KnobI , const DD::Image::SceneItems &items)

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.

using DD::Image::PluginUnloadedFunc = typedef void (*)(const char*)

Specify a function that will be called when plugins are unloaded. This is primarily intended for making sure plugins are correctly unregistered from various global tables.

using DD::Image::ClipTestFunc = typedef bool (*)(const Box& box)

A Regular grid is used to perform ray intersection with an array of DrawableGeo. Multiple threads can query for ray intersection, all the ray test intersection methods are thread safe. Please note that the rebuild method is not thread safe and must be called before any ray intersection test.

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

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::OpHints

strong

Hints for ops so we know how to create tasks for them and how to execute them. In bottom-up mode, Nuke knows to create a cache when the engine method creates an Interest on an input. For top-down, we need to know this information when generating the task tree.

Enumerator
eDefault	=== Base flags (mutually exclusive) === This op uses the default rules for task creation and evaluation, which is to wait for all inputs to be fully evaluated before starting its own computation. Inputs will be evaluated according to the bounding box and channels requested by connected downstream ops, so it is important for the downstream ops to request only the data they will actually fetch from their inputs to avoid over-rendering. For ops that support it, the evaluation will be divided between multiple threads and performed in parallel (currently limited to non-planar 2D Iops).
eChainable	This op does not need to wait for inputs to be fully evaluated before beginning its own evaluation. When a series of eChainable ops are connected together they will be combined into a single task "bubble" and evaluated lazily by the bottom-up renderer. The task is considered to be complete when the final op in the chain has been fully evaluated. Only the results of the final op in the task will be cached for downstream ops to use. This hint will yield the best results for ops such as PixelIops that pass relatively small amounts of data (e.g. a scanline) to each other and modify their input data in-place instead of creating new outputs.
eIgnore	This op should not be rendered in top-down order. It will instead be lazily evaluated in bottom-up order when downstream ops try to fetch its output. This hint should be used for ops that cannot accurately predict which regions and/or channels they will need to request from their inputs until they are evaluated. The top-down system will render inputs based on the region and/or channels requested by their connected downstream ops. If this information is incorrect then over-rendering may occur. The eIgnore hint can be used to avoid this problem, although this is not guaranteed to provide a performance improvement as its use must be balanced against the increased thread synchronisation that may occur as a result of rendering the op lazily.
eIgnoreInputs	=== Modifier flags (can be combined with a Base flag) === This op's inputs should not be rendered in top-down order. They will instead be lazily evaluated in bottom-up order when downstream ops try to fetch their output. This hint is intended for use alongside eIgnore and provides a way to ignore an entire sub-graph if multiple ops are over-rendering as a result of the op at the end of the graph being unable to request the correct region and/or channels in top-down mode.
eSingleThread	This op should not be rendered with multiple scanline threads. This hint should be used in the rare cases where multi-threading an op's evaluation would result in a loss of performance.
eInternalMultithreaded	This op has internal multithreading so the top-down system should try to avoid running it in parallel with other ops. When an op completes, any successors with this hint will be run serially rather than in parallel to get the maximum benefit from the op's internal multithreading.
eUnsupportedTerminal	This op is not part of the top-down system so does not require its inputs to be cached when it is acting as a terminal op (it receives the final output from an evaluated graph). Inputs will instead be lazily evaluated in bottom-up order when the op tries to fetch them.

enum DD::Image::FrameAdvance : unsigned char

Enumerator
eFrameAdvanceStep	do not advance frame
eFrameAdvanceRandom	advance a frame each frame

enum DD::Image::ImageDirection

strong

Indicates whether the logical image stored in a data buffer (e.g. in a GenericImagePlane) is such that y increases with the address, i.e. the bottom of the image is stored at the start of the buffer.

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

enum TransformSpace : uint8_t

enum ViewerMode

enum ViewerEvent

enum CameraLockMode

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

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.

anonymous enum

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.

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 = `nullptr`
	)

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 applicationVersion(), and 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.If DDImage is not being used by Nuke it just returns the DDImage version.

References version().

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::ComplexLightOp::draw_handle(), DD::Image::CameraOp::draw_handle(), DD::Image::Transform::draw_handle(), DD::Image::AxisOp::draw_handle(), DD::Image::LightOp::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::ComplexLightOp::draw_handle(), DD::Image::CameraOp::draw_handle(), DD::Image::AxisOp::draw_handle(), DD::Image::LightOp::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	bottomCapDiameter,
		float	topCapDiameter,
		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 bottomCapDiameter = diameter of endcap 1 topCapDiameter = 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::ComplexLightOp::draw_handle(), and DD::Image::LightOp::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_quadi	(	int	x,
		int	y,
		int	right,
		int	top
	)

gl_quadi Draws a filled quad (int version).

Parameters

x	left bottom value along x axis.
y	left bottom value along y axis.
right	right top value along x axis.
top	right top value along y axis.

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_boxf	(	float	x,
		float	y,
		float	n,
		float	r,
		float	t,
		float	f,
		bool	filled = `false`
	)

Draw a rectangular box. x = position of the bottom left point along the x axis y = position of the bottom left point along the y axis n = position of the near bottom left point along the z axis r = position of the bottom right point from the origin along the x axis f = position of the far bottom left point along the z axis t = position of the top left point from the origin along the y axis

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

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 = nullptr )

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 *
	)

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::LookAt::knobs(), DD::Image::ShutterControls::knobs(), DD::Image::FrameRangeControls::knobs(), DD::Image::Filter::knobs(), DD::Image::NukeWrapper::knobs(), DD::Image::Transform::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::ShutterControls::knobs(), DD::Image::FrameRangeControls::knobs(), DD::Image::NukeWrapper::knobs(), DD::Image::Transform::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.

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::ShutterControls::knobs(), DD::Image::NukeWrapper::knobs(), DD::Image::Transform::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.

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

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 = `nullptr`
	)

inline

Create a Password input field

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

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 = `nullptr`,
		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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`,
		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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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::LookAt::knobs(), DD::Image::ShutterControls::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 = `nullptr`
	)

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 = `nullptr`
	)

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::LookAt::knobs(), DD::Image::NukeWrapper::knobs(), and DD::Image::Transform::knobs().

Knob* DD::Image::Float_knob	(	Knob_Callback	f,
		double *	p,
		NAME	n,
		LABEL	l = `nullptr`
	)

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 = `nullptr`
	)

inline

Controls a single number stored as a float

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

inline

Controls a single frame number stored as a float

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

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

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

inline

Controls dim doubles in an array

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

inline

Controls dim floats in an array

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

inline

Controls dim integers in an array

Knob* DD::Image::PixelAspect_knob	(	Knob_Callback	f,
		double *	p,
		NAME	n,
		LABEL	l = `nullptr`
	)

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 = `nullptr`,
		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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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::IllumShader::knobs(), and DD::Image::NukeWrapper::knobs().

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

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.

Referenced by DD::Image::NukeWrapper::knobs().

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

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 = `nullptr`,
		Knob *	parent = `nullptr`
	)

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 = `nullptr`
	)

inline

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

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

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 = `nullptr`
	)

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 = `nullptr`,
		Knob *	parent = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

inline

obsolete

Knob* DD::Image::ColorChip_knob	(	Knob_Callback	f,
		unsigned *	p,
		NAME	n,
		LABEL	l = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`,
		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 = `nullptr`
	)

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 = `nullptr`
	)

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::Named_Text_knob	(	Knob_Callback	f,
		LABEL	name,
		LABEL	label,
		LABEL	text
	)

inline

Same as Named_Text_knob() with the addition that this text knob have a label in the left column on the property panel to show.

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::LookAt::knobs(), and DD::Image::NukeWrapper::knobs().

Knob* DD::Image::Divider	(	Knob_Callback	f,
		LABEL	label = `nullptr`
	)

inline

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

Referenced by DD::Image::DrawIop::input_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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`
	)

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 = `nullptr`,
		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 = `nullptr`
	)

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 = `nullptr`,
		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 = `nullptr`
	)

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 ParallelFor won't help. ParallelForRange 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 = `nullptr`
	)

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 = `nullptr`
	)

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::DeepWriter::Description::find(), DD::Image::GeoWriter::Description::find(), DD::Image::Writer::Description::find(), DD::Image::Reader::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 = `nullptr`
	)

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::Write::set_file_type(), 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 = `nullptr`
	)

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 ParseBlinkLibraryAbiVersionFromDLErrorMessage(), ParseDDImageAbiVersionFromDLErrorMessage(), 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

std::string DD::Image::GetNukeHomeDir ( )

! GetNukeHomeDir Returns parent path of the .nuke configuration directory. Encoded in UTF-8. Defaults to HOME (or USERPROFILE on Windows). Returns OS-appropriate separators. Path never has a trailing slash/backslash.

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.

bool DD::Image::Encrypt	(	const unsigned int	vendorID,
		const std::string &	message,
		std::string &	encryptedMessage
	)

Retrieve the public RSA key associated with vendorID and use it to encrypt the supplied message. Returns True if encryption succeeded or False if a valid key could not be found or if the encryption itself failed.

bool DD::Image::Encrypt	(	const unsigned char *	publicKeyData,
		const size_t	publicKeyDataSize,
		const std::string &	message,
		std::string &	encryptedMessage
	)

Use the supplied public RSA key data to encrypt the supplied message. Returns True if encryption succeeded or False if it failed.

bool FN_SHARED_IMPORT DD::Image::Decrypt	(	const unsigned char *	privateKeyData,
		const size_t	privateKeyDataSize,
		const std::string &	encryptedMessage,
		std::string &	decryptedMessage
	)

Use the supplied private RSA key data to decrypt the supplied encrypted message. Returns True if decryption succeeded or False if it failed.

void DD::Image::createRIPContext ( )

create and register the DDImage RIP Context with RIP

References DD::Image::Thread::numThreads.

void DD::Image::destroyRIPContext ( )

Destroy the DDImage RIP Context

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::CameraOp::draw_handle(), and DD::Image::Transform::draw_handle().

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.

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)

Copy a string into the clipboard

const char *const DD::Image::display3d_names

Name text array for ViewerContext::display3d() enumeration knob

const char *const DD::Image::display3d_names_source

Same as display3d_names, except missing the "unchanged" entry

void*(* DD::Image::profileRequestEventPointer) (const std::string &name, const uint32_t &color)

! The functions which are defined by Nuke

RIP::Compute::ContextIP DD::Image::gRipContext

Nuke/DDImage's RIP context

Referenced by DD::Image::RefCountedFloatBuffer::allocate().

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

Enumeration Type Documentation

Function Documentation

Variable Documentation