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 {
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 };
450 
452 {
456 };
457 
458 /// A RangeTransform may be set to clamp the values, or not.
460 {
463 };
464 
465 /// Enumeration of the :cpp:class:`FixedFunctionTransform` transform algorithms.
467 {
468  FIXED_FUNCTION_ACES_RED_MOD_03 = 0, ///< Red modifier (ACES 0.3/0.7)
469  FIXED_FUNCTION_ACES_RED_MOD_10, ///< Red modifier (ACES 1.0)
470  FIXED_FUNCTION_ACES_GLOW_03, ///< Glow function (ACES 0.3/0.7)
471  FIXED_FUNCTION_ACES_GLOW_10, ///< Glow function (ACES 1.0)
472  FIXED_FUNCTION_ACES_DARK_TO_DIM_10, ///< Dark to dim surround correction (ACES 1.0)
473  FIXED_FUNCTION_REC2100_SURROUND, ///< Rec.2100 surround correction (takes one double for the gamma param)
474  FIXED_FUNCTION_RGB_TO_HSV, ///< Classic RGB to HSV function
475  FIXED_FUNCTION_XYZ_TO_xyY, ///< CIE XYZ to 1931 xy chromaticity coordinates
476  FIXED_FUNCTION_XYZ_TO_uvY, ///< CIE XYZ to 1976 u'v' chromaticity coordinates
477  FIXED_FUNCTION_XYZ_TO_LUV, ///< CIE XYZ to 1976 CIELUV colour space (D65 white)
478  FIXED_FUNCTION_ACES_GAMUTMAP_02, ///< ACES 0.2 Gamut clamping algorithm -- NOT IMPLEMENTED YET
479  FIXED_FUNCTION_ACES_GAMUTMAP_07, ///< ACES 0.7 Gamut clamping algorithm -- NOT IMPLEMENTED YET
480  FIXED_FUNCTION_ACES_GAMUTMAP_13 ///< ACES 1.3 Gamut mapping algorithm -- NOT IMPLEMENTED YET
481 };
482 
483 /// Enumeration of the :cpp:class:`ExposureContrastTransform` transform algorithms.
485 {
486  EXPOSURE_CONTRAST_LINEAR = 0, ///< E/C to be applied to a linear space image
487  EXPOSURE_CONTRAST_VIDEO, ///< E/C to be applied to a video space image
488  EXPOSURE_CONTRAST_LOGARITHMIC ///< E/C to be applied to a log space image
489 };
490 
491 /**
492  * Enumeration of the :cpp:class:`CDLTransform` transform algorithms.
493  *
494  * \note
495  * The default for reading .cc/.ccc/.cdl files, config file YAML, and CDLTransform is no-clamp,
496  * since that is what is primarily desired in VFX. However, the CLF format default is ASC.
497  */
499 {
500  CDL_ASC = 0, ///< ASC CDL specification v1.2
501  CDL_NO_CLAMP, ///< CDL that does not clamp
503 };
504 
505 /**
506  * Negative values handling style for \ref ExponentTransform and
507  * \ref ExponentWithLinearTransform transform algorithms.
508  */
510 {
511  NEGATIVE_CLAMP = 0, ///< Clamp negative values
512  NEGATIVE_MIRROR, ///< Positive curve is rotated 180 degrees around the origin to handle negatives.
513  NEGATIVE_PASS_THRU, ///< Negative values are passed through unchanged.
514  NEGATIVE_LINEAR ///< Linearly extrapolate the curve for negative values.
515 };
516 
517 /// Styles for grading transforms.
519 {
520  GRADING_LOG = 0, ///< Algorithms for Logarithmic color spaces.
521  GRADING_LIN, ///< Algorithms for Scene Linear color spaces.
522  GRADING_VIDEO ///< Algorithms for Video color spaces.
523 };
524 
525 /// Types for dynamic properties.
527 {
528  DYNAMIC_PROPERTY_EXPOSURE = 0, ///< Image exposure value (double floating point value)
529  DYNAMIC_PROPERTY_CONTRAST, ///< Image contrast value (double floating point value)
530  DYNAMIC_PROPERTY_GAMMA, ///< Image gamma value (double floating point value)
531  DYNAMIC_PROPERTY_GRADING_PRIMARY, ///< Used by GradingPrimaryTransform
532  DYNAMIC_PROPERTY_GRADING_RGBCURVE, ///< Used by GradingRGBCurveTransform
533  DYNAMIC_PROPERTY_GRADING_TONE ///< Used by GradingToneTransform
534 };
535 
536 /// Types for GradingRGBCurve.
538 {
539  RGB_RED = 0,
544 };
545 
546 /// Types for uniform data.
548 {
551  UNIFORM_FLOAT3, ///< Array of 3 floats.
552  UNIFORM_VECTOR_FLOAT, ///< Vector of floats (size is set by uniform).
553  UNIFORM_VECTOR_INT, ///< Vector of int pairs (size is set by uniform).
555 };
556 
557 /// Provides control over how the ops in a Processor are combined in order to improve performance.
558 enum OptimizationFlags : unsigned long
559 {
560  // Below are listed all the optimization types.
561 
562  /// Do not optimize.
563  OPTIMIZATION_NONE = 0x00000000,
564 
565  /// Replace identity ops (other than gamma).
566  OPTIMIZATION_IDENTITY = 0x00000001,
567  /// Replace identity gamma ops.
569 
570  /// Replace a pair of ops where one is the inverse of the other.
579 
580  /// Compose a pair of ops into a single op.
587 
588  /**
589  * For integer and half bit-depths only, replace separable ops (i.e. no channel crosstalk
590  * ops) by a single 1D LUT of input bit-depth domain.
591  */
593 
594  /**
595  * Implement inverse Lut1D and Lut3D evaluations using a a forward LUT (faster but less
596  * accurate). Note that GPU evals always do FAST.
597  */
599 
600  // For CPU processor, in SSE mode, use a faster approximation for log, exp, and pow.
602 
603  // Break down certain ops into simpler components where possible. For example, convert a CDL
604  // to a matrix when possible.
606 
607  /**
608  * Turn off dynamic control of any ops that offer adjustment of parameter values after
609  * finalization (e.g. ExposureContrast).
610  */
612 
613  /// Apply all possible optimizations.
614  OPTIMIZATION_ALL = 0xFFFFFFFF,
615 
616  // The following groupings of flags are provided as a convenient way to select an overall
617  // optimization level.
618 
634 
640 
642 
643  /// For quite lossy optimizations.
645 
647 };
648 
649 //!cpp:type:: Enum to control the behavior of the internal caches e.g. the processor cache in
650 // :cpp:class:`Config` and :cpp:class:`Processor` instances. When debugging problems, it be useful
651 // to disable all the internal caches for example.
652 //
653 // The PROCESSOR_CACHE_SHARE_DYN_PROPERTIES flag allows the reuse of existing processor instances
654 // even if it contains some dynamic properties i.e. it speeds up the processor retrieval. That's the
655 // default behavior to avoid the processor creation hit. However, the caller app must then always
656 // set the dynamic property values prior to any color processing call (in CPU and GPU modes) as the
657 // same processor instance can now be used between several viewports for example.
658 enum ProcessorCacheFlags : unsigned int
659 {
661  PROCESSOR_CACHE_ENABLED = 0x01, // Enable the cache.
662  PROCESSOR_CACHE_SHARE_DYN_PROPERTIES = 0x02, // i.e. When the cache is enabled processor instances
663  // are shared even if they contain some dynamic
664  // properties.
665 
667 };
668 
669 // Conversion
670 
671 extern OCIOEXPORT const char * BoolToString(bool val);
672 extern OCIOEXPORT bool BoolFromString(const char * s);
673 
675 extern OCIOEXPORT LoggingLevel LoggingLevelFromString(const char * s);
676 
678 /// Will throw if string is not recognized.
680 
683  TransformDirection d2);
684 
685 extern OCIOEXPORT const char * BitDepthToString(BitDepth bitDepth);
686 extern OCIOEXPORT BitDepth BitDepthFromString(const char * s);
687 extern OCIOEXPORT bool BitDepthIsFloat(BitDepth bitDepth);
688 extern OCIOEXPORT int BitDepthToInt(BitDepth bitDepth);
689 
690 extern OCIOEXPORT const char * AllocationToString(Allocation allocation);
691 extern OCIOEXPORT Allocation AllocationFromString(const char * s);
692 
695 
696 extern OCIOEXPORT const char * GpuLanguageToString(GpuLanguage language);
697 extern OCIOEXPORT GpuLanguage GpuLanguageFromString(const char * s);
698 
701 
702 extern OCIOEXPORT const char * CDLStyleToString(CDLStyle style);
703 extern OCIOEXPORT CDLStyle CDLStyleFromString(const char * style);
704 
705 extern OCIOEXPORT const char * RangeStyleToString(RangeStyle style);
706 extern OCIOEXPORT RangeStyle RangeStyleFromString(const char * style);
707 
708 extern OCIOEXPORT const char * FixedFunctionStyleToString(FixedFunctionStyle style);
710 
711 extern OCIOEXPORT const char * GradingStyleToString(GradingStyle style);
712 extern OCIOEXPORT GradingStyle GradingStyleFromString(const char * s);
713 
716 
717 extern OCIOEXPORT const char * NegativeStyleToString(NegativeStyle style);
718 extern OCIOEXPORT NegativeStyle NegativeStyleFromString(const char * style);
719 
720 /** \defgroup Env. variables.
721  * @{
722  *
723  * These environmental variables are used by the OpenColorIO library.
724  * For variables that allow specifying more than one token, they should be separated by commas.
725  */
726 
727 // These variables are defined in src/OpenColorIO/Config.cpp.
728 
729 
730 /// The envvar 'OCIO' provides a path to the config file used by \ref Config::CreateFromEnv
731 extern OCIOEXPORT const char * OCIO_CONFIG_ENVVAR;
732 
733 /**
734  * The envvar 'OCIO_ACTIVE_DISPLAYS' provides a list of displays overriding the 'active_displays'
735  * list from the config file.
736  */
737 extern OCIOEXPORT const char * OCIO_ACTIVE_DISPLAYS_ENVVAR;
738 
739 /**
740  * The envvar 'OCIO_ACTIVE_VIEWS' provides a list of views overriding the 'active_views'
741  * list from the config file.
742  */
743 extern OCIOEXPORT const char * OCIO_ACTIVE_VIEWS_ENVVAR;
744 
745 /**
746  * The envvar 'OCIO_INACTIVE_COLORSPACES' provides a list of inactive color spaces
747  * overriding the 'inactive_color_spaces' list from the config file.
748  */
749 extern OCIOEXPORT const char * OCIO_INACTIVE_COLORSPACES_ENVVAR;
750 
751 /**
752  * The envvar 'OCIO_OPTIMIZATION_FLAGS' provides a way to force a given optimization level.
753  * Remove the variable or set the value to empty to not use it. Set the value of the variable
754  * to the desired optimization level as either an integer or hexadecimal value.
755  * Ex: OCIO_OPTIMIZATION_FLAGS="20479" or "0x4FFF" for OPTIMIZATION_LOSSLESS.
756  */
757 extern OCIOEXPORT const char * OCIO_OPTIMIZATION_FLAGS_ENVVAR;
758 
759 /**
760  * The envvar 'OCIO_USER_CATEGORIES' allows the end-user to filter color spaces shown by
761  * applications. Only color spaces that include at least one of the supplied categories will be
762  * shown in application menus. Note that applications may also impose their own category filtering
763  * in addition to the user-supplied categories. For example, an application may filter by
764  * 'working-space' for a menu to select a working space while the user may also filter by
765  * '3d-basic' to only show spaces intended for 3d artists who should see the basic set of color
766  * spaces. The categories will be ignored if they would result in no color spaces being found.
767  */
768 extern OCIOEXPORT const char * OCIO_USER_CATEGORIES_ENVVAR;
769 
770 /** @}*/
771 
772 /** \defgroup VarsRoles
773  * @{
774  */
775 
776 // TODO: Move to .rst
777 /*!rst::
778 Roles
779 *****
780 
781 ColorSpace Roles are used so that plugins, in addition to this API can have
782 abstract ways of asking for common colorspaces, without referring to them
783 by hardcoded names.
784 
785 Internal::
786  Extracting color space from file path - (ROLE_DEFAULT)
787  Interchange color spaces between configs - (ROLE_EXCHANGE_SCENE, ROLE_EXCHANGE_DISPLAY)
788 
789 App Helpers::
790  LegacyViewingPipeline - (ROLE_SCENE_LINEAR (LinearCC for exposure))
791  (ROLE_COLOR_TIMING (ColorTimingCC))
792  MixingColorSpaceManager - (ROLE_COLOR_PICKING)
793 
794 External Plugins (currently known)::
795 
796  Colorpicker UIs - (ROLE_COLOR_PICKING)
797  Compositor LogConvert - (ROLE_SCENE_LINEAR, ROLE_COMPOSITING_LOG)
798 
799 */
800 
801 /// "default"
802 extern OCIOEXPORT const char * ROLE_DEFAULT;
803 /// "reference"
804 extern OCIOEXPORT const char * ROLE_REFERENCE;
805 /// "data"
806 extern OCIOEXPORT const char * ROLE_DATA;
807 /// "color_picking"
808 extern OCIOEXPORT const char * ROLE_COLOR_PICKING;
809 /// "scene_linear"
810 extern OCIOEXPORT const char * ROLE_SCENE_LINEAR;
811 /// "compositing_log"
812 extern OCIOEXPORT const char * ROLE_COMPOSITING_LOG;
813 /// "color_timing"
814 extern OCIOEXPORT const char * ROLE_COLOR_TIMING;
815 /**
816  * This role defines the transform for painting textures. In some
817  * workflows this is just a inverse display gamma with some limits
818  */
819 extern OCIOEXPORT const char * ROLE_TEXTURE_PAINT;
820 /**
821  * This role defines the transform for matte painting. In some workflows
822  * this is a 1D HDR to LDR allocation. It is normally combined with
823  * another display transform in the host app for preview.
824  */
825 extern OCIOEXPORT const char * ROLE_MATTE_PAINT;
826 
827 /**
828  * The rendering role may be used to identify a specific color space to be used by CGI renderers.
829  * This is typically a scene-linear space but the primaries also matter since they influence the
830  * resulting color, especially in areas of indirect illumination.
831  */
832 extern OCIOEXPORT const char * ROLE_RENDERING;
833 /**
834  * The aces_interchange role is used to specify which color space in the config implements the
835  * standard ACES2065-1 color space (SMPTE ST2065-1). This may be used when converting
836  * scene-referred colors from one config to another.
837  */
838 extern OCIOEXPORT const char * ROLE_INTERCHANGE_SCENE;
839 /**
840  * The cie_xyz_d65_interchange role is used to specify which color space in the config implements
841  * CIE XYZ colorimetry with the neutral axis at D65. This may be used when converting
842  * display-referred colors from one config to another.
843  */
844 extern OCIOEXPORT const char * ROLE_INTERCHANGE_DISPLAY;
845 
846 /** @}*/
847 
848 /** \defgroup VarsSharedView
849  * @{
850  */
851 
852 /*!rst::
853 Shared View
854 ***********
855 
856 */
857 
858 /**
859  * A shared view using this for the color space name will use a display color space that
860  * has the same name as the display the shared view is used by.
861  */
862 extern OCIOEXPORT const char * OCIO_VIEW_USE_DISPLAY_NAME;
863 
864 /** @}*/
865 
866 /** \defgroup VarsFormatMetadata
867  * @{
868  */
869 
870 // TODO: Move to .rst
871 /*!rst::
872 FormatMetadata
873 **************
874 
875 These constants describe various types of rich metadata. They are used with FormatMetadata
876 objects as the "name" part of a (name, value) pair. All of these types of metadata are
877 supported in the CLF/CTF file formats whereas other formats support some or none of them.
878 
879 Although the string constants used here match those used in the CLF/CTF formats, the concepts
880 are generic, so the goal is for other file formats to reuse the same constants within a
881 FormatMetadata object (even if the syntax used in a given format is somewhat different).
882 
883 */
884 
885 /**
886  * A description string -- used as the "Description" element in CLF/CTF and CDL, and to
887  * hold comments for other LUT formats when baking.
888  */
889 extern OCIOEXPORT const char * METADATA_DESCRIPTION;
890 
891 /**
892  * A block of informative metadata such as the "Info" element in CLF/CTF.
893  * Usually contains child elements.
894  */
895 extern OCIOEXPORT const char * METADATA_INFO;
896 
897 /**
898  * A string describing the expected input color space -- used as the "InputDescriptor"
899  * element in CLF/CTF and the "InputDescription" in CDL.
900  */
901 extern OCIOEXPORT const char * METADATA_INPUT_DESCRIPTOR;
902 
903 /**
904  * A string describing the output color space -- used as the "OutputDescriptor" element
905  * in CLF/CTF and the "OutputDescription" in CDL.
906  */
907 extern OCIOEXPORT const char * METADATA_OUTPUT_DESCRIPTOR;
908 
909 /**
910  * A name string -- used as a "name" attribute in CLF/CTF elements. Use on a GroupTransform
911  * to get/set the name for the CLF/CTF ProcessList. Use on an individual Transform
912  * (i.e. MatrixTransform, etc.) to get/set the name of the corresponding process node.
913  */
914 extern OCIOEXPORT const char * METADATA_NAME;
915 
916 /**
917  * An ID string -- used as an "id" attribute in CLF/CTF elements. Use on a GroupTransform
918  * to get/set the id for the CLF/CTF ProcessList. Use on an individual Transform
919  * (i.e. MatrixTransform, etc.) to get/set the id of the corresponding process node.
920  */
921 extern OCIOEXPORT const char * METADATA_ID;
922 
923 /** @}*/
924 
925 /** \defgroup VarsCaches
926  * @{
927  */
928 
929 /*!rst::
930 Caches
931 ******
932 
933 */
934 
935 //!rst::
936 // .. c:var:: const char * OCIO_DISABLE_ALL_CACHES
937 //
938 // Disable all caches, including for FileTransforms and Optimized/CPU/GPU Processors. (Provided only
939 // to facilitate developer investigations.)
940 extern OCIOEXPORT const char * OCIO_DISABLE_ALL_CACHES;
941 
942 //!rst::
943 // .. c:var:: const char * OCIO_DISABLE_PROCESSOR_CACHES
944 //
945 // Disable only the Optimized, CPU, and GPU Processor caches. (Provided only to facilitate developer
946 // investigations.)
947 extern OCIOEXPORT const char * OCIO_DISABLE_PROCESSOR_CACHES;
948 
949 //!rst::
950 // .. c:var:: const char * OCIO_DISABLE_CACHE_FALLBACK
951 //
952 // By default the processor caches check for identical color transformations when cache keys do
953 // not match. That fallback introduces a major performance hit in some cases so there is an env.
954 // variable to disable the fallback.
955 extern OCIOEXPORT const char * OCIO_DISABLE_CACHE_FALLBACK;
956 
957 /** @}*/
958 
959 } // namespace OCIO_NAMESPACE
960 
961 #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)
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:2508
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
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:107
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:70
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.
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
ACES 1.3 Gamut mapping algorithm – NOT IMPLEMENTED YET.
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
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:53
OCIO_SHARED_PTR< const LookTransform > ConstLookTransformRcPtr
OCIOEXPORT const char * ROLE_DEFAULT
"default"
OCIO_SHARED_PTR< const ColorSpaceTransform > ConstColorSpaceTransformRcPtr
OCIO_SHARED_PTR< GradingPrimaryTransform > GradingPrimaryTransformRcPtr
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
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:98
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:1607
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
const void * ptr(const T *p)
Definition: format.h:3603
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)
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
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:2333
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
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