# OpenColorIO

## Open Source Color Management

# C++ Types

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

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

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