DD::Image Namespace Reference

Namespaces
namespace	Application
	Contains information about the application that is using DDImage.
namespace	HashFile
	Includes functions to generate and check a hash for a given file.

Classes
class	AnimationHolderI
class	AttribContext
class	Attribute
	General Attribute class. More...
class	Authoring
class	AuthoringSettings
class	AxisOp
	AxisOp is the base class for all the 3D 'scene' objects like locators (usg::XformPrim), cameras (usg::CameraPrim) and lights (usg::tbd). More...
class	AxisVals
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	CameraLensContext
class	CameraOp
class	Channel_KnobI
	The Channel_KnobI class is used to expose the selection handle in DDImage. More...
class	ChannelMap
class	ChannelPack
class	ChannelSet
class	ChannelSetIterator
class	CodecOp
class	CodecReaderFormat
class	ColorKnobI
class	ColorLookup
class	Colorspace_KnobI
class	ComplexLightOp
class	ConvertibleToIop
	Helper class for converting non Iop based classes to Iop. More...
class	Convolve
struct	ConvolveArray
class	CoShaderMaterialInterface
struct	CurveDescription
class	DataInfo
	Class that provides information about component types. More...
class	DeepAccumPixelOp
class	DeepFilterOp
class	DeepInfo
class	DeepInPlaceOutputPlane
class	DeepLightSample
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
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	ExtendedOpProperties
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
	Describes a generic image plane which extends DataInfo, a ColorCurve, an ImageDirection and ChannelSwizzling to an ImagePlaneDescriptor. More...
class	GeoDescription
class	GeoInfo
	Contains a list of points and geometric primitives. More...
struct	GeoInfoRenderState
class	GeometryKnobs
class	GeometryList
struct	GeomKnobSample
class	GeomOp
class	GeomOpEngine
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	ImageableKnobs
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	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	LightMaterialOpI
class	LightOp
	LightOp defines a 3D light. More...
class	Linear
class	LinkableI
class	LinkableKnobInfo
class	LinkKnobI
class	Lock
class	LookAt
	Helper class that adds LookAt functionality. More...
class	LookupCurves
class	LookupCurves_KnobI
class	LUT
class	Material
class	MaterialOpI
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	MeshKnobs
class	ModelKnobs
class	ModifyGeo
class	MultiArray_KnobI
class	MultiTileIop
class	NoIop
class	NukeWrapper
class	NullGeo
class	NullGeomOp
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	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	Path_KnobI
	Abstract base class for a single Path knob. More...
class	PathExpression_KnobI
	Abstract base class for PathExpression knobs. More...
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	PointList
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	PrimitiveList
class	PrimitiveTestCache
class	ProxyContext
struct	PtrStridedIterator
class	Quadtree
struct	QuadtreeNode
class	Radio_KnobI
class	Random
	A random number generator for the use of ParticleOps. More...
class	RawGeneralTile
struct	Ray
class	Read
class	Reader
class	ReaderDescription
	Base class for Reader plugin descriptions. More...
class	ReadFileKnobOwner
class	ReadGeo
class	ReadGuard
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
struct	SceneItem
	Structure used to populate the SceneGraph_knob. More...
class	SceneView_KnobI
class	ShaderOp
class	ShapeKnob
class	ShutterControls
class	SignalLock
class	SmallBlockDefinition
class	SolidShader
	Default solid vertex shader. More...
class	SourceGeo
class	SourceGeomOp
class	SpinGuard
struct	Sprite
class	SpriteGenerator
class	StringKnobI
	interface class for an array of characters or a string. More...
class	SurfaceShaderOp
class	Text_KnobI
class	TextureFilter
class	Thread
class	TimelineRead
	Sub-class of DD::Image::Read used by NukeStudio/Hiero for timeline reads. More...
class	ToBuffer
	Takes the output of an image tree and put it into an 8-bit buffer. More...
class	TQuaternion
	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	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	WorldMatrixProvider
class	WorldPointProvider
class	Write
class	WriteGeo
class	WriteGuard
class	Writer

Typedefs
using	Knob_Callback = Knob_Closure &
typedef RefCountedPtr< Attribute >	AttributePtr
using	AxisValsArray = std::vector< AxisVals >
typedef void()	LensProjectionFunc(const CameraLensContext &context, slr::SlrVertex *vert_array, uint32_t nVerts, void *user_data)
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	GeomOpList = std::vector< GeomOp * >
using	GeomOpSet = std::unordered_set< GeomOp * >
using	GeomStateTargetIdxMap = std::unordered_map< usg::Token, uint32_t >
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 >
using	KnobSet = std::unordered_set< Knob * >
typedef void(*	TimeoutHandler) (void *)
typedef unsigned long long	Flags
typedef unsigned int	ParticleChannelSet
using	PluginUnloadedFunc = void(*)(const char *)
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
using	RasterBox = DD::Image::Box
using	IntPair = std::pair< int32_t, int32_t >
using	IntIntMap = std::map< int32_t, int32_t >
using	StringVecVec = std::vector< std::vector< std::string > >
using	StlStringIntPair = std::pair< std::string, int32_t >
using	StlStringVec = std::vector< std::string >
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 class	LensProjection : int32_t {   PERSPECTIVE , ORTHOGRAPHIC , UV , SPHERICAL ,   RENDER_CAMERA , USER_CAMERA }
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_Coverage , Chan_Cutout_Alpha , Chan_Cutout_Depth , 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_Coverage , Mask_Cutout_Alpha ,   Mask_Cutout_Depth , Mask_Cutouts , 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	{   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 class	OpHints {   eDefault , eChainable , eIgnore , eIgnoreInputs ,   eSingleThread , eInternalMultithreaded , 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	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 class	ImageDirection { eIncreasingY , eDecreasingY }
enum	RippleType {   eRippleOff , eRippleAll , eRippleFromStart , eRippleToEnd ,   eRippleRange }
enum	MotionVectorType { eDisableMotionVector , eClassicMotionVector , eVelocityMotionVector , eDistanceMotionVector }
	Scene motion vector types. More...
enum class	SceneNodeType : unsigned int { eInvalid , eGeometry , eCamera , eAxis }
enum	StoreType {   DoublePtr , FloatPtr , StringPtr , IntPtr ,   UnsignedIntPtr , BoolPtr , ConvolveArrayPtr , ChannelSetPtr ,   ChannelPtr , FormatPairPtr , mFnDeprecatedInNuke14 , LookupCurvesPtr ,   IntSetPtr , IntIntMapPtr , IntPairPtr , StringVecVecPtr ,   StlStringPtr , StlStringIntPairPtr , StlStringVecPtr , Custom ,   Invalid }
enum	StringExpandFlags { eStringExpandNoFlags , eStringExpandFilename , eStringExpandFileNumber }
enum	DrawHandleType {   eDrawHandleAlways , eDrawHandleVertexSelection , eDrawHandleEdgeSelection , eDrawHandleFaceSelection ,   eDrawHandleObjectSelection , eDrawHandleNodeSelection }
enum	ViewerConnected
enum class	TransformSpace : uint8_t
enum	ViewerMode
enum	ViewerEvent
enum	CameraLockMode
enum	Display3DMode : int
enum	RenderMode : int {   RENDER_OFF , RENDER_WIREFRAME , RENDER_SOLID , RENDER_SOLID_LINES ,   RENDER_TEXTURED , RENDER_TEXTURED_LINES , RENDER_UNCHANGED }
enum	SelectionMode3D {   eSelect3DNode , eSelect3DVertex , eSelect3DFace , eSelect3DObject ,   eNumberOfSelectionModes3D }
enum	SelectionOptions3D { eOptionDisableOcclusionTesting }
enum	Select3DAction { eSelectReplace , eSelectAdd , eSelectRemove , eSelectDrag }
enum
enum
enum
enum
enum class	SelectionKind
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 class	SampleFunction { eDoSample , eDoEngine , eDoSampleShadowMap }
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)
const AuthoringSettings &	AuthoringDefaults ()
	Get the default authoring settings - all modes, default mode nothing.
	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
LensProjectionFunc *	LensProjectionFunction (LensProjection mode, const Format *format, CameraLensContext &context)
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)
std::ostream &	operator<< (std::ostream &, const ChannelPack &)
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 ()
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)
DeepOutPixel	DeoverlapPixelSamples (const ChannelMap &channels, const DeepPixel &deepPixel)
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)
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)
void	CompositeSamples (const DeepSampleVector &samples, const ChannelSet &chans, Row &row, int x, float *Zpix, float *Zfrontpix, float *Zbackpix)
bool	DetectOverlappingSamples (const DeepSampleVector &t)
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)
std::ostream &	operator<< (std::ostream &, const Format &)
	Print out terse info about the Format to a stream.
const AttribContext *	GetGeoInfoAttribContext (const GeoInfo *info, const char *attribName, AttribType attribType)
std::ostream &	operator<< (std::ostream &, const GeomOpEngine::InputBinding &)
	Print out InputBinding components to a stream.
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)
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)
std::ostream &	operator<< (std::ostream &o, const Hash &h)
	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 &, const IopInfo &)
	Print out terse info about the IopInfo to a stream.
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)
	Makes a particle channels knob. This displays a dropdown menu of particle channels with a checkbox by each to turn it on, and an option to create new channels.
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 *	PathExpression_knob (Knob_Callback f, std::string *p, NAME n, LABEL l=nullptr)
	Controls a string containing a prim path matching expression.
Knob *	PathExpression_knob (Knob_Callback f, std::string *p, const std::string &filters, NAME n, LABEL l=nullptr)
Knob *	Input_PathExpression_knob (Knob_Callback f, std::string *p, int input, NAME n, LABEL l=nullptr)
Knob *	Input_PathExpression_knob (Knob_Callback f, std::string *p, int input, const std::string &filters, NAME n, LABEL l=nullptr)
Knob *	Path_knob (Knob_Callback f, std::string *p, NAME n, LABEL l=nullptr)
	Controls a string containing a prim path.
Knob *	Path_knob (Knob_Callback f, std::string *p, const std::string &filters, NAME n, LABEL l=nullptr)
Knob *	Input_Path_knob (Knob_Callback f, std::string *p, int input, NAME n, LABEL l=nullptr)
Knob *	Input_Path_knob (Knob_Callback f, std::string *p, int input, const std::string &filters, 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, double *p, NAME n, LABEL l=nullptr, 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, fdk::Mat4d *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	noise (double x, double y, double z, double w)
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<>
GeomOp *	op_cast< GeomOp * > (Op *op)
template<>
ParticleOp *	op_cast< ParticleOp * > (Op *op)
template<>
DeepOnlyOp *	op_cast< DeepOnlyOp * > (Op *op)
template<>
AxisOp *	op_cast< AxisOp * > (Op *op)
template<>
CameraOp *	op_cast< CameraOp * > (Op *op)
template<>
LightOp *	op_cast< LightOp * > (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)
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.
void	setPluginInstallPaths (const std::vector< std::string > &paths)
const std::vector< std::string > &	getPluginInstallPaths ()
const char *	getApplicationPluginPath ()
void	setPluginUnloadedCallback (PluginUnloadedFunc f)
std::vector< std::string >	getRegisteredPluginOps ()
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
const std::string &	StoreTypeName (StoreType storetype)
	Get type name string from StoreType enum.
size_t	StoreTypeBaseSize (StoreType storetype)
StoreType	StoreTypeForValueType (int valuetype)
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)
void	WriteAuthoring (const Authoring &authoring, const Knob *knob, std::ostream &out)
bool	ReadAuthoring (Authoring &authoring, const char *text)
const char *	SetAuthoring (const char *text, Authoring *authoring)
void	InitGeomAuthorMode (const Knob_Closure &f, Authoring::Mode mode, const std::vector< Authoring::Mode > &modes)
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)
void	printTimesMap (std::ostream &o, const usg::TimeGeomStateMap &times)
void	initCachedGLFunctionsTable ()
CacheBlock &	operator<< (CacheBlock &, bool)
CacheBlock &	operator<< (CacheBlock &, unsigned char)
CacheBlock &	operator<< (CacheBlock &, short)
CacheBlock &	operator<< (CacheBlock &, int)
CacheBlock &	operator<< (CacheBlock &, unsigned int)
CacheBlock &	operator<< (CacheBlock &, unsigned long)
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 ()
template<typename T >
bool	setVals (bool clear_keys, Knob &knob, int32_t nvalues, const T *values, const std::vector< double > &times, int32_t nelements, int32_t channel_start_offset, int32_t view)
template<typename T >
bool	setVal (Knob &knob, const T *value, double time, int32_t nelements, int32_t channel_start_offset, int32_t view)
bool	setString (Knob &knob, const std::string &s, double time, int32_t view)
template<typename T >
int32_t	minCnt (const std::vector< T > &values, const std::vector< double > &times)
template<typename T >
void	copyArrayKnobDoubles (ArrayKnobI *array_knob, const OutputContext *context, size_t nelements, T *out)
void	copyArrayKnobDoubles (ArrayKnobI *array_knob, const OutputContext *context, size_t nelements, bool *out)
template<typename T >
void	getVal (const Knob &knob, const OutputContext *context, size_t nelements, T *value)
void	getMat4d (const Knob &knob, const OutputContext *context, Mat4d &value)
void	getMat4f (const Knob &knob, const OutputContext *context, Mat4f &value)
void	getString (const Knob &knob, const OutputContext *context, size_t nelements, std::string *value)
template<typename T >
void	getArray (const Knob &knob, const OutputContext *context, std::vector< T > &array)
template<typename valT , typename dataT >
size_t	getVals (const Knob &knob, int32_t view, size_t nelements, std::vector< valT > &values, std::vector< double > &times)
size_t	getMat4dVals (const Knob &knob, int32_t view, std::vector< Mat4d > &values, std::vector< double > &times)
size_t	getMat4fVals (const Knob &knob, int32_t view, std::vector< Mat4f > &values, std::vector< double > &times)
void	PrintKnobChangedInValidateWarning (Knob *k)
usg::Value	sampleKnobValue (Knob *knob, const fdk::FrameValue &frame, int32_t view, usg::Value::Type value_type_hint)
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 ()
OpHints	opHints (Op *op)
bool	cacheOpInputs (Op *op)
bool	isPlanarOp (Op *op)
bool	isMultiThreadableOp (Op *op)
bool	ignoreOp (Op *op)
bool	ignoreOpInputs (Op *op)
bool	isUnsupportedTerminalOp (Op *op)
bool	isInternalMultithreadedOp (Op *op)
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)
void	RemoveRendererFromSceneLights (DD::Image::Scene *pScene, DD::Image::Render *depthMapCandidate)
float	MyClamp (float in)
void	getSampleArea (const Vector2 &dU, const Vector2 &dV, float &W, float &H)
bool	DoNothing (const char *fileName, SceneGraph_KnobI *, const SceneItems &items)
bool	test_small_block_allocator ()
void	InitialiseThread ()
void	PolygonTriangulate (const Primitive *poly, const int face, const PointList *pointList, std::vector< unsigned > &triangles)
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)
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)

Variables
const Version	gVersion
const Version *	gApplicationVersion
double	gScriptVersion
bool(*	scriptExec )(const char *, bool)
bool(*	scriptEval )(const char *)
bool(*	scriptSingle )(const char *)
void(*	showScriptErrorPopup )()
const char *const	group_names []
const char	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")
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	render_modes []
	Name text array for render_mode enumeration knob.
const char *const	render_modes_source []
	Same as render_modes, except missing the "unchanged" entry.
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
struct DD::Image::Targets	xform_targets
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)
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 &)
const std::string	gEnvDebugShaderBuilding
const std::string	gEnvDebugNukeMaterials
const std::string	gEnvDebugLights
const bool	gDebugShaderBuilding
const bool	gDebugNukeMaterials
const bool	gDebugLights
LUTMapper *(*	NukeLUTMapperFactoryFuncPointer )(Op *pOp)
const std::string	gEnvDebugShaderConnections
const std::string	gEnvDebugTextureHandling
const bool	gDebugShaderConnections
const bool	gDebugTextureHandling
std::string	gOpRootPath
const char *	gOpAssetPathPrintFormat
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)
NodeI *(*	node_GetNodeAtPath )(const std::string &, int32_t)
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)
Op *(*	op_retrieveOp )(const char *, DD::Image::Op::GenerateType, const DD::Image::OutputContext *)
Op *(*	op_retrieveOpByHash )(const char *, const Hash &, int)
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 &, bool)
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
constexpr std::array< const char *, 13 >	kHiddenViewerOps
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 )()

RemoveOp
Removes an op and its connected input ops from the specified trees
enum	ShowMessagesOption { eSMO_DoNotShowMessages , eSMO_ShowMessages }
void	RemoveOpFromTrees (Op *lpOp, const std::vector< OpTree * > &lrTrees)
void	RemoveOpFromTree (Op *lpOp, OpTree *lpTree)
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.

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

GeometryMask

typedef unsigned DD::Image::GeometryMask

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

PluginUnloadedFunc

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.

ClipTestFunc

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.

SlowSignalLock

typedef SignalLock DD::Image::SlowSignalLock

This is for back compatibility only

Enumeration Type Documentation

AttribType

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)

LensProjection

enum class DD::Image::LensProjection : int32_t

strong

Predefined lens projection modes.

Enumerator
PERSPECTIVE	Standard perspective projection.
ORTHOGRAPHIC	Standard orthographic projection.
UV	Replace XY with UV coordinate.
SPHERICAL	360x180 world spherically projected around camera
RENDER_CAMERA	Renderer uses this option to get lens projection from input camera.
USER_CAMERA	Camera user projections start here.

Channel

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)
Chan_Cutout_Alpha	pixel or sample coverage weight
Chan_Cutout_Depth	used to preserve alpha while performing cutout operations
Chan_Unused	used to preserve depth while performing cutout operations

ChannelSetInit

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.

ChannelSet3DInit

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.

GroupType

enum DD::Image::GroupType

Geometry part groups.

anonymous enum

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.

LookupCurvesType

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

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.

OpHints

enum class 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 them. 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, but 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 them. 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.

FrameAdvance

enum DD::Image::FrameAdvance : unsigned char

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

ImageDirection

enum class 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.

MotionVectorType

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

StringExpandFlags

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.

DrawHandleType

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.

ViewerConnected

enum ViewerConnected

related

Values for ViewerContext::connected()

TransformSpace

enum class TransformSpace : uint8_t

related

Value for ViewerContext::transformSpace()

ViewerMode

enum ViewerMode

related

Value for ViewerContext::viewer_mode()

ViewerEvent

enum ViewerEvent

related

Value for ViewerContext::event().

CameraLockMode

enum CameraLockMode

related

Value for camera lock mode

Display3DMode

enum Display3DMode : int

related

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

RenderMode

enum DD::Image::RenderMode : int

Per-object render modes. Deprecated.

SelectionMode3D

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;

SelectionOptions3D

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

anonymous enum

related

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

anonymous enum

related

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

anonymous enum

anonymous enum

related

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

anonymous enum

anonymous enum

related

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

SelectionKind

enum class SelectionKind

related

Values for the selection of the USD kind

FrustumVisibility

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

SetValueProvider()

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

LensProjectionFunction()

LensProjectionFunc * DD::Image::LensProjectionFunction	(	LensProjection	mode,
		const Format *	format,
		CameraLensContext &	context
	)

Returns a standard (built in) lens function appropriate for the LensProjection mode. CameraLensContext is passed so the mode, wrapping and format can be configured.

References DD::Image::CameraLensContext::distortA, DD::Image::CameraLensContext::distortB, DD::Image::CameraLensContext::distortC, DD::Image::CameraLensContext::distortD, DD::Image::CameraLensContext::format, DD::Image::CameraLensContext::formatWrapU, DD::Image::CameraLensContext::formatWrapV, DD::Image::CameraLensContext::mode, and DD::Image::CameraLensContext::transforms.

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

incr()

void DD::Image::incr ( Channel &  c )

inline

Adds one to the Channel and returns it.

operator<<() [1/2]

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

getChannel()

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

getChannelCount()

size_t DD::Image::getChannelCount

(

)

Get the number of channels currently registered.

findChannel()

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.

getName()

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

getLayerName()

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.

colourIndex()

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

brother()

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

compareChannels()

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.

version()

const Version & DD::Image::version ( )

inline

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

Referenced by DD::Image::GeomOp::appendToTarget(), applicationVersion(), and DD::Image::GeoOp::synchronize_cache().

applicationVersion()

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

scriptVersion()

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.

PlusOperation()

DeepLightSample DD::Image::PlusOperation	(	const ChannelMap &	chanMap,
		const DeepLightSample &	sampleA,
		const DeepLightSample &	sampleB
	)

Add two samples together, only adding the samples from the second sample if they are in the provided ChannelMap

Parameters

chanMap	channels from sampleB to add to sampleA
sampleA	starting sample data
sampleB	data to add

Returns

sample where each channel is the sum of sampleA and sampleB for that specific channel

MergeOperation()

DeepLightSample DD::Image::MergeOperation	(	const ChannelMap &	chanMap,
		const DeepLightSample &	sampleA,
		const DeepLightSample &	sampleB
	)

Merge samples together. If the alpha of both is 1, then averages the values per channel. If the alpha of one of them is 1, then that one will override the result. If both of them don't have an alpha of 1, then the result is a weighted sum of sampleA and sampleB.

Parameters

chanMap	the channels to merge together
sampleA	first sample to merge sets the deep front and back data
sampleB	second sample to merge

Returns

a new merged sample

References Chan_DeepBack, and clamp().

CombineOverlappingSamples()

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.

Parameters

channels	channels to combine together
deepPixel	pixel with sample data to combine together
pixels	the output pixel

DeoverlapPixelSamples()

DeepOutPixel DD::Image::DeoverlapPixelSamples	(	const ChannelMap &	channels,
		const DeepPixel &	deepPixel
	)

Splits volumes that partially overlap - perfectly overlapping volumes aren't split

Parameters

channels	channels to de-overlap
deepPixel	pixel to de-overlap

Returns

DeepOutPixel with split volumes

References Chan_DeepBack, DD::Image::DeepPixel::channels(), DD::Image::ChannelMap::contains(), DD::Image::DeepPixel::getSampleCount(), DD::Image::DeepOutPixel::reserve(), and DD::Image::ChannelMap::size().

MergeOverlappingPixelSamples()

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

Merge perfectly overlapping samples - where the Deep_Front and Deep_Back are the same for the sample per channel

Parameters

channels	channels to merge together
in_pixel	the pixel to merge the samples in
f	the function to apply in the case of overlapping samples - for example, PlusOperation, MergeOperation

Returns

DeepOutPixel with the samples merged according to the function provided

References DD::Image::DeepPixel::getSampleCount(), DD::Image::DeepOutPixel::reserve(), and DD::Image::ChannelSet::size().

CompositeSamples() [1/2]

void DD::Image::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.

Parameters

samples	samples to composite
chans	channels to composite
row	row to write into
x	x coordinate of the row to start writing into
Zpix	float address to output the percentage of the alpha relative to the total deep z
Zfrontpix	float address to output the largest Deep_Front of the samples

CompositeSamples() [2/2]

void DD::Image::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.

Parameters

samples	samples to composite
chans	channels to composite
row	row to write into
x	x coordinate of the row to start writing into
Zpix	float address to output the percentage of the alpha relative to the total deep z
Zfrontpix	float address to output the largest Deep_Front of the samples
Zbackpix	float address to output the smallest Deep_Back of the samples

DetectOverlappingSamples()

bool DD::Image::DetectOverlappingSamples

(

const DeepSampleVector &

t

)

Check whether any samples overlap. Samples can be a DeepPixel or a DeepSampleVector.

Parameters

t	samples to check

Returns

true if any of the samples overlap, false if the samples don't have Deep_Front and Deep_Back or don't overlap

RenameTempToFinal()

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

GetGeoInfoAttribContext()

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.

glColor()

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::AxisOp::draw_handle(), DD::Image::CameraOp::draw_handle(), DD::Image::LightOp::draw_handle(), DD::Image::ComplexLightOp::draw_handle(), DD::Image::Transform::draw_handle(), DD::Image::CameraOp::drawCameraIcon(), gl_axis(), and gl_axis_label().

gl_text() [1/6]

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.

References gl_text().

Referenced by DD::Image::AxisOp::draw_handle(), DD::Image::CameraOp::draw_handle(), DD::Image::LightOp::draw_handle(), DD::Image::ComplexLightOp::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().

gl_text() [2/6]

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.

gl_text() [3/6]

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

gl_text() [4/6]

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

gl_text() [5/6]

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

gl_text() [6/6]

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

gl_circlef()

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

gl_circlef: 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().

gl_circlefAsTris()

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

gl_cylinderf()

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

gl_conef()

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

gl_sphere()

void DD::Image::gl_sphere

(

float

radius = 0.5

)

Draw a wireframe sphere around 0,0,0

References gl_circlef().

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

gl_planef()

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

gl_quadi()

void DD::Image::gl_quadi	(	int	x,
		int	y,
		int	right,
		int	top
	)

gl_quadi: Draws a filled quad (int version). 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

gl_rectangle() [1/2]

void DD::Image::gl_rectangle	(	float	x,
		float	y,
		float	r,
		float	t
	)

gl_rectangle: Draw the outline of a 2-D rectangle (float version). 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

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

gl_rectangle() [2/2]

void DD::Image::gl_rectangle	(	int	x,
		int	y,
		int	r,
		int	t
	)

gl_rectangle: Draw the outline of a 2-D rectangle (int version). x = left bottom value along x axis y = left bottom value along y axis r = right top value along x axis t = right top value along y axis

gl_circle()

void DD::Image::gl_circle	(	float	x,
		float	y,
		float	radius,
		float	intervalDegrees
	)

gl_circle: Draw the outline of a 2-D circle. x, y = position of center of cylinder radius = radius of circle intervalDegrees = number of points that define the precision of the shape of circle - the more points are used the more accurate shape of circle is drawn

References gl_ellipse().

gl_ellipse()

void DD::Image::gl_ellipse	(	float	x,
		float	y,
		float	xradius,
		float	yradius,
		unsigned	nPoints
	)

gl_ellipse: Draw the outline of a 2-D ellipse. x, y = position of center of ellipse xradius = radius of ellipse along x axis yradius = radius of ellipse along y axis nPoints = number of points that define the precision of the shape of ellipse - the more points are used the more accurate shape of ellipse is drawn

Referenced by gl_circle().

gl_bracket()

void DD::Image::gl_bracket	(	float	x,
		float	y,
		float	r,
		float	t,
		float	sx,
		float	sy
	)

gl_bracket: Draw brackets using 2-D lines. x = left bottom value along x axis y = left bottom value along y axis r = right top value along x axis t = right top value along y axis sx = length of a bracket segment along x axis sy = length of a bracket segment along y axis

gl_crossf()

void DD::Image::gl_crossf	(	float	x,
		float	y,
		float	z,
		float	size,
		int	plane
	)

gl_crossf: Draw a cross on a 3-D axes plane (float version). x, y, z = position of cross size = length of a segment from the cetner to a side of cross plane = which plane to draw on: XY, YZ, XZ - Provided for convenience

gl_crossi()

void DD::Image::gl_crossi	(	int	x,
		int	y,
		int	z,
		int	size,
		int	plane
	)

gl_crossi: Draw a cross on a 3-D axes plane (int version). x, y, z = position of cross size = length of a segment from the cetner to a side of cross plane = which plane to draw on: XY, YZ, XZ - Provided for convenience

gl_axis()

void DD::Image::gl_axis

(

)

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

References gl_conef(), and glColor().

gl_axis_label()

void DD::Image::gl_axis_label

(

)

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

References gl_text(), and glColor().

gl_boxf()

void DD::Image::gl_boxf	(	float	x,
		float	y,
		float	n,
		float	r,
		float	t,
		float	f,
		bool	filled = false
	)

gl_boxf: Draw a 3-D 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 filled = pass true for drawing the box filled in a solid color or false for the outline

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

gl_cubef()

void DD::Image::gl_cubef	(	float	x,
		float	y,
		float	z,
		float	width
	)

gl_cubef: Draw a 3-D cube. x, y, z = position of center of cube width = width of cube edges

gl_bezierf()

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.

gl_polygon()

void DD::Image::gl_polygon	(	const DD::Image::Vector2 *	points,
		size_t	nPoints,
		DD::Image::Vector2	offset = DD::Image::Vector2()
	)

gl_polygon: Draw the outline of a 2-D polygon. points = points that define the shape of polygon nPoints = number of given points offset = drawing offsets along horizontal and vertical axes

gl_drawTextTopLeftOrthogonal()

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

gl_errorstring()

const char * DD::Image::gl_errorstring

(

int

errorcode

)

Print GL errors - reasonably emulates gluErrorString

References snprintf().

Referenced by glGetErrors().

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

GLProject()

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

escape()

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

Tooltip() [1/2]

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::AxisOp::addCreateOptionsKnobs(), DD::Image::AxisOp::addDisplayOptionsKnobs(), DD::Image::CameraOp::addDisplayOptionsKnobs(), DD::Image::AxisOp::addFileImportKnobs(), DD::Image::CameraOp::addLensKnobs(), DD::Image::AxisOp::addLocalParentingKnobs(), DD::Image::AxisOp::addLocalXformKnobs(), DD::Image::SurfaceShaderOp::addMergeKnobs(), DD::Image::SurfaceShaderOp::addOpacityKnobs(), DD::Image::SurfaceShaderOp::addPresenceKnobs(), DD::Image::CameraOp::addProjectionKnobs(), DD::Image::AxisOp::addScenePrimImporterKnobs(), DD::Image::CameraOp::addShutterKnobs(), DD::Image::AxisOp::createAxisOpKnobs(), DD::Image::ExtendedOpProperties::extendedPropertiesKnobs(), DD::Image::Transform::filter_knobs(), DD::Image::Executable::frameRangeKnobs(), DD::Image::DrawIop::input_knobs(), DD::Image::LookAt::knobs(), DD::Image::SourceGeomOp::knobs(), DD::Image::NukeWrapper::knobs(), DD::Image::Transform::knobs(), DD::Image::Filter::knobs(), DD::Image::FrameRangeControls::knobs(), DD::Image::ShutterControls::knobs(), and DD::Image::Transform::motionblur_knobs().

Tooltip() [2/2]

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

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

SetFlags()

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::AxisOp::addCreateOptionsKnobs(), DD::Image::CameraOp::addDisplayOptionsKnobs(), DD::Image::AxisOp::addFileImportKnobs(), DD::Image::AxisOp::addLocalParentingKnobs(), DD::Image::AxisOp::addLocalXformKnobs(), DD::Image::CameraOp::addProjectionKnobs(), DD::Image::AxisOp::addScenePrimImporterKnobs(), DD::Image::CameraOp::addShutterKnobs(), DD::Image::AxisOp::createAxisOpKnobs(), DD::Image::Transform::filter_knobs(), DD::Image::DrawIop::input_knobs(), DD::Image::NukeWrapper::knobs(), DD::Image::Transform::knobs(), DD::Image::FrameRangeControls::knobs(), DD::Image::ShutterControls::knobs(), DD::Image::Transform::motionblur_knobs(), and DD::Image::DrawIop::output_knobs().

ClearFlags()

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.

Referenced by DD::Image::AxisOp::addCreateOptionsKnobs(), DD::Image::AxisOp::addFileImportKnobs(), DD::Image::AxisOp::addLocalParentingKnobs(), DD::Image::AxisOp::addLocalXformKnobs(), DD::Image::CameraOp::addProjectionKnobs(), DD::Image::AxisOp::addScenePrimImporterKnobs(), DD::Image::CameraOp::addShutterKnobs(), and DD::Image::ExtendedOpProperties::extendedPropertiesKnobs().

SetRange()

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.

Obsolete_knob() [1/2]

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

Obsolete_knob() [2/2]

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.

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

String_knob() [1/2]

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.

Referenced by DD::Image::AxisOp::addCreateOptionsKnobs(), and DD::Image::ExtendedOpProperties::extendedPropertiesKnobs().

Password_knob()

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

inline

Create a Password input field

String_knob() [2/2]

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.

File_knob()

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.

Referenced by DD::Image::AxisOp::addFileImportKnobs().

Read_File_knob() [1/2]

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.

Read_File_knob() [2/2]

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.

Cached_File_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

Write_File_knob() [1/2]

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.

Write_File_knob() [2/2]

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.

Proxyless_Read_File_knob()

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.

Int_knob()

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::AxisOp::addFileImportKnobs(), DD::Image::Executable::frameRangeKnobs(), and DD::Image::FileOp::Reload_Button().

Enumeration_knob()

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::AxisOp::addCreateOptionsKnobs(), DD::Image::AxisOp::addDisplayOptionsKnobs(), DD::Image::AxisOp::addFileImportKnobs(), DD::Image::SurfaceShaderOp::addMergeKnobs(), DD::Image::CameraOp::addProjectionKnobs(), DD::Image::AxisOp::addScenePrimImporterKnobs(), DD::Image::AxisOp::createAxisOpKnobs(), DD::Image::ParticleBehaviour::Falloff_knob(), DD::Image::DrawIop::input_knobs(), DD::Image::LookAt::knobs(), DD::Image::SourceGeomOp::knobs(), DD::Image::Filter::knobs(), DD::Image::FrameRangeControls::knobs(), DD::Image::ShutterControls::knobs(), and DD::Image::DrawIop::output_knobs().

Bitmask_knob()

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.

Bool_knob()

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::AxisOp::addCreateOptionsKnobs(), DD::Image::AxisOp::addDisplayOptionsKnobs(), DD::Image::CameraOp::addDisplayOptionsKnobs(), DD::Image::AxisOp::addFileImportKnobs(), DD::Image::CameraOp::addLensKnobs(), DD::Image::AxisOp::addLocalParentingKnobs(), DD::Image::AxisOp::addLocalXformKnobs(), DD::Image::AxisOp::addScenePrimImporterKnobs(), DD::Image::AxisOp::createAxisOpKnobs(), 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().

Float_knob() [1/2]

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::SurfaceShaderOp::addOpacityKnobs(), DD::Image::DrawIop::input_knobs(), DD::Image::NukeWrapper::knobs(), and DD::Image::Transform::motionblur_knobs().

Float_knob() [2/2]

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

inline

Controls a single number stored as a float

Frame_knob()

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

Deep_knob()

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

MultiFloat_knob() [1/2]

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

inline

Controls dim doubles in an array

MultiFloat_knob() [2/2]

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

inline

Controls dim floats in an array

MultiInt_knob()

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

inline

Controls dim integers in an array

PixelAspect_knob()

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.

Array_knob()

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.

Referenced by DD::Image::AxisOp::addLocalXformKnobs(), and DD::Image::AxisOp::createAxisOpKnobs().

ChannelSet_knob()

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

Input_ChannelSet_knob()

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"

InputOnly_ChannelSet_knob()

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

Channel_knob()

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

Input_Channel_knob()

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::SurfaceShaderOp::addOpacityKnobs(), DD::Image::SurfaceShaderOp::addPresenceKnobs(), DD::Image::DrawIop::input_knobs(), DD::Image::IllumShader::knobs(), and DD::Image::NukeWrapper::knobs().

InputOnly_Channel_knob()

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

XY_knob()

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

XYZ_knob()

Knob * DD::Image::XYZ_knob ( Knob_Callback  f, double *  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.

Referenced by DD::Image::AxisOp::addLocalParentingKnobs().

UV_knob()

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

inline

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

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

CP_knob()

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

WH_knob()

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.

BBox_knob()

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.

Format_knob()

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.

Color_knob()

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.

AColor_knob()

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

Eyedropper_knob()

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

Range_knob()

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.

Transform2d_knob()

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

inline

This knob stores into a Mat4f a 2-D transformation (although a Mat4f 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.

LookupCurves_knob() [1/2]

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.

LookupCurves_knob() [2/2]

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.

Axis_knob()

Knob * DD::Image::Axis_knob ( Knob_Callback  f, fdk::Mat4d *  p, NAME  n, LABEL  l = nullptr  )

inline

This knob stores into a Mat4d 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.

Referenced by DD::Image::AxisOp::addLocalXformKnobs(), DD::Image::AxisOp::createAxisOpKnobs(), and DD::Image::SourceGeomOp::makeTransformKnob().

PositionVector_knob()

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.

Box3_knob()

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.

Histogram_knob()

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

Keyer_knob()

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

inline

obsolete

ColorChip_knob()

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.

Tab_knob()

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::CameraOp::addExtraFrontPanelKnobs(), DD::Image::AxisOp::createAxisOpKnobs(), DD::Image::ExtendedOpProperties::extendedPropertiesKnobs(), DD::Image::LookAt::knobs(), DD::Image::CameraOp::knobs(), DD::Image::SourceGeomOp::makeTransformKnob(), and DD::Image::DrawIop::output_knobs().

BeginGroup()

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.

BeginClosedGroup()

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.

Referenced by DD::Image::AxisOp::addLocalXformKnobs(), and DD::Image::AxisOp::createAxisOpKnobs().

EndGroup()

Knob * DD::Image::EndGroup ( Knob_Callback  f )

inline

Ends a hierarchy level.

Referenced by DD::Image::AxisOp::addLocalXformKnobs(), and DD::Image::AxisOp::createAxisOpKnobs().

BeginToolbar()

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.

EndToolbar()

Knob * DD::Image::EndToolbar ( Knob_Callback  f )

inline

Ends a toolbar.

BeginTabGroup()

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.

EndTabGroup()

Knob * DD::Image::EndTabGroup ( Knob_Callback  f )

inline

Ends a tabbed group.

BeginExoGroup()

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

EndExoGroup()

Knob * DD::Image::EndExoGroup ( Knob_Callback  f )

inline

Ends a extratabular group.

Text_knob() [1/2]

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.

Text_knob() [2/2]

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

Named_Text_knob() [1/2]

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.

Named_Text_knob() [2/2]

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.

Newline()

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::CameraOp::addDisplayOptionsKnobs(), DD::Image::AxisOp::addLocalParentingKnobs(), DD::Image::AxisOp::addScenePrimImporterKnobs(), DD::Image::DrawIop::input_knobs(), DD::Image::LookAt::knobs(), and DD::Image::NukeWrapper::knobs().

Divider()

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::CameraOp::addLensKnobs(), DD::Image::AxisOp::addScenePrimImporterKnobs(), DD::Image::AxisOp::addTransformKnobs(), DD::Image::AxisOp::createAxisOpKnobs(), DD::Image::ExtendedOpProperties::extendedPropertiesKnobs(), DD::Image::DrawIop::input_knobs(), and DD::Image::SourceGeomOp::knobs().

Spacer()

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.

Referenced by DD::Image::CameraOp::addProjectionKnobs(), and DD::Image::ExtendedOpProperties::extendedPropertiesKnobs().

VSpacer()

Knob * DD::Image::VSpacer ( Knob_Callback  f, int  spaceInPixels  )

inline

Vertical gap between knobs.

Icon_knob()

Knob * DD::Image::Icon_knob ( Knob_Callback  f, const char *  icon  )

inline

A non-interactive icon

Help_knob() [1/2]

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.

Help_knob() [2/2]

Knob * DD::Image::Help_knob ( Knob_Callback  f, LABEL  label, LABEL  text  )

inline

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

Button()

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.

Script_knob()

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::AxisOp::addFileImportKnobs(), DD::Image::FrameRangeControls::knobs(), and DD::Image::FileOp::Reload_Button().

PyScript_knob()

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

CancelExecution_knob()

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.

Python_knob()

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.

Pulldown_knob()

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.

PyPulldown_knob()

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.

Multiline_String_knob()

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

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

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

Disable_knob()

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

inline

A knob managing the logic for disabling nodes

operator<<() [2/2]

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

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

Matrix4ToVector()

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

VectorToMatrix4()

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

Matrix4ToArray()

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

Matrix3x4ToArray()

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

noise() [1/3]

double DD::Image::noise

(

double

arg

)

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

Referenced by fBm(), and turbulence().

noise() [2/3]

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

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

noise() [3/3]

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"

fBm()

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

turbulence()

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

p_random() [1/6]

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

p_random() [2/6]

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.

p_random() [3/6]

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.

p_random() [4/6]

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

p_random() [5/6]

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

p_random() [6/6]

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

ParallelFor()

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.

ParallelForRange()

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

plugin_count()

int DD::Image::plugin_count

(

)

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

plugin_name() [1/2]

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

plugin_name() [2/2]

const char * DD::Image::plugin_name

(

int

n

)

Return the filename of the Nth plugin that was found.

plugin_find()

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

plugin_load() [1/2]

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::Reader::Description::find(), DD::Image::Writer::Description::find(), slr::SlrShader::PluginDescription::find(), DD::Image::Op::find_description(), and plugin_load().

plugin_load() [2/2]

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

plugin_load_all()

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

plugin_load_one()

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

plugin_path()

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

plugin_addpath()

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

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

plugin_error() [1/2]

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(), slr::SlrShader::PluginDescription::find(), DD::Image::Op::find_description(), DD::Image::Write::set_file_type(), DD::Image::Write::set_file_type_from_filename(), and DD::Image::WriteGeo::set_file_type_from_filename().

plugin_error() [2/2]

void DD::Image::plugin_error

(

const char *

s

)

Set an error message for the current plugin.

References strlcpy().

plugin_binary()

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(), plugin_verbose, and snprintf().

plugin_path_list()

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

getPluginPath()

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

setPluginInstallPaths()

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.

getPluginInstallPaths()

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

(

)

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

getApplicationPluginPath()

const char * DD::Image::getApplicationPluginPath

(

)

Return the plugin path of the application

getRegisteredPluginOps()

std::vector< std::string > DD::Image::getRegisteredPluginOps

(

)

Return a vector of strings containing names for all the registered plugin Ops.

When Ops are bundled in a plugin, there is not a one to one relationship between plugin files and Ops. Loaded plugins (retrieved with plugin_count/plugin_name) is a record of the plugin files which have been loaded.

Once a plugin file has been loaded, all of the Ops in the file are registered automatically. Use this function to query the registered Ops from the loaded plugin files.

createRIPContext()

void DD::Image::createRIPContext

(

)

create and register the DDImage RIP Context with RIP

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

destroyRIPContext()

void DD::Image::destroyRIPContext

(

)

Destroy the DDImage RIP Context

References gRipContext.

StoreTypeBaseSize()

size_t DD::Image::StoreTypeBaseSize

(

StoreType

storetype

)

Return the nominal size, in bytes, of the base type pointed at by a StoreType pointer.

For example a FloatPtr will return sizeof(float), DoublePtr returns sizeof(double), ConvolveArrayPtr returns sizeof(DD::Image::ConvolveArray), and StlStringIntPairPtr returns sizeof(std::pair<std::string, int32_t>).

Note - this is only accurate for the StoreType's base data size and does not take into account if a Knob is storing an array of the StoreType data. Knobs should implement the virtual numElements() method so that, in conjunction with StoreTypeBaseSize(), the total size of the data block is deduceable.

StoreTypeForValueType()

StoreType DD::Image::StoreTypeForValueType

(

int

valuetype

)

Return a compatible StoreType for an usg::Value::Type. This only handles the base usg::Value data types like String, Int, Bool, etc.

Note this method takes an int to avoid including the ndk headers.

TextureMipSample()

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.

SleepMS()

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

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

style_needs_wireframe()

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

PrintKnobChangedInValidateWarning()

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

ParseDDImageAbiVersionFromDLErrorMessage()

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

Referenced by plugin_binary().

ParseBlinkLibraryAbiVersionFromDLErrorMessage()

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

Referenced by plugin_binary().

Variable Documentation

group_names

const char *const DD::Image::group_names

extern

Group name strings.

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

INVISIBLE

const char DD::Image::INVISIBLE

extern

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::AxisOp::addFileImportKnobs(), DD::Image::NukeWrapper::knobs(), and DD::Image::FileOp::Reload_Button().

root_real_fps

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

(

)

Return the current global setting for frames per second.

Referenced by DD::Image::Read::append(), DD::Image::GeomOp::buildStage(), DD::Image::MaterialOpI::overrideShaderDescInput(), and DD::Image::GeomOpEngine::updateGeomEngineState().

plugin_verbose

bool DD::Image::plugin_verbose

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

Referenced by plugin_binary().

plugin_safe_mode

bool DD::Image::plugin_safe_mode

extern

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

getClipboardContents

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

(

)

Return the contents of the clipboard

setClipboardContents

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

(

std::string &

text

)

Copy a string into the clipboard

display3d_names

const char *const DD::Image::display3d_names

extern

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

display3d_names_source

const char *const DD::Image::display3d_names_source

extern

Same as display3d_names, except missing the "unchanged" entry

Referenced by DD::Image::AxisOp::addDisplayOptionsKnobs(), and DD::Image::AxisOp::createAxisOpKnobs().

profileRequestEventPointer

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

! The functions which are defined by Nuke

gRipContext

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

Nuke/DDImage's RIP context

Referenced by DD::Image::RefCountedFloatBuffer::allocate(), createRIPContext(), and destroyRIPContext().