|
|
@@ -0,0 +1,344 @@
|
|
|
+//********************************** Banshee Engine (www.banshee3d.com) **************************************************//
|
|
|
+//**************** Copyright (c) 2016 Marko Pintera ([email protected]). All rights reserved. **********************//
|
|
|
+using System;
|
|
|
+using System.Runtime.CompilerServices;
|
|
|
+
|
|
|
+namespace BansheeEngine
|
|
|
+{
|
|
|
+ /// <summary>
|
|
|
+ /// Settings that control automatic exposure (eye adaptation) post-process.
|
|
|
+ /// </summary>
|
|
|
+ struct AutoExposureSettings // Note: Must match C++ struct AutoExposureSettings
|
|
|
+ {
|
|
|
+ /// <summary>
|
|
|
+ /// Determines minimum luminance value in the eye adaptation histogram. The histogram is used for calculating the
|
|
|
+ /// average brightness of the scene.Any luminance value below this value will not be included in the histogram and
|
|
|
+ /// ignored in scene brightness calculations. In log2 units (-8 = 1/256). In the range [-16, 0].
|
|
|
+ /// </summary>
|
|
|
+ public float HistogramLog2Min;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Determines maximum luminance value in the eye adaptation histogram. The histogram is used for calculating the
|
|
|
+ /// average brightness of the scene.Any luminance value above this value will not be included in the histogram and
|
|
|
+ /// ignored in scene brightness calculations. In log2 units (4 = 16). In the range [0, 16].
|
|
|
+ /// </summary>
|
|
|
+ public float HistogramLog2Max;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Percentage below which to ignore values in the eye adaptation histogram. The histogram is used for calculating
|
|
|
+ /// the average brightness of the scene.Total luminance in the histogram will be summed up and multiplied by this
|
|
|
+ /// value to calculate minimal luminance. Luminance values below the minimal luminance will be ignored and not used
|
|
|
+ /// in scene brightness calculations.This allows you to remove outliers on the lower end of the histogram (e.g. a
|
|
|
+ /// few very dark pixels in an otherwise bright image). In range [0.0f, 1.0f].
|
|
|
+ /// </summary>
|
|
|
+ public float HistogramPctLow;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Percentage above which to ignore values in the eye adaptation histogram. The histogram is used for calculating
|
|
|
+ /// the average brightness of the scene.Total luminance in the histogram will be summed up and multiplied by this
|
|
|
+ /// value to calculate maximum luminance. Luminance values above the maximum luminance will be ignored and not used
|
|
|
+ /// in scene brightness calculations.This allows you to remove outliers on the high end of the histogram (e.g. a few
|
|
|
+ /// very bright pixels). In range [0.0f, 1.0f].
|
|
|
+ /// </summary>
|
|
|
+ public float HistogramPctHigh;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Clamps the minimum eye adaptation scale to this value. This allows you to limit eye adaptation so that exposure
|
|
|
+ /// is never too high (e.g. when in a very dark room you probably do not want the exposure to be so high that
|
|
|
+ /// everything is still visible). In range [0.0f, 10.0f].
|
|
|
+ /// </summary>
|
|
|
+ public float MinEyeAdaptation;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Clamps the maximum eye adaptation scale to this value. This allows you to limit eye adaptation so that exposure
|
|
|
+ /// is never too low (e.g. when looking at a very bright light source you probably don't want the exposure to be so
|
|
|
+ /// low that the rest of the scene is all white (overexposed). In range [0.0f, 10.0f].
|
|
|
+ /// </summary>
|
|
|
+ public float MaxEyeAdaptation;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Determines how quickly does the eye adaptation adjust to larger values. This affects how quickly does the
|
|
|
+ /// automatic exposure changes when the scene brightness increases. In range [0.01f, 20.0f].
|
|
|
+ /// </summary>
|
|
|
+ public float EyeAdaptationSpeedUp;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Determines how quickly does the eye adaptation adjust to smaller values. This affects how quickly does the
|
|
|
+ /// automatic exposure changes when the scene brightness decreases. In range [0.01f, 20.0f].
|
|
|
+ /// </summary>
|
|
|
+ public float EyeAdaptationSpeedDown;
|
|
|
+ };
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Settings that control tonemap post-process.
|
|
|
+ /// </summary>
|
|
|
+ struct TonemappingSettings // Note: Must match C++ struct TonemappingSettings
|
|
|
+ {
|
|
|
+ /// <summary>
|
|
|
+ /// Controls the shoulder (upper non-linear) section of the filmic curve used for tonemapping. Mostly affects bright
|
|
|
+ /// areas of the image and allows you to reduce over-exposure.
|
|
|
+ /// </summary>
|
|
|
+ public float FilmicCurveShoulderStrength;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Controls the linear (middle) section of the filmic curve used for tonemapping. Mostly affects mid-range areas of
|
|
|
+ /// the image.
|
|
|
+ /// </summary>
|
|
|
+ public float FilmicCurveLinearStrength;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Controls the linear (middle) section of the filmic curve used for tonemapping. Mostly affects mid-range areas of
|
|
|
+ /// the image and allows you to control how quickly does the curve climb.
|
|
|
+ /// </summary>
|
|
|
+ public float FilmicCurveLinearAngle;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Controls the toe (lower non-linear) section of the filmic curve used for tonemapping. Mostly affects dark areas
|
|
|
+ /// of the image and allows you to reduce under-exposure.
|
|
|
+ /// </summary>
|
|
|
+ public float FilmicCurveToeStrength;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Controls the toe (lower non-linear) section of the filmic curve. used for tonemapping. Affects low-range.
|
|
|
+ /// </summary>
|
|
|
+ public float FilmicCurveToeNumerator;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Controls the toe (lower non-linear) section of the filmic curve used for tonemapping. Affects low-range.
|
|
|
+ /// </summary>
|
|
|
+ public float FilmicCurveToeDenominator;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Controls the white point of the filmic curve used for tonemapping. Affects the entire curve.
|
|
|
+ /// </summary>
|
|
|
+ public float FilmicCurveLinearWhitePoint;
|
|
|
+ };
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Settings that control white balance post-process.
|
|
|
+ /// </summary>
|
|
|
+ struct WhiteBalanceSettings // Note: Must match C++ struct WhiteBalanceSettings
|
|
|
+ {
|
|
|
+ /// <summary>
|
|
|
+ /// Temperature used for white balancing, in Kelvins.
|
|
|
+ ///
|
|
|
+ /// Moves along the Planckian locus. In range [1500.0f, 15000.0f].
|
|
|
+ /// </summary>
|
|
|
+ public float Temperature;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Additional tint to be applied during white balancing. Can be used to further tweak the white balancing effect by
|
|
|
+ /// modifying the tint of the light.The tint is chosen on the Planckian locus isothermal, depending on the light
|
|
|
+ /// temperature specified by <see cref="Temperature"/>.
|
|
|
+ ///
|
|
|
+ /// In range [-1.0f, 1.0f].
|
|
|
+ /// </summary>
|
|
|
+ public float Tint;
|
|
|
+ };
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Settings that control color grading post-process.
|
|
|
+ /// </summary>
|
|
|
+ struct ColorGradingSettings // Note: Must match C++ struct ColorGradingSettings
|
|
|
+ {
|
|
|
+ /// <summary>
|
|
|
+ /// Saturation to be applied during color grading. Larger values increase vibrancy of the image.
|
|
|
+ /// In range [0.0f, 2.0f].
|
|
|
+ /// </summary>
|
|
|
+ public Vector3 Saturation;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Contrast to be applied during color grading. Larger values increase difference between light and dark areas of
|
|
|
+ /// the image. In range [0.0f, 2.0f].
|
|
|
+ /// </summary>
|
|
|
+ public Vector3 Contrast;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Gain to be applied during color grading. Simply increases all color values by an equal scale.
|
|
|
+ /// In range [0.0f, 2.0f].
|
|
|
+ /// </summary>
|
|
|
+ public Vector3 Gain;
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Gain to be applied during color grading. Simply offsets all color values by an equal amount.
|
|
|
+ /// In range [-1.0f, 1.0f].
|
|
|
+ /// </summary>
|
|
|
+ public Vector3 Offset;
|
|
|
+ };
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Settings that control the post-process operations.
|
|
|
+ /// </summary>
|
|
|
+ class PostProcessSettings : ScriptObject
|
|
|
+ {
|
|
|
+ public PostProcessSettings()
|
|
|
+ {
|
|
|
+ Internal_CreateInstance(this);
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Determines should automatic exposure be applied to the HDR image. When turned on the average scene brightness
|
|
|
+ /// will be calculated and used to automatically expose the image to the optimal range. Use the parameters provided
|
|
|
+ /// by <see cref="AutoExposure"/> to customize the automatic exposure effect.You may also use
|
|
|
+ /// <see cref="ExposureScale"/> to manually adjust the automatic exposure. When automatic exposure is turned off you
|
|
|
+ /// can use <see cref="ExposureScale"/> to manually set the exposure.
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableAutoExposure
|
|
|
+ {
|
|
|
+ get { return Internal_GetEnableAutoExposure(mCachedPtr); }
|
|
|
+ set { Internal_SetEnableAutoExposure(mCachedPtr, value); }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Parameters used for customizing automatic scene exposure. <see cref="EnableAutoExposure"/>
|
|
|
+ /// </summary>
|
|
|
+ public AutoExposureSettings AutoExposure
|
|
|
+ {
|
|
|
+ get
|
|
|
+ {
|
|
|
+ AutoExposureSettings output;
|
|
|
+ Internal_GetAutoExposureSettings(mCachedPtr, out output);
|
|
|
+
|
|
|
+ return output;
|
|
|
+ }
|
|
|
+
|
|
|
+ set { Internal_SetAutoExposureSettings(mCachedPtr, ref value); }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Determines should the image be tonemapped. Tonemapping converts an HDR image into LDR image by applying
|
|
|
+ /// a filmic curve to the image, simulating the effect of film cameras.Filmic curve improves image quality by
|
|
|
+ /// tapering off lows and highs, preventing under- and over-exposure.This is useful if an image contains both
|
|
|
+ /// very dark and very bright areas, in which case the global exposure parameter would leave some areas either over-
|
|
|
+ /// or under-exposed.Use ::tonemapping to customize how tonemapping performed.
|
|
|
+ ///
|
|
|
+ /// If this is disabled, then color grading and white balancing will not be enabled either.Only relevant for HDR
|
|
|
+ /// images.
|
|
|
+ /// </summary>
|
|
|
+ public bool EnableTonemapping
|
|
|
+ {
|
|
|
+ get { return Internal_GetEnableTonemapping(mCachedPtr); }
|
|
|
+ set { Internal_SetEnableTonemapping(mCachedPtr, value); }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Parameters used for customizing tonemapping. <see cref="EnableTonemapping"/>
|
|
|
+ /// </summary>
|
|
|
+ public TonemappingSettings Tonemapping
|
|
|
+ {
|
|
|
+ get
|
|
|
+ {
|
|
|
+ TonemappingSettings output;
|
|
|
+ Internal_GetTonemappingSettings(mCachedPtr, out output);
|
|
|
+
|
|
|
+ return output;
|
|
|
+ }
|
|
|
+ set { Internal_SetTonemappingSettings(mCachedPtr, ref value); }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Parameters used for customizing white balancing. White balancing converts a scene illuminated by a light of the
|
|
|
+ /// specified temperature into a scene illuminated by a standard D65 illuminant (average midday light) in order to
|
|
|
+ /// simulate the effects of chromatic adaptation of the human visual system.
|
|
|
+ /// </summary>
|
|
|
+ public WhiteBalanceSettings WhiteBalance
|
|
|
+ {
|
|
|
+ get
|
|
|
+ {
|
|
|
+ WhiteBalanceSettings output;
|
|
|
+ Internal_GetWhiteBalanceSettings(mCachedPtr, out output);
|
|
|
+
|
|
|
+ return output;
|
|
|
+ }
|
|
|
+ set { Internal_SetWhiteBalanceSettings(mCachedPtr, ref value); }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Parameters used for customizing color grading.
|
|
|
+ /// </summary>
|
|
|
+ public ColorGradingSettings ColorGrading
|
|
|
+ {
|
|
|
+ get
|
|
|
+ {
|
|
|
+ ColorGradingSettings output;
|
|
|
+ Internal_GetColorGradingSettings(mCachedPtr, out output);
|
|
|
+
|
|
|
+ return output;
|
|
|
+ }
|
|
|
+ set { Internal_SetColorGradingSettings(mCachedPtr, ref value); }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Log2 value to scale the eye adaptation by (e.g. 2^0 = 1). Smaller values yield darker image, while larger yield
|
|
|
+ /// brighter image.Allows you to customize exposure manually, applied on top of eye adaptation exposure (if
|
|
|
+ /// enabled). In range [-8, 8].
|
|
|
+ /// </summary>
|
|
|
+ public float ExposureScale
|
|
|
+ {
|
|
|
+ get { return Internal_GetExposureScale(mCachedPtr); }
|
|
|
+ set { Internal_SetExposureScale(mCachedPtr, value); }
|
|
|
+ }
|
|
|
+
|
|
|
+ /// <summary>
|
|
|
+ /// Gamma value to adjust the image for. Larger values result in a brighter image. When tonemapping is turned
|
|
|
+ /// on the best gamma curve for the output device is chosen automatically and this value can by used to merely tweak
|
|
|
+ /// that curve. If tonemapping is turned off this is the exact value of the gamma curve that will be applied.
|
|
|
+ /// </summary>
|
|
|
+ public float Gamma
|
|
|
+ {
|
|
|
+ get { return Internal_GetGamma(mCachedPtr); }
|
|
|
+ set { Internal_SetGamma(mCachedPtr, value); }
|
|
|
+ }
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_CreateInstance(PostProcessSettings managedInstance);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern bool Internal_GetEnableAutoExposure(IntPtr thisPtr);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_SetEnableAutoExposure(IntPtr thisPtr, bool value);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_GetAutoExposureSettings(IntPtr thisPtr, out AutoExposureSettings value);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_SetAutoExposureSettings(IntPtr thisPtr, ref AutoExposureSettings value);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern bool Internal_GetEnableTonemapping(IntPtr thisPtr);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_SetEnableTonemapping(IntPtr thisPtr, bool value);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_GetTonemappingSettings(IntPtr thisPtr, out TonemappingSettings value);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_SetTonemappingSettings(IntPtr thisPtr, ref TonemappingSettings value);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_GetWhiteBalanceSettings(IntPtr thisPtr, out WhiteBalanceSettings value);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_SetWhiteBalanceSettings(IntPtr thisPtr, ref WhiteBalanceSettings value);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_GetColorGradingSettings(IntPtr thisPtr, out ColorGradingSettings value);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_SetColorGradingSettings(IntPtr thisPtr, ref ColorGradingSettings value);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern float Internal_GetExposureScale(IntPtr thisPtr);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_SetExposureScale(IntPtr thisPtr, float value);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern float Internal_GetGamma(IntPtr thisPtr);
|
|
|
+
|
|
|
+ [MethodImpl(MethodImplOptions.InternalCall)]
|
|
|
+ private static extern void Internal_SetGamma(IntPtr thisPtr, float value);
|
|
|
+ }
|
|
|
+}
|
BearishSun