HDK
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
OpenColorTypes.h
Go to the documentation of this file.
1 // SPDX-License-Identifier: BSD-3-Clause
2 // Copyright Contributors to the OpenColorIO Project.
3 
4 
5 #ifndef INCLUDED_OCIO_OPENCOLORTYPES_H
6 #define INCLUDED_OCIO_OPENCOLORTYPES_H
7 
8 #include "OpenColorABI.h"
9 
10 #ifndef OCIO_NAMESPACE
11 #error This header cannot be used directly. Use <OpenColorIO/OpenColorIO.h> instead.
12 #endif
13 
14 #include <array>
15 #include <limits>
16 #include <string>
17 #include <functional>
18 
19 
20 /*!rst::
21 C++ Types
22 =========
23 */
24 
25 namespace OCIO_NAMESPACE
26 {
27 // Predeclare all class ptr definitions
28 
29 // Core
30 
32 typedef OCIO_SHARED_PTR<const Config> ConstConfigRcPtr;
33 typedef OCIO_SHARED_PTR<Config> ConfigRcPtr;
34 
36 typedef OCIO_SHARED_PTR<const FileRules> ConstFileRulesRcPtr;
37 typedef OCIO_SHARED_PTR<FileRules> FileRulesRcPtr;
38 
40 typedef OCIO_SHARED_PTR<const ViewingRules> ConstViewingRulesRcPtr;
41 typedef OCIO_SHARED_PTR<ViewingRules> ViewingRulesRcPtr;
42 
44 typedef OCIO_SHARED_PTR<const ColorSpace> ConstColorSpaceRcPtr;
45 typedef OCIO_SHARED_PTR<ColorSpace> ColorSpaceRcPtr;
46 
48 typedef OCIO_SHARED_PTR<const ColorSpaceSet> ConstColorSpaceSetRcPtr;
49 typedef OCIO_SHARED_PTR<ColorSpaceSet> ColorSpaceSetRcPtr;
50 
52 typedef OCIO_SHARED_PTR<const Look> ConstLookRcPtr;
53 typedef OCIO_SHARED_PTR<Look> LookRcPtr;
54 
56 typedef OCIO_SHARED_PTR<const NamedTransform> ConstNamedTransformRcPtr;
57 typedef OCIO_SHARED_PTR<NamedTransform> NamedTransformRcPtr;
58 
60 typedef OCIO_SHARED_PTR<const ViewTransform> ConstViewTransformRcPtr;
61 typedef OCIO_SHARED_PTR<ViewTransform> ViewTransformRcPtr;
62 
64 typedef OCIO_SHARED_PTR<const Context> ConstContextRcPtr;
65 typedef OCIO_SHARED_PTR<Context> ContextRcPtr;
66 
68 typedef OCIO_SHARED_PTR<const Processor> ConstProcessorRcPtr;
69 typedef OCIO_SHARED_PTR<Processor> ProcessorRcPtr;
70 
72 typedef OCIO_SHARED_PTR<const CPUProcessor> ConstCPUProcessorRcPtr;
73 typedef OCIO_SHARED_PTR<CPUProcessor> CPUProcessorRcPtr;
74 
76 typedef OCIO_SHARED_PTR<const GPUProcessor> ConstGPUProcessorRcPtr;
77 typedef OCIO_SHARED_PTR<GPUProcessor> GPUProcessorRcPtr;
78 
80 typedef OCIO_SHARED_PTR<const ProcessorMetadata> ConstProcessorMetadataRcPtr;
81 typedef OCIO_SHARED_PTR<ProcessorMetadata> ProcessorMetadataRcPtr;
82 
84 typedef OCIO_SHARED_PTR<const Baker> ConstBakerRcPtr;
85 typedef OCIO_SHARED_PTR<Baker> BakerRcPtr;
86 
88 typedef OCIO_SHARED_PTR<ImageDesc> ImageDescRcPtr;
89 typedef OCIO_SHARED_PTR<const ImageDesc> ConstImageDescRcPtr;
90 
92 
94 typedef OCIO_SHARED_PTR<GpuShaderCreator> GpuShaderCreatorRcPtr;
95 typedef OCIO_SHARED_PTR<const GpuShaderCreator> ConstGpuShaderCreatorRcPtr;
96 
98 typedef OCIO_SHARED_PTR<GpuShaderDesc> GpuShaderDescRcPtr;
99 typedef OCIO_SHARED_PTR<const GpuShaderDesc> ConstGpuShaderDescRcPtr;
100 
102 typedef OCIO_SHARED_PTR<BuiltinTransformRegistry> BuiltinTransformRegistryRcPtr;
103 typedef OCIO_SHARED_PTR<const BuiltinTransformRegistry> ConstBuiltinTransformRegistryRcPtr;
104 
106 typedef OCIO_SHARED_PTR<SystemMonitors> SystemMonitorsRcPtr;
107 typedef OCIO_SHARED_PTR<const SystemMonitors> ConstSystemMonitorsRcPtr;
108 
110 typedef OCIO_SHARED_PTR<const GradingBSplineCurve> ConstGradingBSplineCurveRcPtr;
111 typedef OCIO_SHARED_PTR<GradingBSplineCurve> GradingBSplineCurveRcPtr;
112 
114 typedef OCIO_SHARED_PTR<const GradingRGBCurve> ConstGradingRGBCurveRcPtr;
115 typedef OCIO_SHARED_PTR<GradingRGBCurve> GradingRGBCurveRcPtr;
116 
117 typedef std::array<float, 3> Float3;
118 
119 
120 // Transforms
121 
123 typedef OCIO_SHARED_PTR<const Transform> ConstTransformRcPtr;
124 typedef OCIO_SHARED_PTR<Transform> TransformRcPtr;
125 
127 typedef OCIO_SHARED_PTR<const AllocationTransform> ConstAllocationTransformRcPtr;
128 typedef OCIO_SHARED_PTR<AllocationTransform> AllocationTransformRcPtr;
129 
131 typedef OCIO_SHARED_PTR<const BuiltinTransform> ConstBuiltinTransformRcPtr;
132 typedef OCIO_SHARED_PTR<BuiltinTransform> BuiltinTransformRcPtr;
133 
135 typedef OCIO_SHARED_PTR<const CDLTransform> ConstCDLTransformRcPtr;
136 typedef OCIO_SHARED_PTR<CDLTransform> CDLTransformRcPtr;
137 
139 typedef OCIO_SHARED_PTR<const ColorSpaceTransform> ConstColorSpaceTransformRcPtr;
140 typedef OCIO_SHARED_PTR<ColorSpaceTransform> ColorSpaceTransformRcPtr;
141 
143 typedef OCIO_SHARED_PTR<const DisplayViewTransform> ConstDisplayViewTransformRcPtr;
144 typedef OCIO_SHARED_PTR<DisplayViewTransform> DisplayViewTransformRcPtr;
145 
147 typedef OCIO_SHARED_PTR<const DynamicProperty> ConstDynamicPropertyRcPtr;
148 typedef OCIO_SHARED_PTR<DynamicProperty> DynamicPropertyRcPtr;
149 
151 typedef OCIO_SHARED_PTR<const DynamicPropertyDouble> ConstDynamicPropertyDoubleRcPtr;
152 typedef OCIO_SHARED_PTR<DynamicPropertyDouble> DynamicPropertyDoubleRcPtr;
153 
155 typedef OCIO_SHARED_PTR<const DynamicPropertyGradingPrimary> ConstDynamicPropertyGradingPrimaryRcPtr;
156 typedef OCIO_SHARED_PTR<DynamicPropertyGradingPrimary> DynamicPropertyGradingPrimaryRcPtr;
157 
159 typedef OCIO_SHARED_PTR<const DynamicPropertyGradingRGBCurve> ConstDynamicPropertyGradingRGBCurveRcPtr;
160 typedef OCIO_SHARED_PTR<DynamicPropertyGradingRGBCurve> DynamicPropertyGradingRGBCurveRcPtr;
161 
163 typedef OCIO_SHARED_PTR<const DynamicPropertyGradingTone> ConstDynamicPropertyGradingToneRcPtr;
164 typedef OCIO_SHARED_PTR<DynamicPropertyGradingTone> DynamicPropertyGradingToneRcPtr;
165 
167 typedef OCIO_SHARED_PTR<const ExponentTransform> ConstExponentTransformRcPtr;
168 typedef OCIO_SHARED_PTR<ExponentTransform> ExponentTransformRcPtr;
169 
171 typedef OCIO_SHARED_PTR<const ExponentWithLinearTransform> ConstExponentWithLinearTransformRcPtr;
172 typedef OCIO_SHARED_PTR<ExponentWithLinearTransform> ExponentWithLinearTransformRcPtr;
173 
175 typedef OCIO_SHARED_PTR<const ExposureContrastTransform> ConstExposureContrastTransformRcPtr;
176 typedef OCIO_SHARED_PTR<ExposureContrastTransform> ExposureContrastTransformRcPtr;
177 
179 typedef OCIO_SHARED_PTR<const FileTransform> ConstFileTransformRcPtr;
180 typedef OCIO_SHARED_PTR<FileTransform> FileTransformRcPtr;
181 
183 typedef OCIO_SHARED_PTR<const FixedFunctionTransform> ConstFixedFunctionTransformRcPtr;
184 typedef OCIO_SHARED_PTR<FixedFunctionTransform> FixedFunctionTransformRcPtr;
185 
187 typedef OCIO_SHARED_PTR<const GradingPrimaryTransform> ConstGradingPrimaryTransformRcPtr;
188 typedef OCIO_SHARED_PTR<GradingPrimaryTransform> GradingPrimaryTransformRcPtr;
189 
191 typedef OCIO_SHARED_PTR<const GradingRGBCurveTransform> ConstGradingRGBCurveTransformRcPtr;
192 typedef OCIO_SHARED_PTR<GradingRGBCurveTransform> GradingRGBCurveTransformRcPtr;
193 
195 typedef OCIO_SHARED_PTR<const GradingToneTransform> ConstGradingToneTransformRcPtr;
196 typedef OCIO_SHARED_PTR<GradingToneTransform> GradingToneTransformRcPtr;
197 
199 typedef OCIO_SHARED_PTR<const GroupTransform> ConstGroupTransformRcPtr;
200 typedef OCIO_SHARED_PTR<GroupTransform> GroupTransformRcPtr;
201 
203 typedef OCIO_SHARED_PTR<const LogAffineTransform> ConstLogAffineTransformRcPtr;
204 typedef OCIO_SHARED_PTR<LogAffineTransform> LogAffineTransformRcPtr;
205 
207 typedef OCIO_SHARED_PTR<const LogCameraTransform> ConstLogCameraTransformRcPtr;
208 typedef OCIO_SHARED_PTR<LogCameraTransform> LogCameraTransformRcPtr;
209 
211 typedef OCIO_SHARED_PTR<const LookTransform> ConstLookTransformRcPtr;
212 typedef OCIO_SHARED_PTR<LookTransform> LookTransformRcPtr;
213 
215 typedef OCIO_SHARED_PTR<const LogTransform> ConstLogTransformRcPtr;
216 typedef OCIO_SHARED_PTR<LogTransform> LogTransformRcPtr;
217 
219 typedef OCIO_SHARED_PTR<const Lut1DTransform> ConstLut1DTransformRcPtr;
220 typedef OCIO_SHARED_PTR<Lut1DTransform> Lut1DTransformRcPtr;
221 
223 typedef OCIO_SHARED_PTR<const Lut3DTransform> ConstLut3DTransformRcPtr;
224 typedef OCIO_SHARED_PTR<Lut3DTransform> Lut3DTransformRcPtr;
225 
227 typedef OCIO_SHARED_PTR<const MatrixTransform> ConstMatrixTransformRcPtr;
228 typedef OCIO_SHARED_PTR<MatrixTransform> MatrixTransformRcPtr;
229 
231 typedef OCIO_SHARED_PTR<const RangeTransform> ConstRangeTransformRcPtr;
232 typedef OCIO_SHARED_PTR<RangeTransform> RangeTransformRcPtr;
233 
234 
235 // Application Helpers
236 
238 typedef OCIO_SHARED_PTR<ColorSpaceMenuHelper> ColorSpaceMenuHelperRcPtr;
239 typedef OCIO_SHARED_PTR<const ColorSpaceMenuHelper> ConstColorSpaceMenuHelperRcPtr;
240 
242 typedef OCIO_SHARED_PTR<ColorSpaceMenuParameters> ColorSpaceMenuParametersRcPtr;
243 typedef OCIO_SHARED_PTR<const ColorSpaceMenuParameters> ConstColorSpaceMenuParametersRcPtr;
244 
246 typedef OCIO_SHARED_PTR<MixingColorSpaceManager> MixingColorSpaceManagerRcPtr;
247 typedef OCIO_SHARED_PTR<const MixingColorSpaceManager> ConstMixingColorSpaceManagerRcPtr;
248 
250 typedef OCIO_SHARED_PTR<LegacyViewingPipeline> LegacyViewingPipelineRcPtr;
251 typedef OCIO_SHARED_PTR<const LegacyViewingPipeline> ConstLegacyViewingPipelineRcPtr;
252 
253 
254 template <class T, class U>
255 inline OCIO_SHARED_PTR<T> DynamicPtrCast(OCIO_SHARED_PTR<U> const & ptr)
256 {
257  return OCIO_DYNAMIC_POINTER_CAST<T,U>(ptr);
258 }
259 
260 /// Define the logging function signature.
261 using LoggingFunction = std::function<void(const char*)>;
262 
263 // Enums
264 
266 {
272 
274 };
275 
276 /// Define Compute Hash function signature.
277 using ComputeHashFunction = std::function<std::string(const std::string &)>;
278 
279 /**
280  * OCIO does not mandate the image state of the main reference space and it is not
281  * required to be scene-referred. This enum is used in connection with the display color space
282  * and view transform features which do assume that the main reference space is scene-referred
283  * and the display reference space is display-referred. If a config used a non-scene-referred
284  * reference space, presumably it would not use either display color spaces or view transforms,
285  * so this enum becomes irrelevant.
286  */
288 {
289  REFERENCE_SPACE_SCENE = 0, ///< the main scene reference space
290  REFERENCE_SPACE_DISPLAY ///< the reference space for display color spaces
291 };
292 
294 {
298 };
299 
301 {
305 };
306 
308 {
312 };
313 
315 {
318 };
319 
321 {
324 };
325 
327 {
330 };
331 
333 {
336 };
337 
339 {
362 };
363 
364 /**
365  * Specify the interpolation type to use
366  * If the specified interpolation type is not supported in the requested
367  * context (for example, using tetrahedral interpolationon 1D LUTs)
368  * an exception will be thrown.
369  *
370  * INTERP_DEFAULT will choose the default interpolation type for the requested
371  * context:
372  *
373  * 1D LUT INTERP_DEFAULT: LINEAR
374  * 3D LUT INTERP_DEFAULT: LINEAR
375  *
376  * INTERP_BEST will choose the best interpolation type for the requested
377  * context:
378  *
379  * 1D LUT INTERP_BEST: LINEAR
380  * 3D LUT INTERP_BEST: TETRAHEDRAL
381  *
382  * Note: INTERP_BEST and INTERP_DEFAULT are subject to change in minor
383  * releases, so if you care about locking off on a specific interpolation
384  * type, we'd recommend directly specifying it.
385  */
387 {
389  INTERP_NEAREST = 1, ///< nearest neighbor
390  INTERP_LINEAR = 2, ///< linear interpolation (trilinear for Lut3D)
391  INTERP_TETRAHEDRAL = 3, ///< tetrahedral interpolation (Lut3D only)
392  INTERP_CUBIC = 4, ///< cubic interpolation (not supported)
393 
394  INTERP_DEFAULT = 254, ///< the default interpolation type
395  INTERP_BEST = 255 ///< the 'best' suitable interpolation type
396 };
397 
398 /**
399  * Used in a configuration file to indicate the bit-depth of a color space,
400  * and by the \ref Processor to specify the input and output bit-depths of
401  * images to process.
402  * Note that \ref Processor only supports: UINT8, UINT10, UINT12, UINT16, F16 and F32.
403  */
405 {
412  BIT_DEPTH_UINT32, ///< Here for historical reason but that's not supported.
415 };
416 
417 /// Used by :cpp:class`Lut1DTransform` to control optional hue restoration algorithm.
419 {
420  HUE_NONE = 0, ///< No adjustment.
421  HUE_DW3, ///< Algorithm used in ACES Output Transforms through v0.7.
422  HUE_WYPN ///< Weighted Yellow Power Norm -- NOT IMPLEMENTED YET
423 };
424 
425 /// Used by \ref PackedImageDesc to indicate the channel ordering of the image to process.
427 {
433 };
434 
439 };
440 
441 /// Used when there is a choice of hardware shader language.
443 {
444  GPU_LANGUAGE_CG = 0, ///< Nvidia Cg shader
445  GPU_LANGUAGE_GLSL_1_2, ///< OpenGL Shading Language
446  GPU_LANGUAGE_GLSL_1_3, ///< OpenGL Shading Language
447  GPU_LANGUAGE_GLSL_4_0, ///< OpenGL Shading Language
448  GPU_LANGUAGE_HLSL_DX11, ///< DirectX Shading Language
449  LANGUAGE_OSL_1, ///< Open Shading Language
450  GPU_LANGUAGE_GLSL_ES_1_0, ///< OpenGL ES Shading Language
451  GPU_LANGUAGE_GLSL_ES_3_0, ///< OpenGL ES Shading Language
452  GPU_LANGUAGE_MSL_2_0 ///< Metal Shading Language
453 };
454 
456 {
460 };
461 
462 /// A RangeTransform may be set to clamp the values, or not.
464 {
467 };
468 
469 /// Enumeration of the :cpp:class:`FixedFunctionTransform` transform algorithms.
471 {
472  FIXED_FUNCTION_ACES_RED_MOD_03 = 0, ///< Red modifier (ACES 0.3/0.7)
473  FIXED_FUNCTION_ACES_RED_MOD_10, ///< Red modifier (ACES 1.0)
474  FIXED_FUNCTION_ACES_GLOW_03, ///< Glow function (ACES 0.3/0.7)
475  FIXED_FUNCTION_ACES_GLOW_10, ///< Glow function (ACES 1.0)
476  FIXED_FUNCTION_ACES_DARK_TO_DIM_10, ///< Dark to dim surround correction (ACES 1.0)
477  FIXED_FUNCTION_REC2100_SURROUND, ///< Rec.2100 surround correction (takes one double for the gamma param)
478  FIXED_FUNCTION_RGB_TO_HSV, ///< Classic RGB to HSV function
479  FIXED_FUNCTION_XYZ_TO_xyY, ///< CIE XYZ to 1931 xy chromaticity coordinates
480  FIXED_FUNCTION_XYZ_TO_uvY, ///< CIE XYZ to 1976 u'v' chromaticity coordinates
481  FIXED_FUNCTION_XYZ_TO_LUV, ///< CIE XYZ to 1976 CIELUV colour space (D65 white)
482  FIXED_FUNCTION_ACES_GAMUTMAP_02, ///< ACES 0.2 Gamut clamping algorithm -- NOT IMPLEMENTED YET
483  FIXED_FUNCTION_ACES_GAMUTMAP_07, ///< ACES 0.7 Gamut clamping algorithm -- NOT IMPLEMENTED YET
484  FIXED_FUNCTION_ACES_GAMUT_COMP_13 ///< ACES 1.3 Parametric Gamut Compression (expects ACEScg values)
485 };
486 
487 /// Enumeration of the :cpp:class:`ExposureContrastTransform` transform algorithms.
489 {
490  EXPOSURE_CONTRAST_LINEAR = 0, ///< E/C to be applied to a linear space image
491  EXPOSURE_CONTRAST_VIDEO, ///< E/C to be applied to a video space image
492  EXPOSURE_CONTRAST_LOGARITHMIC ///< E/C to be applied to a log space image
493 };
494 
495 /**
496  * Enumeration of the :cpp:class:`CDLTransform` transform algorithms.
497  *
498  * \note
499  * The default for reading .cc/.ccc/.cdl files, config file YAML, and CDLTransform is no-clamp,
500  * since that is what is primarily desired in VFX. However, the CLF format default is ASC.
501  */
503 {
504  CDL_ASC = 0, ///< ASC CDL specification v1.2
505  CDL_NO_CLAMP, ///< CDL that does not clamp
507 };
508 
509 /**
510  * Negative values handling style for \ref ExponentTransform and
511  * \ref ExponentWithLinearTransform transform algorithms.
512  */
514 {
515  NEGATIVE_CLAMP = 0, ///< Clamp negative values
516  NEGATIVE_MIRROR, ///< Positive curve is rotated 180 degrees around the origin to handle negatives.
517  NEGATIVE_PASS_THRU, ///< Negative values are passed through unchanged.
518  NEGATIVE_LINEAR ///< Linearly extrapolate the curve for negative values.
519 };
520 
521 /// Styles for grading transforms.
523 {
524  GRADING_LOG = 0, ///< Algorithms for Logarithmic color spaces.
525  GRADING_LIN, ///< Algorithms for Scene Linear color spaces.
526  GRADING_VIDEO ///< Algorithms for Video color spaces.
527 };
528 
529 /// Types for dynamic properties.
531 {
532  DYNAMIC_PROPERTY_EXPOSURE = 0, ///< Image exposure value (double floating point value)
533  DYNAMIC_PROPERTY_CONTRAST, ///< Image contrast value (double floating point value)
534  DYNAMIC_PROPERTY_GAMMA, ///< Image gamma value (double floating point value)
535  DYNAMIC_PROPERTY_GRADING_PRIMARY, ///< Used by GradingPrimaryTransform
536  DYNAMIC_PROPERTY_GRADING_RGBCURVE, ///< Used by GradingRGBCurveTransform
537  DYNAMIC_PROPERTY_GRADING_TONE ///< Used by GradingToneTransform
538 };
539 
540 /// Types for GradingRGBCurve.
542 {
543  RGB_RED = 0,
548 };
549 
550 /// Types for uniform data.
552 {
555  UNIFORM_FLOAT3, ///< Array of 3 floats.
556  UNIFORM_VECTOR_FLOAT, ///< Vector of floats (size is set by uniform).
557  UNIFORM_VECTOR_INT, ///< Vector of int pairs (size is set by uniform).
559 };
560 
561 /// Provides control over how the ops in a Processor are combined in order to improve performance.
562 enum OptimizationFlags : unsigned long
563 {
564  // Below are listed all the optimization types.
565 
566  /// Do not optimize.
567  OPTIMIZATION_NONE = 0x00000000,
568 
569  /// Replace identity ops (other than gamma).
570  OPTIMIZATION_IDENTITY = 0x00000001,
571  /// Replace identity gamma ops.
573 
574  /// Replace a pair of ops where one is the inverse of the other.
583 
584  /// Compose a pair of ops into a single op.
591 
592  /**
593  * For integer and half bit-depths only, replace separable ops (i.e. no channel crosstalk
594  * ops) by a single 1D LUT of input bit-depth domain.
595  */
597 
598  /**
599  * Implement inverse Lut1D and Lut3D evaluations using a a forward LUT (faster but less
600  * accurate). Note that GPU evals always do FAST.
601  */
603 
604  // For CPU processor, in SSE mode, use a faster approximation for log, exp, and pow.
606 
607  // Break down certain ops into simpler components where possible. For example, convert a CDL
608  // to a matrix when possible.
610 
611  /**
612  * Turn off dynamic control of any ops that offer adjustment of parameter values after
613  * finalization (e.g. ExposureContrast).
614  */
616 
617  /// Apply all possible optimizations.
618  OPTIMIZATION_ALL = 0xFFFFFFFF,
619 
620  // The following groupings of flags are provided as a convenient way to select an overall
621  // optimization level.
622 
638 
644 
646 
647  /// For quite lossy optimizations.
649 
651 };
652 
653 //!cpp:type:: Enum to control the behavior of the internal caches e.g. the processor cache in
654 // :cpp:class:`Config` and :cpp:class:`Processor` instances. When debugging problems, it be useful
655 // to disable all the internal caches for example.
656 //
657 // The PROCESSOR_CACHE_SHARE_DYN_PROPERTIES flag allows the reuse of existing processor instances
658 // even if it contains some dynamic properties i.e. it speeds up the processor retrieval. That's the
659 // default behavior to avoid the processor creation hit. However, the caller app must then always
660 // set the dynamic property values prior to any color processing call (in CPU and GPU modes) as the
661 // same processor instance can now be used between several viewports for example.
662 enum ProcessorCacheFlags : unsigned int
663 {
665  PROCESSOR_CACHE_ENABLED = 0x01, // Enable the cache.
666  PROCESSOR_CACHE_SHARE_DYN_PROPERTIES = 0x02, // i.e. When the cache is enabled processor instances
667  // are shared even if they contain some dynamic
668  // properties.
669 
671 };
672 
673 // Conversion
674 
675 extern OCIOEXPORT const char * BoolToString(bool val);
676 extern OCIOEXPORT bool BoolFromString(const char * s);
677 
679 extern OCIOEXPORT LoggingLevel LoggingLevelFromString(const char * s);
680 
682 /// Will throw if string is not recognized.
684 
687  TransformDirection d2);
688 
689 extern OCIOEXPORT const char * BitDepthToString(BitDepth bitDepth);
690 extern OCIOEXPORT BitDepth BitDepthFromString(const char * s);
691 extern OCIOEXPORT bool BitDepthIsFloat(BitDepth bitDepth);
692 extern OCIOEXPORT int BitDepthToInt(BitDepth bitDepth);
693 
694 extern OCIOEXPORT const char * AllocationToString(Allocation allocation);
695 extern OCIOEXPORT Allocation AllocationFromString(const char * s);
696 
699 
700 extern OCIOEXPORT const char * GpuLanguageToString(GpuLanguage language);
701 extern OCIOEXPORT GpuLanguage GpuLanguageFromString(const char * s);
702 
705 
706 extern OCIOEXPORT const char * CDLStyleToString(CDLStyle style);
707 extern OCIOEXPORT CDLStyle CDLStyleFromString(const char * style);
708 
709 extern OCIOEXPORT const char * RangeStyleToString(RangeStyle style);
710 extern OCIOEXPORT RangeStyle RangeStyleFromString(const char * style);
711 
712 extern OCIOEXPORT const char * FixedFunctionStyleToString(FixedFunctionStyle style);
714 
715 extern OCIOEXPORT const char * GradingStyleToString(GradingStyle style);
716 extern OCIOEXPORT GradingStyle GradingStyleFromString(const char * s);
717 
720 
721 extern OCIOEXPORT const char * NegativeStyleToString(NegativeStyle style);
722 extern OCIOEXPORT NegativeStyle NegativeStyleFromString(const char * style);
723 
724 /** \defgroup Env. variables.
725  * @{
726  *
727  * These environmental variables are used by the OpenColorIO library.
728  * For variables that allow specifying more than one token, they should be separated by commas.
729  */
730 
731 // These variables are defined in src/OpenColorIO/Config.cpp.
732 
733 
734 /// The envvar 'OCIO' provides a path to the config file used by \ref Config::CreateFromEnv
735 extern OCIOEXPORT const char * OCIO_CONFIG_ENVVAR;
736 
737 /**
738  * The envvar 'OCIO_ACTIVE_DISPLAYS' provides a list of displays overriding the 'active_displays'
739  * list from the config file.
740  */
741 extern OCIOEXPORT const char * OCIO_ACTIVE_DISPLAYS_ENVVAR;
742 
743 /**
744  * The envvar 'OCIO_ACTIVE_VIEWS' provides a list of views overriding the 'active_views'
745  * list from the config file.
746  */
747 extern OCIOEXPORT const char * OCIO_ACTIVE_VIEWS_ENVVAR;
748 
749 /**
750  * The envvar 'OCIO_INACTIVE_COLORSPACES' provides a list of inactive color spaces
751  * overriding the 'inactive_color_spaces' list from the config file.
752  */
753 extern OCIOEXPORT const char * OCIO_INACTIVE_COLORSPACES_ENVVAR;
754 
755 /**
756  * The envvar 'OCIO_OPTIMIZATION_FLAGS' provides a way to force a given optimization level.
757  * Remove the variable or set the value to empty to not use it. Set the value of the variable
758  * to the desired optimization level as either an integer or hexadecimal value.
759  * Ex: OCIO_OPTIMIZATION_FLAGS="20479" or "0x4FFF" for OPTIMIZATION_LOSSLESS.
760  */
761 extern OCIOEXPORT const char * OCIO_OPTIMIZATION_FLAGS_ENVVAR;
762 
763 /**
764  * The envvar 'OCIO_USER_CATEGORIES' allows the end-user to filter color spaces shown by
765  * applications. Only color spaces that include at least one of the supplied categories will be
766  * shown in application menus. Note that applications may also impose their own category filtering
767  * in addition to the user-supplied categories. For example, an application may filter by
768  * 'working-space' for a menu to select a working space while the user may also filter by
769  * '3d-basic' to only show spaces intended for 3d artists who should see the basic set of color
770  * spaces. The categories will be ignored if they would result in no color spaces being found.
771  */
772 extern OCIOEXPORT const char * OCIO_USER_CATEGORIES_ENVVAR;
773 
774 /** @}*/
775 
776 /** \defgroup VarsRoles
777  * @{
778  */
779 
780 // TODO: Move to .rst
781 /*!rst::
782 Roles
783 *****
784 
785 ColorSpace Roles are used so that plugins, in addition to this API can have
786 abstract ways of asking for common colorspaces, without referring to them
787 by hardcoded names.
788 
789 Internal::
790  Extracting color space from file path - (ROLE_DEFAULT)
791  Interchange color spaces between configs - (ROLE_EXCHANGE_SCENE, ROLE_EXCHANGE_DISPLAY)
792 
793 App Helpers::
794  LegacyViewingPipeline - (ROLE_SCENE_LINEAR (LinearCC for exposure))
795  (ROLE_COLOR_TIMING (ColorTimingCC))
796  MixingColorSpaceManager - (ROLE_COLOR_PICKING)
797 
798 External Plugins (currently known)::
799 
800  Colorpicker UIs - (ROLE_COLOR_PICKING)
801  Compositor LogConvert - (ROLE_SCENE_LINEAR, ROLE_COMPOSITING_LOG)
802 
803 */
804 
805 /// "default"
806 extern OCIOEXPORT const char * ROLE_DEFAULT;
807 /// "reference"
808 extern OCIOEXPORT const char * ROLE_REFERENCE;
809 /// "data"
810 extern OCIOEXPORT const char * ROLE_DATA;
811 /// "color_picking"
812 extern OCIOEXPORT const char * ROLE_COLOR_PICKING;
813 /// "scene_linear"
814 extern OCIOEXPORT const char * ROLE_SCENE_LINEAR;
815 /// "compositing_log"
816 extern OCIOEXPORT const char * ROLE_COMPOSITING_LOG;
817 /// "color_timing"
818 extern OCIOEXPORT const char * ROLE_COLOR_TIMING;
819 /**
820  * This role defines the transform for painting textures. In some
821  * workflows this is just a inverse display gamma with some limits
822  */
823 extern OCIOEXPORT const char * ROLE_TEXTURE_PAINT;
824 /**
825  * This role defines the transform for matte painting. In some workflows
826  * this is a 1D HDR to LDR allocation. It is normally combined with
827  * another display transform in the host app for preview.
828  */
829 extern OCIOEXPORT const char * ROLE_MATTE_PAINT;
830 
831 /**
832  * The rendering role may be used to identify a specific color space to be used by CGI renderers.
833  * This is typically a scene-linear space but the primaries also matter since they influence the
834  * resulting color, especially in areas of indirect illumination.
835  */
836 extern OCIOEXPORT const char * ROLE_RENDERING;
837 /**
838  * The aces_interchange role is used to specify which color space in the config implements the
839  * standard ACES2065-1 color space (SMPTE ST2065-1). This may be used when converting
840  * scene-referred colors from one config to another.
841  */
842 extern OCIOEXPORT const char * ROLE_INTERCHANGE_SCENE;
843 /**
844  * The cie_xyz_d65_interchange role is used to specify which color space in the config implements
845  * CIE XYZ colorimetry with the neutral axis at D65. This may be used when converting
846  * display-referred colors from one config to another.
847  */
848 extern OCIOEXPORT const char * ROLE_INTERCHANGE_DISPLAY;
849 
850 /** @}*/
851 
852 /** \defgroup VarsSharedView
853  * @{
854  */
855 
856 /*!rst::
857 Shared View
858 ***********
859 
860 */
861 
862 /**
863  * A shared view using this for the color space name will use a display color space that
864  * has the same name as the display the shared view is used by.
865  */
866 extern OCIOEXPORT const char * OCIO_VIEW_USE_DISPLAY_NAME;
867 
868 /** @}*/
869 
870 /** \defgroup VarsFormatMetadata
871  * @{
872  */
873 
874 // TODO: Move to .rst
875 /*!rst::
876 FormatMetadata
877 **************
878 
879 These constants describe various types of rich metadata. They are used with FormatMetadata
880 objects as the "name" part of a (name, value) pair. All of these types of metadata are
881 supported in the CLF/CTF file formats whereas other formats support some or none of them.
882 
883 Although the string constants used here match those used in the CLF/CTF formats, the concepts
884 are generic, so the goal is for other file formats to reuse the same constants within a
885 FormatMetadata object (even if the syntax used in a given format is somewhat different).
886 
887 */
888 
889 /**
890  * A description string -- used as the "Description" element in CLF/CTF and CDL, and to
891  * hold comments for other LUT formats when baking.
892  */
893 extern OCIOEXPORT const char * METADATA_DESCRIPTION;
894 
895 /**
896  * A block of informative metadata such as the "Info" element in CLF/CTF.
897  * Usually contains child elements.
898  */
899 extern OCIOEXPORT const char * METADATA_INFO;
900 
901 /**
902  * A string describing the expected input color space -- used as the "InputDescriptor"
903  * element in CLF/CTF and the "InputDescription" in CDL.
904  */
905 extern OCIOEXPORT const char * METADATA_INPUT_DESCRIPTOR;
906 
907 /**
908  * A string describing the output color space -- used as the "OutputDescriptor" element
909  * in CLF/CTF and the "OutputDescription" in CDL.
910  */
911 extern OCIOEXPORT const char * METADATA_OUTPUT_DESCRIPTOR;
912 
913 /**
914  * A name string -- used as a "name" attribute in CLF/CTF elements. Use on a GroupTransform
915  * to get/set the name for the CLF/CTF ProcessList. Use on an individual Transform
916  * (i.e. MatrixTransform, etc.) to get/set the name of the corresponding process node.
917  */
918 extern OCIOEXPORT const char * METADATA_NAME;
919 
920 /**
921  * An ID string -- used as an "id" attribute in CLF/CTF elements. Use on a GroupTransform
922  * to get/set the id for the CLF/CTF ProcessList. Use on an individual Transform
923  * (i.e. MatrixTransform, etc.) to get/set the id of the corresponding process node.
924  */
925 extern OCIOEXPORT const char * METADATA_ID;
926 
927 /** @}*/
928 
929 /** \defgroup VarsCaches
930  * @{
931  */
932 
933 /*!rst::
934 Caches
935 ******
936 
937 */
938 
939 //!rst::
940 // .. c:var:: const char * OCIO_DISABLE_ALL_CACHES
941 //
942 // Disable all caches, including for FileTransforms and Optimized/CPU/GPU Processors. (Provided only
943 // to facilitate developer investigations.)
944 extern OCIOEXPORT const char * OCIO_DISABLE_ALL_CACHES;
945 
946 //!rst::
947 // .. c:var:: const char * OCIO_DISABLE_PROCESSOR_CACHES
948 //
949 // Disable only the Optimized, CPU, and GPU Processor caches. (Provided only to facilitate developer
950 // investigations.)
951 extern OCIOEXPORT const char * OCIO_DISABLE_PROCESSOR_CACHES;
952 
953 //!rst::
954 // .. c:var:: const char * OCIO_DISABLE_CACHE_FALLBACK
955 //
956 // By default the processor caches check for identical color transformations when cache keys do
957 // not match. That fallback introduces a major performance hit in some cases so there is an env.
958 // variable to disable the fallback.
959 extern OCIOEXPORT const char * OCIO_DISABLE_CACHE_FALLBACK;
960 
961 /** @}*/
962 
963 } // namespace OCIO_NAMESPACE
964 
965 #endif
OCIO_SHARED_PTR< const ExponentWithLinearTransform > ConstExponentWithLinearTransformRcPtr
OCIO_SHARED_PTR< const LegacyViewingPipeline > ConstLegacyViewingPipelineRcPtr
Algorithm used in ACES Output Transforms through v0.7.
ASC CDL specification v1.2.
OCIO_SHARED_PTR< DisplayViewTransform > DisplayViewTransformRcPtr
Represents exponent transform: pow( clamp(color), value ).
OCIO_SHARED_PTR< const GpuShaderCreator > ConstGpuShaderCreatorRcPtr
OCIO_SHARED_PTR< const ViewTransform > ConstViewTransformRcPtr
Linearly extrapolate the curve for negative values.
OCIO_SHARED_PTR< const LogAffineTransform > ConstLogAffineTransformRcPtr
OCIOEXPORT const char * InterpolationToString(Interpolation interp)
Image gamma value (double floating point value)
OCIOEXPORT EnvironmentMode EnvironmentModeFromString(const char *s)
This class holds the GPU-related information needed to build a shader program from a specific process...
Definition: OpenColorIO.h:3070
cubic interpolation (not supported)
OCIO_SHARED_PTR< LookTransform > LookTransformRcPtr
OCIOEXPORT const char * RangeStyleToString(RangeStyle style)
OCIO_SHARED_PTR< ViewingRules > ViewingRulesRcPtr
OCIO_SHARED_PTR< GpuShaderCreator > GpuShaderCreatorRcPtr
Classic RGB to HSV function.
std::array< float, 3 > Float3
Image contrast value (double floating point value)
RangeStyle
A RangeTransform may be set to clamp the values, or not.
OCIOEXPORT const char * GradingStyleToString(GradingStyle style)
ChannelOrdering
Used by PackedImageDesc to indicate the channel ordering of the image to process. ...
This is a light-weight wrapper around an image, that provides a context for pixel access...
Definition: OpenColorIO.h:2495
OCIO_SHARED_PTR< const LogCameraTransform > ConstLogCameraTransformRcPtr
Algorithms for Scene Linear color spaces.
OCIO_SHARED_PTR< Processor > ProcessorRcPtr
OCIO_SHARED_PTR< const ColorSpaceMenuHelper > ConstColorSpaceMenuHelperRcPtr
Represents a 1D-LUT transform.
OCIOEXPORT const char * ROLE_TEXTURE_PAINT
OCIO_SHARED_PTR< ExponentTransform > ExponentTransformRcPtr
OpenGL ES Shading Language.
ACES 1.3 Parametric Gamut Compression (expects ACEScg values)
OCIO_SHARED_PTR< DynamicPropertyGradingTone > DynamicPropertyGradingToneRcPtr
OCIOEXPORT const char * ROLE_COLOR_PICKING
"color_picking"
OCIOEXPORT const char * ROLE_INTERCHANGE_SCENE
OCIOEXPORT Allocation AllocationFromString(const char *s)
OCIO_SHARED_PTR< ColorSpaceMenuParameters > ColorSpaceMenuParametersRcPtr
OptimizationFlags
Provides control over how the ops in a Processor are combined in order to improve performance...
Interface used to access dynamic property double value.
OCIO_SHARED_PTR< const GpuShaderDesc > ConstGpuShaderDescRcPtr
OCIO_SHARED_PTR< AllocationTransform > AllocationTransformRcPtr
OCIO_SHARED_PTR< const Transform > ConstTransformRcPtr
GLint level
Definition: glcorearb.h:108
OCIO_SHARED_PTR< const ExponentTransform > ConstExponentTransformRcPtr
OCIO_SHARED_PTR< GPUProcessor > GPUProcessorRcPtr
OCIO_SHARED_PTR< FileRules > FileRulesRcPtr
Replace identity ops (other than gamma).
OCIOEXPORT const char * OCIO_ACTIVE_DISPLAYS_ENVVAR
An exception class to throw for errors detected at runtime.
Definition: OpenColorIO.h:76
OCIO_SHARED_PTR< const BuiltinTransformRegistry > ConstBuiltinTransformRegistryRcPtr
OCIO_SHARED_PTR< const DynamicPropertyGradingPrimary > ConstDynamicPropertyGradingPrimaryRcPtr
OCIOEXPORT const char * ROLE_SCENE_LINEAR
"scene_linear"
OCIOEXPORT const char * OCIO_DISABLE_PROCESSOR_CACHES
rst::
OCIO_SHARED_PTR< Lut1DTransform > Lut1DTransformRcPtr
OCIOEXPORT const char * NegativeStyleToString(NegativeStyle style)
#define OCIO_NAMESPACE
Definition: OpenColorABI.h:8
OCIO_SHARED_PTR< const ExposureContrastTransform > ConstExposureContrastTransformRcPtr
OCIO_SHARED_PTR< LogCameraTransform > LogCameraTransformRcPtr
Positive curve is rotated 180 degrees around the origin to handle negatives.
DynamicPropertyType
Types for dynamic properties.
Open Shading Language.
Interface used to access dynamic property GradingTone value.
CIE XYZ to 1976 CIELUV colour space (D65 white)
OCIO_SHARED_PTR< const Lut3DTransform > ConstLut3DTransformRcPtr
OCIO_SHARED_PTR< const CDLTransform > ConstCDLTransformRcPtr
CIE XYZ to 1931 xy chromaticity coordinates.
Clamp negative values.
OCIO_SHARED_PTR< FixedFunctionTransform > FixedFunctionTransformRcPtr
OCIO_SHARED_PTR< LegacyViewingPipeline > LegacyViewingPipelineRcPtr
the 'best' suitable interpolation type
OCIO_SHARED_PTR< const NamedTransform > ConstNamedTransformRcPtr
OCIOEXPORT BitDepth BitDepthFromString(const char *s)
OCIO_SHARED_PTR< const MixingColorSpaceManager > ConstMixingColorSpaceManagerRcPtr
OCIO_SHARED_PTR< DynamicPropertyGradingRGBCurve > DynamicPropertyGradingRGBCurveRcPtr
OCIO_SHARED_PTR< ExponentWithLinearTransform > ExponentWithLinearTransformRcPtr
OCIOEXPORT const char * LoggingLevelToString(LoggingLevel level)
the reference space for display color spaces
OCIOEXPORT const char * CDLStyleToString(CDLStyle style)
GpuLanguage
Used when there is a choice of hardware shader language.
ProcessorCacheFlags
cpp:type:: Enum to control the behavior of the internal caches e.g. the processor cache in ...
OCIO_SHARED_PTR< const ColorSpaceMenuParameters > ConstColorSpaceMenuParametersRcPtr
OCIOEXPORT const char * METADATA_INFO
OCIO_SHARED_PTR< const LogTransform > ConstLogTransformRcPtr
OCIO_SHARED_PTR< Look > LookRcPtr
OCIO_SHARED_PTR< const RangeTransform > ConstRangeTransformRcPtr
OCIOEXPORT bool BoolFromString(const char *s)
OCIO_SHARED_PTR< const ProcessorMetadata > ConstProcessorMetadataRcPtr
OCIO_SHARED_PTR< const GroupTransform > ConstGroupTransformRcPtr
OCIOEXPORT LoggingLevel LoggingLevelFromString(const char *s)
Replace a pair of ops where one is the inverse of the other.
OCIO_SHARED_PTR< ColorSpaceTransform > ColorSpaceTransformRcPtr
OCIO_SHARED_PTR< const FileTransform > ConstFileTransformRcPtr
OCIOEXPORT const char * AllocationToString(Allocation allocation)
OCIO_SHARED_PTR< const Context > ConstContextRcPtr
Vector of floats (size is set by uniform).
OCIO_SHARED_PTR< ProcessorMetadata > ProcessorMetadataRcPtr
OCIO_SHARED_PTR< const CPUProcessor > ConstCPUProcessorRcPtr
Interface used to access dynamic property ConstGradingRGBCurveRcPtr value.
Algorithms for Logarithmic color spaces.
OCIO_SHARED_PTR< DynamicPropertyDouble > DynamicPropertyDoubleRcPtr
OCIO_SHARED_PTR< Lut3DTransform > Lut3DTransformRcPtr
ACES 0.7 Gamut clamping algorithm – NOT IMPLEMENTED YET.
OCIOEXPORT const char * EnvironmentModeToString(EnvironmentMode mode)
OCIO_SHARED_PTR< const DynamicPropertyGradingRGBCurve > ConstDynamicPropertyGradingRGBCurveRcPtr
OCIO_SHARED_PTR< ExposureContrastTransform > ExposureContrastTransformRcPtr
OCIO_SHARED_PTR< const Baker > ConstBakerRcPtr
OCIOEXPORT const char * METADATA_NAME
OCIOEXPORT const char * GpuLanguageToString(GpuLanguage language)
E/C to be applied to a linear space image.
OCIOEXPORT TransformDirection TransformDirectionFromString(const char *s)
Will throw if string is not recognized.
OCIO_SHARED_PTR< Baker > BakerRcPtr
OCIO_SHARED_PTR< LogTransform > LogTransformRcPtr
Image exposure value (double floating point value)
OCIO_SHARED_PTR< MixingColorSpaceManager > MixingColorSpaceManagerRcPtr
GLuint interp
Definition: glew.h:8307
OCIOEXPORT GradingStyle GradingStyleFromString(const char *s)
OCIOEXPORT const char * ROLE_MATTE_PAINT
A config defines all the color spaces to be available at runtime.
Definition: OpenColorIO.h:236
OCIOEXPORT TransformDirection CombineTransformDirections(TransformDirection d1, TransformDirection d2)
OCIOEXPORT const char * METADATA_DESCRIPTION
Used by GradingRGBCurveTransform.
For quite lossy optimizations.
linear interpolation (trilinear for Lut3D)
Vector of int pairs (size is set by uniform).
OCIOEXPORT const char * ExposureContrastStyleToString(ExposureContrastStyle style)
std::function< void(const char *)> LoggingFunction
Define the logging function signature.
OCIOEXPORT GpuLanguage GpuLanguageFromString(const char *s)
OCIO_SHARED_PTR< CPUProcessor > CPUProcessorRcPtr
the default interpolation type
#define OCIOEXPORT
Definition: OpenColorABI.h:67
OCIO_SHARED_PTR< const LookTransform > ConstLookTransformRcPtr
OCIOEXPORT const char * ROLE_DEFAULT
"default"
OCIO_SHARED_PTR< const ColorSpaceTransform > ConstColorSpaceTransformRcPtr
OCIO_SHARED_PTR< GradingPrimaryTransform > GradingPrimaryTransformRcPtr
Here for historical reason but that's not supported.
OCIO_SHARED_PTR< GradingBSplineCurve > GradingBSplineCurveRcPtr
OCIO_SHARED_PTR< const Processor > ConstProcessorRcPtr
OCIOEXPORT const char * METADATA_INPUT_DESCRIPTOR
OCIO_SHARED_PTR< const ColorSpaceSet > ConstColorSpaceSetRcPtr
OCIO_SHARED_PTR< const FileRules > ConstFileRulesRcPtr
OCIOEXPORT const char * OCIO_DISABLE_ALL_CACHES
rst::
OCIO_SHARED_PTR< const ImageDesc > ConstImageDescRcPtr
OCIO_SHARED_PTR< GradingRGBCurve > GradingRGBCurveRcPtr
An implementation of the ASC Color Decision List (CDL), based on the ASC v1.2 specification.
Base class for all the transform classes.
OCIO_SHARED_PTR< MatrixTransform > MatrixTransformRcPtr
UniformDataType
Types for uniform data.
OCIOEXPORT const char * FixedFunctionStyleToString(FixedFunctionStyle style)
OCIO_SHARED_PTR< Transform > TransformRcPtr
Weighted Yellow Power Norm – NOT IMPLEMENTED YET.
OCIOEXPORT const char * ROLE_REFERENCE
"reference"
GLenum mode
Definition: glcorearb.h:99
GradingStyle
Styles for grading transforms.
OCIO_SHARED_PTR< const DisplayViewTransform > ConstDisplayViewTransformRcPtr
OCIOEXPORT NegativeStyle NegativeStyleFromString(const char *style)
std::function< std::string(const std::string &)> ComputeHashFunction
Define Compute Hash function signature.
OCIOEXPORT const char * OCIO_CONFIG_ENVVAR
The envvar 'OCIO' provides a path to the config file used by Config::CreateFromEnv.
OCIO_SHARED_PTR< const Lut1DTransform > ConstLut1DTransformRcPtr
OCIO_SHARED_PTR< const SystemMonitors > ConstSystemMonitorsRcPtr
OCIOEXPORT const char * OCIO_DISABLE_CACHE_FALLBACK
rst::
OCIOEXPORT const char * OCIO_VIEW_USE_DISPLAY_NAME
OCIO_SHARED_PTR< ColorSpaceSet > ColorSpaceSetRcPtr
OCIO_SHARED_PTR< SystemMonitors > SystemMonitorsRcPtr
OCIOEXPORT const char * ROLE_COLOR_TIMING
"color_timing"
CDL that does not clamp.
OCIOEXPORT const char * OCIO_INACTIVE_COLORSPACES_ENVVAR
OCIO_SHARED_PTR< ColorSpaceMenuHelper > ColorSpaceMenuHelperRcPtr
GLuint GLfloat * val
Definition: glcorearb.h:1608
OCIO_SHARED_PTR< const Config > ConstConfigRcPtr
Compose a pair of ops into a single op.
OCIO_SHARED_PTR< RangeTransform > RangeTransformRcPtr
OCIO_SHARED_PTR< GradingToneTransform > GradingToneTransformRcPtr
OCIO_SHARED_PTR< NamedTransform > NamedTransformRcPtr
OCIO_SHARED_PTR< const MatrixTransform > ConstMatrixTransformRcPtr
OCIOEXPORT FixedFunctionStyle FixedFunctionStyleFromString(const char *style)
OCIO_SHARED_PTR< const Look > ConstLookRcPtr
OCIO_SHARED_PTR< const BuiltinTransform > ConstBuiltinTransformRcPtr
the main scene reference space
E/C to be applied to a video space image.
OCIO_SHARED_PTR< DynamicPropertyGradingPrimary > DynamicPropertyGradingPrimaryRcPtr
OCIOEXPORT const char * METADATA_OUTPUT_DESCRIPTOR
OCIO_SHARED_PTR< const GradingRGBCurveTransform > ConstGradingRGBCurveTransformRcPtr
OCIO_SHARED_PTR< const AllocationTransform > ConstAllocationTransformRcPtr
Interface used to access dynamic property GradingPrimary value.
OCIOEXPORT const char * BoolToString(bool val)
OCIO_SHARED_PTR< Config > ConfigRcPtr
OCIO_SHARED_PTR< const FixedFunctionTransform > ConstFixedFunctionTransformRcPtr
E/C to be applied to a log space image.
Rec.2100 surround correction (takes one double for the gamma param)
OCIO_SHARED_PTR< BuiltinTransform > BuiltinTransformRcPtr
OCIO_SHARED_PTR< Context > ContextRcPtr
OCIO_SHARED_PTR< FileTransform > FileTransformRcPtr
OCIO_SHARED_PTR< BuiltinTransformRegistry > BuiltinTransformRegistryRcPtr
OCIO_SHARED_PTR< const GradingPrimaryTransform > ConstGradingPrimaryTransformRcPtr
OCIOEXPORT Interpolation InterpolationFromString(const char *s)
auto ptr(T p) -> const void *
Definition: format.h:2448
OCIO_SHARED_PTR< ImageDesc > ImageDescRcPtr
OCIOEXPORT RangeStyle RangeStyleFromString(const char *style)
OCIO_SHARED_PTR< const DynamicProperty > ConstDynamicPropertyRcPtr
Apply all possible optimizations.
Lut1DHueAdjust
Used by :cpp:classLut1DTransform to control optional hue restoration algorithm.
OCIOEXPORT const char * ROLE_DATA
"data"
OCIOEXPORT ExposureContrastStyle ExposureContrastStyleFromString(const char *style)
OCIO_SHARED_PTR< const GradingBSplineCurve > ConstGradingBSplineCurveRcPtr
OCIOEXPORT CDLStyle CDLStyleFromString(const char *style)
OCIOEXPORT const char * OCIO_USER_CATEGORIES_ENVVAR
OCIO_SHARED_PTR< LogAffineTransform > LogAffineTransformRcPtr
OCIOEXPORT int BitDepthToInt(BitDepth bitDepth)
OCIO_SHARED_PTR< GpuShaderDesc > GpuShaderDescRcPtr
OCIOEXPORT const char * OCIO_OPTIMIZATION_FLAGS_ENVVAR
FixedFunctionStyle
Enumeration of the :cpp:class:FixedFunctionTransform transform algorithms.
OCIO_SHARED_PTR< GroupTransform > GroupTransformRcPtr
Represents a 3D-LUT transform.
ACES 0.2 Gamut clamping algorithm – NOT IMPLEMENTED YET.
OCIO_SHARED_PTR< const DynamicPropertyGradingTone > ConstDynamicPropertyGradingToneRcPtr
OCIOEXPORT const char * TransformDirectionToString(TransformDirection dir)
OCIOEXPORT TransformDirection GetInverseTransformDirection(TransformDirection dir)
OCIO_SHARED_PTR< CDLTransform > CDLTransformRcPtr
OCIO_SHARED_PTR< const GradingToneTransform > ConstGradingToneTransformRcPtr
OCIOEXPORT bool BitDepthIsFloat(BitDepth bitDepth)
OCIO_SHARED_PTR< const ViewingRules > ConstViewingRulesRcPtr
OCIO_SHARED_PTR< GradingRGBCurveTransform > GradingRGBCurveTransformRcPtr
A BSpline curve defined with GradingControlPoint.
OCIO_SHARED_PTR< ColorSpace > ColorSpaceRcPtr
GLdouble s
Definition: glew.h:1395
OCIO_SHARED_PTR< const GradingRGBCurve > ConstGradingRGBCurveRcPtr
OpenGL ES Shading Language.
This class contains meta information about the process that generated this processor. The results of these functions do not impact the pixel processing.
Definition: OpenColorIO.h:2324
OCIO_SHARED_PTR< const DynamicPropertyDouble > ConstDynamicPropertyDoubleRcPtr
tetrahedral interpolation (Lut3D only)
OCIO_SHARED_PTR< const ColorSpace > ConstColorSpaceRcPtr
CIE XYZ to 1976 u'v' chromaticity coordinates.
Negative values are passed through unchanged.
RGBCurveType
Types for GradingRGBCurve.
OCIOEXPORT const char * OCIO_ACTIVE_VIEWS_ENVVAR
OCIOEXPORT const char * ROLE_INTERCHANGE_DISPLAY
Dark to dim surround correction (ACES 1.0)
OCIO_SHARED_PTR< T > DynamicPtrCast(OCIO_SHARED_PTR< U > const &ptr)
OCIO_SHARED_PTR< const GPUProcessor > ConstGPUProcessorRcPtr
OCIOEXPORT const char * BitDepthToString(BitDepth bitDepth)
OCIOEXPORT const char * METADATA_ID
OCIOEXPORT const char * ROLE_RENDERING
The File Rules are a set of filepath to color space mappings that are evaluated from first to last...
Definition: OpenColorIO.h:1203
OCIO_SHARED_PTR< ViewTransform > ViewTransformRcPtr
Algorithms for Video color spaces.
ExposureContrastStyle
Enumeration of the :cpp:class:ExposureContrastTransform transform algorithms.
OCIOEXPORT const char * ROLE_COMPOSITING_LOG
"compositing_log"
OCIO_SHARED_PTR< DynamicProperty > DynamicPropertyRcPtr