Game/UltimateFishing
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
master
UltimateFishing/Assets/Scripts/Assembly-CSharp/BeautifyEffect/Beautify.cs
BobSong 006a5b7e21 first commit
2026-02-21 16:45:37 +08:00

4591 lines
92 KiB
C#
Raw Permalink Blame History

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
namespace BeautifyEffect
{
[HelpURLAttribute("http://kronnect.com/taptapgo")]
[ExecuteInEditMode]
[AddComponentMenu("Image Effects/Rendering/Beautify")]
[RequireComponent(typeof(Camera))]
[ImageEffectAllowedInSceneView]
public class Beautify : MonoBehaviour
{
[SerializeField]
private BEAUTIFY_PRESET _preset = BEAUTIFY_PRESET.Medium;
[SerializeField]
private BEAUTIFY_QUALITY _quality;
[SerializeField]
private BeautifyProfile _profile;
[SerializeField]
private bool _compareMode;
[SerializeField]
[Range(-(float)Math.PI, (float)Math.PI)]
private float _compareLineAngle = 1.4f;
[Range(0.0001f, 0.05f)]
[SerializeField]
private float _compareLineWidth = 0.002f;
[Range(0f, 0.2f)]
[SerializeField]
private float _dither = 0.02f;
[SerializeField]
[Range(0f, 1f)]
private float _ditherDepth;
[Range(0f, 1f)]
[SerializeField]
private float _sharpenMinDepth;
[SerializeField]
[Range(0f, 1.1f)]
private float _sharpenMaxDepth = 0.999f;
[SerializeField]
[Range(0f, 15f)]
private float _sharpen = 2f;
[SerializeField]
[Range(0f, 0.05f)]
private float _sharpenDepthThreshold = 0.035f;
[SerializeField]
private Color _tintColor = new Color(1f, 1f, 1f, 0f);
[SerializeField]
[Range(0f, 0.2f)]
private float _sharpenRelaxation = 0.08f;
[Range(0f, 1f)]
[SerializeField]
private float _sharpenClamp = 0.45f;
[SerializeField]
[Range(0f, 1f)]
private float _sharpenMotionSensibility = 0.5f;
[SerializeField]
[Range(-2f, 3f)]
private float _saturate = 1f;
[SerializeField]
[Range(0.5f, 1.5f)]
private float _contrast = 1.02f;
[SerializeField]
private float _brightness = 1.05f;
[SerializeField]
[Range(0f, 2f)]
private float _daltonize;
[SerializeField]
private bool _vignetting;
[SerializeField]
private Color _vignettingColor = new Color(0.3f, 0.3f, 0.3f, 0.05f);
[SerializeField]
[Range(0f, 1f)]
private float _vignettingFade;
[SerializeField]
private bool _vignettingCircularShape;
[SerializeField]
private float _vignettingAspectRatio = 1f;
[Range(0f, 1f)]
[SerializeField]
private float _vignettingBlink;
[SerializeField]
private Texture2D _vignettingMask;
[SerializeField]
private bool _frame;
[SerializeField]
private Color _frameColor = new Color(1f, 1f, 1f, 0.047f);
[SerializeField]
private Texture2D _frameMask;
[SerializeField]
private bool _lut;
[Range(0f, 1f)]
[SerializeField]
private float _lutIntensity = 1f;
[SerializeField]
private Texture2D _lutTexture;
[SerializeField]
private bool _nightVision;
[SerializeField]
private Color _nightVisionColor = new Color(0.5f, 1f, 0.5f, 0.5f);
[SerializeField]
private bool _outline;
[SerializeField]
private Color _outlineColor = new Color(0f, 0f, 0f, 0.8f);
[SerializeField]
private bool _thermalVision;
[SerializeField]
private bool _lensDirt;
[SerializeField]
[Range(0f, 1f)]
private float _lensDirtThreshold = 0.5f;
[Range(0f, 1f)]
[SerializeField]
private float _lensDirtIntensity = 0.9f;
[SerializeField]
private Texture2D _lensDirtTexture;
[SerializeField]
private bool _bloom;
[SerializeField]
private LayerMask _bloomCullingMask = 0;
[Range(1f, 4f)]
[SerializeField]
private float _bloomLayerMaskDownsampling = 1f;
[Range(0f, 10f)]
[SerializeField]
private float _bloomIntensity = 1f;
[SerializeField]
private float _bloomMaxBrightness = 1000f;
[Range(0f, 3f)]
[SerializeField]
private float _bloomBoost0;
[SerializeField]
[Range(0f, 3f)]
private float _bloomBoost1;
[SerializeField]
[Range(0f, 3f)]
private float _bloomBoost2;
[Range(0f, 3f)]
[SerializeField]
private float _bloomBoost3;
[SerializeField]
[Range(0f, 3f)]
private float _bloomBoost4;
[Range(0f, 3f)]
[SerializeField]
private float _bloomBoost5;
[SerializeField]
private bool _bloomAntiflicker;
[SerializeField]
private bool _bloomUltra;
[Range(0f, 5f)]
[SerializeField]
private float _bloomThreshold = 0.75f;
[SerializeField]
private bool _bloomCustomize;
[SerializeField]
private bool _bloomDebug;
[Range(0f, 1f)]
[SerializeField]
private float _bloomWeight0 = 0.5f;
[Range(0f, 1f)]
[SerializeField]
private float _bloomWeight1 = 0.5f;
[SerializeField]
[Range(0f, 1f)]
private float _bloomWeight2 = 0.5f;
[SerializeField]
[Range(0f, 1f)]
private float _bloomWeight3 = 0.5f;
[Range(0f, 1f)]
[SerializeField]
private float _bloomWeight4 = 0.5f;
[SerializeField]
[Range(0f, 1f)]
private float _bloomWeight5 = 0.5f;
[SerializeField]
private bool _bloomBlur = true;
[Range(0f, 1f)]
[SerializeField]
private float _bloomDepthAtten;
[SerializeField]
[Range(-1f, 1f)]
private float _bloomLayerZBias;
[SerializeField]
private bool _anamorphicFlares;
[SerializeField]
[Range(0f, 10f)]
private float _anamorphicFlaresIntensity = 1f;
[SerializeField]
private bool _anamorphicFlaresAntiflicker;
[SerializeField]
private bool _anamorphicFlaresUltra;
[Range(0f, 5f)]
[SerializeField]
private float _anamorphicFlaresThreshold = 0.75f;
[SerializeField]
[Range(0.1f, 2f)]
private float _anamorphicFlaresSpread = 1f;
[SerializeField]
private bool _anamorphicFlaresVertical;
[SerializeField]
private Color _anamorphicFlaresTint = new Color(0.5f, 0.5f, 1f, 0f);
[SerializeField]
private bool _anamorphicFlaresBlur = true;
[SerializeField]
private bool _depthOfField;
[SerializeField]
private bool _depthOfFieldTransparencySupport;
[SerializeField]
private LayerMask _depthOfFieldTransparencyLayerMask = -1;
[SerializeField]
private Transform _depthOfFieldTargetFocus;
[SerializeField]
private bool _depthOfFieldDebug;
[SerializeField]
private bool _depthOfFieldAutofocus;
[SerializeField]
private Vector2 _depthofFieldAutofocusViewportPoint = new Vector2(0.5f, 0.5f);
[SerializeField]
private float _depthOfFieldAutofocusMinDistance;
[SerializeField]
private float _depthOfFieldAutofocusMaxDistance = 10000f;
[SerializeField]
private LayerMask _depthOfFieldAutofocusLayerMask = -1;
[SerializeField]
private LayerMask _depthOfFieldExclusionLayerMask = 0;
[Range(1f, 4f)]
[SerializeField]
private float _depthOfFieldExclusionLayerMaskDownsampling = 1f;
[Range(1f, 4f)]
[SerializeField]
private float _depthOfFieldTransparencySupportDownsampling = 1f;
[SerializeField]
[Range(0.9f, 1f)]
private float _depthOfFieldExclusionBias = 0.99f;
[SerializeField]
[Range(1f, 100f)]
private float _depthOfFieldDistance = 1f;
[SerializeField]
[Range(0.001f, 5f)]
private float _depthOfFieldFocusSpeed = 1f;
[Range(1f, 5f)]
[SerializeField]
private int _depthOfFieldDownsampling = 2;
[SerializeField]
[Range(2f, 16f)]
private int _depthOfFieldMaxSamples = 4;
[SerializeField]
[Range(0.005f, 0.5f)]
private float _depthOfFieldFocalLength = 0.05f;
[SerializeField]
private float _depthOfFieldAperture = 2.8f;
[SerializeField]
private bool _depthOfFieldForegroundBlur = true;
[SerializeField]
private bool _depthOfFieldForegroundBlurHQ;
[SerializeField]
private float _depthOfFieldForegroundDistance = 0.25f;
[SerializeField]
private bool _depthOfFieldBokeh = true;
[Range(0.5f, 3f)]
[SerializeField]
private float _depthOfFieldBokehThreshold = 1f;
[Range(0f, 8f)]
[SerializeField]
private float _depthOfFieldBokehIntensity = 2f;
[SerializeField]
private float _depthOfFieldMaxBrightness = 1000f;
[SerializeField]
[Range(0f, 1f)]
private float _depthOfFieldMaxDistance = 1f;
[SerializeField]
private FilterMode _depthOfFieldFilterMode = FilterMode.Bilinear;
[NonSerialized]
public OnBeforeFocusEvent OnBeforeFocus;
[SerializeField]
private bool _eyeAdaptation;
[Range(0f, 1f)]
[SerializeField]
private float _eyeAdaptationMinExposure = 0.2f;
[Range(1f, 100f)]
[SerializeField]
private float _eyeAdaptationMaxExposure = 5f;
[Range(0f, 1f)]
[SerializeField]
private float _eyeAdaptationSpeedToLight = 0.4f;
[Range(0f, 1f)]
[SerializeField]
private float _eyeAdaptationSpeedToDark = 0.2f;
[SerializeField]
private bool _purkinje;
[Range(0f, 5f)]
[SerializeField]
private float _purkinjeAmount = 1f;
[Range(0f, 1f)]
[SerializeField]
private float _purkinjeLuminanceThreshold = 0.15f;
[SerializeField]
private BEAUTIFY_TMO _tonemap;
[SerializeField]
private bool _sunFlares;
[SerializeField]
private Transform _sun;
[SerializeField]
private LayerMask _sunFlaresLayerMask = -1;
[SerializeField]
[Range(0f, 1f)]
private float _sunFlaresIntensity = 1f;
[Range(0f, 1f)]
[SerializeField]
private float _sunFlaresSolarWindSpeed = 0.01f;
[SerializeField]
private Color _sunFlaresTint = new Color(1f, 1f, 1f);
[Range(1f, 5f)]
[SerializeField]
private int _sunFlaresDownsampling = 1;
[Range(0f, 1f)]
[SerializeField]
private float _sunFlaresSunIntensity = 0.1f;
[SerializeField]
[Range(0f, 1f)]
private float _sunFlaresSunDiskSize = 0.05f;
[Range(0f, 10f)]
[SerializeField]
private float _sunFlaresSunRayDiffractionIntensity = 3.5f;
[SerializeField]
[Range(0f, 1f)]
private float _sunFlaresSunRayDiffractionThreshold = 0.13f;
[Range(0f, 0.2f)]
[SerializeField]
private float _sunFlaresCoronaRays1Length = 0.02f;
[SerializeField]
[Range(2f, 30f)]
private int _sunFlaresCoronaRays1Streaks = 12;
[Range(0f, 0.1f)]
[SerializeField]
private float _sunFlaresCoronaRays1Spread = 0.001f;
[Range(0f, (float)Math.PI * 2f)]
[SerializeField]
private float _sunFlaresCoronaRays1AngleOffset;
[Range(0f, 0.2f)]
[SerializeField]
private float _sunFlaresCoronaRays2Length = 0.05f;
[SerializeField]
[Range(2f, 30f)]
private int _sunFlaresCoronaRays2Streaks = 12;
[Range(0f, 0.1f)]
[SerializeField]
private float _sunFlaresCoronaRays2Spread = 0.1f;
[Range(0f, (float)Math.PI * 2f)]
[SerializeField]
private float _sunFlaresCoronaRays2AngleOffset;
[Range(0f, 1f)]
[SerializeField]
private float _sunFlaresGhosts1Size = 0.03f;
[SerializeField]
[Range(-3f, 3f)]
private float _sunFlaresGhosts1Offset = 1.04f;
[SerializeField]
[Range(0f, 1f)]
private float _sunFlaresGhosts1Brightness = 0.037f;
[SerializeField]
[Range(0f, 1f)]
private float _sunFlaresGhosts2Size = 0.1f;
[SerializeField]
[Range(-3f, 3f)]
private float _sunFlaresGhosts2Offset = 0.71f;
[Range(0f, 1f)]
[SerializeField]
private float _sunFlaresGhosts2Brightness = 0.03f;
[Range(0f, 1f)]
[SerializeField]
private float _sunFlaresGhosts3Size = 0.24f;
[Range(-3f, 3f)]
[SerializeField]
private float _sunFlaresGhosts3Brightness = 0.025f;
[Range(0f, 1f)]
[SerializeField]
private float _sunFlaresGhosts3Offset = 0.31f;
[Range(0f, 1f)]
[SerializeField]
private float _sunFlaresGhosts4Size = 0.016f;
[Range(-3f, 3f)]
[SerializeField]
private float _sunFlaresGhosts4Offset;
[Range(0f, 1f)]
[SerializeField]
private float _sunFlaresGhosts4Brightness = 0.017f;
[Range(0f, 1f)]
[SerializeField]
private float _sunFlaresHaloOffset = 0.22f;
[Range(0f, 50f)]
[SerializeField]
private float _sunFlaresHaloAmplitude = 15.1415f;
[Range(0f, 1f)]
[SerializeField]
private float _sunFlaresHaloIntensity = 0.01f;
[SerializeField]
private bool _sunFlaresRotationDeadZone;
[SerializeField]
private bool _blur;
[Range(0f, 4f)]
[SerializeField]
private float _blurIntensity = 1f;
[Range(1f, 256f)]
[SerializeField]
private int _pixelateAmount = 1;
[SerializeField]
private bool _pixelateDownscale;
[Range(0f, 20f)]
[SerializeField]
private float _antialiasStrength = 5f;
[Range(0f, 0.05f)]
[SerializeField]
private float _antialiasDepthThreshold = 0.001f;
public bool isDirty;
private static Beautify _beautify;
public const string SKW_BLOOM = "BEAUTIFY_BLOOM";
public const string SKW_LUT = "BEAUTIFY_LUT";
public const string SKW_NIGHT_VISION = "BEAUTIFY_NIGHT_VISION";
public const string SKW_THERMAL_VISION = "BEAUTIFY_THERMAL_VISION";
public const string SKW_OUTLINE = "BEAUTIFY_OUTLINE";
public const string SKW_FRAME = "BEAUTIFY_FRAME";
public const string SKW_FRAME_MASK = "BEAUTIFY_FRAME_MASK";
public const string SKW_DALTONIZE = "BEAUTIFY_DALTONIZE";
public const string SKW_DIRT = "BEAUTIFY_DIRT";
public const string SKW_VIGNETTING = "BEAUTIFY_VIGNETTING";
public const string SKW_VIGNETTING_MASK = "BEAUTIFY_VIGNETTING_MASK";
public const string SKW_DEPTH_OF_FIELD = "BEAUTIFY_DEPTH_OF_FIELD";
public const string SKW_DEPTH_OF_FIELD_TRANSPARENT = "BEAUTIFY_DEPTH_OF_FIELD_TRANSPARENT";
public const string SKW_EYE_ADAPTATION = "BEAUTIFY_EYE_ADAPTATION";
public const string SKW_TONEMAP_ACES = "BEAUTIFY_TONEMAP_ACES";
public const string SKW_PURKINJE = "BEAUTIFY_PURKINJE";
public const string SKW_BLOOM_USE_DEPTH = "BEAUTIFY_BLOOM_USE_DEPTH";
public const string SKW_BLOOM_USE_LAYER = "BEAUTIFY_BLOOM_USE_LAYER";
private Material bMatDesktop;
private Material bMatMobile;
private Material bMatBasic;
[SerializeField]
private Material bMat;
private Camera currentCamera;
private Vector3 camPrevForward;
private Vector3 camPrevPos;
private float currSens;
private int renderPass;
private RenderTextureFormat rtFormat;
private RenderTexture[] rt;
private RenderTexture[] rtAF;
private RenderTexture[] rtEA;
private RenderTexture rtEAacum;
private RenderTexture rtEAHist;
private float dofPrevDistance;
private float dofLastAutofocusDistance;
private Vector4 dofLastBokehData;
private Camera sceneCamera;
private Camera depthCam;
private GameObject depthCamObj;
private List<string> shaderKeywords;
private Shader depthShader;
private Shader dofExclusionShader;
private bool shouldUpdateMaterialProperties;
private const string BEAUTIFY_BUILD_HINT = "BeautifyBuildHint700RC1";
private float sunFlareCurrentIntensity;
private Vector4 sunLastScrPos;
private float sunLastRot;
private Texture2D flareNoise;
private RenderTexture dofDepthTexture;
private RenderTexture dofExclusionTexture;
private RenderTexture bloomSourceTexture;
private RenderTexture bloomSourceDepthTexture;
private RenderTexture pixelateTexture;
private RenderTextureDescriptor rtDescBase;
private float sunFlareTime;
private int dofCurrentLayerMaskValue;
public BEAUTIFY_PRESET preset
{
get
{
return _preset;
}
set
{
if (_preset != value)
{
_preset = value;
UpdateMaterialProperties();
}
}
}
public BEAUTIFY_QUALITY quality
{
get
{
return _quality;
}
set
{
if (_quality != value)
{
_quality = value;
UpdateQualitySettings();
UpdateMaterialProperties();
}
}
}
public BeautifyProfile profile
{
get
{
return _profile;
}
set
{
if (_profile != value)
{
_profile = value;
if (_profile != null)
{
_profile.Load(this);
_preset = BEAUTIFY_PRESET.Custom;
}
}
}
}
public bool compareMode
{
get
{
return _compareMode;
}
set
{
if (_compareMode != value)
{
_compareMode = value;
UpdateMaterialProperties();
}
}
}
public float compareLineAngle
{
get
{
return _compareLineAngle;
}
set
{
if (_compareLineAngle != value)
{
_compareLineAngle = value;
UpdateMaterialProperties();
}
}
}
public float compareLineWidth
{
get
{
return _compareLineWidth;
}
set
{
if (_compareLineWidth != value)
{
_compareLineWidth = value;
UpdateMaterialProperties();
}
}
}
public float dither
{
get
{
return _dither;
}
set
{
if (_dither != value)
{
_preset = BEAUTIFY_PRESET.Custom;
_dither = value;
UpdateMaterialProperties();
}
}
}
public float ditherDepth
{
get
{
return _ditherDepth;
}
set
{
if (_ditherDepth != value)
{
_preset = BEAUTIFY_PRESET.Custom;
_ditherDepth = value;
UpdateMaterialProperties();
}
}
}
public float sharpenMinDepth
{
get
{
return _sharpenMinDepth;
}
set
{
if (_sharpenMinDepth != value)
{
_sharpenMinDepth = value;
UpdateMaterialProperties();
}
}
}
public float sharpenMaxDepth
{
get
{
return _sharpenMaxDepth;
}
set
{
if (_sharpenMaxDepth != value)
{
_sharpenMaxDepth = value;
UpdateMaterialProperties();
}
}
}
public float sharpen
{
get
{
return _sharpen;
}
set
{
if (_sharpen != value)
{
_preset = BEAUTIFY_PRESET.Custom;
_sharpen = value;
UpdateMaterialProperties();
}
}
}
public float sharpenDepthThreshold
{
get
{
return _sharpenDepthThreshold;
}
set
{
if (_sharpenDepthThreshold != value)
{
_preset = BEAUTIFY_PRESET.Custom;
_sharpenDepthThreshold = value;
UpdateMaterialProperties();
}
}
}
public Color tintColor
{
get
{
return _tintColor;
}
set
{
if (_tintColor != value)
{
_tintColor = value;
UpdateMaterialProperties();
}
}
}
public float sharpenRelaxation
{
get
{
return _sharpenRelaxation;
}
set
{
if (_sharpenRelaxation != value)
{
_preset = BEAUTIFY_PRESET.Custom;
_sharpenRelaxation = value;
UpdateMaterialProperties();
}
}
}
public float sharpenClamp
{
get
{
return _sharpenClamp;
}
set
{
if (_sharpenClamp != value)
{
_preset = BEAUTIFY_PRESET.Custom;
_sharpenClamp = value;
UpdateMaterialProperties();
}
}
}
public float sharpenMotionSensibility
{
get
{
return _sharpenMotionSensibility;
}
set
{
if (_sharpenMotionSensibility != value)
{
_sharpenMotionSensibility = value;
UpdateMaterialProperties();
}
}
}
public float saturate
{
get
{
return _saturate;
}
set
{
if (_saturate != value)
{
_preset = BEAUTIFY_PRESET.Custom;
_saturate = value;
UpdateMaterialProperties();
}
}
}
public float contrast
{
get
{
return _contrast;
}
set
{
if (_contrast != value)
{
_preset = BEAUTIFY_PRESET.Custom;
_contrast = value;
UpdateMaterialProperties();
}
}
}
public float brightness
{
get
{
return _brightness;
}
set
{
if (_brightness != value)
{
_preset = BEAUTIFY_PRESET.Custom;
_brightness = value;
UpdateMaterialProperties();
}
}
}
public float daltonize
{
get
{
return _daltonize;
}
set
{
if (_daltonize != value)
{
_preset = BEAUTIFY_PRESET.Custom;
_daltonize = value;
UpdateMaterialProperties();
}
}
}
public bool vignetting
{
get
{
return _vignetting;
}
set
{
if (_vignetting != value)
{
_vignetting = value;
UpdateMaterialProperties();
}
}
}
public Color vignettingColor
{
get
{
return _vignettingColor;
}
set
{
if (_vignettingColor != value)
{
_vignettingColor = value;
UpdateMaterialProperties();
}
}
}
public float vignettingFade
{
get
{
return _vignettingFade;
}
set
{
if (_vignettingFade != value)
{
_vignettingFade = value;
UpdateMaterialProperties();
}
}
}
public bool vignettingCircularShape
{
get
{
return _vignettingCircularShape;
}
set
{
if (_vignettingCircularShape != value)
{
_vignettingCircularShape = value;
UpdateMaterialProperties();
}
}
}
public float vignettingAspectRatio
{
get
{
return _vignettingAspectRatio;
}
set
{
if (_vignettingAspectRatio != value)
{
_vignettingAspectRatio = value;
UpdateMaterialProperties();
}
}
}
public float vignettingBlink
{
get
{
return _vignettingBlink;
}
set
{
if (_vignettingBlink != value)
{
_vignettingBlink = value;
UpdateMaterialProperties();
}
}
}
public Texture2D vignettingMask
{
get
{
return _vignettingMask;
}
set
{
if (_vignettingMask != value)
{
_vignettingMask = value;
UpdateMaterialProperties();
}
}
}
public bool frame
{
get
{
return _frame;
}
set
{
if (_frame != value)
{
_frame = value;
UpdateMaterialProperties();
}
}
}
public Color frameColor
{
get
{
return _frameColor;
}
set
{
if (_frameColor != value)
{
_frameColor = value;
UpdateMaterialProperties();
}
}
}
public Texture2D frameMask
{
get
{
return _frameMask;
}
set
{
if (_frameMask != value)
{
_frameMask = value;
UpdateMaterialProperties();
}
}
}
public bool lut
{
get
{
return _lut;
}
set
{
if (_lut != value)
{
_lut = value;
if (_lut)
{
_nightVision = false;
_thermalVision = false;
}
UpdateMaterialProperties();
}
}
}
public float lutIntensity
{
get
{
return _lutIntensity;
}
set
{
if (_lutIntensity != value)
{
_lutIntensity = value;
UpdateMaterialProperties();
}
}
}
public Texture2D lutTexture
{
get
{
return _lutTexture;
}
set
{
if (_lutTexture != value)
{
_lutTexture = value;
UpdateMaterialProperties();
}
}
}
public bool nightVision
{
get
{
return _nightVision;
}
set
{
if (_nightVision != value)
{
_nightVision = value;
if (_nightVision)
{
_thermalVision = false;
_lut = false;
_vignetting = true;
_vignettingFade = 0f;
_vignettingColor = new Color(0f, 0f, 0f, 0.1254902f);
_vignettingCircularShape = true;
}
else
{
_vignetting = false;
}
UpdateMaterialProperties();
}
}
}
public Color nightVisionColor
{
get
{
return _nightVisionColor;
}
set
{
if (_nightVisionColor != value)
{
_nightVisionColor = value;
UpdateMaterialProperties();
}
}
}
public bool outline
{
get
{
return _outline;
}
set
{
if (_outline != value)
{
_outline = value;
UpdateMaterialProperties();
}
}
}
public Color outlineColor
{
get
{
return _outlineColor;
}
set
{
if (_outlineColor != value)
{
_outlineColor = value;
UpdateMaterialProperties();
}
}
}
public bool thermalVision
{
get
{
return _thermalVision;
}
set
{
if (_thermalVision != value)
{
_thermalVision = value;
if (_thermalVision)
{
_nightVision = false;
_lut = false;
_vignetting = true;
_vignettingFade = 0f;
_vignettingColor = new Color(1f, 0.0627451f, 0.0627451f, 6f / 85f);
_vignettingCircularShape = true;
}
else
{
_vignetting = false;
}
UpdateMaterialProperties();
}
}
}
public bool lensDirt
{
get
{
return _lensDirt;
}
set
{
if (_lensDirt != value)
{
_lensDirt = value;
UpdateMaterialProperties();
}
}
}
public float lensDirtThreshold
{
get
{
return _lensDirtThreshold;
}
set
{
if (_lensDirtThreshold != value)
{
_lensDirtThreshold = value;
UpdateMaterialProperties();
}
}
}
public float lensDirtIntensity
{
get
{
return _lensDirtIntensity;
}
set
{
if (_lensDirtIntensity != value)
{
_lensDirtIntensity = value;
UpdateMaterialProperties();
}
}
}
public Texture2D lensDirtTexture
{
get
{
return _lensDirtTexture;
}
set
{
if (_lensDirtTexture != value)
{
_lensDirtTexture = value;
UpdateMaterialProperties();
}
}
}
public bool bloom
{
get
{
return _bloom;
}
set
{
if (_bloom != value)
{
_bloom = value;
UpdateMaterialProperties();
}
}
}
public LayerMask bloomCullingMask
{
get
{
return _bloomCullingMask;
}
set
{
if ((int)_bloomCullingMask != (int)value)
{
_bloomCullingMask = value;
UpdateMaterialProperties();
}
}
}
public float bloomLayerMaskDownsampling
{
get
{
return _bloomLayerMaskDownsampling;
}
set
{
if (_bloomLayerMaskDownsampling != value)
{
_bloomLayerMaskDownsampling = Mathf.Max(value, 1f);
UpdateMaterialProperties();
}
}
}
public float bloomIntensity
{
get
{
return _bloomIntensity;
}
set
{
if (_bloomIntensity != value)
{
_bloomIntensity = Mathf.Abs(value);
UpdateMaterialProperties();
}
}
}
public float bloomMaxBrightness
{
get
{
return _bloomMaxBrightness;
}
set
{
if (_bloomMaxBrightness != value)
{
_bloomMaxBrightness = Mathf.Abs(value);
UpdateMaterialProperties();
}
}
}
public float bloomBoost0
{
get
{
return _bloomBoost0;
}
set
{
if (_bloomBoost0 != value)
{
_bloomBoost0 = value;
UpdateMaterialProperties();
}
}
}
public float bloomBoost1
{
get
{
return _bloomBoost1;
}
set
{
if (_bloomBoost1 != value)
{
_bloomBoost1 = value;
UpdateMaterialProperties();
}
}
}
public float bloomBoost2
{
get
{
return _bloomBoost2;
}
set
{
if (_bloomBoost2 != value)
{
_bloomBoost2 = value;
UpdateMaterialProperties();
}
}
}
public float bloomBoost3
{
get
{
return _bloomBoost3;
}
set
{
if (_bloomBoost3 != value)
{
_bloomBoost3 = value;
UpdateMaterialProperties();
}
}
}
public float bloomBoost4
{
get
{
return _bloomBoost4;
}
set
{
if (_bloomBoost4 != value)
{
_bloomBoost4 = value;
UpdateMaterialProperties();
}
}
}
public float bloomBoost5
{
get
{
return _bloomBoost5;
}
set
{
if (_bloomBoost5 != value)
{
_bloomBoost5 = value;
UpdateMaterialProperties();
}
}
}
public bool bloomAntiflicker
{
get
{
return _bloomAntiflicker;
}
set
{
if (_bloomAntiflicker != value)
{
_bloomAntiflicker = value;
UpdateMaterialProperties();
}
}
}
public bool bloomUltra
{
get
{
return _bloomUltra;
}
set
{
if (_bloomUltra != value)
{
_bloomUltra = value;
UpdateMaterialProperties();
}
}
}
public float bloomThreshold
{
get
{
return _bloomThreshold;
}
set
{
if (_bloomThreshold != value)
{
_bloomThreshold = value;
UpdateMaterialProperties();
}
}
}
public bool bloomCustomize
{
get
{
return _bloomCustomize;
}
set
{
if (_bloomCustomize != value)
{
_bloomCustomize = value;
UpdateMaterialProperties();
}
}
}
public bool bloomDebug
{
get
{
return _bloomDebug;
}
set
{
if (_bloomDebug != value)
{
_bloomDebug = value;
UpdateMaterialProperties();
}
}
}
public float bloomWeight0
{
get
{
return _bloomWeight0;
}
set
{
if (_bloomWeight0 != value)
{
_bloomWeight0 = value;
UpdateMaterialProperties();
}
}
}
public float bloomWeight1
{
get
{
return _bloomWeight1;
}
set
{
if (_bloomWeight1 != value)
{
_bloomWeight1 = value;
UpdateMaterialProperties();
}
}
}
public float bloomWeight2
{
get
{
return _bloomWeight2;
}
set
{
if (_bloomWeight2 != value)
{
_bloomWeight2 = value;
UpdateMaterialProperties();
}
}
}
public float bloomWeight3
{
get
{
return _bloomWeight3;
}
set
{
if (_bloomWeight3 != value)
{
_bloomWeight3 = value;
UpdateMaterialProperties();
}
}
}
public float bloomWeight4
{
get
{
return _bloomWeight4;
}
set
{
if (_bloomWeight4 != value)
{
_bloomWeight4 = value;
UpdateMaterialProperties();
}
}
}
public float bloomWeight5
{
get
{
return _bloomWeight5;
}
set
{
if (_bloomWeight5 != value)
{
_bloomWeight5 = value;
UpdateMaterialProperties();
}
}
}
public bool bloomBlur
{
get
{
return _bloomBlur;
}
set
{
if (_bloomBlur != value)
{
_bloomBlur = value;
UpdateMaterialProperties();
}
}
}
public float bloomDepthAtten
{
get
{
return _bloomDepthAtten;
}
set
{
if (_bloomDepthAtten != value)
{
_bloomDepthAtten = value;
UpdateMaterialProperties();
}
}
}
public float bloomLayerZBias
{
get
{
return _bloomLayerZBias;
}
set
{
if (_bloomLayerZBias != value)
{
_bloomLayerZBias = Mathf.Clamp(value, -1f, 1f);
UpdateMaterialProperties();
}
}
}
public bool anamorphicFlares
{
get
{
return _anamorphicFlares;
}
set
{
if (_anamorphicFlares != value)
{
_anamorphicFlares = value;
UpdateMaterialProperties();
}
}
}
public float anamorphicFlaresIntensity
{
get
{
return _anamorphicFlaresIntensity;
}
set
{
if (_anamorphicFlaresIntensity != value)
{
_anamorphicFlaresIntensity = Mathf.Abs(value);
UpdateMaterialProperties();
}
}
}
public bool anamorphicFlaresAntiflicker
{
get
{
return _anamorphicFlaresAntiflicker;
}
set
{
if (_anamorphicFlaresAntiflicker != value)
{
_anamorphicFlaresAntiflicker = value;
UpdateMaterialProperties();
}
}
}
public bool anamorphicFlaresUltra
{
get
{
return _anamorphicFlaresUltra;
}
set
{
if (_anamorphicFlaresUltra != value)
{
_anamorphicFlaresUltra = value;
UpdateMaterialProperties();
}
}
}
public float anamorphicFlaresThreshold
{
get
{
return _anamorphicFlaresThreshold;
}
set
{
if (_anamorphicFlaresThreshold != value)
{
_anamorphicFlaresThreshold = value;
UpdateMaterialProperties();
}
}
}
public float anamorphicFlaresSpread
{
get
{
return _anamorphicFlaresSpread;
}
set
{
if (_anamorphicFlaresSpread != value)
{
_anamorphicFlaresSpread = value;
UpdateMaterialProperties();
}
}
}
public bool anamorphicFlaresVertical
{
get
{
return _anamorphicFlaresVertical;
}
set
{
if (_anamorphicFlaresVertical != value)
{
_anamorphicFlaresVertical = value;
UpdateMaterialProperties();
}
}
}
public Color anamorphicFlaresTint
{
get
{
return _anamorphicFlaresTint;
}
set
{
if (_anamorphicFlaresTint != value)
{
_anamorphicFlaresTint = value;
UpdateMaterialProperties();
}
}
}
public bool anamorphicFlaresBlur
{
get
{
return _anamorphicFlaresBlur;
}
set
{
if (_anamorphicFlaresBlur != value)
{
_anamorphicFlaresBlur = value;
UpdateMaterialProperties();
}
}
}
public bool depthOfField
{
get
{
return _depthOfField;
}
set
{
if (_depthOfField != value)
{
_depthOfField = value;
UpdateMaterialProperties();
}
}
}
public bool depthOfFieldTransparencySupport
{
get
{
return _depthOfFieldTransparencySupport;
}
set
{
if (_depthOfFieldTransparencySupport != value)
{
_depthOfFieldTransparencySupport = value;
UpdateMaterialProperties();
}
}
}
public LayerMask depthOfFieldTransparencyLayerMask
{
get
{
return _depthOfFieldTransparencyLayerMask;
}
set
{
if ((int)_depthOfFieldTransparencyLayerMask != (int)value)
{
_depthOfFieldTransparencyLayerMask = value;
UpdateMaterialProperties();
}
}
}
public Transform depthOfFieldTargetFocus
{
get
{
return _depthOfFieldTargetFocus;
}
set
{
if (_depthOfFieldTargetFocus != value)
{
_depthOfFieldTargetFocus = value;
UpdateMaterialProperties();
}
}
}
public bool depthOfFieldDebug
{
get
{
return _depthOfFieldDebug;
}
set
{
if (_depthOfFieldDebug != value)
{
_depthOfFieldDebug = value;
UpdateMaterialProperties();
}
}
}
public bool depthOfFieldAutofocus
{
get
{
return _depthOfFieldAutofocus;
}
set
{
if (_depthOfFieldAutofocus != value)
{
_depthOfFieldAutofocus = value;
UpdateMaterialProperties();
}
}
}
public Vector2 depthofFieldAutofocusViewportPoint
{
get
{
return _depthofFieldAutofocusViewportPoint;
}
set
{
if (_depthofFieldAutofocusViewportPoint != value)
{
_depthofFieldAutofocusViewportPoint = value;
UpdateMaterialProperties();
}
}
}
public float depthOfFieldAutofocusMinDistance
{
get
{
return _depthOfFieldAutofocusMinDistance;
}
set
{
if (_depthOfFieldAutofocusMinDistance != value)
{
_depthOfFieldAutofocusMinDistance = value;
UpdateMaterialProperties();
}
}
}
public float depthOfFieldAutofocusMaxDistance
{
get
{
return _depthOfFieldAutofocusMaxDistance;
}
set
{
if (_depthOfFieldAutofocusMaxDistance != value)
{
_depthOfFieldAutofocusMaxDistance = value;
UpdateMaterialProperties();
}
}
}
public LayerMask depthOfFieldAutofocusLayerMask
{
get
{
return _depthOfFieldAutofocusLayerMask;
}
set
{
if ((int)_depthOfFieldAutofocusLayerMask != (int)value)
{
_depthOfFieldAutofocusLayerMask = value;
UpdateMaterialProperties();
}
}
}
public LayerMask depthOfFieldExclusionLayerMask
{
get
{
return _depthOfFieldExclusionLayerMask;
}
set
{
if ((int)_depthOfFieldExclusionLayerMask != (int)value)
{
_depthOfFieldExclusionLayerMask = value;
UpdateMaterialProperties();
}
}
}
public float depthOfFieldExclusionLayerMaskDownsampling
{
get
{
return _depthOfFieldExclusionLayerMaskDownsampling;
}
set
{
if (_depthOfFieldExclusionLayerMaskDownsampling != value)
{
_depthOfFieldExclusionLayerMaskDownsampling = Mathf.Max(value, 1f);
UpdateMaterialProperties();
}
}
}
public float depthOfFieldTransparencySupportDownsampling
{
get
{
return _depthOfFieldTransparencySupportDownsampling;
}
set
{
if (_depthOfFieldTransparencySupportDownsampling != value)
{
_depthOfFieldTransparencySupportDownsampling = Mathf.Max(value, 1f);
UpdateMaterialProperties();
}
}
}
public float depthOfFieldExclusionBias
{
get
{
return _depthOfFieldExclusionBias;
}
set
{
if (_depthOfFieldExclusionBias != value)
{
_depthOfFieldExclusionBias = Mathf.Clamp01(value);
UpdateMaterialProperties();
}
}
}
public float depthOfFieldDistance
{
get
{
return _depthOfFieldDistance;
}
set
{
if (_depthOfFieldDistance != value)
{
_depthOfFieldDistance = Mathf.Max(value, 1f);
UpdateMaterialProperties();
}
}
}
public float depthOfFieldFocusSpeed
{
get
{
return _depthOfFieldFocusSpeed;
}
set
{
if (_depthOfFieldFocusSpeed != value)
{
_depthOfFieldFocusSpeed = Mathf.Clamp(value, 0.001f, 1f);
UpdateMaterialProperties();
}
}
}
public int depthOfFieldDownsampling
{
get
{
return _depthOfFieldDownsampling;
}
set
{
if (_depthOfFieldDownsampling != value)
{
_depthOfFieldDownsampling = Mathf.Max(value, 1);
UpdateMaterialProperties();
}
}
}
public int depthOfFieldMaxSamples
{
get
{
return _depthOfFieldMaxSamples;
}
set
{
if (_depthOfFieldMaxSamples != value)
{
_depthOfFieldMaxSamples = Mathf.Max(value, 2);
UpdateMaterialProperties();
}
}
}
public float depthOfFieldFocalLength
{
get
{
return _depthOfFieldFocalLength;
}
set
{
if (_depthOfFieldFocalLength != value)
{
_depthOfFieldFocalLength = Mathf.Abs(value);
UpdateMaterialProperties();
}
}
}
public float depthOfFieldAperture
{
get
{
return _depthOfFieldAperture;
}
set
{
if (_depthOfFieldAperture != value)
{
_depthOfFieldAperture = Mathf.Abs(value);
UpdateMaterialProperties();
}
}
}
public bool depthOfFieldForegroundBlur
{
get
{
return _depthOfFieldForegroundBlur;
}
set
{
if (_depthOfFieldForegroundBlur != value)
{
_depthOfFieldForegroundBlur = value;
UpdateMaterialProperties();
}
}
}
public bool depthOfFieldForegroundBlurHQ
{
get
{
return _depthOfFieldForegroundBlurHQ;
}
set
{
if (_depthOfFieldForegroundBlurHQ != value)
{
_depthOfFieldForegroundBlurHQ = value;
UpdateMaterialProperties();
}
}
}
public float depthOfFieldForegroundDistance
{
get
{
return _depthOfFieldForegroundDistance;
}
set
{
if (_depthOfFieldForegroundDistance != value)
{
_depthOfFieldForegroundDistance = value;
UpdateMaterialProperties();
}
}
}
public bool depthOfFieldBokeh
{
get
{
return _depthOfFieldBokeh;
}
set
{
if (_depthOfFieldBokeh != value)
{
_depthOfFieldBokeh = value;
UpdateMaterialProperties();
}
}
}
public float depthOfFieldBokehThreshold
{
get
{
return _depthOfFieldBokehThreshold;
}
set
{
if (_depthOfFieldBokehThreshold != value)
{
_depthOfFieldBokehThreshold = Mathf.Max(value, 0f);
UpdateMaterialProperties();
}
}
}
public float depthOfFieldBokehIntensity
{
get
{
return _depthOfFieldBokehIntensity;
}
set
{
if (_depthOfFieldBokehIntensity != value)
{
_depthOfFieldBokehIntensity = Mathf.Max(value, 0f);
UpdateMaterialProperties();
}
}
}
public float depthOfFieldMaxBrightness
{
get
{
return _depthOfFieldMaxBrightness;
}
set
{
if (_depthOfFieldMaxBrightness != value)
{
_depthOfFieldMaxBrightness = Mathf.Abs(value);
UpdateMaterialProperties();
}
}
}
public float depthOfFieldMaxDistance
{
get
{
return _depthOfFieldMaxDistance;
}
set
{
if (_depthOfFieldMaxDistance != value)
{
_depthOfFieldMaxDistance = Mathf.Abs(value);
UpdateMaterialProperties();
}
}
}
public FilterMode depthOfFieldFilterMode
{
get
{
return _depthOfFieldFilterMode;
}
set
{
if (_depthOfFieldFilterMode != value)
{
_depthOfFieldFilterMode = value;
UpdateMaterialProperties();
}
}
}
public bool eyeAdaptation
{
get
{
return _eyeAdaptation;
}
set
{
if (_eyeAdaptation != value)
{
_eyeAdaptation = value;
UpdateMaterialProperties();
}
}
}
public float eyeAdaptationMinExposure
{
get
{
return _eyeAdaptationMinExposure;
}
set
{
if (_eyeAdaptationMinExposure != value)
{
_eyeAdaptationMinExposure = Mathf.Clamp01(value);
UpdateMaterialProperties();
}
}
}
public float eyeAdaptationMaxExposure
{
get
{
return _eyeAdaptationMaxExposure;
}
set
{
if (_eyeAdaptationMaxExposure != value)
{
_eyeAdaptationMaxExposure = Mathf.Clamp(value, 1f, 100f);
UpdateMaterialProperties();
}
}
}
public float eyeAdaptationSpeedToLight
{
get
{
return _eyeAdaptationSpeedToLight;
}
set
{
if (_eyeAdaptationSpeedToLight != value)
{
_eyeAdaptationSpeedToLight = Mathf.Clamp01(value);
UpdateMaterialProperties();
}
}
}
public float eyeAdaptationSpeedToDark
{
get
{
return _eyeAdaptationSpeedToDark;
}
set
{
if (_eyeAdaptationSpeedToDark != value)
{
_eyeAdaptationSpeedToDark = Mathf.Clamp01(value);
UpdateMaterialProperties();
}
}
}
public bool purkinje
{
get
{
return _purkinje;
}
set
{
if (_purkinje != value)
{
_purkinje = value;
UpdateMaterialProperties();
}
}
}
public float purkinjeAmount
{
get
{
return _purkinjeAmount;
}
set
{
if (_purkinjeAmount != value)
{
_purkinjeAmount = Mathf.Clamp(value, 0f, 5f);
UpdateMaterialProperties();
}
}
}
public float purkinjeLuminanceThreshold
{
get
{
return _purkinjeLuminanceThreshold;
}
set
{
if (purkinjeLuminanceThreshold != value)
{
_purkinjeLuminanceThreshold = Mathf.Clamp(value, 0f, 1f);
UpdateMaterialProperties();
}
}
}
public BEAUTIFY_TMO tonemap
{
get
{
return _tonemap;
}
set
{
if (_tonemap != value)
{
_tonemap = value;
if (_tonemap == BEAUTIFY_TMO.ACES)
{
_saturate = 0f;
_contrast = 1f;
}
UpdateMaterialProperties();
}
}
}
public bool sunFlares
{
get
{
return _sunFlares;
}
set
{
if (_sunFlares != value)
{
_sunFlares = value;
UpdateMaterialProperties();
}
}
}
public Transform sun
{
get
{
return _sun;
}
set
{
if (_sun != value)
{
_sun = value;
UpdateMaterialProperties();
}
}
}
public LayerMask sunFlaresLayerMask
{
get
{
return _sunFlaresLayerMask;
}
set
{
if ((int)_sunFlaresLayerMask != (int)value)
{
_sunFlaresLayerMask = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresIntensity
{
get
{
return _sunFlaresIntensity;
}
set
{
if (_sunFlaresIntensity != value)
{
_sunFlaresIntensity = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresSolarWindSpeed
{
get
{
return _sunFlaresSolarWindSpeed;
}
set
{
if (_sunFlaresSolarWindSpeed != value)
{
_sunFlaresSolarWindSpeed = value;
UpdateMaterialProperties();
}
}
}
public Color sunFlaresTint
{
get
{
return _sunFlaresTint;
}
set
{
if (_sunFlaresTint != value)
{
_sunFlaresTint = value;
UpdateMaterialProperties();
}
}
}
public int sunFlaresDownsampling
{
get
{
return _sunFlaresDownsampling;
}
set
{
if (_sunFlaresDownsampling != value)
{
_sunFlaresDownsampling = Mathf.Max(value, 1);
UpdateMaterialProperties();
}
}
}
public float sunFlaresSunIntensity
{
get
{
return _sunFlaresSunIntensity;
}
set
{
if (_sunFlaresSunIntensity != value)
{
_sunFlaresSunIntensity = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresSunDiskSize
{
get
{
return _sunFlaresSunDiskSize;
}
set
{
if (_sunFlaresSunDiskSize != value)
{
_sunFlaresSunDiskSize = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresSunRayDiffractionIntensity
{
get
{
return _sunFlaresSunRayDiffractionIntensity;
}
set
{
if (_sunFlaresSunRayDiffractionIntensity != value)
{
_sunFlaresSunRayDiffractionIntensity = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresSunRayDiffractionThreshold
{
get
{
return _sunFlaresSunRayDiffractionThreshold;
}
set
{
if (_sunFlaresSunRayDiffractionThreshold != value)
{
_sunFlaresSunRayDiffractionThreshold = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresCoronaRays1Length
{
get
{
return _sunFlaresCoronaRays1Length;
}
set
{
if (_sunFlaresCoronaRays1Length != value)
{
_sunFlaresCoronaRays1Length = value;
UpdateMaterialProperties();
}
}
}
public int sunFlaresCoronaRays1Streaks
{
get
{
return _sunFlaresCoronaRays1Streaks;
}
set
{
if (_sunFlaresCoronaRays1Streaks != value)
{
_sunFlaresCoronaRays1Streaks = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresCoronaRays1Spread
{
get
{
return _sunFlaresCoronaRays1Spread;
}
set
{
if (_sunFlaresCoronaRays1Spread != value)
{
_sunFlaresCoronaRays1Spread = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresCoronaRays1AngleOffset
{
get
{
return _sunFlaresCoronaRays1AngleOffset;
}
set
{
if (_sunFlaresCoronaRays1AngleOffset != value)
{
_sunFlaresCoronaRays1AngleOffset = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresCoronaRays2Length
{
get
{
return _sunFlaresCoronaRays2Length;
}
set
{
if (_sunFlaresCoronaRays2Length != value)
{
_sunFlaresCoronaRays2Length = value;
UpdateMaterialProperties();
}
}
}
public int sunFlaresCoronaRays2Streaks
{
get
{
return _sunFlaresCoronaRays2Streaks;
}
set
{
if (_sunFlaresCoronaRays2Streaks != value)
{
_sunFlaresCoronaRays2Streaks = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresCoronaRays2Spread
{
get
{
return _sunFlaresCoronaRays2Spread;
}
set
{
if (_sunFlaresCoronaRays2Spread != value)
{
_sunFlaresCoronaRays2Spread = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresCoronaRays2AngleOffset
{
get
{
return _sunFlaresCoronaRays2AngleOffset;
}
set
{
if (_sunFlaresCoronaRays2AngleOffset != value)
{
_sunFlaresCoronaRays2AngleOffset = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts1Size
{
get
{
return _sunFlaresGhosts1Size;
}
set
{
if (_sunFlaresGhosts1Size != value)
{
_sunFlaresGhosts1Size = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts1Offset
{
get
{
return _sunFlaresGhosts1Offset;
}
set
{
if (_sunFlaresGhosts1Offset != value)
{
_sunFlaresGhosts1Offset = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts1Brightness
{
get
{
return _sunFlaresGhosts1Brightness;
}
set
{
if (_sunFlaresGhosts1Brightness != value)
{
_sunFlaresGhosts1Brightness = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts2Size
{
get
{
return _sunFlaresGhosts2Size;
}
set
{
if (_sunFlaresGhosts2Size != value)
{
_sunFlaresGhosts2Size = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts2Offset
{
get
{
return _sunFlaresGhosts2Offset;
}
set
{
if (_sunFlaresGhosts2Offset != value)
{
_sunFlaresGhosts2Offset = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts2Brightness
{
get
{
return _sunFlaresGhosts2Brightness;
}
set
{
if (_sunFlaresGhosts2Brightness != value)
{
_sunFlaresGhosts2Brightness = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts3Size
{
get
{
return _sunFlaresGhosts3Size;
}
set
{
if (_sunFlaresGhosts3Size != value)
{
_sunFlaresGhosts3Size = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts3Brightness
{
get
{
return _sunFlaresGhosts3Brightness;
}
set
{
if (_sunFlaresGhosts3Brightness != value)
{
_sunFlaresGhosts3Brightness = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts3Offset
{
get
{
return _sunFlaresGhosts3Offset;
}
set
{
if (_sunFlaresGhosts3Offset != value)
{
_sunFlaresGhosts3Offset = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts4Size
{
get
{
return _sunFlaresGhosts4Size;
}
set
{
if (_sunFlaresGhosts4Size != value)
{
_sunFlaresGhosts4Size = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts4Offset
{
get
{
return _sunFlaresGhosts4Offset;
}
set
{
if (_sunFlaresGhosts4Offset != value)
{
_sunFlaresGhosts4Offset = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresGhosts4Brightness
{
get
{
return _sunFlaresGhosts4Brightness;
}
set
{
if (_sunFlaresGhosts4Brightness != value)
{
_sunFlaresGhosts4Brightness = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresHaloOffset
{
get
{
return _sunFlaresHaloOffset;
}
set
{
if (_sunFlaresHaloOffset != value)
{
_sunFlaresHaloOffset = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresHaloAmplitude
{
get
{
return _sunFlaresHaloAmplitude;
}
set
{
if (_sunFlaresHaloAmplitude != value)
{
_sunFlaresHaloAmplitude = value;
UpdateMaterialProperties();
}
}
}
public float sunFlaresHaloIntensity
{
get
{
return _sunFlaresHaloIntensity;
}
set
{
if (_sunFlaresHaloIntensity != value)
{
_sunFlaresHaloIntensity = value;
UpdateMaterialProperties();
}
}
}
public bool sunFlaresRotationDeadZone
{
get
{
return _sunFlaresRotationDeadZone;
}
set
{
if (_sunFlaresRotationDeadZone != value)
{
_sunFlaresRotationDeadZone = value;
UpdateMaterialProperties();
}
}
}
public bool blur
{
get
{
return _blur;
}
set
{
if (_blur != value)
{
_blur = value;
UpdateMaterialProperties();
}
}
}
public float blurIntensity
{
get
{
return _blurIntensity;
}
set
{
if (_blurIntensity != value)
{
_blurIntensity = value;
UpdateMaterialProperties();
}
}
}
public int pixelateAmount
{
get
{
return _pixelateAmount;
}
set
{
if (_pixelateAmount != value)
{
_pixelateAmount = value;
UpdateMaterialProperties();
}
}
}
public bool pixelateDownscale
{
get
{
return _pixelateDownscale;
}
set
{
if (_pixelateDownscale != value)
{
_pixelateDownscale = value;
UpdateMaterialProperties();
}
}
}
public float antialiasStrength
{
get
{
return _antialiasStrength;
}
set
{
if (_antialiasStrength != value)
{
_antialiasStrength = value;
UpdateMaterialProperties();
}
}
}
public float antialiasDepthThreshold
{
get
{
return _antialiasDepthThreshold;
}
set
{
if (_antialiasDepthThreshold != value)
{
_antialiasDepthThreshold = value;
UpdateMaterialProperties();
}
}
}
public static Beautify instance
{
get
{
if (_beautify == null)
{
Camera[] allCameras = Camera.allCameras;
foreach (Camera camera in allCameras)
{
_beautify = camera.GetComponent<Beautify>();
if (_beautify != null)
{
break;
}
}
}
return _beautify;
}
}
public Camera cameraEffect
{
get
{
return currentCamera;
}
}
public float depthOfFieldCurrentFocalPointDistance
{
get
{
return dofLastAutofocusDistance;
}
}
private void OnEnable()
{
currentCamera = GetComponent<Camera>();
if (_profile != null)
{
_profile.Load(this);
}
UpdateMaterialPropertiesNow();
}
private void OnDestroy()
{
CleanUpRT();
if (depthCamObj != null)
{
UnityEngine.Object.DestroyImmediate(depthCamObj);
depthCamObj = null;
}
if (rtEAacum != null)
{
rtEAacum.Release();
}
if (rtEAHist != null)
{
rtEAHist.Release();
}
if (bMatDesktop != null)
{
UnityEngine.Object.DestroyImmediate(bMatDesktop);
bMatDesktop = null;
}
if (bMatMobile != null)
{
UnityEngine.Object.DestroyImmediate(bMatMobile);
bMatMobile = null;
}
if (bMatBasic != null)
{
UnityEngine.Object.DestroyImmediate(bMatBasic);
bMatBasic = null;
}
bMat = null;
}
private void Reset()
{
UpdateMaterialPropertiesNow();
}
private void LateUpdate()
{
if (bMat == null || !Application.isPlaying || _sharpenMotionSensibility <= 0f)
{
return;
}
float num = Vector3.Angle(camPrevForward, currentCamera.transform.forward) * _sharpenMotionSensibility;
float num2 = (currentCamera.transform.position - camPrevPos).sqrMagnitude * 10f * _sharpenMotionSensibility;
float num3 = num + num2;
if (num3 > 0.1f)
{
camPrevForward = currentCamera.transform.forward;
camPrevPos = currentCamera.transform.position;
if (num3 > _sharpenMotionSensibility)
{
num3 = _sharpenMotionSensibility;
}
currSens += num3;
float min = _sharpen * _sharpenMotionSensibility * 0.75f;
float max = _sharpen * (1f + _sharpenMotionSensibility) * 0.5f;
currSens = Mathf.Clamp(currSens, min, max);
}
else
{
if (currSens <= 0.001f)
{
return;
}
currSens *= 0.75f;
}
float num4 = Mathf.Clamp(_sharpen - currSens, 0f, _sharpen);
UpdateSharpenParams(num4);
}
private void OnPreCull()
{
bool flag = (_bloom || _anamorphicFlares) && (int)_bloomCullingMask != 0;
if (base.enabled && base.gameObject.activeSelf && !(currentCamera == null) && !(bMat == null) && (_depthOfField || flag))
{
CleanUpRT();
if (dofCurrentLayerMaskValue != _depthOfFieldExclusionLayerMask.value)
{
shouldUpdateMaterialProperties = true;
}
if (depthOfField && (_depthOfFieldTransparencySupport || (int)_depthOfFieldExclusionLayerMask != 0))
{
CheckDoFTransparencySupport();
CheckDoFExclusionMask();
}
if (flag)
{
CheckBloomCullingLayer();
}
}
}
private void OnPreRender()
{
if (_pixelateDownscale && _pixelateAmount > 1 && rtDescBase.width > 1 && rtDescBase.height > 1)
{
RenderTextureDescriptor desc = rtDescBase;
desc.width = Mathf.RoundToInt(Mathf.Max(1, currentCamera.pixelWidth / _pixelateAmount));
float num = (float)currentCamera.pixelHeight / (float)currentCamera.pixelWidth;
desc.height = Mathf.Max(1, Mathf.RoundToInt((float)desc.width * num));
pixelateTexture = RenderTexture.GetTemporary(desc);
currentCamera.targetTexture = pixelateTexture;
}
}
private void CleanUpRT()
{
if (dofDepthTexture != null)
{
RenderTexture.ReleaseTemporary(dofDepthTexture);
dofDepthTexture = null;
}
if (dofExclusionTexture != null)
{
RenderTexture.ReleaseTemporary(dofExclusionTexture);
dofExclusionTexture = null;
}
if (bloomSourceTexture != null)
{
RenderTexture.ReleaseTemporary(bloomSourceTexture);
bloomSourceTexture = null;
}
if (bloomSourceDepthTexture != null)
{
RenderTexture.ReleaseTemporary(bloomSourceDepthTexture);
bloomSourceDepthTexture = null;
}
if (pixelateTexture != null)
{
RenderTexture.ReleaseTemporary(pixelateTexture);
pixelateTexture = null;
}
}
private void CheckDoFTransparencySupport()
{
if (depthCam == null)
{
if (depthCamObj == null)
{
depthCamObj = new GameObject("DepthCamera");
depthCamObj.hideFlags = HideFlags.HideAndDontSave;
depthCam = depthCamObj.AddComponent<Camera>();
depthCam.enabled = false;
}
else
{
depthCam = depthCamObj.GetComponent<Camera>();
if (depthCam == null)
{
UnityEngine.Object.DestroyImmediate(depthCamObj);
depthCamObj = null;
return;
}
}
}
depthCam.CopyFrom(currentCamera);
depthCam.rect = new Rect(0f, 0f, 1f, 1f);
depthCam.depthTextureMode = DepthTextureMode.None;
depthCam.renderingPath = RenderingPath.Forward;
float num = _depthOfFieldTransparencySupportDownsampling * (float)_depthOfFieldDownsampling;
dofDepthTexture = RenderTexture.GetTemporary((int)((float)currentCamera.pixelWidth / num), (int)((float)currentCamera.pixelHeight / num), 16, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
dofDepthTexture.filterMode = FilterMode.Point;
depthCam.backgroundColor = new Color(84f / 85f, 0.4470558f, 0.75f, 0f);
depthCam.clearFlags = CameraClearFlags.Color;
depthCam.targetTexture = dofDepthTexture;
depthCam.cullingMask = _depthOfFieldTransparencyLayerMask;
if (depthShader == null)
{
depthShader = Shader.Find("Beautify/CopyDepth");
}
depthCam.RenderWithShader(depthShader, "RenderType");
bMat.SetTexture("_DepthTexture", dofDepthTexture);
}
private void CheckDoFExclusionMask()
{
if (depthCam == null)
{
if (depthCamObj == null)
{
depthCamObj = new GameObject("DepthCamera");
depthCamObj.hideFlags = HideFlags.HideAndDontSave;
depthCam = depthCamObj.AddComponent<Camera>();
depthCam.enabled = false;
}
else
{
depthCam = depthCamObj.GetComponent<Camera>();
if (depthCam == null)
{
UnityEngine.Object.DestroyImmediate(depthCamObj);
depthCamObj = null;
return;
}
}
}
depthCam.CopyFrom(currentCamera);
depthCam.rect = new Rect(0f, 0f, 1f, 1f);
depthCam.depthTextureMode = DepthTextureMode.None;
depthCam.renderingPath = RenderingPath.Forward;
float num = _depthOfFieldExclusionLayerMaskDownsampling * (float)_depthOfFieldDownsampling;
dofExclusionTexture = RenderTexture.GetTemporary((int)((float)currentCamera.pixelWidth / num), (int)((float)currentCamera.pixelHeight / num), 16, RenderTextureFormat.ARGB32, RenderTextureReadWrite.Linear);
dofExclusionTexture.filterMode = FilterMode.Point;
depthCam.backgroundColor = new Color(84f / 85f, 0.4470558f, 0.75f, 0f);
depthCam.clearFlags = CameraClearFlags.Color;
depthCam.targetTexture = dofExclusionTexture;
depthCam.cullingMask = _depthOfFieldExclusionLayerMask;
if (dofExclusionShader == null)
{
dofExclusionShader = Shader.Find("Beautify/CopyDepthBiased");
}
depthCam.RenderWithShader(dofExclusionShader, null);
bMat.SetTexture("_DofExclusionTexture", dofExclusionTexture);
}
private void CheckBloomCullingLayer()
{
if (depthCam == null)
{
if (depthCamObj == null)
{
depthCamObj = new GameObject("DepthCamera");
depthCamObj.hideFlags = HideFlags.HideAndDontSave;
depthCam = depthCamObj.AddComponent<Camera>();
depthCam.enabled = false;
}
else
{
depthCam = depthCamObj.GetComponent<Camera>();
if (depthCam == null)
{
UnityEngine.Object.DestroyImmediate(depthCamObj);
depthCamObj = null;
return;
}
}
}
depthCam.CopyFrom(currentCamera);
depthCam.rect = new Rect(0f, 0f, 1f, 1f);
depthCam.depthTextureMode = DepthTextureMode.None;
depthCam.allowMSAA = false;
depthCam.allowHDR = false;
int num;
if (_quality == BEAUTIFY_QUALITY.BestPerformance)
{
num = 256;
}
else
{
num = ((!_bloomUltra) ? 512 : (currentCamera.pixelHeight / 4 * 4));
num = (int)((float)num * (1f / _bloomLayerMaskDownsampling) / 4f) * 4;
}
float num2 = (float)currentCamera.pixelHeight / (float)currentCamera.pixelWidth;
bloomSourceTexture = RenderTexture.GetTemporary(num, Mathf.Max(1, (int)((float)num * num2)), 0, rtFormat);
bloomSourceDepthTexture = RenderTexture.GetTemporary(bloomSourceTexture.width, bloomSourceTexture.height, 24, RenderTextureFormat.Depth);
depthCam.clearFlags = CameraClearFlags.Color;
depthCam.stereoTargetEye = StereoTargetEyeMask.None;
depthCam.renderingPath = RenderingPath.Forward;
depthCam.backgroundColor = Color.black;
depthCam.SetTargetBuffers(bloomSourceTexture.colorBuffer, bloomSourceDepthTexture.depthBuffer);
depthCam.cullingMask = _bloomCullingMask;
depthCam.Render();
bMat.SetTexture("_BloomSourceTex", bloomSourceTexture);
bMat.SetTexture("_BloomSourceDepth", bloomSourceDepthTexture);
}
protected virtual void OnRenderImage(RenderTexture source, RenderTexture destination)
{
if (bMat == null || !base.enabled)
{
Graphics.Blit(source, destination);
return;
}
if (shouldUpdateMaterialProperties)
{
UpdateMaterialPropertiesNow();
}
bool flag = _quality != BEAUTIFY_QUALITY.Basic;
rtDescBase = source.descriptor;
rtDescBase.msaaSamples = 1;
rtDescBase.colorFormat = rtFormat;
rtDescBase.depthBufferBits = 0;
RenderTexture renderTexture = null;
RenderTexture renderTexture2 = null;
RenderTexture renderTexture3 = null;
float num = (float)source.height / (float)source.width;
bool flag2 = _blur && _blurIntensity > 0f && flag;
if (renderPass == 0 || flag2)
{
if (flag2)
{
int num2;
if (_blurIntensity < 1f)
{
num2 = (int)Mathf.Lerp(currentCamera.pixelWidth, 512f, _blurIntensity);
if (_quality == BEAUTIFY_QUALITY.BestPerformance)
{
num2 /= 2;
}
}
else
{
num2 = ((_quality != BEAUTIFY_QUALITY.BestQuality) ? 256 : 512);
num2 = (int)((float)num2 / _blurIntensity);
}
RenderTextureDescriptor desc = rtDescBase;
desc.width = num2;
desc.height = Mathf.Max(1, (int)((float)num2 * num));
renderTexture2 = RenderTexture.GetTemporary(desc);
if (renderPass == 0)
{
renderTexture = RenderTexture.GetTemporary(desc);
}
}
else
{
renderTexture = RenderTexture.GetTemporary(rtDescBase);
}
}
RenderTexture renderTexture4 = null;
RenderTexture renderTexture5 = null;
if (flag)
{
if (_pixelateAmount > 1)
{
source.filterMode = FilterMode.Point;
if (!_pixelateDownscale)
{
RenderTextureDescriptor desc2 = rtDescBase;
desc2.width = Mathf.RoundToInt(Mathf.Max(1, source.width / _pixelateAmount));
desc2.height = Mathf.Max(1, Mathf.RoundToInt((float)desc2.width * num));
renderTexture4 = RenderTexture.GetTemporary(desc2);
renderTexture4.filterMode = FilterMode.Point;
Graphics.Blit(source, renderTexture4, bMat, (_quality != BEAUTIFY_QUALITY.BestQuality) ? 18 : 22);
source = renderTexture4;
}
}
if (_depthOfField)
{
UpdateDepthOfFieldData();
int pass = ((_quality != BEAUTIFY_QUALITY.BestQuality) ? 6 : 12);
RenderTextureDescriptor desc3 = rtDescBase;
desc3.width = source.width / _depthOfFieldDownsampling;
desc3.height = source.height / _depthOfFieldDownsampling;
renderTexture5 = RenderTexture.GetTemporary(desc3);
renderTexture5.filterMode = _depthOfFieldFilterMode;
Graphics.Blit(source, renderTexture5, bMat, pass);
pass = ((_quality != BEAUTIFY_QUALITY.BestQuality) ? ((!_depthOfFieldBokeh) ? 15 : 8) : ((!_depthOfFieldBokeh) ? 19 : 14));
if (_quality == BEAUTIFY_QUALITY.BestQuality && _depthOfFieldForegroundBlur && _depthOfFieldForegroundBlurHQ)
{
BlurThisAlpha(renderTexture5, 16f);
}
BlurThisDoF(renderTexture5, pass);
if (_depthOfFieldDebug)
{
source.MarkRestoreExpected();
pass = ((_quality != BEAUTIFY_QUALITY.BestQuality) ? 7 : 13);
Graphics.Blit(renderTexture5, destination, bMat, pass);
RenderTexture.ReleaseTemporary(renderTexture5);
return;
}
bMat.SetTexture("_DoFTex", renderTexture5);
}
}
bool flag3 = _sunFlares && _sun != null;
if (flag && (_lensDirt || _bloom || _anamorphicFlares || flag3))
{
RenderTexture renderTexture6 = null;
int num3;
int num4;
if (_quality == BEAUTIFY_QUALITY.BestPerformance)
{
num3 = 4;
num4 = 256;
}
else
{
num3 = 5;
num4 = ((!_bloomUltra) ? 512 : (source.height / 4 * 4));
}
if (rt == null || rt.Length != num3 + 1)
{
rt = new RenderTexture[num3 + 1];
}
if (rtAF == null || rtAF.Length != num3 + 1)
{
rtAF = new RenderTexture[num3 + 1];
}
if (_bloom || (_lensDirt && !_anamorphicFlares))
{
UpdateMaterialBloomIntensityAndThreshold();
RenderTextureDescriptor desc4 = rtDescBase;
for (int i = 0; i <= num3; i++)
{
desc4.width = num4;
desc4.height = Mathf.Max(1, (int)((float)num4 * num));
rt[i] = RenderTexture.GetTemporary(desc4);
num4 /= 2;
}
renderTexture6 = rt[0];
if (_quality == BEAUTIFY_QUALITY.BestQuality && _bloomAntiflicker)
{
Graphics.Blit(source, rt[0], bMat, 9);
}
else
{
Graphics.Blit(source, rt[0], bMat, 2);
}
BlurThis(rt[0]);
for (int j = 0; j < num3; j++)
{
if (_quality == BEAUTIFY_QUALITY.BestPerformance)
{
if (_bloomBlur)
{
BlurThisDownscaling(rt[j], rt[j + 1]);
}
else
{
Graphics.Blit(rt[j], rt[j + 1], bMat, 18);
}
}
else
{
Graphics.Blit(rt[j], rt[j + 1], bMat, 7);
BlurThis(rt[j + 1]);
}
}
if (_bloom)
{
for (int num5 = num3; num5 > 0; num5--)
{
rt[num5 - 1].MarkRestoreExpected();
Graphics.Blit(rt[num5], rt[num5 - 1], bMat, (_quality != BEAUTIFY_QUALITY.BestQuality) ? 13 : 8);
}
if (quality == BEAUTIFY_QUALITY.BestQuality && _bloomCustomize)
{
bMat.SetTexture("_BloomTex4", rt[4]);
bMat.SetTexture("_BloomTex3", rt[3]);
bMat.SetTexture("_BloomTex2", rt[2]);
bMat.SetTexture("_BloomTex1", rt[1]);
bMat.SetTexture("_BloomTex", rt[0]);
RenderTextureDescriptor descriptor = rt[0].descriptor;
renderTexture3 = RenderTexture.GetTemporary(descriptor);
renderTexture6 = renderTexture3;
Graphics.Blit(rt[num3], renderTexture6, bMat, 6);
}
}
}
if (_anamorphicFlares)
{
UpdateMaterialAnamorphicIntensityAndThreshold();
int num6 = ((_quality != BEAUTIFY_QUALITY.BestPerformance) ? ((!_anamorphicFlaresUltra) ? 512 : (source.height / 4 * 4)) : 256);
RenderTextureDescriptor desc5 = rtDescBase;
int num7 = num6;
for (int k = 0; k <= num3; k++)
{
if (_anamorphicFlaresVertical)
{
desc5.width = num7;
desc5.height = Mathf.Max(1, (int)((float)num6 * num / _anamorphicFlaresSpread));
rtAF[k] = RenderTexture.GetTemporary(desc5);
}
else
{
desc5.width = Mathf.Max(1, (int)((float)num6 * num / _anamorphicFlaresSpread));
desc5.height = num7;
rtAF[k] = RenderTexture.GetTemporary(desc5);
}
num6 /= 2;
}
if (_anamorphicFlaresAntiflicker && _quality == BEAUTIFY_QUALITY.BestQuality)
{
Graphics.Blit(source, rtAF[0], bMat, 9);
}
else
{
Graphics.Blit(source, rtAF[0], bMat, 2);
}
rtAF[0] = BlurThisOneDirection(rtAF[0], _anamorphicFlaresVertical);
for (int l = 0; l < num3; l++)
{
if (_quality == BEAUTIFY_QUALITY.BestPerformance)
{
Graphics.Blit(rtAF[l], rtAF[l + 1], bMat, 18);
if (_anamorphicFlaresBlur)
{
rtAF[l + 1] = BlurThisOneDirection(rtAF[l + 1], _anamorphicFlaresVertical);
}
}
else
{
Graphics.Blit(rtAF[l], rtAF[l + 1], bMat, 7);
rtAF[l + 1] = BlurThisOneDirection(rtAF[l + 1], _anamorphicFlaresVertical);
}
}
for (int num8 = num3; num8 > 0; num8--)
{
rtAF[num8 - 1].MarkRestoreExpected();
if (num8 == 1)
{
Graphics.Blit(rtAF[num8], rtAF[num8 - 1], bMat, (_quality != BEAUTIFY_QUALITY.BestQuality) ? 14 : 10);
}
else
{
Graphics.Blit(rtAF[num8], rtAF[num8 - 1], bMat, (_quality != BEAUTIFY_QUALITY.BestQuality) ? 13 : 8);
}
}
if (_bloom)
{
if (_lensDirt)
{
rt[3].MarkRestoreExpected();
Graphics.Blit(rtAF[3], rt[3], bMat, (_quality != BEAUTIFY_QUALITY.BestQuality) ? 13 : 11);
}
renderTexture6.MarkRestoreExpected();
Graphics.Blit(rtAF[0], renderTexture6, bMat, (_quality != BEAUTIFY_QUALITY.BestQuality) ? 13 : 11);
}
else
{
renderTexture6 = rtAF[0];
}
UpdateMaterialBloomIntensityAndThreshold();
}
if (flag3)
{
Vector3 vector = currentCamera.transform.position - _sun.transform.forward * 1000f;
Vector3 vector2 = currentCamera.WorldToViewportPoint(vector);
float num9 = 0f;
if (vector2.z > 0f && vector2.x >= -0.1f && vector2.x < 1.1f && vector2.y >= -0.1f && vector2.y < 1.1f)
{
Ray ray = new Ray(currentCamera.transform.position, (vector - currentCamera.transform.position).normalized);
if (!Physics.Raycast(ray, currentCamera.farClipPlane, _sunFlaresLayerMask))
{
Vector2 vector3 = vector2 - Vector3.one * 0.5f;
num9 = _sunFlaresIntensity * Mathf.Clamp01((0.6f - Mathf.Max(Mathf.Abs(vector3.x), Mathf.Abs(vector3.y))) / 0.6f);
}
}
sunFlareCurrentIntensity = Mathf.Lerp(sunFlareCurrentIntensity, num9, (!Application.isPlaying) ? 1f : 0.5f);
if (sunFlareCurrentIntensity > 0f)
{
if (num9 > 0f)
{
sunLastScrPos = vector2;
}
bMat.SetColor("_SunTint", _sunFlaresTint * sunFlareCurrentIntensity);
sunLastScrPos.z = 0.5f + sunFlareTime * _sunFlaresSolarWindSpeed;
Vector2 vector4 = new Vector2(0.5f - sunLastScrPos.y, sunLastScrPos.x - 0.5f);
if (!_sunFlaresRotationDeadZone || vector4.sqrMagnitude > 0.00025f)
{
sunLastRot = Mathf.Atan2(vector4.x, vector4.y);
}
sunLastScrPos.w = sunLastRot;
sunFlareTime += Time.deltaTime;
bMat.SetVector("_SunPos", sunLastScrPos);
RenderTextureDescriptor desc6 = rtDescBase;
desc6.width = currentCamera.pixelWidth / _sunFlaresDownsampling;
desc6.height = currentCamera.pixelHeight / _sunFlaresDownsampling;
RenderTexture temporary = RenderTexture.GetTemporary(desc6);
Graphics.Blit(pass: (_quality != BEAUTIFY_QUALITY.BestQuality) ? ((!(renderTexture6 != null)) ? 16 : 17) : ((!(renderTexture6 != null)) ? 20 : 21), source: renderTexture6, dest: temporary, mat: bMat);
if (_lensDirt && _bloom)
{
rt[3].MarkRestoreExpected();
Graphics.Blit(temporary, rt[3], bMat, (_quality != BEAUTIFY_QUALITY.BestQuality) ? 13 : 11);
}
renderTexture6 = temporary;
RenderTexture.ReleaseTemporary(temporary);
if (!_bloom && !_anamorphicFlares)
{
bMat.SetVector("_Bloom", Vector4.one);
if (!bMat.IsKeywordEnabled("BEAUTIFY_BLOOM"))
{
bMat.EnableKeyword("BEAUTIFY_BLOOM");
}
}
}
}
if (renderTexture6 != null)
{
bMat.SetTexture("_BloomTex", renderTexture6);
}
else
{
if (bMat.IsKeywordEnabled("BEAUTIFY_BLOOM"))
{
bMat.DisableKeyword("BEAUTIFY_BLOOM");
}
bMat.SetVector("_Bloom", Vector4.zero);
}
if (_lensDirt)
{
bMat.SetTexture("_ScreenLum", (!_anamorphicFlares || _bloom) ? rt[3] : rtAF[3]);
}
}
if (_lensDirt)
{
Vector4 value = new Vector4(1f, 1f / (1.01f - _lensDirtIntensity), _lensDirtThreshold, Mathf.Max(_bloomIntensity, 1f));
bMat.SetVector("_Dirt", value);
}
if (Application.isPlaying && flag && (_eyeAdaptation || _purkinje))
{
int num10 = ((_quality != BEAUTIFY_QUALITY.BestQuality) ? 8 : 9);
int num11 = (int)Mathf.Pow(2f, num10);
if (rtEA == null || rtEA.Length < num10)
{
rtEA = new RenderTexture[num10];
}
RenderTextureDescriptor desc7 = rtDescBase;
for (int m = 0; m < num10; m++)
{
desc7.width = num11;
desc7.height = num11;
rtEA[m] = RenderTexture.GetTemporary(desc7);
num11 /= 2;
}
Graphics.Blit(source, rtEA[0], bMat, (_quality != BEAUTIFY_QUALITY.BestQuality) ? 18 : 22);
int num12 = num10 - 1;
int num13 = ((_quality != BEAUTIFY_QUALITY.BestQuality) ? 9 : 15);
for (int n = 0; n < num12; n++)
{
Graphics.Blit(rtEA[n], rtEA[n + 1], bMat, (n != 0) ? (num13 + 1) : num13);
}
bMat.SetTexture("_EALumSrc", rtEA[num12]);
if (rtEAacum == null)
{
int pass2 = ((_quality != BEAUTIFY_QUALITY.BestQuality) ? 18 : 22);
RenderTextureDescriptor desc8 = rtDescBase;
desc8.width = 2;
desc8.height = 2;
rtEAacum = new RenderTexture(desc8);
Graphics.Blit(rtEA[num12], rtEAacum, bMat, pass2);
rtEAHist = new RenderTexture(desc8);
Graphics.Blit(rtEAacum, rtEAHist, bMat, pass2);
}
else
{
rtEAacum.MarkRestoreExpected();
Graphics.Blit(rtEA[num12], rtEAacum, bMat, num13 + 2);
Graphics.Blit(rtEAacum, rtEAHist, bMat, num13 + 3);
}
bMat.SetTexture("_EAHist", rtEAHist);
}
if (renderTexture != null)
{
Graphics.Blit(source, renderTexture, bMat, 1);
bMat.SetTexture("_CompareTex", renderTexture);
}
if (renderTexture2 != null)
{
float blurScale = ((!(_blurIntensity > 1f)) ? _blurIntensity : 1f);
if (renderTexture != null)
{
Graphics.Blit(renderTexture, renderTexture2, bMat, renderPass);
BlurThis(renderTexture2, blurScale);
}
else
{
BlurThisDownscaling(source, renderTexture2, blurScale);
}
BlurThis(renderTexture2, blurScale);
if (_quality == BEAUTIFY_QUALITY.BestQuality)
{
BlurThis(renderTexture2, blurScale);
}
if (renderTexture != null)
{
bMat.SetTexture("_CompareTex", renderTexture2);
Graphics.Blit(source, destination, bMat, renderPass);
}
else
{
Graphics.Blit(renderTexture2, destination, bMat, renderPass);
}
RenderTexture.ReleaseTemporary(renderTexture2);
}
else
{
Graphics.Blit(source, destination, bMat, renderPass);
}
if (rtEA != null)
{
for (int num14 = 0; num14 < rtEA.Length; num14++)
{
if (rtEA[num14] != null)
{
RenderTexture.ReleaseTemporary(rtEA[num14]);
rtEA[num14] = null;
}
}
}
if (rt != null)
{
for (int num15 = 0; num15 < rt.Length; num15++)
{
if (rt[num15] != null)
{
RenderTexture.ReleaseTemporary(rt[num15]);
rt[num15] = null;
}
}
}
if (rtAF != null)
{
for (int num16 = 0; num16 < rtAF.Length; num16++)
{
if (rtAF[num16] != null)
{
RenderTexture.ReleaseTemporary(rtAF[num16]);
rtAF[num16] = null;
}
}
}
if (renderTexture3 != null)
{
RenderTexture.ReleaseTemporary(renderTexture3);
}
if (renderTexture5 != null)
{
RenderTexture.ReleaseTemporary(renderTexture5);
}
if (renderTexture != null)
{
RenderTexture.ReleaseTemporary(renderTexture);
}
if (renderTexture4 != null)
{
RenderTexture.ReleaseTemporary(renderTexture4);
}
}
private void OnPostRender()
{
if (_pixelateDownscale && _pixelateAmount > 1 && pixelateTexture != null)
{
RenderTexture.active = null;
currentCamera.targetTexture = null;
pixelateTexture.filterMode = FilterMode.Point;
Graphics.Blit((Texture)pixelateTexture, (RenderTexture)null);
}
}
private void BlurThis(RenderTexture rt, float blurScale = 1f)
{
RenderTextureDescriptor descriptor = rt.descriptor;
RenderTexture temporary = RenderTexture.GetTemporary(descriptor);
temporary.filterMode = FilterMode.Bilinear;
bMat.SetFloat("_BlurScale", blurScale);
Graphics.Blit(rt, temporary, bMat, 4);
Graphics.Blit(temporary, rt, bMat, 5);
RenderTexture.ReleaseTemporary(temporary);
}
private void BlurThisDownscaling(RenderTexture rt, RenderTexture downscaled, float blurScale = 1f)
{
RenderTextureDescriptor descriptor = rt.descriptor;
descriptor.width = downscaled.width;
descriptor.height = downscaled.height;
RenderTexture temporary = RenderTexture.GetTemporary(descriptor);
temporary.filterMode = FilterMode.Bilinear;
float num = rt.width / descriptor.width;
bMat.SetFloat("_BlurScale", blurScale * num);
Graphics.Blit(rt, temporary, bMat, 4);
bMat.SetFloat("_BlurScale", blurScale);
Graphics.Blit(temporary, downscaled, bMat, 5);
RenderTexture.ReleaseTemporary(temporary);
}
private RenderTexture BlurThisOneDirection(RenderTexture rt, bool vertical, float blurScale = 1f)
{
RenderTextureDescriptor descriptor = rt.descriptor;
RenderTexture temporary = RenderTexture.GetTemporary(descriptor);
temporary.filterMode = FilterMode.Bilinear;
bMat.SetFloat("_BlurScale", blurScale);
Graphics.Blit(rt, temporary, bMat, (!vertical) ? 4 : 5);
RenderTexture.ReleaseTemporary(rt);
return temporary;
}
private void BlurThisDoF(RenderTexture rt, int renderPass)
{
RenderTextureDescriptor descriptor = rt.descriptor;
RenderTexture temporary = RenderTexture.GetTemporary(descriptor);
RenderTexture temporary2 = RenderTexture.GetTemporary(descriptor);
temporary.filterMode = _depthOfFieldFilterMode;
temporary2.filterMode = _depthOfFieldFilterMode;
UpdateDepthOfFieldBlurData(new Vector2(0.44721f, -0.89443f));
Graphics.Blit(rt, temporary, bMat, renderPass);
UpdateDepthOfFieldBlurData(new Vector2(-1f, 0f));
Graphics.Blit(temporary, temporary2, bMat, renderPass);
UpdateDepthOfFieldBlurData(new Vector2(0.44721f, 0.89443f));
Graphics.Blit(temporary2, rt, bMat, renderPass);
RenderTexture.ReleaseTemporary(temporary2);
RenderTexture.ReleaseTemporary(temporary);
}
private void BlurThisAlpha(RenderTexture rt, float blurScale = 1f)
{
RenderTextureDescriptor descriptor = rt.descriptor;
RenderTexture temporary = RenderTexture.GetTemporary(descriptor);
temporary.filterMode = FilterMode.Bilinear;
bMat.SetFloat("_BlurScale", blurScale);
Graphics.Blit(rt, temporary, bMat, 23);
Graphics.Blit(temporary, rt, bMat, 24);
RenderTexture.ReleaseTemporary(temporary);
}
private void OnDidApplyAnimationProperties()
{
shouldUpdateMaterialProperties = true;
}
public void UpdateQualitySettings()
{
switch (_quality)
{
case BEAUTIFY_QUALITY.BestPerformance:
_depthOfFieldDownsampling = 2;
_depthOfFieldMaxSamples = 4;
_sunFlaresDownsampling = 2;
break;
case BEAUTIFY_QUALITY.BestQuality:
_depthOfFieldDownsampling = 1;
_depthOfFieldMaxSamples = 8;
_sunFlaresDownsampling = 1;
break;
}
isDirty = true;
}
public void UpdateMaterialProperties()
{
if (Application.isPlaying)
{
shouldUpdateMaterialProperties = true;
}
else
{
UpdateMaterialPropertiesNow();
}
}
public void UpdateMaterialPropertiesNow()
{
shouldUpdateMaterialProperties = false;
if (currentCamera != null && currentCamera.depthTextureMode == DepthTextureMode.None && _quality != BEAUTIFY_QUALITY.Basic)
{
currentCamera.depthTextureMode = DepthTextureMode.Depth;
}
string graphicsDeviceName = SystemInfo.graphicsDeviceName;
if (graphicsDeviceName != null && graphicsDeviceName.ToUpper().Contains("MALI-T720"))
{
rtFormat = RenderTextureFormat.Default;
_bloomBlur = false;
_anamorphicFlaresBlur = false;
}
else
{
rtFormat = (SystemInfo.SupportsRenderTextureFormat(RenderTextureFormat.ARGBHalf) ? RenderTextureFormat.ARGBHalf : RenderTextureFormat.ARGB32);
}
switch (_quality)
{
case BEAUTIFY_QUALITY.BestQuality:
if (bMatDesktop == null)
{
bMatDesktop = new Material(Shader.Find("Beautify/Beautify"));
bMatDesktop.hideFlags = HideFlags.DontSave;
}
bMat = bMatDesktop;
break;
case BEAUTIFY_QUALITY.BestPerformance:
if (bMatMobile == null)
{
bMatMobile = new Material(Shader.Find("Beautify/BeautifyMobile"));
bMatMobile.hideFlags = HideFlags.DontSave;
}
bMat = bMatMobile;
break;
case BEAUTIFY_QUALITY.Basic:
if (bMatBasic == null)
{
bMatBasic = new Material(Shader.Find("Beautify/BeautifyBasic"));
bMatBasic.hideFlags = HideFlags.DontSave;
}
bMat = bMatBasic;
break;
}
bool flag = QualitySettings.activeColorSpace == ColorSpace.Linear;
switch (_preset)
{
case BEAUTIFY_PRESET.Soft:
_sharpen = 2f;
if (flag)
{
_sharpen *= 2f;
}
_sharpenDepthThreshold = 0.035f;
_sharpenRelaxation = 0.065f;
_sharpenClamp = 0.4f;
_saturate = 0.5f;
_contrast = 1.005f;
_brightness = 1.05f;
_dither = 0.02f;
_ditherDepth = 0f;
_daltonize = 0f;
break;
case BEAUTIFY_PRESET.Medium:
_sharpen = 3f;
if (flag)
{
_sharpen *= 2f;
}
_sharpenDepthThreshold = 0.035f;
_sharpenRelaxation = 0.07f;
_sharpenClamp = 0.45f;
_saturate = 1f;
_contrast = 1.02f;
_brightness = 1.05f;
_dither = 0.02f;
_ditherDepth = 0f;
_daltonize = 0f;
break;
case BEAUTIFY_PRESET.Strong:
_sharpen = 4.75f;
if (flag)
{
_sharpen *= 2f;
}
_sharpenDepthThreshold = 0.035f;
_sharpenRelaxation = 0.075f;
_sharpenClamp = 0.5f;
_saturate = 1.5f;
_contrast = 1.03f;
_brightness = 1.05f;
_dither = 0.022f;
_ditherDepth = 0f;
_daltonize = 0f;
break;
case BEAUTIFY_PRESET.Exaggerated:
_sharpen = 6f;
if (flag)
{
_sharpen *= 2f;
}
_sharpenDepthThreshold = 0.035f;
_sharpenRelaxation = 0.08f;
_sharpenClamp = 0.55f;
_saturate = 2.25f;
_contrast = 1.035f;
_brightness = 1.05f;
_dither = 0.025f;
_ditherDepth = 0f;
_daltonize = 0f;
break;
}
isDirty = true;
if (bMat == null)
{
return;
}
renderPass = 1;
if (_pixelateAmount > 1)
{
if (QualitySettings.antiAliasing > 1)
{
QualitySettings.antiAliasing = 1;
}
if (_pixelateDownscale)
{
_dither = 0f;
}
}
UpdateSharpenParams(_sharpen);
bool flag2 = currentCamera != null && currentCamera.orthographic;
bMat.SetVector("_Dither", new Vector4(_dither, (!flag2) ? _ditherDepth : 0f, (_sharpenMaxDepth + _sharpenMinDepth) * 0.5f, Mathf.Abs(_sharpenMaxDepth - _sharpenMinDepth) * 0.5f + ((!flag2) ? 0f : 1000f)));
bMat.SetVector("_AntialiasData", new Vector3(_antialiasStrength, _antialiasDepthThreshold, 0f));
float y = ((!flag) ? _contrast : (1f + (_contrast - 1f) / 2.2f));
bMat.SetVector("_ColorBoost", new Vector4(_brightness, y, _saturate, _daltonize * 10f));
Color value = _vignettingColor;
value.a *= ((!_vignetting) ? 0f : 32f);
float num = 1f - _vignettingBlink * 2f;
if (num < 0f)
{
num = 0f;
}
value.r *= num;
value.g *= num;
value.b *= num;
bMat.SetColor("_Vignetting", value);
if (currentCamera != null)
{
bMat.SetFloat("_VignettingAspectRatio", (!_vignettingCircularShape || !(_vignettingBlink <= 0f)) ? (_vignettingAspectRatio + 1.001f / (1.001f - _vignettingBlink) - 1f) : (1f / currentCamera.aspect));
}
if (_frame)
{
Vector4 value2 = new Vector4(_frameColor.r, _frameColor.g, _frameColor.b, (1.00001f - _frameColor.a) * 0.5f);
bMat.SetVector("_Frame", value2);
}
bMat.SetColor("_Outline", _outlineColor);
float num2 = 1E-05f + _bloomWeight0 + _bloomWeight1 + _bloomWeight2 + _bloomWeight3 + _bloomWeight4 + _bloomWeight5;
bMat.SetVector("_BloomWeights", new Vector4(_bloomWeight0 / num2 + _bloomBoost0, _bloomWeight1 / num2 + _bloomBoost1, _bloomWeight2 / num2 + _bloomBoost2, _bloomWeight3 / num2 + _bloomBoost3));
bMat.SetVector("_BloomWeights2", new Vector4(_bloomWeight4 / num2 + _bloomBoost4, _bloomWeight5 / num2 + _bloomBoost5, _bloomMaxBrightness, num2));
if (_bloomDebug && (_bloom || _anamorphicFlares || _sunFlares))
{
renderPass = 3;
}
if (_sunFlares)
{
bMat.SetVector("_SunData", new Vector4(_sunFlaresSunIntensity, _sunFlaresSunDiskSize, _sunFlaresSunRayDiffractionIntensity, _sunFlaresSunRayDiffractionThreshold));
bMat.SetVector("_SunCoronaRays1", new Vector4(_sunFlaresCoronaRays1Length, Mathf.Max((float)_sunFlaresCoronaRays1Streaks / 2f, 1f), Mathf.Max(_sunFlaresCoronaRays1Spread, 0.0001f), _sunFlaresCoronaRays1AngleOffset));
bMat.SetVector("_SunCoronaRays2", new Vector4(_sunFlaresCoronaRays2Length, Mathf.Max((float)_sunFlaresCoronaRays2Streaks / 2f, 1f), Mathf.Max(_sunFlaresCoronaRays2Spread + 0.0001f), _sunFlaresCoronaRays2AngleOffset));
bMat.SetVector("_SunGhosts1", new Vector4(0f, _sunFlaresGhosts1Size, _sunFlaresGhosts1Offset, _sunFlaresGhosts1Brightness));
bMat.SetVector("_SunGhosts2", new Vector4(0f, _sunFlaresGhosts2Size, _sunFlaresGhosts2Offset, _sunFlaresGhosts2Brightness));
bMat.SetVector("_SunGhosts3", new Vector4(0f, _sunFlaresGhosts3Size, _sunFlaresGhosts3Offset, _sunFlaresGhosts3Brightness));
bMat.SetVector("_SunGhosts4", new Vector4(0f, _sunFlaresGhosts4Size, _sunFlaresGhosts4Offset, _sunFlaresGhosts4Brightness));
bMat.SetVector("_SunHalo", new Vector3(_sunFlaresHaloOffset, _sunFlaresHaloAmplitude, _sunFlaresHaloIntensity * 100f));
}
if (_lensDirtTexture == null)
{
_lensDirtTexture = Resources.Load<Texture2D>("Textures/dirt2");
}
bMat.SetTexture("_OverlayTex", _lensDirtTexture);
bMat.SetColor("_AFTint", _anamorphicFlaresTint);
if (_depthOfField && (int)_depthOfFieldAutofocusLayerMask != 0)
{
Shader.SetGlobalFloat("_BeautifyDepthBias", _depthOfFieldExclusionBias);
}
dofCurrentLayerMaskValue = _depthOfFieldExclusionLayerMask.value;
if (_compareMode)
{
renderPass = 0;
bMat.SetVector("_CompareParams", new Vector4(Mathf.Cos(_compareLineAngle), Mathf.Sin(_compareLineAngle), 0f - Mathf.Cos(_compareLineAngle), _compareLineWidth));
}
if (shaderKeywords == null)
{
shaderKeywords = new List<string>();
}
else
{
shaderKeywords.Clear();
}
if (_quality != BEAUTIFY_QUALITY.Basic)
{
if (_lut && _lutTexture != null)
{
shaderKeywords.Add("BEAUTIFY_LUT");
bMat.SetTexture("_LUTTex", _lutTexture);
bMat.SetColor("_FXColor", new Color(0f, 0f, 0f, _lutIntensity));
}
else if (_nightVision)
{
shaderKeywords.Add("BEAUTIFY_NIGHT_VISION");
Color value3 = _nightVisionColor;
if (flag)
{
value3.a *= 5f * value3.a;
}
else
{
value3.a *= 3f * value3.a;
}
value3.r *= value3.a;
value3.g *= value3.a;
value3.b *= value3.a;
bMat.SetColor("_FXColor", value3);
}
else if (_thermalVision)
{
shaderKeywords.Add("BEAUTIFY_THERMAL_VISION");
}
else if (_daltonize > 0f)
{
shaderKeywords.Add("BEAUTIFY_DALTONIZE");
}
else
{
bMat.SetColor("_FXColor", new Color(0f, 0f, 0f, _lutIntensity));
}
bMat.SetColor("_TintColor", _tintColor);
if (_sunFlares)
{
if (flareNoise == null)
{
flareNoise = Resources.Load<Texture2D>("Textures/flareNoise");
}
flareNoise.wrapMode = TextureWrapMode.Repeat;
bMat.SetTexture("_FlareTex", flareNoise);
if (_sun == null)
{
Light[] array = UnityEngine.Object.FindObjectsOfType<Light>();
foreach (Light light in array)
{
if (light.type == LightType.Directional && light.enabled && light.gameObject.activeSelf)
{
_sun = light.transform;
break;
}
}
}
}
if (_vignetting)
{
if (_vignettingMask != null)
{
bMat.SetTexture("_VignettingMask", _vignettingMask);
shaderKeywords.Add("BEAUTIFY_VIGNETTING_MASK");
}
else
{
shaderKeywords.Add("BEAUTIFY_VIGNETTING");
}
}
if (_frame)
{
if (_frameMask != null)
{
bMat.SetTexture("_FrameMask", _frameMask);
shaderKeywords.Add("BEAUTIFY_FRAME_MASK");
}
else
{
shaderKeywords.Add("BEAUTIFY_FRAME");
}
}
if (_outline)
{
shaderKeywords.Add("BEAUTIFY_OUTLINE");
}
if (_lensDirt)
{
shaderKeywords.Add("BEAUTIFY_DIRT");
}
if (_bloom || _anamorphicFlares || _sunFlares)
{
shaderKeywords.Add("BEAUTIFY_BLOOM");
if (_bloomDepthAtten > 0f)
{
bMat.SetFloat("_BloomDepthTreshold", _bloomDepthAtten);
shaderKeywords.Add("BEAUTIFY_BLOOM_USE_DEPTH");
}
if ((_bloom || _anamorphicFlares) && (int)_bloomCullingMask != 0)
{
bMat.SetFloat("_BloomLayerZBias", _bloomLayerZBias);
shaderKeywords.Add("BEAUTIFY_BLOOM_USE_LAYER");
}
}
if (_depthOfField)
{
if (_depthOfFieldTransparencySupport || (int)_depthOfFieldExclusionLayerMask != 0)
{
shaderKeywords.Add("BEAUTIFY_DEPTH_OF_FIELD_TRANSPARENT");
}
else
{
shaderKeywords.Add("BEAUTIFY_DEPTH_OF_FIELD");
}
}
if (_eyeAdaptation)
{
Vector4 value4 = new Vector4(_eyeAdaptationMinExposure, _eyeAdaptationMaxExposure, _eyeAdaptationSpeedToDark, _eyeAdaptationSpeedToLight);
bMat.SetVector("_EyeAdaptation", value4);
shaderKeywords.Add("BEAUTIFY_EYE_ADAPTATION");
}
if (_quality == BEAUTIFY_QUALITY.BestQuality && _tonemap == BEAUTIFY_TMO.ACES)
{
shaderKeywords.Add("BEAUTIFY_TONEMAP_ACES");
}
if (_purkinje || _vignetting)
{
float z = _vignettingFade + _vignettingBlink * 0.5f;
if (_vignettingBlink > 0.99f)
{
z = 1f;
}
Vector3 vector = new Vector3(_purkinjeAmount, _purkinjeLuminanceThreshold, z);
bMat.SetVector("_Purkinje", vector);
shaderKeywords.Add("BEAUTIFY_PURKINJE");
}
}
bMat.shaderKeywords = shaderKeywords.ToArray();
}
private void UpdateMaterialBloomIntensityAndThreshold()
{
float num = _bloomThreshold;
if (QualitySettings.activeColorSpace == ColorSpace.Linear)
{
num *= num;
}
bMat.SetVector("_Bloom", new Vector4(_bloomIntensity + ((!_anamorphicFlares) ? 0f : 0.0001f), 0f, 0f, num));
}
private void UpdateMaterialAnamorphicIntensityAndThreshold()
{
float num = _anamorphicFlaresThreshold;
if (QualitySettings.activeColorSpace == ColorSpace.Linear)
{
num *= num;
}
float x = _anamorphicFlaresIntensity / (_bloomIntensity + 0.0001f);
bMat.SetVector("_Bloom", new Vector4(x, 0f, 0f, num));
}
private void UpdateSharpenParams(float sharpen)
{
bMat.SetVector("_Sharpen", new Vector4(sharpen, _sharpenDepthThreshold, _sharpenClamp, _sharpenRelaxation));
}
private void UpdateDepthOfFieldData()
{
float num;
if (!_depthOfFieldAutofocus)
{
num = ((!(_depthOfFieldTargetFocus != null)) ? _depthOfFieldDistance : ((!(currentCamera.WorldToScreenPoint(_depthOfFieldTargetFocus.position).z < 0f)) ? Vector3.Distance(currentCamera.transform.position, _depthOfFieldTargetFocus.position) : currentCamera.farClipPlane));
}
else
{
UpdateDoFAutofocusDistance();
num = ((!(dofLastAutofocusDistance > 0f)) ? currentCamera.farClipPlane : dofLastAutofocusDistance);
}
if (OnBeforeFocus != null)
{
num = OnBeforeFocus(num);
}
dofPrevDistance = Mathf.Lerp(dofPrevDistance, num, (!Application.isPlaying) ? 1f : (_depthOfFieldFocusSpeed * Time.deltaTime * 30f));
float y = _depthOfFieldAperture * (_depthOfFieldFocalLength / Mathf.Max(dofPrevDistance - _depthOfFieldFocalLength, 0.001f)) * 41.666668f;
dofLastBokehData = new Vector4(dofPrevDistance, y, 0f, 0f);
bMat.SetVector("_BokehData", dofLastBokehData);
bMat.SetVector("_BokehData2", new Vector4((!_depthOfFieldForegroundBlur) ? currentCamera.farClipPlane : _depthOfFieldForegroundDistance, _depthOfFieldMaxSamples, _depthOfFieldBokehThreshold, _depthOfFieldBokehIntensity * _depthOfFieldBokehIntensity));
bMat.SetVector("_BokehData3", new Vector3(_depthOfFieldMaxBrightness, _depthOfFieldMaxDistance * (currentCamera.farClipPlane + 1f), 0f));
}
private void UpdateDepthOfFieldBlurData(Vector2 blurDir)
{
float num = 1f / (float)_depthOfFieldDownsampling;
blurDir *= num;
dofLastBokehData.z = blurDir.x;
dofLastBokehData.w = blurDir.y;
bMat.SetVector("_BokehData", dofLastBokehData);
}
private void UpdateDoFAutofocusDistance()
{
Vector3 position = _depthofFieldAutofocusViewportPoint;
position.z = 10f;
Ray ray = currentCamera.ViewportPointToRay(position);
RaycastHit hitInfo;
if (Physics.Raycast(ray, out hitInfo, currentCamera.farClipPlane, _depthOfFieldAutofocusLayerMask))
{
dofLastAutofocusDistance = Mathf.Clamp(hitInfo.distance, _depthOfFieldAutofocusMinDistance, _depthOfFieldAutofocusMaxDistance);
}
else
{
dofLastAutofocusDistance = currentCamera.farClipPlane;
}
}
public Texture2D GenerateSepiaLUT()
{
Texture2D texture2D = new Texture2D(1024, 32, TextureFormat.ARGB32, false, true);
Color[] array = new Color[32768];
Vector3 lhs = default(Vector3);
for (int i = 0; i < 32; i++)
{
for (int j = 0; j < 1024; j++)
{
lhs.z = (float)(j / 32 * 8) / 255f;
lhs.y = (float)(i * 8) / 255f;
lhs.x = (float)(j % 32 * 8) / 255f;
float r = Vector3.Dot(lhs, new Vector3(0.393f, 0.769f, 0.189f));
float g = Vector3.Dot(lhs, new Vector3(0.349f, 0.686f, 0.168f));
float b = Vector3.Dot(lhs, new Vector3(0.272f, 0.534f, 0.131f));
array[i * 1024 + j] = new Color(r, g, b);
}
}
texture2D.SetPixels(array);
texture2D.Apply();
return texture2D;
}
public void Blink(float duration, float maxValue = 1f)
{
if (!(duration <= 0f))
{
StartCoroutine(DoBlink(duration, maxValue));
}
}
private IEnumerator DoBlink(float duration, float maxValue)
{
float start = Time.time;
float t = 0f;
WaitForEndOfFrame w = new WaitForEndOfFrame();
do
{
t = (Time.time - start) / duration;
if (t > 1f)
{
t = 1f;
}
float easeOut = t * (2f - t);
vignettingBlink = easeOut * maxValue;
yield return w;
}
while (t < 1f);
start = Time.time;
do
{
t = (Time.time - start) / duration;
if (t > 1f)
{
t = 1f;
}
float easeIn = t * t;
vignettingBlink = (1f - easeIn) * maxValue;
yield return w;
}
while (t < 1f);
}
}
}
Reference in New Issue View Git Blame Copy Permalink