DD::Image Namespace Reference

Namespaces

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

Classes

class  AllocationTracker
 A class for checkpoint tracking of memory allocations allocated by the HeapAllocator. More...
 
struct  AllocTrackingInfo
 A structure holding information about a tracked object's memory allocation. More...
 
class  AttribContext
 
class  Attribute
 General Attribute class. More...
 
class  AudioReaderI
 
struct  AudioReadInfo
 
class  AutoProfileEvent
 
class  AxisOp
 AxisOp is the base class for all the 3D objects. It simply contains a transform matrix. More...
 
class  BaseHandle
 
class  BaseLockGuard
 
class  BaseReadWriteGuard
 Base class for Read/Write Guard classes. More...
 
class  BasicGrid
 
class  Black
 
class  BlockAllocator
 
class  Blur
 
class  Box
 Describes a rectangle with integer boundaries. More...
 
class  Box2f
 
class  Box3
 3D Box More...
 
class  BufferIop
 Base class for Iops which buffer the output of another Iop into an image plane. More...
 
class  BufferIopTile
 
class  CameraOp
 
class  ChannelMap
 
class  ChannelSet
 
class  ChannelSetIterator
 
class  CodecHandler
 
class  CodecOp
 
class  ColorLookup
 
class  Colorspace_KnobI
 
class  ComplexLightOp
 
class  ConvertibleToIop
 Helper class for converting non Iop based classes to Iop. More...
 
class  Convolve
 
struct  ConvolveArray
 
struct  CurveDescription
 
class  DataInfo
 Class that provides information about component types. More...
 
class  DebugTopDownGraphObserver
 An observer class for tracking topdown rendering events and logging them to standard output. More...
 
class  DeepAccumPixelOp
 
class  DeepFilterOp
 
class  DeepInfo
 
class  DeepInPlaceOutputPlane
 
class  DeepLightSample
 helper class representing a small float vector, one for each channel in a set More...
 
class  DeepOnlyOp
 
class  DeepOp
 
class  DeepOutPixel
 
class  DeepOutputPixel
 
class  DeepOutputPlane
 
class  DeepPixel
 
class  DeepPixelOp
 DeepPixelOp is a base class that provides similar functionality to the combination of NukeWrapper and PixelOp. More...
 
class  DeepPlane
 
class  DeepReader
 
class  DeepSample
 helper class representing a small float vector, one for each channel in a set More...
 
class  DeepSampleVector
 
class  DeepWriter
 
class  DeepWriterOwner
 
class  DepthMapRender
 Depth map rendering for a shadow buffer. More...
 
class  Description
 
class  DirectGeneralTile
 
class  DownRez
 
struct  Draw_Handle_Callback
 
class  DrawIop
 
class  EngineContext
 
class  Enumeration_KnobI
 
class  Executable
 Class to wrap up node graph execution. More...
 
class  Execute
 
class  File_KnobI
 
class  FileOp
 
class  FileRead
 
class  FileReader
 
class  FileSet
 
class  FileWriter
 
class  Filter
 
class  Format
 Describes the size and shape of an image. More...
 
class  FrameExtentProviderI
 
class  FrameRangeControls
 Class used to standardise frame range controls throughout NUKE. More...
 
class  GeneralInfo
 Base class for defining a time bounded region. More...
 
class  GeneralTile
 
class  GenericImagePlane
 Class to wrap up an image plane of arbitrary type. This is used by the readers to return image data with the minimal amount of conversion needed. More...
 
class  GenericImagePlaneDescriptor
 
class  GeoDescription
 
class  GeoInfo
 Contains a list of points and geometric primitives. More...
 
struct  GeoInfoRenderState
 
class  GeometryList
 
class  GeoOp
 
class  GeoReader
 
class  GeoWriter
 
class  GPUContext
 
class  Guard
 
class  Handle
 Standard handle, which allocates via DD Images memory pool. More...
 
class  Hash
 
class  HConvolve
 
class  HeapAllocator
 
class  Histogram_Data
 
class  IAllocator
 Allocator interface. More...
 
class  IllumShader
 This subclass of Material provides some convienence functions so that it is easier to write a lighting surface shader. More...
 
class  Image_Cache
 
class  ImageCacheReadI
 Holder of temporary data to read files from cache: More...
 
class  ImageCacheWriteI
 Holder of temporary data to write files to cache: More...
 
class  ImagePlane
 
class  ImagePlaneDescriptor
 
class  Info2D
 
class  Interest
 
class  InterestRatchet
 
class  InternalOCIOOp
 Helper class to enable Readers and Writers to use internal OCIOColorpace Ops. More...
 
class  Iop
 Iop is the base class for all the image operators. More...
 
class  IopInfo
 
class  IopInfoOwner
 IopInfo holder. More...
 
struct  IRange
 
class  Knob
 
class  KnobChangedObserverI
 
class  KnobChangeGroup
 
class  License
 
class  LightContext
 
class  LightOp
 LightOp defines a 3D light. More...
 
class  Linear
 
class  LinkableI
 
class  LinkableKnobInfo
 
class  Lock
 
class  LookAt
 Helper class that adds LookAt functionality. More...
 
class  LookupCurves
 
class  LookupCurves_KnobI
 
class  LUT
 
class  LUTInfo
 
class  Material
 
class  Matrix3
 A 3x3 transformation matrix. More...
 
class  Matrix4
 A 4x4 transformation matrix. More...
 
class  MatrixArray
 
class  MBParticleSpriteGenerator
 
class  MBSceneSpriteGenerator
 
class  Memory
 
class  MemoryHolder
 
class  Menu
 
class  Mesh
 
class  ModifyGeo
 
class  MultiArray_KnobI
 
class  MultiTileIop
 
class  NoIop
 
class  NukeWrapper
 
class  NullGeo
 
struct  ObjectCell
 
class  Op
 Base class of all the things that can be created by Nuke nodes. More...
 
class  OpMessage
 This class encapsulates a text message to the user produced by an op. More...
 
class  OpMessageHandler
 This component of an op handles its messages to the user. More...
 
class  OpMessageObserver
 
class  OpTask
 
class  OpTimer
 
class  OpTree
 
class  OpTreeHandler
 This component of an op handles the manipulations of its trees: adding to, removing from, checking statuses, etc. More...
 
class  OrderedMap
 
class  OutputContext
 
class  ParticleBehaviour
 
class  ParticleNodeState
 
class  ParticleNodeStateFactory
 
class  ParticleOp
 
class  ParticleRender
 
class  Particles
 
class  ParticlesSprite
 
class  ParticleSystem
 
class  Pixel
 
class  PixelIop
 
class  PlanarI
 
class  PlanarIop
 
class  PlanarReadInfo
 Information about a generic image plane, as opposed to a scan line, and how it can be read and decoded. More...
 
class  Plane
 
class  Point
 
class  Polygon
 
class  PolygonPrimitive
 
class  PolyMesh
 PolyMesh is a connected series of polygons comprising a contiguous surface. More...
 
class  PositionVector_KnobI
 The interface for position vector knobs. More...
 
class  PreValidateContext
 
class  Primitive
 
class  PrimitiveContext
 
class  PrimitiveTestCache
 
class  ProfileEvent
 
class  ProxyContext
 
class  Quadtree
 
struct  QuadtreeNode
 
class  Quaternion
 A implementation of a way of representing rotations that avoid a lot of the problems that the standard rotation about the axis methods have. More...
 
class  Radio_KnobI
 
class  Random
 A random number generator for the use of ParticleOps. More...
 
class  RandomBoxes
 Vector of boxes with member functions. More...
 
class  RawGeneralTile
 
struct  Ray
 
class  Read
 
class  Reader
 
class  ReaderDescription
 Base class for Reader plugin descriptions. More...
 
class  ReaderImpl
 Private, hidden implementation for DD::Image::Reader objects. More...
 
class  ReadFileKnobOwner
 
class  ReadGeo
 
class  ReadGuard
 
class  ReadImpl
 Private, hidden implementation for DD::Image::Read objects. More...
 
class  ReadWriteLock
 
class  RecursiveLock
 
class  RefCountedFloatBuffer
 
class  RefCountedObject
 
class  RefCountedPtr
 
class  Render
 Base class for rendering a 3D scene to an image. More...
 
class  RenderScene
 3D image renderer parent class More...
 
class  RequestOutput
 
class  Row
 
class  RowCacheTile
 
class  rPoint
 
class  rPrimitive
 This is the base class of anything renderable! We use this class to handle renderable objects that can have simple geometry such as triangles, spheres, etc. More...
 
class  rTriangle
 
struct  SamplePosition
 
class  Sampler
 
class  Scene
 
class  SceneGraph_KnobI
 
class  SceneView_KnobI
 
class  ShapeKnob
 
class  ShutdownBroadcaster
 
class  ShutDownListener
 
class  ShutterControls
 
class  SignalLock
 
class  SmallBlockDefinition
 
class  SolidShader
 Default solid vertex shader. More...
 
class  SourceGeo
 
class  SpinGuard
 
struct  Sprite
 
class  SpriteGenerator
 
class  Text_KnobI
 
class  TextureFilter
 
class  Thread
 
class  ThreadProfileEvent
 
class  TimelineRead
 Sub-class of DD::Image::Read used by NukeStudio/Hiero for timeline reads. More...
 
class  TimelineReadInternals
 A used by TimelineRead to hide internal implementations that we don't want to expose in the public DDImage API. More...
 
class  ToBuffer
 Takes the output of an image tree and put it into an 8-bit buffer. More...
 
class  TopDownGraphEvaluator
 
class  TopDownGraphNotifier
 
class  TopDownGraphObserver
 
class  TopDownPImpl
 Helper functions used by the top-down graph evaluator's private implementation. More...
 
class  Transform
 
class  TransformGeo
 Operator that transforms geometric points. More...
 
class  TransformJack_ClientI
 
class  TransformReceiverI
 
class  Triangle
 
class  TryWriteGuard
 
class  UpRez
 
class  ValueStuffI
 Container for values. More...
 
class  VArray
 
class  VConvolve
 
class  Vector2
 
class  Vector3
 
class  Vector4
 
class  Version
 
class  VertexContext
 
class  ViewerCache
 Image cache for the viewer. More...
 
class  ViewerContext
 
class  ViewFrustum
 
class  WireframeShader
 Default wireframe shader. More...
 
class  Write
 
class  WriteGeo
 
class  WriteGuard
 
class  Writer
 
class  WriterImpl
 Private, hidden implementation for DD::Image::Writer objects. More...
 

Typedefs

typedef Knob_Closure & Knob_Callback
 
typedef RefCountedPtr< AttributeAttributePtr
 
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< AttribContextAttribContextList
 
using ObjectSelections = std::vector< float >
 
using SelectionWeights = std::vector< float >
 
using VertexSelection = ObjectSelections
 
using FaceSelection = ObjectSelections
 
using VertexWeights = SelectionWeights
 
using FaceWeights = SelectionWeights
 
typedef std::map< DD::Image::Hash, Image_Cache_Entry > Cache_Entry_Map
 
using ImageTilePtr = PtrStridedIterator< float >
 
using ImageTileReadOnlyPtr = PtrStridedIterator< const float >
 
typedef void(* TimeoutHandler) (void *)
 
typedef unsigned long long Flags
 
typedef unsigned int ParticleChannelSet
 
using PluginUnloadedFunc = void(*)(const char *)
 
using OpTasks = std::map< Op *, OpTask * >
 
using Quaternion = TQuaternion< double >
 
using Quaternion4d = TQuaternion< double >
 
using Quaternion4f = TQuaternion< float >
 
using ClipTestFunc = bool(*)(const Box &box)
 
typedef Read ReaderOwner
 
typedef RefCountedPtr< BaseHandleHandlePtr
 
typedef std::vector< SceneItem > SceneItems
 
typedef std::pair< std::string, int > StlStringIntPair
 
typedef pthread_t ThreadId
 
typedef SignalLock SlowSignalLock
 
typedef DD::Image::RawGeneralTile Tile
 typedef for our preferred Tele type
 
typedef void(* DrawHandleCallbackFunc) (void *, ViewerContext *)
 
typedef unsigned int DrawHandleTypeMask
 
typedef PlanarI::PlaneID PlaneID
 
template<SampleFunction function>
using ReturnType = typename std::conditional< function==SampleFunction::eDoSampleShadowMap, float, void >::type
 
template<SampleFunction function>
using ArgType = typename std::conditional< function==SampleFunction::eDoEngine, TransformI, Iop >::type
 
typedef RefCountedPtr< ObjectGrid > ObjectGridPtr
 
typedef bool(* plugin_interpret_callback) (const char *name)
 
typedef pthread_t ThreadID
 

Enumerations

enum  AttribType {
  INVALID_ATTRIB, FLOAT_ATTRIB, VECTOR2_ATTRIB, VECTOR3_ATTRIB,
  VECTOR4_ATTRIB, NORMAL_ATTRIB, INT_ATTRIB, STRING_ATTRIB,
  STD_STRING_ATTRIB, POINTER_ATTRIB, MATRIX3_ATTRIB, MATRIX4_ATTRIB
}
 
enum  Channel {
  Chan_Black, Chan_Red, Chan_Green, Chan_Blue,
  Chan_Alpha, Chan_Z, Chan_U, Chan_V,
  Chan_Backward_U, Chan_Backward_V, Chan_Stereo_Disp_Left_X, Chan_Stereo_Disp_Left_Y,
  Chan_Stereo_Disp_Right_X, Chan_Stereo_Disp_Right_Y, Chan_Mask, Chan_RotoPaint_Mask,
  Chan_DeepFront, Chan_DeepBack, Chan_Mask_PlanarTrack, Chan_Mask_SplineWarp,
  Chan_Unused
}
 
enum  ChannelSetInit {
  Mask_None, Mask_Red, Mask_Green, Mask_Blue,
  Mask_Alpha, Mask_Z, Mask_DeepBack, Mask_DeepFront,
  Mask_Deep, Mask_U, Mask_V, Mask_Backward_U,
  Mask_Backward_V, Mask_Stereo_Disp_Left_X, Mask_Stereo_Disp_Left_Y, Mask_Stereo_Disp_Right_X,
  Mask_Stereo_Disp_Right_Y, Mask_RGB, Mask_RGBA, Mask_UV,
  Mask_MoVecForward, Mask_MoVecBackward, Mask_MoVec, Mask_Stereo_Disp_Left,
  Mask_Stereo_Disp_Right, Mask_Stereo_Disp, Mask_Mask, Mask_RotoPaint_Mask,
  Mask_PlanarTrack, Mask_SplineWarp, Mask_Builtin, Mask_All
}
 
enum  {
  Chan_Px, Chan_Py, Chan_Pz, Chan_Pw,
  Chan_UVx, Chan_UVy, Chan_UVz, Chan_UVw,
  Chan_Nx, Chan_Ny, Chan_Nz, Chan_PLx,
  Chan_PLy, Chan_PLz, Chan_PWx, Chan_PWy,
  Chan_PWz, Chan_MBx, Chan_MBy, Chan_MBz,
  Chan_VELx, Chan_VELy, Chan_VELz, Chan_P_,
  Chan_UV_, Chan_N_, Chan_PL_, Chan_PW_,
  Chan_MB_, Chan_VEL_
}
 
enum  ChannelSet3DInit {
  Mask_Px, Mask_Py, Mask_Pz, Mask_Pw,
  Mask_UVx, Mask_UVy, Mask_UVz, Mask_UVw,
  Mask_Nx, Mask_Ny, Mask_Nz, Mask_PLx,
  Mask_PLy, Mask_PLz, Mask_PWx, Mask_PWy,
  Mask_PWz, Mask_MBx, Mask_MBy, Mask_MBz,
  Mask_VELx, Mask_VELy, Mask_VELz, Mask_CF_,
  Mask_P_, Mask_UV_, Mask_N_, Mask_PL_,
  Mask_PW_, Mask_MB_, Mask_VEL_
}
 
enum  GroupType {
  Group_None, Group_Primitives, Group_Vertices, Group_Points,
  Group_Object, Group_Matrix, Group_Attributes, Group_Last
}
 
enum  {
  Mask_No_Geometry, Mask_Primitives, Mask_Vertices, Mask_Points,
  Mask_Geometry, Mask_Object, Mask_Matrix, Mask_Attributes,
  Mask_All_Geometry
}
 
enum  RenderMode {
  RENDER_OFF, RENDER_WIREFRAME, RENDER_SOLID, RENDER_SOLID_LINES,
  RENDER_TEXTURED, RENDER_TEXTURED_LINES, RENDER_UNCHANGED
}
 
enum  Display3DMode
 
enum  {
  XY, XZ, YZ, YX,
  ZX, ZY
}
 
enum  FileKnob_Type {
  Normal_File, Read_File_Proxy, Write_File_Proxy, Geo_File,
  Write_File_Normal, Script_File, Read_File_Cached, Read_File_NoProxy,
  OCIO_File, Particle_Cache_File, Cube_File
}
 
enum  {
  TRANSFORM, POSITIONER, TO_PROXY, NO_SCALE,
  NO_UNIFORM_SCALE, NO_SKEW, NO_CENTER, T2D_GAUGE,
  T2D_INVERT
}
 
enum  LookupCurvesType {
  eLookupCurvesTypeTime, eLookupCurvesTypePlot, eLookupCurvesTypeRGBLut, eLookupCurvesTypeYLut,
  eLookupCurvesTypeALut, eLookupCurvesTypeHue1, eLookupCurvesTypeHue2
}
 
enum  {
  LOCAL_SPACE, WORLD_SPACE, EYE_SPACE, CLIP_SPACE,
  SCREEN_SPACE
}
 
enum  {
  OBJECT_MATRIX, OBJECT_iMATRIX, CAMERA_MATRIX, CAMERA_iMATRIX,
  PROJECTION_MATRIX, PROJECTION_iMATRIX, FORMAT_MATRIX, FORMAT_iMATRIX
}
 
enum  { PLANE_XY, PLANE_YZ, PLANE_ZX }
 
enum  MeshSubdivisionMethod {
  ROWS, COLUMNS, ROWS_COLUMNS, QUADS,
  TRIANGLES_A, TRIANGLES_B, ALT_TRIANGLES
}
 
enum  ViewerWorldCoordinate { eViewerWorldCoordinateYUp, eViewerWorldCoordinateZUp, eViewerWorldCoordinateCount }
 
enum  OpHints {
  OpHints::eDefault, OpHints::eChainable, OpHints::eIgnore, OpHints::eIgnoreInputs,
  OpHints::eSingleThread, OpHints::eInternalMultithreaded
}
 
enum  { eAlignNone, eAlignSpin, eAlignVelocity }
 
enum  { eBlendNone, eBlendModulate }
 
enum  FrameAdvance : unsigned char { eFrameAdvanceConstant, eFrameAdvanceStep, eFrameAdvanceRandom }
 
enum  PrimitiveType {
  eUnknownPrimitive, eTriangle, ePolygon, eMesh,
  ePoint, eParticles, eParticlesSprite, ePolyMesh,
  ePrimitiveTypeCount
}
 
enum  SelectionPrecedence : uint8_t { TransformHandle, PointHighest, PointLowest }
 
enum  ColorCurveEnum {
  eColorCurveLinear, eColorCurveSRGB, eColorCurveRec709, eColorCurveLog,
  eColorCurveGamma18, eColorCurveGamma22, eColorCurveGamma24, eColorCurveGamma26,
  eColorCurvePanalog, eColorCurveREDLog, eColorCurveViperLog, eColorCurveAlexaV3LogC,
  eColorCurvePLogLin, eColorCurveSLog, eColorCurveSLog1, eColorCurveSLog2,
  eColorCurveSLog3, eColorCurveCLog, eColorCurveLog3G10, eColorCurveLog3G12,
  eColorCurveHybridLogGamma, eColorCurveProtune, eColorCurveBT1886, eColorCurveHDR2084,
  eColorCurveST2084, eColorCurveBMfilmgen5, eColorCurveUnknown
}
 Enum to label standard lookup curves applied to colours.
 
enum  DataTypeEnum {
  eDataTypeNone, eDataTypeUInt8, eDataTypeUInt16, eDataTypeUInt32,
  eDataTypeFloat16, eDataTypeFloat32, eDataTypeUInt32_10bit
}
 Enumeration for data types that DataInfo supports.
 
enum  ImageDirection { eIncreasingY, eDecreasingY }
 
enum  RippleType {
  eRippleOff, eRippleAll, eRippleFromStart, eRippleToEnd,
  eRippleRange
}
 
enum  MotionVectorType { eDisableMotionVector, eClassicMotionVector, eVelocityMotionVector, eDistanceMotionVector }
 Scene motion vector types. More...
 
enum  SceneNodeType : unsigned int { eInvalid, eGeometry, eCamera, eAxis }
 
enum  StoreType {
  DoublePtr, FloatPtr, StringPtr, IntPtr,
  UnsignedIntPtr, BoolPtr, ConvolveArrayPtr, ChannelSetPtr,
  ChannelPtr, FormatPairPtr, MatrixPtr, LookupCurvesPtr,
  IntSetPtr, IntIntMapPtr, IntPairPtr, StringVecVecPtr,
  StlStringPtr, StlStringIntPairPtr, StlStringVecPtr, Custom
}
 
enum  StringExpandFlags { eStringExpandNoFlags, eStringExpandFilename, eStringExpandFileNumber }
 
enum  DrawHandleType {
  eDrawHandleAlways, eDrawHandleVertexSelection, eDrawHandleEdgeSelection, eDrawHandleFaceSelection,
  eDrawHandleObjectSelection, eDrawHandleNodeSelection
}
 
enum  ViewerConnected
 
enum  TransformSpace : uint8_t
 
enum  ViewerMode
 
enum  ViewerEvent
 
enum  CameraLockMode
 
enum  SelectionMode3D {
  eSelect3DNode, eSelect3DVertex, eSelect3DFace, eSelect3DObject,
  eNumberOfSelectionModes3D
}
 
enum  SelectionOptions3D { eOptionDisableOcclusionTesting }
 
enum  Select3DAction { eSelectReplace, eSelectAdd, eSelectRemove, eSelectDrag }
 
enum  
 
enum  
 
enum  
 
enum  
 
enum  FrustumPlane {
  eNear, eFar, eLeft, eRight,
  eTop, eBottom, eMax
}
 Frustum planes enumerations.
 
enum  FrustumVisibility { eNotVisible, eFullVisible, ePartialVisible }
 Frustum visibility result. More...
 
enum  SampleType : unsigned int { eBoth, eFront, eBack }
 
enum  SampleFunction { eDoSample, eDoEngine, eDoSampleShadowMap }
 
enum  ShowMessagesOption { eSMO_DoNotShowMessages, eSMO_ShowMessages }
 
enum  AttributeType {
  kAttrTypeInvalid, kAttrTypeFloat, kAttrTypeFloat2, kAttrTypeFloat3,
  kAttrTypeFloat4, kAttrTypeNormal, kAttrTypeInt32, kAttrTypeString,
  kAttrTypeStdString, kAttrTypePointer, kAttrTypeFloat3x3, kAttrTypeFloat4x4,
  kAttrTypeBoolean, kAttrTypeDouble, kAttrTypeUInt32, kAttrTypeQuaternion,
  kAttrTypeSource, kAttrTypeBounceInfo, kAttrTypeFrameAdvance, kAttrTypeChannelSet
}
 
enum  {
  eNoDomain, eSphereDomain, eBoxDomain, eHalfSpaceDomain,
  eCylinderDomain, eMaxDomain
}
 

Functions

 mFnCreateGlobalSTLAllocator (STL3DAllocator, Allocators::g3DAllocator) mFnCreateGlobalSTLAllocator(STLNodeAllocator
 
Allocators::gNodeAllocator mFnCreateGlobalSTLAllocator (STLOpAllocator, Allocators::gOpAllocator) mFnCreateGlobalSTLAllocator(STLKnobAllocator
 
void SetValueProvider (Knob_Callback f, ArrayKnobI::ValueProvider *valueProvider)
 
 mFnCreateInstanceSTLAllocator (STLBlockAllcoator, BlockAllocator) template< typename T > inline T *BlockAllocator
 Create STL allocator class using macro.
 
bool operator== (const DD::Image::Box &b1, const DD::Image::Box &b2)
 equality of boxes
 
bool operator!= (const DD::Image::Box &b1, const DD::Image::Box &b2)
 inequality of boxes
 
void incr (Channel &c)
 
std::ostream & operator<< (std::ostream &, Channel)
 
Channel getChannel (const char *name, bool sort=true)
 
size_t getChannelCount ()
 
Channel findChannel (const char *name)
 
const char * getName (Channel)
 
const char * getLayerName (Channel)
 
unsigned colourIndex (Channel, const char *layer=nullptr)
 
Channel brother (Channel, unsigned index)
 
bool compareChannels (Channel a, Channel b)
 
ChannelSetInit operator| (ChannelSetInit a, ChannelSetInit b)
 
ChannelSetInit operator& (ChannelSetInit a, ChannelSetInit b)
 
ChannelSetInit operator& (ChannelSetInit a, Channel b)
 
bool intersect (const ChannelSet &m, const ChannelSet &c)
 
bool intersect (const ChannelSet &m, ChannelSetInit c)
 
bool intersect (const ChannelSet &m, Channel z)
 
bool turn_off (const ChannelSet &c, const ChannelSet &m)
 
bool turn_off (ChannelSetInit c, const ChannelSet &m)
 
bool turn_off (Channel c, const ChannelSet &m)
 
ChannelSetInit depth2mask (int d)
 
void mask2array (Channel *array, unsigned n, ChannelMask mask, const char *layer)
 
ChannelSet array2mask (const Channel *array, int n)
 
Channel mask (Channel c)
 
ChannelSetIterator begin (const ChannelSet &channels)
 Implementation of begin() needed to support ranged-for loops.
 
ChannelSetIterator end (const ChannelSet &channels)
 Implementation of end() needed to support ranged-for loops.
 
const Versionversion ()
 
const VersionapplicationVersion ()
 
double scriptVersion ()
 
 mFnDeprecatedInNuke13Func ("PlusSamples(const ChannelMap&, DeepSample, DeepSample) has been deprecated.\n", DeepSample PlusSamples(const ChannelMap &chanMap, DeepSample sampleA, DeepSample sampleB);) mFnDeprecatedInNuke13Func("MergeSamples( const ChannelMap&
 
DeepSample has been deprecated DeepSample MergeSamples (const ChannelMap &chanMap, DeepSample sampleA, DeepSample sampleB)
 
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)
 
bool RenameTempToFinal (const char *lpTempName, const char *lpFinalName, Op *lpOp)
 
std::string RemapPath (const std::string &path)
 Apply path remapping configured in Nuke's preferences to a path, and return the result.
 
template<class T , class V >
bool IsEqualFloat (T val1, T val2)
 Accepts float or double.
 
bool IsEqual (float val1, float val2)
 
bool IsEqual (double val1, double val2)
 
bool IsNonZero (float val1)
 
bool IsNonZero (double val1)
 
const AttribContextGetGeoInfoAttribContext (const GeoInfo *info, const char *attribName, AttribType attribType)
 
GeoSelection & GetGeometrySelection ()
 
void glColor (unsigned)
 
void glColor4 (unsigned)
 
void glColor4fvLUT (const float *)
 
void gl_text (const char *str)
 
void gl_text (const char *str, int n)
 
void gl_text (const char *str, float x, float y, float z=0)
 
void gl_text (const char *str, int n, float x, float y, float z=0)
 
void gl_text (const char *str, int x, int y, int z=0)
 
void gl_text (const char *str, int n, int x, int y, int z=0)
 
void gl_text (const char *str, double x, double y, double z=0)
 
void gl_text (const char *str, int n, double x, double y, double z=0)
 
void gl_enable_line_smoothing (float width)
 
void gl_disable_line_smoothing ()
 
void gl_circlef (float x, float y, float z, float diam, int plane, bool filled=false, float normal=1.0f)
 
void gl_circlefAsTris (float x, float y, float z, float diam, float lineWidth, int plane, bool filled=false, float normal=1.0f)
 
void gl_cylinderf (float x, float y, float z, float width, float bottomCapDiameter, float topCapDiameter, int plane, bool capped=true, bool filled=false)
 
void gl_conef (float x, float y, float z, float length, float diam, int plane)
 
void gl_sphere (float radius=0.5)
 
void gl_planef (float x, float y, float z, float width, float height, int plane)
 
void gl_gridf (float x, float y, float z, int numW, int numH, int plane)
 
void gl_quadi (int x, int y, int right, int top)
 gl_quadi Draws a filled quad (int version). More...
 
void gl_rectangle (float x, float y, float r, float t)
 
void gl_rectangle (int x, int y, int r, int t)
 
void gl_circle (float x, float y, float radius, float intervalDegrees)
 
void gl_ellipse (float x, float y, float xradius, float yradius, unsigned nPoints)
 
void gl_bracket (float x, float y, float r, float t, float sx, float sy)
 
void gl_crossf (float x, float y, float z, float size, int plane)
 
void gl_crossi (int x, int y, int z, int size, int plane)
 
void gl_axis ()
 
void gl_axis_label ()
 
void gl_boxf (float x, float y, float n, float r, float t, float f, bool filled=false)
 
void gl_cubef (float x, float y, float z, float width)
 
void gl_bezierf (float x, float y, float x1, float y1, float x2, float y2, float x3, float y3, float scale=1)
 
void gl_polygon (const DD::Image::Vector2 *points, size_t nPoints, DD::Image::Vector2 offset=DD::Image::Vector2())
 
void gl_drawTextTopLeftOrthogonal (const std::string &text, DD::Image::ViewerContext *ctx, bool redColour=true)
 
const char * gl_errorstring (int errorcode)
 
int glGetErrors (const char *message=nullptr)
 
bool GLProject (float x, float y, float z, const DD::Image::Matrix4 &m, const DD::Image::Box &vp, float *winx, float *winy, float *winz)
 
bool GLUnproject (float wx, float wy, float wz, const DD::Image::Matrix4 &m, const DD::Image::Box &vp, float *objx, float *objy, float *objz)
 
DD::Image::Box GLProjectCube (const DD::Image::Box3 &cube, const DD::Image::Matrix4 &m, const DD::Image::Box &vp)
 
void GLZOffsetProjection (float offsetAmount)
 
void cacheglBegin (unsigned int mode)
 
void cacheglEnd ()
 
void cacheglVertex2f (float x, float y)
 
void cacheglVertex2fv (const float *v)
 
void cacheglVertex2d (double x, double y)
 
void cacheglVertex3f (float x, float y, float z)
 
void cacheglVertex3fv (const float *c)
 
void cacheglNormal3f (float nx, float ny, float nz)
 
void cacheglNormal3fv (const float *n)
 
void cacheglColor3f (float r, float g, float b)
 
void cacheglColor4fv (const float *c)
 
void cacheglLineWidth (float width)
 
void cacheglLineStipple (int factor, short pattern)
 
void cacheglPushAttrib (unsigned int mask)
 
void cacheglPopAttrib ()
 
void cacheglPushMatrix ()
 
void cacheglPopMatrix ()
 
void cacheglMatrixMode (unsigned int mode)
 
void cacheglLoadIdentity ()
 
void cacheglEnable (unsigned int cap)
 
void cacheglDisable (unsigned int cap)
 
void cacheglHint (unsigned int target, unsigned int mode)
 
void cacheglLoadName (unsigned int name)
 
void cacheglLoadMatrixf (const float *m)
 
void cacheglStoreColor (float *c)
 
void cacheglRestoreColor (float *c)
 
void cacheglPointSize (float size)
 
void cacheglTranslatef (float tx, float ty, float tz)
 
void cacheglScaled (double sx, double sy, double sz)
 
void cacheglAlphaFunc (unsigned int func, float ref)
 
void cacheglBlendFunc (unsigned int sfactor, unsigned int dfactor)
 
void cacheglDepthMask (bool flag)
 
void cacheglClear (unsigned long mask)
 
void cacheglDepthFunc (unsigned int func)
 
void cacheglFlush ()
 
void cacheglPolygonMode (unsigned int face, unsigned int mode)
 
void cacheglColor4f (float r, float g, float b, float a)
 
void cacheglTexCoord2f (float s, float t)
 
void cacheglVertex2i (int x, int y)
 
void cacheglScalef (float sx, float sy, float sz)
 
void cacheglRectf (float x1, float y1, float x2, float y2)
 
void cacheglOrtho (double left, double right, double bottom, double top, double zNear, double zFar)
 
void cacheglRotatef (float angle, float x, float y, float z)
 
void cacheglRotated (double angle, double x, double y, double z)
 
void cacheuglColor (unsigned int color)
 
void cacheuglText (const char *str, float x, float y, float z=0.0f)
 
void cacheuglZOffsetProjection (float offsetAmount)
 
void cacheuglBezierf (float x, float y, float x1, float y1, float x2, float y2, float x3, float y3, float scale=1.0f)
 
void cacheuglProjectionMatrix ()
 
void cacheuglRectangle (float x, float y, float r, float t)
 
void cacheuglEllipse (float center_x, float center_y, float xradius, float yradius, unsigned nPoints)
 
void cacheuglPolygon (const DD::Image::Vector2 *points, size_t nPoints, DD::Image::Vector2 offset=DD::Image::Vector2())
 
template<class T >
U64 getHashValue (const T s)
 
 mFnCreateInstanceSTLAllocator (STLHeapAllocator, HeapAllocator) template< typename T > inline T *HeapAllocator
 Create STL allocator class using macro.
 
bool RGBtoHSV (float r, float g, float b, float &h, float &s, float &v)
 
void HSVtoRGB (float h, float s, float v, float &r, float &g, float &b)
 
bool RGBtoHSL (float r, float g, float b, float &H, float &S, float &L)
 
void HSLtoRGB (float H, float S, float L, float &r, float &g, float &b)
 
void HSVtoHSL (float h, float s, float v, float &H, float &S, float &L)
 
void HSLtoHSV (float H, float S, float L, float &h, float &s, float &v)
 
std::ostream & operator<< (std::ostream &o, const Knob::cstring &c)
 
std::ostream & operator<< (std::ostream &o, const Knob::Indent *)
 
std::string escape (const char *s)
 
void Tooltip (Knob_Callback f, const char *)
 
void Tooltip (Knob_Callback f, const std::string &text)
 
void SetFlags (Knob_Callback f, Knob::FlagMask n)
 
void ClearFlags (Knob_Callback f, Knob::FlagMask n)
 
void SetRange (Knob_Callback f, double minimum, double maximum)
 
KnobObsolete_knob (Knob_Callback f, const char *linkto, NAME name, const char *script)
 
KnobObsolete_knob (Knob_Callback f, NAME name, const char *script)
 
KnobOp_knob (Knob_Callback f, Op *op, NAME name)
 
KnobString_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr)
 
KnobPassword_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr)
 
KnobString_knob (Knob_Callback f, std::string *p, NAME n, LABEL l=nullptr)
 
KnobString_knob (Knob_Callback f, NAME n, LABEL l=nullptr)
 
KnobFile_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr, FileKnob_Type type=Normal_File)
 
KnobRead_File_knob (ReadFileKnobOwner *ptr, Knob_Callback f, const char **p, NAME n, LABEL l=nullptr)
 
KnobRead_File_knob (ReadFileKnobOwner *ptr, Knob_Callback f, std::string *p, NAME n, LABEL l=nullptr)
 
KnobCached_File_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr, FileKnob_Type type=Normal_File)
 
KnobWrite_File_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr)
 
KnobWrite_File_knob (Knob_Callback f, std::string *p, NAME n, LABEL l=nullptr)
 
KnobProxyless_Read_File_knob (ReadFileKnobOwner *ptr, Knob_Callback f, const char **p, NAME n, LABEL l=nullptr)
 
KnobInt_knob (Knob_Callback f, int *p, NAME n, LABEL l=nullptr)
 
KnobEnumeration_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=nullptr)
 
KnobCascadingEnumeration_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=nullptr)
 
KnobColorspace_knob (Knob_Callback f, int *p, const char *e, NAME n, LABEL l=nullptr)
 
KnobSceneGraph_knob (Knob_Callback f, int *p, std::vector< SceneItem > *e, NAME n, LABEL l=nullptr)
 
KnobSceneView_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=nullptr)
 
KnobSceneView_knob (Knob_Callback f, SceneView_KnobI::ItemList *p, NAME n, LABEL l=nullptr)
 
KnobFreeTypeFont_knob (Knob_Callback f, StlStringIntPair *p, NAME n, LABEL l=nullptr)
 
KnobOneView_knob (Knob_Callback f, int *p, NAME n, LABEL l=nullptr, const char *defcaption=nullptr)
 
KnobViewPair_knob (Knob_Callback f, std::pair< int, int > *p, NAME n, LABEL l=nullptr)
 
KnobMetaData_knob (Knob_Callback f, NAME n, LABEL l=nullptr)
 
KnobMultiView_knob (Knob_Callback f, std::set< int > *p, NAME n, LABEL l=nullptr)
 
KnobViewView_knob (Knob_Callback f, std::map< int, int > *p, NAME n, std::pair< std::string, std::string > *headings, LABEL l=nullptr)
 
KnobParticleChannels_knob (Knob_Callback f, unsigned int *p, NAME n, LABEL l=nullptr)
 
KnobBitmask_knob (Knob_Callback f, unsigned int *p, ENUM_LABELS e, NAME n, LABEL l=nullptr)
 
KnobDynamic_Bitmask_knob (Knob_Callback f, unsigned int *p, std::map< int, std::string > *e, NAME n, LABEL l=nullptr)
 
KnobBool_knob (Knob_Callback f, bool *p, NAME n, LABEL l=nullptr)
 
KnobFloat_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)
 
KnobFloat_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)
 
KnobFrame_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)
 
KnobDeep_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)
 
KnobMultiFloat_knob (Knob_Callback f, double *p, int dim, NAME n, LABEL l=nullptr)
 
KnobMultiFloat_knob (Knob_Callback f, float *p, int dim, NAME n, LABEL l=nullptr)
 
KnobMultiInt_knob (Knob_Callback f, int *p, int dim, NAME n, LABEL l=nullptr)
 
KnobPixelAspect_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)
 
KnobArray_knob (Knob_Callback f, ConvolveArray *p, int width, int height, NAME n, LABEL l=nullptr, bool defaultData=false)
 
KnobResizableArray_knob (Knob_Callback f, ConvolveArray *p, int width, int height, NAME n, LABEL l=nullptr, bool defaultData=false)
 
KnobChannelSet_knob (Knob_Callback f, ChannelSet *p, NAME n, LABEL l=nullptr)
 
KnobInput_ChannelSet_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=nullptr)
 
KnobInputOnly_ChannelSet_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=nullptr)
 
KnobChannel_knob (Knob_Callback f, Channel *p, int count, NAME n, LABEL l=nullptr)
 
KnobInput_Channel_knob (Knob_Callback f, Channel *p, int count, int input, NAME n, LABEL l=nullptr)
 
KnobInputOnly_Channel_knob (Knob_Callback f, Channel *p, int count, int input, NAME n, LABEL l=nullptr)
 
KnobXY_knob (Knob_Callback f, double *p, NAME n, LABEL l, Knob *parent=nullptr)
 
KnobXY_knob (Knob_Callback f, double *p, NAME n, Knob *parent=nullptr)
 
KnobXY_knob (Knob_Callback f, float *p, NAME n, LABEL l, Knob *parent=nullptr)
 
KnobXY_knob (Knob_Callback f, float *p, NAME n, Knob *parent=nullptr)
 
KnobXYZ_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr, Knob *parent=nullptr)
 
KnobUV_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)
 
KnobUV_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)
 
KnobCP_knob (Knob_Callback f, float *p, int dim, NAME n, LABEL l=nullptr)
 
KnobWH_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)
 
KnobWH_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)
 
KnobBBox_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr, Knob *parent=nullptr)
 
KnobBBox_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr, Knob *parent=nullptr)
 
KnobFormat_knob (Knob_Callback f, FormatPair *p, NAME n, LABEL l=nullptr)
 
KnobColor_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)
 
KnobColor_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)
 
KnobAColor_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)
 
KnobAColor_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)
 
KnobEyedropper_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)
 
KnobRange_knob (Knob_Callback f, double *p, int np, NAME n, LABEL l=nullptr)
 
KnobRange_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)
 
KnobTransform2d_knob (Knob_Callback f, Matrix4 *p, NAME n, int type=0)
 
KnobTransform2d_knob (Knob_Callback f, Matrix4 *p, NAME n, LABEL l, int type=0)
 
KnobLookupCurves_knob (Knob_Callback f, LookupCurves *p, DD::Image::LookupCurvesType type, NAME n, LABEL l=nullptr)
 
KnobLookupCurves_knob (Knob_Callback f, LookupCurves *p, NAME n, LABEL l=nullptr)
 
KnobAxis_knob (Knob_Callback f, Matrix4 *p, NAME n, LABEL l=nullptr)
 
KnobPositionVector_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)
 
KnobBox3_knob (Knob_Callback f, float *p, NAME n, LABEL l=nullptr)
 
KnobHistogram_knob (Knob_Callback f, Histogram_Data *p, NAME n, LABEL l=nullptr)
 
KnobKeyer_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)
 
KnobColorChip_knob (Knob_Callback f, unsigned *p, NAME n, LABEL l=nullptr)
 
KnobTab_knob (Knob_Callback f, LABEL label)
 
KnobMultiArray_knob (Knob_Callback f, NAME n, LABEL l=nullptr)
 
KnobBeginGroup (Knob_Callback f, NAME name, LABEL label=nullptr)
 
KnobBeginClosedGroup (Knob_Callback f, NAME name, LABEL label=nullptr)
 
KnobEndGroup (Knob_Callback f)
 
KnobBeginToolbar (Knob_Callback f, NAME name, LABEL label=nullptr, int position=Knob::TOOLBAR_TOP)
 
KnobEndToolbar (Knob_Callback f)
 
KnobBeginTabGroup (Knob_Callback f, NAME name, LABEL label=nullptr)
 
KnobEndTabGroup (Knob_Callback f)
 
KnobBeginExoGroup (Knob_Callback f, NAME name, LABEL label=nullptr)
 
KnobEndExoGroup (Knob_Callback f)
 
KnobText_knob (Knob_Callback f, LABEL text)
 
KnobText_knob (Knob_Callback f, LABEL label, LABEL text)
 
KnobNamed_Text_knob (Knob_Callback f, LABEL name, LABEL text)
 
KnobNamed_Text_knob (Knob_Callback f, LABEL name, LABEL label, LABEL text)
 
KnobNewline (Knob_Callback f, LABEL label=" ")
 
KnobDivider (Knob_Callback f, LABEL label=nullptr)
 
KnobSpacer (Knob_Callback f, int spaceInPixels)
 
KnobVSpacer (Knob_Callback f, int spaceInPixels)
 
KnobIcon_knob (Knob_Callback f, const char *icon)
 
KnobHelp_knob (Knob_Callback f, LABEL text)
 
KnobHelp_knob (Knob_Callback f, LABEL label, LABEL text)
 
KnobButton (Knob_Callback f, NAME n, LABEL l=nullptr)
 
KnobScript_knob (Knob_Callback f, NAME command, NAME n, LABEL l=nullptr)
 
KnobPyScript_knob (Knob_Callback f, NAME command, NAME n, LABEL l=nullptr)
 
KnobCancelExecution_knob (Knob_Callback f, NAME n, LABEL l=nullptr)
 
KnobMenu_knob (Knob_Callback f, const char *menuName, NAME name, LABEL label=nullptr)
 
KnobPython_knob (Knob_Callback f, NAME command, NAME n, LABEL l=nullptr)
 
KnobPulldown_knob (Knob_Callback f, ENUM_LABELS e, NAME n, LABEL l=nullptr)
 
KnobPyPulldown_knob (Knob_Callback f, ENUM_LABELS e, NAME n, LABEL l=nullptr)
 
KnobMultiline_String_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr, int lines=5)
 
KnobRangeStuff (Knob_Callback f, Knob *knob, const IRange &r)
 
KnobInt_knob (Knob_Callback f, int *p, const IRange &r, NAME n, LABEL l=nullptr)
 
KnobDouble_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)
 
KnobDouble_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=nullptr)
 
KnobFloat_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=nullptr)
 
KnobFloat_knob (Knob_Callback f, float *p, const IRange &r, NAME n, LABEL l=nullptr)
 
KnobChannelMask_knob (Knob_Callback f, ChannelSet *p, NAME n, LABEL l=nullptr)
 
KnobInput_ChannelMask_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=nullptr)
 
KnobInputOnly_ChannelMask_knob (Knob_Callback f, ChannelSet *p, int input, NAME n, LABEL l=nullptr)
 
KnobWH_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=nullptr)
 
KnobScale_knob (Knob_Callback f, double *p, NAME n, LABEL l=nullptr)
 
KnobScale_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=nullptr)
 
KnobColor_knob (Knob_Callback f, float *p, const IRange &r, NAME n, LABEL l=nullptr)
 
KnobColor_knob (Knob_Callback f, double *p, const IRange &r, NAME n, LABEL l=nullptr)
 
KnobAColor_knob (Knob_Callback f, float *p, const IRange &r, NAME n, LABEL l=nullptr)
 
KnobList_knob (Knob_Callback f, std::vector< std::vector< std::string > > *p, NAME n, LABEL l=nullptr)
 
KnobTable_knob (Knob_Callback f, NAME n, LABEL l=nullptr)
 
KnobRange_knob (Knob_Callback f, double *p, int np, int ixp, NAME n, LABEL l=nullptr, double min=0.0, double max=1.0)
 
KnobTab_knob (Knob_Callback f, int level, LABEL label)
 
KnobLink_knob (Knob_Callback f, const char *linkto, NAME name, LABEL label=nullptr)
 
KnobMultiline_Eval_String_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr, int lines=5)
 
KnobEval_String_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr)
 
KnobTextEditor_knob (Knob_Callback f, const char **p, NAME n, LABEL l=nullptr, int lines=5)
 
KnobToolbox_knob (Knob_Callback f, int *p, bool expanded, ENUM_LABELS e, NAME n, LABEL l=nullptr, bool changeOnClick=false)
 
KnobGeoSelect_knob (DD::Image::Knob_Callback f, const char *name)
 
KnobControlPointCollection_knob (Knob_Callback f, NAME n, LABEL l=nullptr)
 
KnobMetaKeyFrame_knob (Knob_Callback f, NAME n, LABEL l=nullptr, const DD::Image::MetaKeyFrameOptions &options=DD::Image::MetaKeyFrameOptions())
 
KnobTransformJack_knob (Knob_Callback f, NAME n)
 
KnobRipple_knob (Knob_Callback f, NAME n, LABEL l=nullptr)
 
KnobDisable_knob (Knob_Callback f, bool *p, NAME n, LABEL l=nullptr)
 
KnobFrameExtent_knob (Knob_Callback f, DD::Image::FrameExtentProviderI *prov, NAME n, LABEL l=nullptr)
 
KnobRadio_knob (Knob_Callback f, int *p, ENUM_LABELS e, NAME n, LABEL l=nullptr)
 
std::ostream & operator<< (std::ostream &o, const Matrix4 &matrix)
 
std::vector< double > Matrix4ToVector (const Matrix4 &matrix)
 
Matrix4 VectorToMatrix4 (const std::vector< double > &matrix)
 
void Matrix4ToArray (Matrix4 &matrix, double *arr)
 
void Matrix3x4ToArray (Matrix4 &matrix, double *arr)
 
std::ostream & operator<< (std::ostream &o, const Memory::bytes &c)
 
double noise (double x)
 
double noise (double x, double y)
 
double noise (double x, double y, double z)
 
double fBm (double x, double y, double z, int octaves, double lacunarity, double gain)
 
double turbulence (double x, double y, double z, int octaves, double lacunarity, double gain)
 
double p_random (int x)
 
double p_random (int x, int y)
 
double p_random (int x, int y, int z)
 
double p_random (double x)
 
double p_random (double x, double y)
 
double p_random (double x, double y, double z)
 
template<class T >
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<>
Iopop_cast< Iop * > (Op *op)
 
template<>
GeoOpop_cast< GeoOp * > (Op *op)
 
template<>
ParticleOpop_cast< ParticleOp * > (Op *op)
 
template<>
DeepOnlyOpop_cast< DeepOnlyOp * > (Op *op)
 
constexpr OpHints operator| (OpHints lhs, OpHints rhs)
 
OpHintsoperator|= (OpHints &lhs, OpHints rhs)
 
constexpr OpHints operator& (OpHints lhs, OpHints rhs)
 
OpHintsoperator&= (OpHints &lhs, OpHints rhs)
 
template<typename Function >
void ParallelFor (unsigned int numItems, Function f, unsigned int maxThreads=0, unsigned int minItems=1000)
 
template<typename Function >
void ParallelForRange (unsigned int numItems, Function f, unsigned int maxThreads=0, unsigned int minItems=1000)
 
int plugin_count ()
 
const char * plugin_name ()
 
const char * plugin_name (int n)
 
const char * plugin_find (const char *name, const char *const *extensions=nullptr)
 
const char * plugin_load (const char *name, const char *altname=nullptr)
 load a plugin with the basename 'name' (or 'altname' if specified and nothing by name can be found) More...
 
void * plugin_load (const char *name, void *(*test)(const char *), const char *arg, const char *symbol=nullptr)
 
const char * plugin_load_all (const char *name)
 
const char * plugin_load_one (const char *name)
 
const char * plugin_path (int n)
 
void plugin_addpath (const char *)
 
void plugin_appendpath (const char *)
 
const char * plugin_error ()
 
void plugin_error (const char *)
 
void * plugin_binary (const char *name, const char *symbol=nullptr)
 
const char *const * plugin_default_extensions ()
 
const std::vector< const char * > & plugin_path_list (int n)
 
void setPluginHashCheck (bool lEnabled)
 
const std::vector< const char * > & getPluginPath ()
 Returns the entire plugin path as a vector. More...
 
void setPluginInstallPaths (const std::vector< std::string > &paths)
 
const std::vector< std::string > & getPluginInstallPaths ()
 
const char * getApplicationPluginPath ()
 
void setPluginUnloadedCallback (PluginUnloadedFunc f)
 
void FnLicensingShutdown ()
 
std::string GetNukeHomeDir ()
 
OpHints opHints (Op *op)
 Return a mask of hints used to control how the specified op should be rendered by the top-down system.
 
bool cacheOpInputs (Op *op)
 Support functions used during top-down task graph construction and execution.
 
bool isPlanarOp (Op *op)
 
bool isMultiThreadableOp (Op *op)
 
bool ignoreOpInputs (Op *op)
 
bool ignoreOp (Op *op)
 
bool isInternalMultithreadedOp (Op *op)
 
void RemoveRendererFromSceneLights (DD::Image::Scene *pScene, DD::Image::Render *depthMapCandidate)
 
void PostAbortTeardown ()
 
void InitialiseThread ()
 
bool Encrypt (const unsigned int vendorID, const std::string &message, std::string &encryptedMessage)
 
bool Encrypt (const unsigned char *publicKeyData, const size_t publicKeyDataSize, const std::string &message, std::string &encryptedMessage)
 
bool Decrypt (const unsigned char *privateKeyData, const size_t privateKeyDataSize, const std::string &encryptedMessage, std::string &decryptedMessage)
 
void GetScreenToWorldRay (ViewerContext *ctx, int screenX, int screenY, Ray &ray)
 
size_t DataTypeSizeInBytes (DataTypeEnum dataType)
 
ParticlesMakeRenderParticles (Point::RenderMode renderMode, unsigned points, unsigned start, bool haveNormals, float particleSize)
 
float GetRenderParticlesPointSize (const Primitive *prim)
 
void createRIPContext ()
 
void destroyRIPContext ()
 
std::ostream & operator<< (std::ostream &os, const DD::Image::SceneItem &item)
 
bool operator< (const SceneItem &a, const SceneItem &b)
 
 mFnCreateGlobalSTLAllocator (STLAllocator, DefaultAllocator::getInstance()) template< class T > class STL
 
void TextureMipSample (const Vector2 &center, const Vector2 &dU, const Vector2 &dV, TextureFilter *filter, Iop **mip, Pixel &out)
 
void SleepMS (int ms)
 
void sleepFor (double seconds)
 
void setThreadGUIMode (bool guiMode)
 Threading needs to know whether the GUI is active for priority settings.
 
std::ostream & VersionStreamPut (std::ostream &s, const DD::Image::Version &v)
 put to a stream. Doesn't persist the date yet
 
std::istream & VersionStreamGet (std::istream &s, DD::Image::Version &v)
 get from a stream. The thing should be in the regex format above. Doesn't persist the date yet
 
bool VersionLessThan (const Version &a, const Version &b)
 
bool VersionCompare (const Version &a, const Version &b)
 
bool style_needs_wireframe (int x)
 
template<class T , class Out >
void CombineOverlappingSamplesT (const ChannelMap &chanMap, const T &deepPixel, Out &pixels)
 
void CompositeSamples (const DeepPixel &samples, const ChannelSet &channels, Row &row, int x, float *Zpix, float *Zfrontpix)
 
void CompositeSamples (const DeepSampleVector &samples, const ChannelSet &channels, Row &row, int x, float *Zpix, float *Zfrontpix)
 
void CompositeSamples (const DeepPixel &samples, const ChannelSet &channels, Row &row, int x, float *Zpix, float *Zfrontpix, float *Zbackpix)
 
void CompositeSamples (const DeepSampleVector &samples, const ChannelSet &channels, Row &row, int x, float *Zpix, float *Zfrontpix, float *Zbackpix)
 
bool DetectOverlappingSamples (const DeepSampleVector &t)
 
bool DetectOverlappingSamples (const DeepPixel &t)
 
decltype(auto) SplitVolume (const ChannelMap &cm, const DeepLightSample &openSample, float zSplit)
 
DeepSample PlusSamples (const ChannelMap &chanMap, DeepSample sample_a, DeepSample sample_b)
 
void DeoverlapSamples (const ChannelMap &channelMap, const DeepPixel &deepPixel, DeepOutPixel &pixels)
 
DeepOutPixel DeoverlapPixelSamples (const ChannelMap &channelMap, const DeepPixel &deepPixel)
 
void MergeOverlappingSamples (const DD::Image::ChannelSet &channels, const DeepPixel &in_pixel, DeepOutPixel &out_pixel, CombineFunc func)
 
DeepOutPixel MergeOverlappingPixelSamples (const DD::Image::ChannelSet &channels, const DeepPixel &in_pixel, CombineOperation func)
 
GeoSelection & DefaultGetGeometrySelection ()
 
void initCachedGLFunctionsTable ()
 
CacheBlock & operator<< (CacheBlock &, bool)
 
CacheBlock & operator<< (CacheBlock &, unsigned char)
 
CacheBlock & operator<< (CacheBlock &, short)
 
CacheBlock & operator<< (CacheBlock &, int)
 
CacheBlock & operator<< (CacheBlock &, float)
 
CacheBlock & operator<< (CacheBlock &, double)
 
CacheBlock & operator<< (CacheBlock &, char *)
 
CacheBlock & operator>> (CacheBlock &, bool &)
 
CacheBlock & operator>> (CacheBlock &, unsigned char &)
 
CacheBlock & operator>> (CacheBlock &, int &)
 
CacheBlock & operator>> (CacheBlock &, short &)
 
CacheBlock & operator>> (CacheBlock &, unsigned int &)
 
CacheBlock & operator>> (CacheBlock &, unsigned long &)
 
CacheBlock & operator>> (CacheBlock &, float &)
 
CacheBlock & operator>> (CacheBlock &, double &)
 
CacheBlock & operator>> (CacheBlock &, const char *&)
 
void internalglBegin ()
 
void internalglEnd ()
 
void internalglVertex2f ()
 
void internalglVertex2fv ()
 
void internalglVertex3f ()
 
void internalglVertex3fv ()
 
void internalglNormal3f ()
 
void internalglNormal3fv ()
 
void internalglColor3f ()
 
void internalglColor4fv ()
 
void internalglColor4ub ()
 
void internalglLineWidth ()
 
void internalglLineStipple ()
 
void internalglPushAttrib ()
 
void internalglPopAttrib ()
 
void internalglPushMatrix ()
 
void internalglPopMatrix ()
 
void internalglMatrixMode ()
 
void internalglLoadIdentity ()
 
void internalglEnable ()
 
void internalglDisable ()
 
void internalglHint ()
 
void internalglLoadName ()
 
void internalglLoadMatrix ()
 
void internalStoreColor ()
 
void internalRestoreColor ()
 
void internalPointSize ()
 
void internalglTranslatef ()
 
void internalglScaled ()
 
void internalglAlphaFunc ()
 
void internalglBlendFunc ()
 
void internalglDepthMask ()
 
void internalglClear ()
 
void internalglDepthFunc ()
 
void internalglFlush ()
 
void internalglPolygonMode ()
 
void internalglColor4f ()
 
void internalglTexCoord2f ()
 
void internalglVertex2i ()
 
void internalglOrtho ()
 
void internalglVertex2d ()
 
void internalglScalef ()
 
void internalglRotatef ()
 
void internalglRotated ()
 
void internalRectf ()
 
void internaluglColor ()
 
void internaluglText ()
 
void internaluglRectangle ()
 
void internaluglEllipse ()
 
void internaluglPolygon ()
 
void PrintKnobChangedInValidateWarning (Knob *k)
 
std::string reformatTime (const std::string &timestamp)
 
template<SampleFunction function, typename... Ts>
ReturnType< function > MultiTileCall (ArgType< function > &self, Iop &checkIfPlanar, Ts &&...args)
 
bool DefaultGetBoolPreference (const char *name)
 
unsigned int DefaultGetUIntPreference (const char *name)
 
int DefaultGetIntPreference (const char *name)
 
float DefaultGetFloatPreference (const char *name)
 
double DefaultGetDoublePreference (const char *name)
 
std::string DefaultGetStringPreference (const char *)
 
std::string DefaultGetLocalisationPath ()
 
std::vector< Op * > GetAllConnectedOps (Op *lpRoot)
 Returns a vector of all ops connected to the given one (including the original)
 
std::string GetOpText (const Op *lpOp, ShowMessagesOption lShowMsgs=eSMO_ShowMessages)
 Returns text describing the op, or an appropriate valid string if null.
 
std::string GetOpTreeText (const OpTree *lpTree)
 Returns text describing the op tree, or an appropriate valid string if null.
 
bool RecursiveGetStepsPerFrame (ParticleOp *op, std::set< ParticleOp * > &ops, bool &gotStepsFrame, int &stepsFrame)
 
int RecursivePushParticleOps (ParticleOp *lPop, std::vector< ParticleOp * > &ops, std::vector< unsigned > &masks, int &nextBit)
 
void RecursiveGetStartFrame (ParticleOp *op, std::set< ParticleOp * > &ops, double &startFrame)
 
void RecursiveUseFilesystem (ParticleRender *op, std::set< ParticleRender * > &ops, bool &useFilesystem, bool &filesystemReadOnly, bool &renderingCache)
 Searches Particle tree for a ParticleCache node and retrieves settings. Called on each ParticleOp in tree.
 
 mDefineAccessors (Vector3, _initialPosition, particleInitialPosition) mDefineAccessors(Vector3
 
particlePosition mDefineAccessors (Vector3, _lastPosition, particleLastPosition) mDefineAccessors(Vector3
 
particlePosition particleVelocity mDefineAccessors (Vector3, _size, particleSize) mDefineAccessors(Vector4
 
particlePosition particleVelocity particleColor mDefineAccessors (Quaternion4f, _orientation, particleOrientation) mDefineAccessors(Vector3
 
particlePosition particleVelocity particleColor particleRotationAxis mDefineAccessors (float, _rotationAngle, particleRotationAngle) mDefineAccessors(float
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity mDefineAccessors (float, _mass, particleMass) mDefineAccessors(float
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife mDefineAccessors (float, _expirationChance, particleExpirationChance) mDefineAccessors(float
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime mDefineAccessors (int, _id, particleId) mDefineAccessors(ParticleChannelSet
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels mDefineAccessors (unsigned int, _pathMask, particlePathMask) mDefineAccessors(bool
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive mDefineAccessors (ParticleSystem::Source, _source, particleSource) mDefineAccessors(float
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive particleRepresentationFrame mDefineAccessors (int, _representationFirstFrame, particleRepresentationFirstFrame) mDefineAccessors(int
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive particleRepresentationFrame particleRepresentationLastFrame mDefineAccessors (FrameAdvance, _frameAdvance, particleFrameAdvance) mDefineAccessors(float
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive particleRepresentationFrame particleRepresentationLastFrame particleDeltaT mDefineAccessors (ParticleSystem::BounceInfo, _bounceInfo, particleBounceInfo) int ParticleSystem
 
ChannelSet MaskRequestedChannelsForPlane (const Iop *iop, const ChannelSet &planeChannels)
 
std::set< ChannelSetMaskRequestedChannelsForPlaneSet (const Iop *iop, const std::set< ChannelSet > &planeChannels)
 
const char * plugin_is_loaded (const char *name)
 
bool ParseDDImageAbiVersionFromDLErrorMessage (const char *dlErrorMessage, int &majorVersion, int &minorVersion)
 
bool ParseBlinkLibraryAbiVersionFromDLErrorMessage (const char *dlErrorMessage, int &majorVersion, int &minorVersion)
 
std::string GenerateRandomString (const size_t length)
 
bool IsPluginAuthoredByPermittedVendor (void *handle, const char *filename)
 
bool IsWhiteListedPlugin (const char *filename)
 
void pluginCleanup (const char *filename)
 
template<typename ValueType >
ostream & operator<< (ostream &o, const TQuaternion< ValueType > &q)
 
float MyClamp (float in)
 
enum SceneGraphNodeType unsigned int bool DoNothing (const char *fileName, SceneGraph_KnobI *, const SceneItems &items)
 
bool test_small_block_allocator ()
 
void PolygonTriangulate (const Primitive *poly, const int face, const PointList *pointList, std::vector< unsigned > &triangles)
 
AddOp

Adds an op and its connected input ops to the specified trees

void AddOpToTrees (Op *lpOp, const std::vector< OpTree * > &lrTrees)
 
void AddOpToTree (Op *lpOp, OpTree *lpTree)
 
RemoveOp

Removes an op and its connected input ops from the specified trees

void RemoveOpFromTrees (Op *lpOp, const std::vector< OpTree * > &lrTrees)
 
void RemoveOpFromTree (Op *lpOp, OpTree *lpTree)
 

Variables

const Version gVersion
 
const VersiongApplicationVersion
 
double gScriptVersion
 
bool(* scriptExec )(const char *, bool)
 
bool(* scriptEval )(const char *)
 
bool(* scriptSingle )(const char *)
 
void(* showScriptErrorPopup )()
 
 DeepSample
 
DeepSample has been deprecated n
 
const char *const group_names []
 
const char *const render_modes []
 
const char *const render_modes_source []
 
const char INVISIBLE []
 
const char *const plane_orientation_modes []
 
const char *const subdivision_modes []
 
const char * kViewerBGColor
 
const char * kViewerFGColor
 
const char * kViewerBGColor3D
 
const char * kViewerFGColor3D
 
const char * kViewerSelColor3D
 
const char * kViewerMinSelColor3D
 
const char * kUIHighlightColor
 
const char * kUIHighlightedTextColor
 
const char * kUIFontSize
 
const char * kViewerWorldCoordinateSystem
 
const char * kViewerHandleSize
 
const char * kViewerHandlePickSize
 
const char * kViewerHandleSize3D
 
const char * kViewerTransformHandleSize3D
 
const char * kViewerHandlePickSize3D
 
const char * kChannelWarningThreshold
 
bool(* GetBoolPreference )(const char *name)
 
unsigned int(* GetUIntPreference )(const char *name)
 
int(* GetIntPreference )(const char *name)
 
float(* GetFloatPreference )(const char *name)
 
double(* GetDoublePreference )(const char *name)
 
std::string(* GetStringPreference )(const char *name)
 
std::string(* GetLocalisationPath )()
 
float(* root_real_fps )()
 
OpManager gOpManager
 Global singleton-style manager object - not a true singleton due to compiler and module issues.
 
bool plugin_verbose
 
bool plugin_safe_mode
 
bool(* plugin_interpret_tcl )(const char *name)
 
bool(* plugin_interpret_py )(const char *name)
 
const char * plugin_ext
 ! The standard extension used for plugins on this platform (e.g. ".so" or ".dll")
 
Callbacks * gCallbacks
 
DD::Image::ViewerEvent(* context_menu )(ViewerContext *, Menu *)
 
void(* menu_add )(Menu *, const char *, int shortcut, int event)
 
void(* menu_stuff )(Menu *, int command, int event)
 
void(* menu_set_data )(Menu *, int event, MenuItemData *data)
 
const MenuItemData *(* menu_get_data )(Menu *, int event)
 
bool(* evaluateString )(const char *string, int expandFlags, NodeI *node, const OutputContext &oc, std::string &expandedString)
 
std::string(* getClipboardContents )()
 
void(* setClipboardContents )(std::string &text)
 
const char *const display3d_names []
 
const char *const display3d_names_source []
 
const ViewerContext *(* activeViewerContext )()
 
void(* setSelectionMode3D )(SelectionMode3D newMode)
 
void(* setSelection3D )(const DD::Image::GeoSelection &newSelection)
 
const DD::Image::GeoSelection *(* getSelection3D )()
 
void(* viewThroughCamera )(const CameraOp *camOp, CameraLockMode lockMode)
 
bool _createdAllocators
 
Lock _AllocatorLock
 
bool(* isColourSamplingFromCache )(const Hash &hash)
 
Channel(* pGetChannel )(const char *, bool)
 
size_t(* pGetChannelCount )()
 
Channel(* pFindChannel )(const char *)
 
const char *(* pGetName )(Channel)
 
const char *(* pGetLayerName )(Channel)
 
unsigned(* pColourIndex )(Channel, const char *layer)
 
Channel(* pBrother )(Channel, unsigned)
 
bool(* pCompareChannels )(Channel, Channel)
 
const int gMaxPixelValueSize
 
void *(* profileRequestEventPointer )(const std::string &name, const uint32_t &color)
 
void(* profileEventPointerComplete )(void *&)
 
void(* profileEventStart )(void *&)
 
void(* profileEventStop )(void *&)
 
std::string(* path_remap )(const std::string &)
 
void(* set_knob_disallowed_to_edit )(const Knob *const)
 
GeoSelection &(* get_geometry_selection )()
 
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)
 
LUTMapper *(* NukeLUTMapperFactoryFuncPointer )(Op *pOp)
 
Op *(* node_get_firstop )(const Node *node)
 
int(* op_node_inputs )(const Op *)
 
Op *(* op_node_input )(const Op *, int, Op::GenerateType, const DD::Image::OutputContext *outputContext)
 
void(* op_update_handles )(const Op *)
 
Hash(* knob_curve_hash )(const Op *op)
 
bool(* knob_op_current )(const Op *op)
 
void(* op_begin_handle )(Op *op, Op::HandleType command, ViewerContext *ctx, Op::EventCallback *cb, int index, float x, float y, float z, ViewerContext::Cursor cursor)
 
void(* op_end_handle )(ViewerContext *ctx)
 
Op::NodeContext(* op_node_context )(const Node *)
 
DD::Image::NodeI *(* convertNodeToInterface )(Node *)
 
Op *(* op_root )(const Op *)
 
bool(* node_script_command )(Node *, const char *, bool py, bool eval)
 
bool(* node_script_expand )(Node *, const char *, int)
 
const char *(* node_script_result )()
 
const char *(* node_script_result_py )()
 
void(* node_script_unlock )()
 
int(* op_message_vf )(char, const char *, va_list)
 
void(* op_add_timeout )(float t, TimeoutHandler, void *)
 
void(* op_repeat_timeout )(float t, TimeoutHandler, void *)
 
bool(* op_has_timeout )(TimeoutHandler, void *)
 
void(* op_remove_timeout )(TimeoutHandler, void *)
 
bool(* op_pushed )(const Op *)
 
void(* op_add_input_handle )(const Op *, int, ViewerContext *)
 
Op::HandlesMode(* op_any_input_handle )(const Op *, ViewerContext *)
 
Op *(* op_get )(const Op *, const Op::Description *)
 
void(* op_setKnobsToContext )(Op *, const OutputContext &)
 
void(* op_gotoContext )(Op *, const OutputContext &, bool)
 
double(* evaluate )(const Animation *, double t)
 
bool gTimingEnabled
 
bool gParticleCacheDebugMessages
 
 _position
 
particlePosition _velocity
 
particlePosition particleVelocity _color
 
particlePosition particleVelocity particleColor _rotationAxis
 
particlePosition particleVelocity particleColor particleRotationAxis _rotationVelocity
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity _life
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife _startTime
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime _channels
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels _active
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive _representationFrame
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive particleRepresentationFrame _representationLastFrame
 
particlePosition particleVelocity particleColor particleRotationAxis particleRotationVelocity particleLife particleStartTime particleChannels particleActive particleRepresentationFrame particleRepresentationLastFrame _deltaT
 
bool plugin_unapproved
 
const char * ddimage_program_name
 
const char * first_in_plugin_path
 
const int kAveragePointsPerCell
 
const unsigned int kMaxGridSize
 
RIP::Compute::ContextIP gRipContext
 
bool(* create_scene_graph_browser )(const char *fileName, DD::Image::SceneGraph_KnobI *, const DD::Image::SceneItems &items)
 
bool(* ShapeKnob_keys )(ShapeKnob *, int, float)
 
bool(* ShapeKnob_handle )(ShapeKnob *, int, double)
 
Knob *(* ShapeKnob_constructor )(Knob_Closure *, ShapeKnob *, const char *, const char *)
 
float(* ShapeKnob_time )(const ShapeKnob *, int)
 
float(* ShapeKnob_shape )(const ShapeKnob *, double)
 
bool gShowTransformPreview
 
void(* doInitCache )()
 

Detailed Description

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

Typedef Documentation

typedef unsigned DD::Image::GeometryMask

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

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

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

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

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

This is for back compatibility only

Enumeration Type Documentation

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)

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)

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.

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.

Geometry part groups.

anonymous enum

Geometry part mask flags.

Enumerator
Mask_Primitives 

Primitive list.

Mask_Vertices 

Vertex group.

Mask_Points 

Point list.

Mask_Object 

The Object.

Mask_Matrix 

Local->World Transform Matrix.

Mask_Attributes 

Attribute list.

Value for render_mode.

enum Display3DMode
related

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

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

anonymous enum

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

Enumerator
LOCAL_SPACE 

Point in locally defined space.

WORLD_SPACE 

Object transform applied.

EYE_SPACE 

Inverse camera transform applied(camera becomes 0,0,0)

CLIP_SPACE 

Camera projection applied, homogeneous-space.

SCREEN_SPACE 

Homogeneous-space scaled to pixel coordinates.

enum DD::Image::OpHints
strong

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

Enumerator
eDefault 

=== Base flags (mutually exclusive) ===

This op uses the default rules for task creation and evaluation, which is to wait for all inputs to be fully evaluated before starting its own computation. Inputs will be evaluated according to the bounding box and channels requested by connected downstream ops, so it is important for the downstream ops to request only the data they will actually fetch from their inputs to avoid over-rendering. For ops that support it, the evaluation will be divided between multiple threads and performed in parallel (currently limited to non-planar 2D Iops).

eChainable 

This op does not need to wait for inputs to be fully evaluated before beginning its own evaluation. When a series of eChainable ops are connected together they will be combined into a single task "bubble" and evaluated lazily by the bottom-up renderer. The task is considered to be complete when the final op in the chain has been fully evaluated. Only the results of the final op in the task will be cached for downstream ops to use. This hint will yield the best results for ops such as PixelIops that pass relatively small amounts of data (e.g. a scanline) to each other and modify their input data in-place instead of creating new outputs.

eIgnore 

This op should not be rendered in top-down order. It will instead be lazily evaluated in bottom-up order when downstream ops try to fetch its output. This hint should be used for ops that cannot accurately predict which regions and/or channels they will need to request from their inputs until they are evaluated. The top-down system will render inputs based on the region and/or channels requested by their connected downstream ops. If this information is incorrect then over-rendering may occur. The eIgnore hint can be used to avoid this problem, although this is not guaranteed to provide a performance improvement as its use must be balanced against the increased thread synchronisation that may occur as a result of rendering the op lazily.

eIgnoreInputs 

=== Modifier flags (can be combined with a Base flag) ===

This op's inputs should not be rendered in top-down order. They will instead be lazily evaluated in bottom-up order when downstream ops try to fetch their output. This hint is intended for use alongside eIgnore and provides a way to ignore an entire sub-graph if multiple ops are over-rendering as a result of the op at the end of the graph being unable to request the correct region and/or channels in top-down mode.

eSingleThread 

This op should not be rendered with multiple scanline threads. This hint should be used in the rare cases where multi-threading an op's evaluation would result in a loss of performance.

eInternalMultithreaded 

This op has internal multithreading so the top-down system should try to avoid running it in parallel with other ops. When an op completes, any successors with this hint will be run serially rather than in parallel to get the maximum benefit from the op's internal multithreading.

enum DD::Image::FrameAdvance : unsigned char
Enumerator
eFrameAdvanceStep 

do not advance frame

eFrameAdvanceRandom 

advance a frame each frame

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.

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

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

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

enum ViewerConnected
related
enum TransformSpace : uint8_t
related
enum ViewerMode
related
enum ViewerEvent
related
enum CameraLockMode
related

Value for camera lock mode

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;

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

anonymous enum
related

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

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

anonymous enum
related

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

Frustum visibility result.

Enumerator
eNotVisible 

the primitive is completely outside the view frustum

eFullVisible 

the primitive is completely inside the view frustum

ePartialVisible 

part of the primitive is inside the view frustum

Function Documentation

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

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

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

Adds one to the Channel and returns it.

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

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

References getName().

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

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

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

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

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

size_t DD::Image::getChannelCount ( )

Get the number of channels currently registered.

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

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

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

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

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

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

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

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

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

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

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

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

Returns Chan_Black if no such channel exists.

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

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

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

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

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

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

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

Returns a structure that you can query to get the Nuke version in various forms.If DDImage is not being used by Nuke it just returns the DDImage version.

References version().

double DD::Image::scriptVersion ( )
inline

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

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

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

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

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

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

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

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

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

Get a valid and not empty attribute context from GeoInfo

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

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

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

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

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

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

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

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

References gl_text().

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

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

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

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

References gl_text().

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

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

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

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

Referenced by gl_cylinderf(), and gl_sphere().

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

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

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

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

References gl_circlef().

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

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

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

Referenced by gl_axis().

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

Draw a wireframe sphere around 0,0,0

References gl_circlef().

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

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

Draw a flat plane in any of the three basic planes

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

gl_quadi Draws a filled quad (int version).

Parameters
xleft bottom value along x axis.
yleft bottom value along y axis.
rightright top value along x axis.
topright top value along y axis.
void DD::Image::gl_axis ( )

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

References gl_conef(), and glColor().

void DD::Image::gl_axis_label ( )

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

References gl_text(), and glColor().

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

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

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

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

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

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

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

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

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

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

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

Print GL errors - reasonably emulates gluErrorString

Referenced by glGetErrors().

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

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

References gl_errorstring().

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

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

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

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

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

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

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

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

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

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

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

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

Values that work for any knob:

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

Values that work for knobs that store numbers:

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

Values that work for Enumeration_knob():

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

Values that work for BeginGroup():

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

Values that work for Format_knob():

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Create a Password input field

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Controls a single integer value.

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

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

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

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

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

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

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

Controls a single number stored as a float

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

Controls a single frame number stored as a float

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

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

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

Controls dim doubles in an array

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

Controls dim floats in an array

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

Controls dim integers in an array

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

It's used to store a collection of control points

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

POSITIONER|TO_PROXY = Does both.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

obsolete

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

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

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

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

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

Knob* DD::Image::BeginGroup ( Knob_Callback  f,
NAME  name,
LABEL  label = nullptr 
)
inline

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

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

Knob* DD::Image::BeginClosedGroup ( Knob_Callback  f,
NAME  name,
LABEL  label = nullptr 
)
inline

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

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

Ends a hierarchy level.

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

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

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

Ends a toolbar.

Knob* DD::Image::BeginTabGroup ( Knob_Callback  f,
NAME  name,
LABEL  label = nullptr 
)
inline

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

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

Ends a tabbed group.

Knob* DD::Image::BeginExoGroup ( Knob_Callback  f,
NAME  name,
LABEL  label = nullptr 
)
inline

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

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

Ends a extratabular group.

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

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

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

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

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

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

Knob* DD::Image::Named_Text_knob ( Knob_Callback  f,
LABEL  name,
LABEL  label,
LABEL  text 
)
inline

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

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

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

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

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

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

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

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

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

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

Vertical gap between knobs.

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

A non-interactive icon

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

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

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

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

Knob* DD::Image::Button ( Knob_Callback  f,
NAME  n,
LABEL  l = nullptr 
)
inline

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

Knob* DD::Image::Script_knob ( Knob_Callback  f,
NAME  command,
NAME  n,
LABEL  l = nullptr 
)
inline

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

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

Knob* DD::Image::PyScript_knob ( Knob_Callback  f,
NAME  command,
NAME  n,
LABEL  l = nullptr 
)
inline

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

Knob* DD::Image::CancelExecution_knob ( Knob_Callback  f,
NAME  n,
LABEL  l = nullptr 
)
inline

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

Knob* DD::Image::Python_knob ( Knob_Callback  f,
NAME  command,
NAME  n,
LABEL  l = nullptr 
)
inline

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

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

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

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

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

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

Multi-line text editor.

Referenced by Eval_String_knob().

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

Creates a new String knob that may contain an expression.

References Multiline_String_knob().

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

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

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

A knob managing the logic for disabling nodes

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

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

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

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

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

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

void DD::Image::Matrix4ToArray ( Matrix4 matrix,
double *  arr 
)
inline

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

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

void DD::Image::Matrix3x4ToArray ( Matrix4 matrix,
double *  arr 
)
inline

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

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

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

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

Referenced by fBm(), and turbulence().

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

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

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

3D Perlin noise function.

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

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

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

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

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

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

References noise().

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

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

References noise().

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

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

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

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

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

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

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

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

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

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

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

References p_random().

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

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

References p_random().

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

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

References p_random().

template<typename Function >
void DD::Image::ParallelFor ( unsigned int  numItems,
Function  f,
unsigned int  maxThreads = 0,
unsigned int  minItems = 1000 
)

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

template<typename Function >
void DD::Image::ParallelForRange ( unsigned int  numItems,
Function  f,
unsigned int  maxThreads = 0,
unsigned int  minItems = 1000 
)

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

int DD::Image::plugin_count ( )

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

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

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

Referenced by plugin_find(), and plugin_load().

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

Return the filename of the Nth plugin that was found.

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

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

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

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

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

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

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

Referenced by plugin_load(), and plugin_load_one().

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

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

Try to load a shared-object or tcl plugin.

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

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

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

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

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

References plugin_find(), and snprintf().

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

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

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

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

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

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

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

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

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

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

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

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

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

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

References getPluginPath(), and strlcpy().

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

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

References plugin_find(), and snprintf().

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

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

References getPluginPath().

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

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

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

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

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

References strlcpy().

Referenced by plugin_appendpath().

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

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

References plugin_addpath().

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

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

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

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

Set an error message for the current plugin.

References strlcpy().

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

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

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

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

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

References ParseBlinkLibraryAbiVersionFromDLErrorMessage(), ParseDDImageAbiVersionFromDLErrorMessage(), and snprintf().

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

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

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

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

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

Returns the entire plugin path as a vector.

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

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

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

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

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

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

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

Return the plugin path of the application

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

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

void DD::Image::PostAbortTeardown ( )

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

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

void DD::Image::InitialiseThread ( )

Initialises DDImage threading Should be called from the MainThread.

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

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

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

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

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

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

void DD::Image::createRIPContext ( )

create and register the DDImage RIP Context with RIP

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

void DD::Image::destroyRIPContext ( )

Destroy the DDImage RIP Context

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

Sample a parallelogram of an iop with a mipmap technique.

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

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

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

Referenced by sleepFor().

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

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

References SleepMS().

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

Test to see if you should draw lines

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

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

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

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

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

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

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

References ParseDDImageAbiVersionFromDLErrorMessage().

Referenced by ParseDDImageAbiVersionFromDLErrorMessage(), and plugin_binary().

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

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

References ParseBlinkLibraryAbiVersionFromDLErrorMessage().

Referenced by ParseBlinkLibraryAbiVersionFromDLErrorMessage(), and plugin_binary().

Variable Documentation

const char *const DD::Image::group_names

Group name strings.

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

const char *const DD::Image::render_modes

Name text array for render_mode enumeration knob

const char *const DD::Image::render_modes_source

Same as render_modes, except missing the "unchanged" entry

const char DD::Image::INVISIBLE

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

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

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

Return the current global setting for frames per second.

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

bool DD::Image::plugin_verbose

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

bool DD::Image::plugin_safe_mode

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

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

Return the contents of the clipboard

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

Copy a string into the clipboard

const char *const DD::Image::display3d_names

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

const char *const DD::Image::display3d_names_source

Same as display3d_names, except missing the "unchanged" entry

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

! The functions which are defined by Nuke

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

Nuke/DDImage's RIP context

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



©2021 The Foundry Visionmongers, Ltd. All Rights Reserved.
www.thefoundry.co.uk