Core¶

type ConstConfigRcPtr¶

type ConfigRcPtr¶

type ConstColorSpaceRcPtr¶

type ColorSpaceRcPtr¶

type ConstLookRcPtr¶

type LookRcPtr¶

type ConstContextRcPtr¶

type ContextRcPtr¶

type ConstProcessorRcPtr¶

type ProcessorRcPtr¶

type ConstProcessorMetadataRcPtr¶

type ProcessorMetadataRcPtr¶

type ConstBakerRcPtr¶

type BakerRcPtr¶

Transforms¶

type ConstTransformRcPtr¶

type TransformRcPtr¶

type ConstAllocationTransformRcPtr¶

type AllocationTransformRcPtr¶

type ConstCDLTransformRcPtr¶

type CDLTransformRcPtr¶

type ConstColorSpaceTransformRcPtr¶

type ColorSpaceTransformRcPtr¶

type ConstDisplayTransformRcPtr¶

type DisplayTransformRcPtr¶

type ConstExponentTransformRcPtr¶

type ExponentTransformRcPtr¶

type ConstFileTransformRcPtr¶

type FileTransformRcPtr¶

type ConstGroupTransformRcPtr¶

type GroupTransformRcPtr¶

type ConstLogTransformRcPtr¶

type LogTransformRcPtr¶

type ConstLookTransformRcPtr¶

type LookTransformRcPtr¶

type ConstMatrixTransformRcPtr¶

type MatrixTransformRcPtr¶

type ConstTruelightTransformRcPtr¶

type TruelightTransformRcPtr¶

Enums¶

type ColorSpaceDirection¶

type TransformDirection¶

type Interpolation¶

Specify the interpolation type to use If the specified interpolation type is not supported in the requested context (for example, using tetrahedral interpolationon 1D luts) an exception will be throw.

INTERP_BEST will choose the best interpolation type for the requested context:

Lut1D INTERP_BEST: LINEAR Lut3D INTERP_BEST: LINEAR

Note: INTERP_BEST is subject to change in minor releases, so if you care about locking off on a specific interpolation type, we’d recommend directly specifying it.

type BitDepth¶

type Allocation¶

type GpuLanguage¶

Used when there is a choice of hardware shader language.

type EnvironmentMode¶

Conversion¶

const char* BoolToString(bool val)¶

bool BoolFromString(const char* s)¶

const char* LoggingLevelToString(LoggingLevel level)¶

LoggingLevel LoggingLevelFromString(const char* s)¶

const char* TransformDirectionToString(TransformDirection dir)¶

TransformDirection TransformDirectionFromString(const char* s)¶

TransformDirection GetInverseTransformDirection(TransformDirection dir)¶

TransformDirection CombineTransformDirections(TransformDirection d1, TransformDirection d2)¶

const char* ColorSpaceDirectionToString(ColorSpaceDirection dir)¶

ColorSpaceDirection ColorSpaceDirectionFromString(const char* s)¶

const char* BitDepthToString(BitDepth bitDepth)¶

BitDepth BitDepthFromString(const char* s)¶

bool BitDepthIsFloat(BitDepth bitDepth)¶

int BitDepthToInt(BitDepth bitDepth)¶

const char* AllocationToString(Allocation allocation)¶

Allocation AllocationFromString(const char* s)¶

const char* InterpolationToString(Interpolation interp)¶

Interpolation InterpolationFromString(const char* s)¶

const char* GpuLanguageToString(GpuLanguage language)¶

GpuLanguage GpuLanguageFromString(const char* s)¶

const char* EnvironmentModeToString(EnvironmentMode mode)¶

EnvironmentMode EnvironmentModeFromString(const char* s)¶

Roles¶

ColorSpace Roles are used so that plugins, in addition to this API can have abstract ways of asking for common colorspaces, without referring to them by hardcoded names.

Internal:

GetGPUDisplayTransform - (ROLE_SCENE_LINEAR (fstop exposure))
                         (ROLE_COLOR_TIMING (ASCColorCorrection))

External Plugins (currently known):

Colorpicker UIs       - (ROLE_COLOR_PICKING)
Compositor LogConvert - (ROLE_SCENE_LINEAR, ROLE_COMPOSITING_LOG)

const char* ROLE_DEFAULT¶

“default”

const char* ROLE_REFERENCE¶

“reference”

const char* ROLE_DATA¶

“data”

const char* ROLE_COLOR_PICKING¶

“color_picking”

const char* ROLE_SCENE_LINEAR¶

“scene_linear”

const char* ROLE_COMPOSITING_LOG¶

“compositing_log”

const char* ROLE_COLOR_TIMING¶

“color_timing”

const char* ROLE_TEXTURE_PAINT¶

This role defines the transform for painting textures. In some workflows this is just a inverse display gamma with some limits

const char* ROLE_MATTE_PAINT¶

This role defines the transform for matte painting. In some workflows this is a 1D HDR to LDR allocation. It is normally combined with another display transform in the host app for preview.