1048 lines
35 KiB
C#
1048 lines
35 KiB
C#
using System;
|
|
using UnityEngine;
|
|
|
|
namespace Artngame.SKYMASTER
|
|
{
|
|
[ExecuteInEditMode]
|
|
[RequireComponent(typeof(Camera), typeof(CloudTemporalAntiAliasing))]
|
|
public class CloudScriptTRANSP : SceneViewFilter
|
|
{
|
|
public enum RandomJitter
|
|
{
|
|
Off = 0,
|
|
Random = 1,
|
|
BlueNoise = 2
|
|
}
|
|
|
|
public CloudScript cloudsBelow;
|
|
|
|
public bool changeOnHeight = true;
|
|
|
|
public float changeAboveTranspHeight = 200f;
|
|
|
|
public Vector4 specialFX = new Vector4(0f, 0f, 1f, 0f);
|
|
|
|
public bool enableEdgeControl;
|
|
|
|
public int debugClouds;
|
|
|
|
public Vector4 edgeControl = new Vector4(1f, 1f, 1f, 1f);
|
|
|
|
public bool autoRegulateEdgeMode = true;
|
|
|
|
public float autoRegulateCutoffDistance = 1000f;
|
|
|
|
public float controlBackAlphaPower = 1f;
|
|
|
|
public float controlCloudAlphaPower = 0.001f;
|
|
|
|
private float controlBackAlphaPowerP = 1f;
|
|
|
|
private float controlCloudAlphaPowerP = 0.001f;
|
|
|
|
public Vector4 controlCloudEdgeA = new Vector4(1f, 1f, 1f, 1f);
|
|
|
|
public Vector4 controlCloudEdgeAP = new Vector4(1f, 1f, 1f, 1f);
|
|
|
|
public float depthDilation;
|
|
|
|
private float depthDilationP;
|
|
|
|
public bool useCustomTexture;
|
|
|
|
public Texture2D weatherTexture;
|
|
|
|
public Vector3 _CameraWSOffset = new Vector3(0f, 0f, 0f);
|
|
|
|
public float cameraScale = 1f;
|
|
|
|
public float extendFarPlaneAboveClouds = 1f;
|
|
|
|
public Vector4 YCutHeightDepthScale = new Vector4(0f, 1f, 0f, 1f);
|
|
|
|
public float multiplyStepsAboveClouds = 1f;
|
|
|
|
public Vector3 cloudDistanceParams = new Vector3(0f, 0f, 1f);
|
|
|
|
public int scatterOn = 1;
|
|
|
|
public int sunRaysOn;
|
|
|
|
public float sunRaysPower = 1f;
|
|
|
|
public float zeroCountSteps;
|
|
|
|
public int sunShaftSteps = 5;
|
|
|
|
public Vector4 raysResolution = new Vector4(1f, 1f, 1f, 1f);
|
|
|
|
public Vector4 rayShadowing = new Vector4(1f, 1f, 1f, 1f);
|
|
|
|
public bool enableShadowCastOnClouds;
|
|
|
|
public float shadowPower = 1f;
|
|
|
|
public Vector4 superCellControls = new Vector4(0f, 0f, 0f, 0f);
|
|
|
|
public int renderInFront;
|
|
|
|
public Texture2D _InteractTexture;
|
|
|
|
public Vector4 _InteractTexturePos = new Vector4(1f, 1f, 0f, 0f);
|
|
|
|
public Vector4 _InteractTextureAtr = new Vector4(1f, 1f, 0f, 0f);
|
|
|
|
public Vector4 _InteractTextureOffset = new Vector4(0f, 0f, 0f, 0f);
|
|
|
|
[Tooltip("Distance fog is based on radial distance from camera when checked")]
|
|
public bool useRadialDistance;
|
|
|
|
[Tooltip("Fog top Y coordinate")]
|
|
public float height = 1f;
|
|
|
|
[Range(1E-05f, 10f)]
|
|
public float heightDensity = 2f;
|
|
|
|
[Tooltip("Push fog away from the camera by this amount")]
|
|
public float startDistance;
|
|
|
|
public Light localLight;
|
|
|
|
public float localLightFalloff = 2f;
|
|
|
|
public float localLightIntensity = 1f;
|
|
|
|
public float currentLocalLightIntensity;
|
|
|
|
public float _Scatter = 0.008f;
|
|
|
|
public float _HGCoeff = 0.5f;
|
|
|
|
public float _Extinct = 0.01f;
|
|
|
|
public Vector3 _SkyTint = new Vector3(0.5f, 0.5f, 0.5f);
|
|
|
|
public float _BackShade = 1f;
|
|
|
|
public float luminance = 0.8f;
|
|
|
|
public float lumFac = 0.9f;
|
|
|
|
public float ScatterFac = 24.4f;
|
|
|
|
public float TurbFac = 324.74f;
|
|
|
|
public float HorizFac = 1f;
|
|
|
|
public float turbidity = 10f;
|
|
|
|
public float reileigh = 0.8f;
|
|
|
|
public float mieCoefficient = 0.1f;
|
|
|
|
public float mieDirectionalG = 0.7f;
|
|
|
|
public float bias = 0.6f;
|
|
|
|
public float contrast = 4.12f;
|
|
|
|
public bool FogSky;
|
|
|
|
public Vector3 TintColor = new Vector3(68f, 155f, 345f);
|
|
|
|
public float ClearSkyFac = 1f;
|
|
|
|
[Header("Vortex")]
|
|
public bool enableVORTEX;
|
|
|
|
public Vector3 vortexPosition = new Vector3(0f, 0f, 0f);
|
|
|
|
public float vortexRadius = 1000f;
|
|
|
|
public Vector4 vortexControls = new Vector4(1f, 1f, 1f, 1f);
|
|
|
|
[Header("Debugging")]
|
|
public bool debugNoLowFreqNoise;
|
|
|
|
public bool debugNoHighFreqNoise;
|
|
|
|
public bool debugNoCurlNoise;
|
|
|
|
[Header("Performance")]
|
|
[Range(1f, 1024f)]
|
|
public int steps = 256;
|
|
|
|
public bool adjustDensity = true;
|
|
|
|
public AnimationCurve stepDensityAdjustmentCurve = new AnimationCurve(new Keyframe(0f, 3.019f), new Keyframe(0.25f, 1.233f), new Keyframe(0.5f, 1f), new Keyframe(1f, 0.892f));
|
|
|
|
public bool allowFlyingInClouds;
|
|
|
|
[Range(1f, 8f)]
|
|
public int downSample = 2;
|
|
|
|
public Texture2D blueNoiseTexture;
|
|
|
|
public RandomJitter randomJitterNoise = RandomJitter.BlueNoise;
|
|
|
|
public bool temporalAntiAliasing = true;
|
|
|
|
[Header("Cloud modeling")]
|
|
public Gradient gradientLow;
|
|
|
|
public Gradient gradientMed;
|
|
|
|
public Gradient gradientHigh;
|
|
|
|
public Texture2D curlNoise;
|
|
|
|
public TextAsset lowFreqNoise;
|
|
|
|
public TextAsset highFreqNoise;
|
|
|
|
public float startHeight = 1500f;
|
|
|
|
public float thickness = 4000f;
|
|
|
|
public float planetSize = 35000f;
|
|
|
|
public Vector3 planetZeroCoordinate = new Vector3(0f, 0f, 0f);
|
|
|
|
[Range(0f, 1f)]
|
|
public float scale = 0.3f;
|
|
|
|
[Range(0f, 32f)]
|
|
public float detailScale = 13.9f;
|
|
|
|
[Range(0f, 1f)]
|
|
public float lowFreqMin = 0.366f;
|
|
|
|
[Range(0f, 1f)]
|
|
public float lowFreqMax = 0.8f;
|
|
|
|
[Range(0f, 1f)]
|
|
public float highFreqModifier = 0.21f;
|
|
|
|
[Range(0f, 10f)]
|
|
public float curlDistortScale = 7.44f;
|
|
|
|
[Range(0f, 1000f)]
|
|
public float curlDistortAmount = 407f;
|
|
|
|
[Range(0f, 1f)]
|
|
public float weatherScale = 0.1f;
|
|
|
|
[Range(0f, 2f)]
|
|
public float coverage = 1.06f;
|
|
|
|
[Range(0f, 2f)]
|
|
public float cloudSampleMultiplier = 1f;
|
|
|
|
[Header("High altitude clouds")]
|
|
public Texture2D cloudsHighTexture;
|
|
|
|
[Range(0f, 2f)]
|
|
public float coverageHigh = 2f;
|
|
|
|
[Range(0f, 2f)]
|
|
public float highCoverageScale = 1f;
|
|
|
|
[Range(0f, 1f)]
|
|
public float highCloudsScale = 0.02f;
|
|
|
|
[Header("Cloud Lighting")]
|
|
public Light sunLight;
|
|
|
|
public Color cloudBaseColor = new Color32(199, 220, byte.MaxValue, 0);
|
|
|
|
public Color cloudTopColor = new Color32(byte.MaxValue, byte.MaxValue, byte.MaxValue, byte.MaxValue);
|
|
|
|
[Range(0f, 1f)]
|
|
public float ambientLightFactor = 0.551f;
|
|
|
|
[Range(0f, 5f)]
|
|
public float sunLightFactor = 3.79f;
|
|
|
|
public Color highSunColor = new Color32(byte.MaxValue, 252, 210, byte.MaxValue);
|
|
|
|
public Color lowSunColor = new Color32(byte.MaxValue, 174, 0, byte.MaxValue);
|
|
|
|
[Range(0f, 1f)]
|
|
public float henyeyGreensteinGForward = 0.4f;
|
|
|
|
[Range(0f, 1f)]
|
|
public float henyeyGreensteinGBackward = 0.179f;
|
|
|
|
[Range(0f, 200f)]
|
|
public float lightStepLength = 64f;
|
|
|
|
[Range(0f, 1f)]
|
|
public float lightConeRadius = 0.4f;
|
|
|
|
public bool randomUnitSphere = true;
|
|
|
|
[Range(0f, 4f)]
|
|
public float density = 1f;
|
|
|
|
public bool aLotMoreLightSamples;
|
|
|
|
[Header("Animating")]
|
|
public float globalMultiplier = 1f;
|
|
|
|
public float windSpeed = 15.9f;
|
|
|
|
public float windDirection = -22.4f;
|
|
|
|
public float coverageWindSpeed = 25f;
|
|
|
|
public float coverageWindDirection = 5f;
|
|
|
|
public float highCloudsWindSpeed = 49.2f;
|
|
|
|
public float highCloudsWindDirection = 77.8f;
|
|
|
|
private Vector3 _windOffset;
|
|
|
|
private Vector2 _coverageWindOffset;
|
|
|
|
private Vector2 _highCloudsWindOffset;
|
|
|
|
private Vector3 _windDirectionVector;
|
|
|
|
private float _multipliedWindSpeed;
|
|
|
|
private Texture3D _cloudShapeTexture;
|
|
|
|
private Texture3D _cloudDetailTexture;
|
|
|
|
private CloudTemporalAntiAliasing _temporalAntiAliasing;
|
|
|
|
private Material _CloudMaterial;
|
|
|
|
private Material _UpscaleMaterial;
|
|
|
|
public Camera _CurrentCamera;
|
|
|
|
private Matrix4x4 left_world_from_view;
|
|
|
|
private Matrix4x4 right_world_from_view;
|
|
|
|
private Matrix4x4 left_screen_from_view;
|
|
|
|
private Matrix4x4 right_screen_from_view;
|
|
|
|
private Matrix4x4 left_view_from_screen;
|
|
|
|
private Matrix4x4 right_view_from_screen;
|
|
|
|
private GradientColorKey[] colorKey;
|
|
|
|
private GradientAlphaKey[] alphaKey;
|
|
|
|
public Material CloudMaterial
|
|
{
|
|
get
|
|
{
|
|
if (!_CloudMaterial)
|
|
{
|
|
_CloudMaterial = new Material(Shader.Find("Hidden/Clouds"));
|
|
_CloudMaterial.hideFlags = HideFlags.HideAndDontSave;
|
|
}
|
|
return _CloudMaterial;
|
|
}
|
|
}
|
|
|
|
public Material UpscaleMaterial
|
|
{
|
|
get
|
|
{
|
|
if (!_UpscaleMaterial)
|
|
{
|
|
_UpscaleMaterial = new Material(Shader.Find("Hidden/CloudBlender"));
|
|
_UpscaleMaterial.hideFlags = HideFlags.HideAndDontSave;
|
|
}
|
|
return _UpscaleMaterial;
|
|
}
|
|
}
|
|
|
|
public Camera CurrentCamera
|
|
{
|
|
get
|
|
{
|
|
if (!_CurrentCamera)
|
|
{
|
|
_CurrentCamera = GetComponent<Camera>();
|
|
}
|
|
return _CurrentCamera;
|
|
}
|
|
}
|
|
|
|
private void Reset()
|
|
{
|
|
_temporalAntiAliasing = GetComponent<CloudTemporalAntiAliasing>();
|
|
_temporalAntiAliasing.SetCamera(CurrentCamera);
|
|
}
|
|
|
|
private void Awake()
|
|
{
|
|
Reset();
|
|
if (useCustomTexture)
|
|
{
|
|
CloudMaterial.SetTexture("_WeatherTexture", weatherTexture);
|
|
}
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
controlBackAlphaPowerP = controlBackAlphaPower;
|
|
controlCloudAlphaPowerP = controlCloudAlphaPower;
|
|
depthDilationP = depthDilation;
|
|
controlCloudEdgeAP = controlCloudEdgeA;
|
|
if ((bool)_CloudMaterial)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(_CloudMaterial);
|
|
}
|
|
if ((bool)_UpscaleMaterial)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(_UpscaleMaterial);
|
|
}
|
|
_windOffset = new Vector3(0f, 0f, 0f);
|
|
_coverageWindOffset = new Vector3(0.5f / (weatherScale * 0.00025f), 0.5f / (weatherScale * 0.00025f));
|
|
_highCloudsWindOffset = new Vector3(1500f, -900f);
|
|
if (useCustomTexture)
|
|
{
|
|
CloudMaterial.SetTexture("_WeatherTexture", weatherTexture);
|
|
}
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
if (gradientLow == null)
|
|
{
|
|
createGradient(ref gradientLow);
|
|
}
|
|
if (gradientMed == null)
|
|
{
|
|
createGradient(ref gradientMed);
|
|
}
|
|
if (gradientHigh == null)
|
|
{
|
|
createGradient(ref gradientHigh);
|
|
}
|
|
if (sunLight == null && !Application.isPlaying)
|
|
{
|
|
controlWeatherTOD_SM_SRP component = base.transform.gameObject.GetComponent<controlWeatherTOD_SM_SRP>();
|
|
if (component != null && component.temporalSunMoon != null)
|
|
{
|
|
Light component2 = component.temporalSunMoon.GetComponent<Light>();
|
|
if (component2 != null)
|
|
{
|
|
sunLight = component2;
|
|
}
|
|
}
|
|
if (sunLight == null)
|
|
{
|
|
Light[] array = UnityEngine.Object.FindObjectsOfType(typeof(Light)) as Light[];
|
|
Light[] array2 = array;
|
|
foreach (Light light in array2)
|
|
{
|
|
if (light.type == LightType.Directional && light.gameObject.name.Contains("Sun") && light.enabled && light.gameObject.activeInHierarchy)
|
|
{
|
|
sunLight = light;
|
|
break;
|
|
}
|
|
}
|
|
if (sunLight == null)
|
|
{
|
|
array2 = array;
|
|
foreach (Light light2 in array2)
|
|
{
|
|
if (light2.type == LightType.Directional && light2.gameObject.activeInHierarchy)
|
|
{
|
|
sunLight = light2;
|
|
break;
|
|
}
|
|
}
|
|
if (sunLight == null)
|
|
{
|
|
Light light3 = new GameObject
|
|
{
|
|
name = "Sky Master Sun"
|
|
}.AddComponent<Light>();
|
|
sunLight = light3;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if (autoRegulateEdgeMode && Application.isPlaying)
|
|
{
|
|
if (Camera.main.transform.position.y > autoRegulateCutoffDistance)
|
|
{
|
|
controlBackAlphaPower = 1f;
|
|
controlCloudAlphaPower = 0.001f;
|
|
depthDilation = 0f;
|
|
controlCloudEdgeA = Vector4.Lerp(controlCloudEdgeA, new Vector4(1f, 1f, 1f, 1f), Time.deltaTime * 0.4f);
|
|
}
|
|
else
|
|
{
|
|
controlBackAlphaPower = controlBackAlphaPowerP;
|
|
controlCloudAlphaPower = controlCloudAlphaPowerP;
|
|
depthDilation = depthDilationP;
|
|
controlCloudEdgeA = Vector4.Lerp(controlCloudEdgeA, controlCloudEdgeAP, Time.deltaTime * 0.4f);
|
|
}
|
|
}
|
|
_multipliedWindSpeed = windSpeed * globalMultiplier;
|
|
float f = windDirection * (MathF.PI / 180f);
|
|
_windDirectionVector = new Vector3(Mathf.Cos(f), -0.25f, Mathf.Sin(f));
|
|
_windOffset += _multipliedWindSpeed * _windDirectionVector * Time.deltaTime;
|
|
float f2 = coverageWindDirection * (MathF.PI / 180f);
|
|
Vector2 vector = new Vector2(Mathf.Cos(f2), Mathf.Sin(f2));
|
|
_coverageWindOffset += coverageWindSpeed * globalMultiplier * vector * Time.deltaTime;
|
|
float f3 = highCloudsWindDirection * (MathF.PI / 180f);
|
|
Vector2 vector2 = new Vector2(Mathf.Cos(f3), Mathf.Sin(f3));
|
|
_highCloudsWindOffset += highCloudsWindSpeed * globalMultiplier * vector2 * Time.deltaTime;
|
|
}
|
|
|
|
private void OnDestroy()
|
|
{
|
|
if ((bool)_CloudMaterial)
|
|
{
|
|
UnityEngine.Object.DestroyImmediate(_CloudMaterial);
|
|
}
|
|
}
|
|
|
|
private void OnDrawGizmos()
|
|
{
|
|
Gizmos.color = Color.green;
|
|
Matrix4x4 frustumCorners = GetFrustumCorners(CurrentCamera);
|
|
Vector3 position = CurrentCamera.transform.position;
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
frustumCorners.SetRow(i, CurrentCamera.cameraToWorldMatrix * frustumCorners.GetRow(i));
|
|
Gizmos.DrawLine(position, position + (Vector3)frustumCorners.GetRow(i));
|
|
}
|
|
Gizmos.color = Color.red;
|
|
int num = 10;
|
|
for (int j = 1; j < num; j++)
|
|
{
|
|
float t = (float)j / (float)num;
|
|
Vector3 a = Vector3.Lerp(frustumCorners.GetRow(0), frustumCorners.GetRow(1), t);
|
|
Vector3 b = Vector3.Lerp(frustumCorners.GetRow(3), frustumCorners.GetRow(2), t);
|
|
for (int k = 1; k < num; k++)
|
|
{
|
|
float t2 = (float)k / (float)num;
|
|
Vector3 normalized = Vector3.Lerp(a, b, t2).normalized;
|
|
Gizmos.DrawLine(position + normalized, position + normalized * 1.2f);
|
|
}
|
|
}
|
|
}
|
|
|
|
private Vector4 gradientToVector4(Gradient gradient)
|
|
{
|
|
if (gradient.colorKeys.Length != 4)
|
|
{
|
|
return new Vector4(0f, 0f, 0f, 0f);
|
|
}
|
|
float time = gradient.colorKeys[0].time;
|
|
float time2 = gradient.colorKeys[1].time;
|
|
float time3 = gradient.colorKeys[2].time;
|
|
float time4 = gradient.colorKeys[3].time;
|
|
return new Vector4(time, time2, time3, time4);
|
|
}
|
|
|
|
public void OnRenderImage(RenderTexture source, RenderTexture destination)
|
|
{
|
|
changeOnHeight = cloudsBelow.changeOnHeight;
|
|
changeAboveTranspHeight = cloudsBelow.changeAboveTranspHeight;
|
|
specialFX = cloudsBelow.specialFX;
|
|
enableEdgeControl = cloudsBelow.enableEdgeControl;
|
|
debugClouds = cloudsBelow.debugClouds;
|
|
edgeControl = cloudsBelow.edgeControl;
|
|
autoRegulateEdgeMode = cloudsBelow.autoRegulateEdgeMode;
|
|
autoRegulateCutoffDistance = cloudsBelow.autoRegulateCutoffDistance;
|
|
controlBackAlphaPower = cloudsBelow.controlBackAlphaPower;
|
|
controlCloudAlphaPower = cloudsBelow.controlCloudAlphaPower;
|
|
controlCloudEdgeA = cloudsBelow.controlCloudEdgeA;
|
|
controlCloudEdgeAP = cloudsBelow.controlCloudEdgeAP;
|
|
depthDilation = cloudsBelow.depthDilation;
|
|
useCustomTexture = cloudsBelow.useCustomTexture;
|
|
weatherTexture = cloudsBelow.weatherTexture;
|
|
_CameraWSOffset = cloudsBelow._CameraWSOffset;
|
|
scatterOn = cloudsBelow.scatterOn;
|
|
sunRaysOn = cloudsBelow.sunRaysOn;
|
|
extendFarPlaneAboveClouds = cloudsBelow.extendFarPlaneAboveClouds;
|
|
cameraScale = cloudsBelow.cameraScale;
|
|
YCutHeightDepthScale = cloudsBelow.YCutHeightDepthScale;
|
|
multiplyStepsAboveClouds = cloudsBelow.multiplyStepsAboveClouds;
|
|
cloudDistanceParams = cloudsBelow.cloudDistanceParams;
|
|
sunRaysPower = cloudsBelow.sunRaysPower;
|
|
raysResolution = cloudsBelow.raysResolution;
|
|
rayShadowing = cloudsBelow.rayShadowing;
|
|
enableShadowCastOnClouds = cloudsBelow.enableShadowCastOnClouds;
|
|
shadowPower = cloudsBelow.shadowPower;
|
|
superCellControls = cloudsBelow.superCellControls;
|
|
zeroCountSteps = cloudsBelow.zeroCountSteps;
|
|
sunShaftSteps = cloudsBelow.sunShaftSteps;
|
|
renderInFront = cloudsBelow.renderInFront;
|
|
_InteractTexture = cloudsBelow._InteractTexture;
|
|
_InteractTexturePos = cloudsBelow._InteractTexturePos;
|
|
_InteractTextureAtr = cloudsBelow._InteractTextureAtr;
|
|
_InteractTextureOffset = cloudsBelow._InteractTextureOffset;
|
|
useRadialDistance = cloudsBelow.useRadialDistance;
|
|
height = cloudsBelow.height;
|
|
heightDensity = cloudsBelow.heightDensity;
|
|
startDistance = cloudsBelow.startDistance;
|
|
localLight = cloudsBelow.localLight;
|
|
localLightFalloff = cloudsBelow.localLightFalloff;
|
|
localLightIntensity = cloudsBelow.localLightIntensity;
|
|
currentLocalLightIntensity = cloudsBelow.currentLocalLightIntensity;
|
|
_Scatter = cloudsBelow._Scatter;
|
|
_HGCoeff = cloudsBelow._HGCoeff;
|
|
_Extinct = cloudsBelow._Extinct;
|
|
_SkyTint = cloudsBelow._SkyTint;
|
|
_BackShade = cloudsBelow._BackShade;
|
|
luminance = cloudsBelow.luminance;
|
|
lumFac = cloudsBelow.lumFac;
|
|
ScatterFac = cloudsBelow.ScatterFac;
|
|
TurbFac = cloudsBelow.TurbFac;
|
|
HorizFac = cloudsBelow.HorizFac;
|
|
turbidity = cloudsBelow.turbidity;
|
|
reileigh = cloudsBelow.reileigh;
|
|
mieCoefficient = cloudsBelow.mieCoefficient;
|
|
mieDirectionalG = cloudsBelow.mieDirectionalG;
|
|
bias = cloudsBelow.bias;
|
|
contrast = cloudsBelow.contrast;
|
|
FogSky = cloudsBelow.FogSky;
|
|
TintColor = cloudsBelow.TintColor;
|
|
ClearSkyFac = cloudsBelow.ClearSkyFac;
|
|
enableVORTEX = cloudsBelow.enableVORTEX;
|
|
vortexPosition = cloudsBelow.vortexPosition;
|
|
vortexRadius = cloudsBelow.vortexRadius;
|
|
vortexControls = cloudsBelow.vortexControls;
|
|
debugNoLowFreqNoise = cloudsBelow.debugNoLowFreqNoise;
|
|
debugNoHighFreqNoise = cloudsBelow.debugNoHighFreqNoise;
|
|
debugNoCurlNoise = cloudsBelow.debugNoCurlNoise;
|
|
steps = cloudsBelow.steps;
|
|
adjustDensity = cloudsBelow.adjustDensity;
|
|
stepDensityAdjustmentCurve = cloudsBelow.stepDensityAdjustmentCurve;
|
|
allowFlyingInClouds = cloudsBelow.allowFlyingInClouds;
|
|
downSample = cloudsBelow.downSample;
|
|
blueNoiseTexture = cloudsBelow.blueNoiseTexture;
|
|
temporalAntiAliasing = cloudsBelow.temporalAntiAliasing;
|
|
gradientLow = cloudsBelow.gradientLow;
|
|
gradientMed = cloudsBelow.gradientMed;
|
|
gradientHigh = cloudsBelow.gradientHigh;
|
|
curlNoise = cloudsBelow.curlNoise;
|
|
lowFreqNoise = cloudsBelow.lowFreqNoise;
|
|
highFreqNoise = cloudsBelow.highFreqNoise;
|
|
startHeight = cloudsBelow.startHeight;
|
|
thickness = cloudsBelow.thickness;
|
|
planetSize = cloudsBelow.planetSize;
|
|
planetZeroCoordinate = cloudsBelow.planetZeroCoordinate;
|
|
scale = cloudsBelow.scale;
|
|
detailScale = cloudsBelow.detailScale;
|
|
lowFreqMin = cloudsBelow.lowFreqMin;
|
|
lowFreqMax = cloudsBelow.lowFreqMax;
|
|
highFreqModifier = cloudsBelow.highFreqModifier;
|
|
curlDistortScale = cloudsBelow.curlDistortScale;
|
|
curlDistortAmount = cloudsBelow.curlDistortAmount;
|
|
weatherScale = cloudsBelow.weatherScale;
|
|
coverage = cloudsBelow.coverage;
|
|
cloudSampleMultiplier = cloudsBelow.cloudSampleMultiplier;
|
|
cloudsHighTexture = cloudsBelow.cloudsHighTexture;
|
|
coverageHigh = cloudsBelow.coverageHigh;
|
|
highCoverageScale = cloudsBelow.highCoverageScale;
|
|
highCloudsScale = cloudsBelow.highCloudsScale;
|
|
sunLight = cloudsBelow.sunLight;
|
|
cloudBaseColor = cloudsBelow.cloudBaseColor;
|
|
cloudTopColor = cloudsBelow.cloudTopColor;
|
|
ambientLightFactor = cloudsBelow.ambientLightFactor;
|
|
sunLightFactor = cloudsBelow.sunLightFactor;
|
|
highSunColor = cloudsBelow.highSunColor;
|
|
lowSunColor = cloudsBelow.lowSunColor;
|
|
henyeyGreensteinGForward = cloudsBelow.henyeyGreensteinGForward;
|
|
henyeyGreensteinGBackward = cloudsBelow.henyeyGreensteinGBackward;
|
|
lightStepLength = cloudsBelow.lightStepLength;
|
|
lightConeRadius = cloudsBelow.lightConeRadius;
|
|
randomUnitSphere = cloudsBelow.randomUnitSphere;
|
|
density = cloudsBelow.density;
|
|
aLotMoreLightSamples = cloudsBelow.aLotMoreLightSamples;
|
|
globalMultiplier = cloudsBelow.globalMultiplier;
|
|
windSpeed = cloudsBelow.windSpeed;
|
|
windDirection = cloudsBelow.windDirection;
|
|
coverageWindSpeed = cloudsBelow.coverageWindSpeed;
|
|
coverageWindDirection = cloudsBelow.coverageWindDirection;
|
|
highCloudsWindSpeed = cloudsBelow.highCloudsWindSpeed;
|
|
highCloudsWindDirection = cloudsBelow.highCloudsWindDirection;
|
|
CloudMaterial.SetTexture("_WeatherTexture", cloudsBelow.CloudMaterial.GetTexture("_WeatherTexture"));
|
|
if (changeOnHeight && Camera.main != null && Camera.main.transform.position.y <= changeAboveTranspHeight)
|
|
{
|
|
Graphics.Blit(source, destination);
|
|
return;
|
|
}
|
|
if (CloudMaterial == null || curlNoise == null || blueNoiseTexture == null || lowFreqNoise == null || highFreqNoise == null)
|
|
{
|
|
Graphics.Blit(source, destination);
|
|
return;
|
|
}
|
|
if (_cloudShapeTexture == null)
|
|
{
|
|
_cloudShapeTexture = TGALoader.load3DFromTGASlices(lowFreqNoise);
|
|
}
|
|
if (_cloudDetailTexture == null)
|
|
{
|
|
_cloudDetailTexture = TGALoader.load3DFromTGASlices(highFreqNoise);
|
|
}
|
|
Vector3 position = CurrentCamera.transform.position;
|
|
float num = sunLightFactor;
|
|
float num2 = ambientLightFactor;
|
|
float x = sunLight.transform.eulerAngles.x;
|
|
Color value = highSunColor;
|
|
float num3 = henyeyGreensteinGBackward;
|
|
float num4 = 1E-05f + scale * 0.0004f;
|
|
if (x > 170f)
|
|
{
|
|
float num5 = Mathf.Max(0f, (x - 330f) / 30f);
|
|
float num6 = num5 * num5;
|
|
num *= num5;
|
|
num2 *= num5;
|
|
num3 *= num6 * num5;
|
|
num2 = Mathf.Max(0.02f, num2);
|
|
value = Color.Lerp(lowSunColor, highSunColor, num6);
|
|
}
|
|
updateMaterialKeyword(enableVORTEX, "DEBUG_NO_LOW_FREQ_NOISE");
|
|
CloudMaterial.SetVector("vortexPosRadius", new Vector4(vortexPosition.x, vortexPosition.y, vortexPosition.z, vortexRadius));
|
|
CloudMaterial.SetVector("vortexControlsA", vortexControls);
|
|
updateMaterialKeyword(debugNoHighFreqNoise, "DEBUG_NO_HIGH_FREQ_NOISE");
|
|
updateMaterialKeyword(allowFlyingInClouds, "ALLOW_IN_CLOUDS");
|
|
updateMaterialKeyword(randomUnitSphere, "RANDOM_UNIT_SPHERE");
|
|
updateMaterialKeyword(aLotMoreLightSamples, "SLOW_LIGHTING");
|
|
switch (randomJitterNoise)
|
|
{
|
|
case RandomJitter.Off:
|
|
updateMaterialKeyword(b: false, "RANDOM_JITTER_WHITE");
|
|
updateMaterialKeyword(b: false, "RANDOM_JITTER_BLUE");
|
|
break;
|
|
case RandomJitter.Random:
|
|
updateMaterialKeyword(b: true, "RANDOM_JITTER_WHITE");
|
|
updateMaterialKeyword(b: false, "RANDOM_JITTER_BLUE");
|
|
break;
|
|
case RandomJitter.BlueNoise:
|
|
updateMaterialKeyword(b: false, "RANDOM_JITTER_WHITE");
|
|
updateMaterialKeyword(b: true, "RANDOM_JITTER_BLUE");
|
|
break;
|
|
}
|
|
CloudMaterial.SetVector("_SunDir", sunLight.transform ? (-sunLight.transform.forward).normalized : Vector3.up);
|
|
CloudMaterial.SetVector("_PlanetCenter", planetZeroCoordinate - new Vector3(0f, planetSize, 0f));
|
|
CloudMaterial.SetVector("_ZeroPoint", planetZeroCoordinate);
|
|
CloudMaterial.SetColor("_SunColor", value);
|
|
CloudMaterial.SetColor("_CloudBaseColor", cloudBaseColor);
|
|
CloudMaterial.SetColor("_CloudTopColor", cloudTopColor);
|
|
CloudMaterial.SetFloat("_AmbientLightFactor", num2);
|
|
CloudMaterial.SetFloat("_SunLightFactor", num);
|
|
CloudMaterial.SetTexture("_ShapeTexture", _cloudShapeTexture);
|
|
CloudMaterial.SetTexture("_DetailTexture", _cloudDetailTexture);
|
|
CloudMaterial.SetTexture("_CurlNoise", curlNoise);
|
|
CloudMaterial.SetTexture("_BlueNoise", blueNoiseTexture);
|
|
CloudMaterial.SetVector("_Randomness", new Vector4(UnityEngine.Random.value, UnityEngine.Random.value, UnityEngine.Random.value, UnityEngine.Random.value));
|
|
CloudMaterial.SetTexture("_AltoClouds", cloudsHighTexture);
|
|
CloudMaterial.SetFloat("_CoverageHigh", 1f - coverageHigh);
|
|
CloudMaterial.SetFloat("_CoverageHighScale", highCoverageScale * weatherScale * 0.001f);
|
|
CloudMaterial.SetFloat("_HighCloudsScale", highCloudsScale * 0.002f);
|
|
CloudMaterial.SetFloat("_CurlDistortAmount", 150f + curlDistortAmount);
|
|
CloudMaterial.SetFloat("_CurlDistortScale", curlDistortScale * num4);
|
|
CloudMaterial.SetFloat("_LightConeRadius", lightConeRadius);
|
|
CloudMaterial.SetFloat("_LightStepLength", lightStepLength);
|
|
CloudMaterial.SetFloat("_SphereSize", planetSize);
|
|
CloudMaterial.SetVector("_CloudHeightMinMax", new Vector2(startHeight, startHeight + thickness));
|
|
CloudMaterial.SetFloat("_Thickness", thickness);
|
|
CloudMaterial.SetFloat("_Scale", num4);
|
|
CloudMaterial.SetFloat("_DetailScale", detailScale * num4);
|
|
CloudMaterial.SetVector("_LowFreqMinMax", new Vector4(lowFreqMin, lowFreqMax));
|
|
CloudMaterial.SetFloat("_HighFreqModifier", highFreqModifier);
|
|
CloudMaterial.SetFloat("_WeatherScale", weatherScale * 0.00025f);
|
|
CloudMaterial.SetFloat("_Coverage", 1f - coverage);
|
|
CloudMaterial.SetFloat("_HenyeyGreensteinGForward", henyeyGreensteinGForward);
|
|
CloudMaterial.SetFloat("_HenyeyGreensteinGBackward", 0f - num3);
|
|
if (adjustDensity)
|
|
{
|
|
CloudMaterial.SetFloat("_SampleMultiplier", cloudSampleMultiplier * stepDensityAdjustmentCurve.Evaluate((float)steps / 256f));
|
|
}
|
|
else
|
|
{
|
|
CloudMaterial.SetFloat("_SampleMultiplier", cloudSampleMultiplier);
|
|
}
|
|
CloudMaterial.SetFloat("_Density", density);
|
|
CloudMaterial.SetFloat("_WindSpeed", _multipliedWindSpeed);
|
|
CloudMaterial.SetVector("_WindDirection", _windDirectionVector);
|
|
CloudMaterial.SetVector("_WindOffset", _windOffset);
|
|
CloudMaterial.SetVector("_CoverageWindOffset", _coverageWindOffset);
|
|
CloudMaterial.SetVector("_HighCloudsWindOffset", _highCloudsWindOffset);
|
|
if (gradientLow == null)
|
|
{
|
|
createGradient(ref gradientLow);
|
|
}
|
|
if (gradientMed == null)
|
|
{
|
|
createGradient(ref gradientMed);
|
|
}
|
|
if (gradientHigh == null)
|
|
{
|
|
createGradient(ref gradientHigh);
|
|
}
|
|
CloudMaterial.SetVector("_Gradient1", gradientToVector4(gradientLow));
|
|
CloudMaterial.SetVector("_Gradient2", gradientToVector4(gradientMed));
|
|
CloudMaterial.SetVector("_Gradient3", gradientToVector4(gradientHigh));
|
|
CloudMaterial.SetInt("_Steps", steps);
|
|
CloudMaterial.SetInt("_renderInFront", renderInFront);
|
|
CloudMaterial.SetMatrix("_FrustumCornersES", GetFrustumCorners(CurrentCamera));
|
|
if (CurrentCamera.stereoEnabled)
|
|
{
|
|
left_world_from_view = CurrentCamera.GetStereoViewMatrix(Camera.StereoscopicEye.Left).inverse;
|
|
right_world_from_view = CurrentCamera.GetStereoViewMatrix(Camera.StereoscopicEye.Right).inverse;
|
|
left_screen_from_view = CurrentCamera.GetStereoProjectionMatrix(Camera.StereoscopicEye.Left);
|
|
right_screen_from_view = CurrentCamera.GetStereoProjectionMatrix(Camera.StereoscopicEye.Right);
|
|
left_view_from_screen = GL.GetGPUProjectionMatrix(left_screen_from_view, renderIntoTexture: true).inverse;
|
|
right_view_from_screen = GL.GetGPUProjectionMatrix(right_screen_from_view, renderIntoTexture: true).inverse;
|
|
left_view_from_screen[1, 1] *= -1f;
|
|
right_view_from_screen[1, 1] *= -1f;
|
|
CloudMaterial.SetMatrix("_LeftWorldFromView", left_world_from_view);
|
|
CloudMaterial.SetMatrix("_RightWorldFromView", right_world_from_view);
|
|
CloudMaterial.SetMatrix("_LeftViewFromScreen", left_view_from_screen);
|
|
CloudMaterial.SetMatrix("_RightViewFromScreen", right_view_from_screen);
|
|
}
|
|
else
|
|
{
|
|
left_world_from_view = CurrentCamera.cameraToWorldMatrix;
|
|
left_screen_from_view = CurrentCamera.projectionMatrix;
|
|
left_view_from_screen = GL.GetGPUProjectionMatrix(left_screen_from_view, renderIntoTexture: true).inverse;
|
|
left_view_from_screen[1, 1] *= -1f;
|
|
CloudMaterial.SetMatrix("_LeftWorldFromView", left_world_from_view);
|
|
CloudMaterial.SetMatrix("_LeftViewFromScreen", left_view_from_screen);
|
|
}
|
|
CloudMaterial.SetMatrix("_CameraInvViewMatrix", CurrentCamera.cameraToWorldMatrix);
|
|
CloudMaterial.SetVector("_CameraWS", position);
|
|
CloudMaterial.SetVector("_CameraWSOffset", _CameraWSOffset);
|
|
CloudMaterial.SetFloat("_FarPlane", CurrentCamera.farClipPlane);
|
|
CloudMaterial.SetFloat("extendFarPlaneAboveClouds", extendFarPlaneAboveClouds);
|
|
CloudMaterial.SetFloat("cameraScale", cameraScale);
|
|
CloudMaterial.SetVector("YCutHeightDepthScale", YCutHeightDepthScale);
|
|
CloudMaterial.SetFloat("multiplyStepsAboveClouds", multiplyStepsAboveClouds);
|
|
CloudMaterial.SetTexture("_InteractTexture", _InteractTexture);
|
|
CloudMaterial.SetVector("_InteractTexturePos", _InteractTexturePos);
|
|
CloudMaterial.SetVector("_InteractTextureAtr", _InteractTextureAtr);
|
|
CloudMaterial.SetVector("_InteractTextureOffset", _InteractTextureOffset);
|
|
CloudMaterial.SetInt("scatterOn", scatterOn);
|
|
CloudMaterial.SetInt("sunRaysOn", sunRaysOn);
|
|
CloudMaterial.SetFloat("sunRaysPower", sunRaysPower);
|
|
CloudMaterial.SetVector("raysResolution", raysResolution);
|
|
CloudMaterial.SetVector("rayShadowing", rayShadowing);
|
|
CloudMaterial.SetFloat("shadowPower", shadowPower);
|
|
CloudMaterial.SetVector("superCellControlsA", superCellControls);
|
|
updateMaterialKeyword(enableShadowCastOnClouds, "DEBUG_NO_CURL");
|
|
CloudMaterial.SetFloat("zeroCountSteps", zeroCountSteps);
|
|
CloudMaterial.SetInt("sunShaftSteps", sunShaftSteps);
|
|
float num7 = CurrentCamera.transform.position.y - height;
|
|
float z = ((num7 <= 0f) ? 1f : 0f);
|
|
CloudMaterial.SetVector("_HeightParams", new Vector4(height, num7, z, heightDensity * 0.5f));
|
|
CloudMaterial.SetVector("_DistanceParams", new Vector4(0f - Mathf.Max(startDistance, 0f), cloudDistanceParams.x, cloudDistanceParams.y, cloudDistanceParams.z));
|
|
CloudMaterial.SetFloat("_Scatter", _Scatter);
|
|
CloudMaterial.SetFloat("_HGCoeff", _HGCoeff);
|
|
CloudMaterial.SetFloat("_Extinct", _Extinct);
|
|
CloudMaterial.SetVector("_SkyTint", _SkyTint);
|
|
CloudMaterial.SetFloat("_BackShade", _BackShade);
|
|
if (localLight != null)
|
|
{
|
|
Vector3 position2 = localLight.transform.position;
|
|
currentLocalLightIntensity = Mathf.Pow(10f, 3f + (localLightFalloff - 3f) * 3f);
|
|
CloudMaterial.SetVector("_LocalLightPos", new Vector4(position2.x, position2.y, position2.z, localLight.intensity * localLightIntensity * currentLocalLightIntensity));
|
|
CloudMaterial.SetVector("_LocalLightColor", new Vector4(localLight.color.r, localLight.color.g, localLight.color.b, localLightFalloff));
|
|
}
|
|
else if (currentLocalLightIntensity > 0f)
|
|
{
|
|
currentLocalLightIntensity = 0f;
|
|
CloudMaterial.SetVector("_LocalLightColor", Vector4.zero);
|
|
}
|
|
CloudMaterial.SetFloat("luminance", luminance);
|
|
CloudMaterial.SetFloat("lumFac", lumFac);
|
|
CloudMaterial.SetFloat("Multiplier1", ScatterFac);
|
|
CloudMaterial.SetFloat("Multiplier2", TurbFac);
|
|
CloudMaterial.SetFloat("Multiplier3", HorizFac);
|
|
CloudMaterial.SetFloat("turbidity", turbidity);
|
|
CloudMaterial.SetFloat("reileigh", reileigh);
|
|
CloudMaterial.SetFloat("mieCoefficient", mieCoefficient);
|
|
CloudMaterial.SetFloat("mieDirectionalG", mieDirectionalG);
|
|
CloudMaterial.SetFloat("bias", bias);
|
|
CloudMaterial.SetFloat("contrast", contrast);
|
|
CloudMaterial.SetVector("v3LightDir", -sunLight.transform.forward);
|
|
CloudMaterial.SetVector("_TintColor", new Vector4(TintColor.x, TintColor.y, TintColor.z, 1f));
|
|
float value2 = 0f;
|
|
if (FogSky)
|
|
{
|
|
value2 = 1f;
|
|
}
|
|
CloudMaterial.SetFloat("FogSky", value2);
|
|
CloudMaterial.SetFloat("ClearSkyFac", ClearSkyFac);
|
|
FogMode fogMode = RenderSettings.fogMode;
|
|
float num8 = 0.01f;
|
|
float fogStartDistance = RenderSettings.fogStartDistance;
|
|
float fogEndDistance = RenderSettings.fogEndDistance;
|
|
bool flag = fogMode == FogMode.Linear;
|
|
float num9 = (flag ? (fogEndDistance - fogStartDistance) : 0f);
|
|
float num10 = ((Mathf.Abs(num9) > 0.0001f) ? (1f / num9) : 0f);
|
|
Vector4 value3 = default(Vector4);
|
|
value3.x = num8 * 1.2011224f;
|
|
value3.y = num8 * 1.442695f;
|
|
value3.z = (flag ? (0f - num10) : 0f);
|
|
value3.w = (flag ? (fogEndDistance * num10) : 0f);
|
|
CloudMaterial.SetVector("_SceneFogParams", value3);
|
|
CloudMaterial.SetVector("_SceneFogMode", new Vector4((float)fogMode, useRadialDistance ? 1 : 0, 0f, 0f));
|
|
CloudMaterial.SetVector("specialFX", specialFX);
|
|
UpscaleMaterial.SetFloat("controlBackAlphaPower", controlBackAlphaPower);
|
|
UpscaleMaterial.SetFloat("controlCloudAlphaPower", controlCloudAlphaPower);
|
|
UpscaleMaterial.SetVector("controlCloudEdgeA", controlCloudEdgeA);
|
|
CloudMaterial.SetFloat("depthDilation", depthDilation);
|
|
UpscaleMaterial.SetFloat("depthDilation", depthDilation);
|
|
RenderTexture temporary = RenderTexture.GetTemporary((int)((float)source.width / (float)downSample), (int)((float)source.height / (float)downSample), 0, source.format, RenderTextureReadWrite.Default, source.antiAliasing);
|
|
CustomGraphicsBlit(source, temporary, CloudMaterial, 0);
|
|
if (enableEdgeControl)
|
|
{
|
|
UpscaleMaterial.SetVector("edgeControl", edgeControl);
|
|
if (debugClouds > 0)
|
|
{
|
|
UpscaleMaterial.SetInt("enableEdges", debugClouds - 1);
|
|
}
|
|
else
|
|
{
|
|
UpscaleMaterial.SetInt("enableEdges", 1);
|
|
}
|
|
RenderTexture temporary2 = RenderTexture.GetTemporary(temporary.width, temporary.height, 0, temporary.format, RenderTextureReadWrite.Default);
|
|
Graphics.Blit(temporary, temporary2, UpscaleMaterial, 1);
|
|
if (temporalAntiAliasing && Application.isPlaying)
|
|
{
|
|
RenderTexture temporary3 = RenderTexture.GetTemporary(temporary.width, temporary.height, 0, temporary.format, RenderTextureReadWrite.Default, source.antiAliasing);
|
|
_temporalAntiAliasing.TemporalAntiAliasing(temporary2, temporary3);
|
|
UpscaleMaterial.SetTexture("_Clouds", temporary3);
|
|
if (debugClouds > 0)
|
|
{
|
|
Graphics.Blit(temporary2, destination, UpscaleMaterial, 0);
|
|
}
|
|
else
|
|
{
|
|
Graphics.Blit(source, destination, UpscaleMaterial, 0);
|
|
}
|
|
RenderTexture.ReleaseTemporary(temporary3);
|
|
}
|
|
else
|
|
{
|
|
UpscaleMaterial.SetTexture("_Clouds", temporary2);
|
|
if (debugClouds > 0)
|
|
{
|
|
Graphics.Blit(temporary2, destination, UpscaleMaterial, 0);
|
|
}
|
|
else
|
|
{
|
|
Graphics.Blit(source, destination, UpscaleMaterial, 0);
|
|
}
|
|
}
|
|
RenderTexture.ReleaseTemporary(temporary);
|
|
RenderTexture.ReleaseTemporary(temporary2);
|
|
}
|
|
else
|
|
{
|
|
UpscaleMaterial.SetInt("enableEdges", 0);
|
|
if (temporalAntiAliasing && Application.isPlaying)
|
|
{
|
|
RenderTexture temporary4 = RenderTexture.GetTemporary(temporary.width, temporary.height, 0, temporary.format, RenderTextureReadWrite.Default, source.antiAliasing);
|
|
_temporalAntiAliasing.TemporalAntiAliasing(temporary, temporary4);
|
|
UpscaleMaterial.SetTexture("_Clouds", temporary4);
|
|
RenderTexture.ReleaseTemporary(temporary4);
|
|
}
|
|
else
|
|
{
|
|
UpscaleMaterial.SetTexture("_Clouds", temporary);
|
|
}
|
|
Graphics.Blit(source, destination, UpscaleMaterial, 0);
|
|
RenderTexture.ReleaseTemporary(temporary);
|
|
}
|
|
}
|
|
|
|
private void updateMaterialKeyword(bool b, string keyword)
|
|
{
|
|
if (b != CloudMaterial.IsKeywordEnabled(keyword))
|
|
{
|
|
if (b)
|
|
{
|
|
CloudMaterial.EnableKeyword(keyword);
|
|
}
|
|
else
|
|
{
|
|
CloudMaterial.DisableKeyword(keyword);
|
|
}
|
|
}
|
|
}
|
|
|
|
private Matrix4x4 GetFrustumCorners(Camera cam)
|
|
{
|
|
float fieldOfView = cam.fieldOfView;
|
|
float aspect = cam.aspect;
|
|
Matrix4x4 identity = Matrix4x4.identity;
|
|
float num = Mathf.Tan(fieldOfView * 0.5f * (MathF.PI / 180f));
|
|
Vector3 vector = Vector3.right * num * aspect;
|
|
Vector3 vector2 = Vector3.up * num;
|
|
Vector3 vector3 = -Vector3.forward - vector + vector2;
|
|
Vector3 vector4 = -Vector3.forward + vector + vector2;
|
|
Vector3 vector5 = -Vector3.forward + vector - vector2;
|
|
Vector3 vector6 = -Vector3.forward - vector - vector2;
|
|
identity.SetRow(0, vector3);
|
|
identity.SetRow(1, vector4);
|
|
identity.SetRow(2, vector5);
|
|
identity.SetRow(3, vector6);
|
|
return identity;
|
|
}
|
|
|
|
private static void CustomGraphicsBlit(RenderTexture source, RenderTexture dest, Material fxMaterial, int passNr)
|
|
{
|
|
RenderTexture.active = dest;
|
|
GL.PushMatrix();
|
|
GL.LoadOrtho();
|
|
fxMaterial.SetPass(passNr);
|
|
GL.Begin(7);
|
|
GL.MultiTexCoord2(0, 0f, 0f);
|
|
GL.Vertex3(0f, 0f, 3f);
|
|
GL.MultiTexCoord2(0, 1f, 0f);
|
|
GL.Vertex3(1f, 0f, 2f);
|
|
GL.MultiTexCoord2(0, 1f, 1f);
|
|
GL.Vertex3(1f, 1f, 1f);
|
|
GL.MultiTexCoord2(0, 0f, 1f);
|
|
GL.Vertex3(0f, 1f, 0f);
|
|
GL.End();
|
|
GL.PopMatrix();
|
|
}
|
|
|
|
private void createGradient(ref Gradient gradient)
|
|
{
|
|
gradient = new Gradient();
|
|
colorKey = new GradientColorKey[4];
|
|
colorKey[0].color = Color.black;
|
|
colorKey[0].time = 0f;
|
|
colorKey[1].color = Color.white;
|
|
colorKey[1].time = 0.1f;
|
|
colorKey[2].color = Color.white;
|
|
colorKey[2].time = 0.9f;
|
|
colorKey[3].color = Color.black;
|
|
colorKey[3].time = 1f;
|
|
alphaKey = new GradientAlphaKey[4];
|
|
alphaKey[0].alpha = 1f;
|
|
alphaKey[0].time = 0f;
|
|
alphaKey[1].alpha = 1f;
|
|
alphaKey[1].time = 0.1f;
|
|
alphaKey[2].alpha = 1f;
|
|
alphaKey[2].time = 0.9f;
|
|
alphaKey[3].alpha = 1f;
|
|
alphaKey[3].time = 1f;
|
|
gradient.SetKeys(colorKey, alphaKey);
|
|
}
|
|
}
|
|
}
|