4285 lines
140 KiB
C#
4285 lines
140 KiB
C#
using System;
|
|
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
#endif
|
|
|
|
|
|
namespace Tenkoku.Core
|
|
{
|
|
|
|
|
|
[ExecuteInEditMode]
|
|
[System.Serializable]
|
|
public class TenkokuModule : MonoBehaviour
|
|
{
|
|
|
|
|
|
|
|
//PUBLIC VARIABLES
|
|
public string tenkokuVersionNumber = "";
|
|
|
|
public bool useAutoFX = true;
|
|
public float systemTime = 1f;
|
|
public bool enableAutoAdvance = true;
|
|
public Transform mainCamera;
|
|
public Transform manualCamera;
|
|
public int cameraTypeIndex = 0;
|
|
public int ambientTypeIndex = 0;
|
|
|
|
public int atmosphereModelTypeIndex = 0;
|
|
public int useAtmosphereIndex = -1;
|
|
|
|
public Gradient cloudGradient;
|
|
public Gradient cloudAmbGradient;
|
|
public Gradient sunGradient;
|
|
public Gradient horizGradient;
|
|
public Gradient skyGradient;
|
|
public Gradient ambColorGradient;
|
|
public Gradient moonGradient;
|
|
public Gradient ambDayGradient;
|
|
public Gradient ambLightGradient;
|
|
|
|
public Gradient temperatureGradient;
|
|
|
|
public int lightLayer = 2;
|
|
public LayerMask lightLayerMask;
|
|
[System.NonSerialized] public List<string> tenLayerMasks = new List<string>();
|
|
|
|
public Color temperatureColor;
|
|
public Color colorOverlay = Color.white;
|
|
public Color colorSky = new Color(1f,1f,1f,0f);
|
|
public Color colorAmbient = new Color(0f,0f,0f,0.6f);
|
|
private Color useColorAmbient = new Color(0f,0f,0f,0.6f);
|
|
public float ambientDayAmt = 1f;
|
|
public float ambientNightAmt = 1f;
|
|
|
|
public Color colorFog = new Color(0f,0.25f,1f,0.25f);
|
|
public Color moonHorizColor = new Color(1f,0.27f,0f,0.5f);
|
|
|
|
|
|
public bool useSunFlare = true;
|
|
public Flare flareObject;
|
|
public bool useSunRays = true;
|
|
public float sunRayIntensity = 1.0f;
|
|
public float sunRayLength = 0.2f;
|
|
public float moonRayIntensity = 1.0f;
|
|
public bool useAmbient = true;
|
|
public bool adjustOvercastAmbient = true;
|
|
public float useAmbientIntensity = 1f;
|
|
//bool _isForward = false;
|
|
|
|
public bool disableMSA = true;
|
|
public bool enableIBL = false;
|
|
public bool enableFog = true;
|
|
public bool autoFog = true;
|
|
|
|
public bool showColors = false;
|
|
public bool showConfig = false;
|
|
public bool showCelSet = false;
|
|
public bool showTimer = true;
|
|
public bool showSounds = false;
|
|
|
|
public bool showConfigTime = false;
|
|
public bool showConfigAtmos = false;
|
|
public bool showConfigWeather = false;
|
|
|
|
public bool showIBL = false;
|
|
public bool allowMultiLights = true;
|
|
|
|
float cloudRotSpeed = 0.2f;
|
|
float cloudOverRot = 0.0f;
|
|
//float cloudSz = 1.0f;
|
|
float cloudSc = 1.0f;
|
|
public float skyBrightness = 1.0f;
|
|
public float mieAmount = 1.0f;
|
|
public float mieMnAmount = 1.0f;
|
|
float useSkyBright = 1.0f;
|
|
public float nightBrightness = 0.4f;
|
|
public float fogDistance = 0.0015f;
|
|
public float fogAtmosphere = 0.2f;
|
|
public float fadeDistance = 1.0f;
|
|
public float fogObscurance = 0.0f;
|
|
|
|
public float setRotation = 180.0f;
|
|
|
|
//float useLatitude = 0.0f;
|
|
public float setLatitude = 0.0f;
|
|
public float setLongitude = 0.0f;
|
|
public int setTZOffset = 0;
|
|
public bool enableDST = false;
|
|
|
|
//bool sunIsVisible = true;
|
|
public float sunSize = 0.02f;
|
|
public float sunBright = 1.0f;
|
|
public float sunSat = 1.0f;
|
|
|
|
|
|
bool moonIsVisible = true;
|
|
public float moonSize = 0.02f;
|
|
public float moonPos = 0.0f;
|
|
public float moonBright = 1.0f;
|
|
public float moonSat = 1.0f;
|
|
|
|
bool auroraIsVisible = true;
|
|
public float auroraSize = 1.4f;
|
|
public float auroraLatitude = 1.0f;
|
|
public float auroraIntensity = 1.0f;
|
|
public float auroraSpeed = 0.5f;
|
|
|
|
public float planetIntensity = 1.0f;
|
|
//bool starIsVisible = true;
|
|
|
|
public float ambientShift = 0.0f;
|
|
public float moonLightIntensity = 0.25f;
|
|
public float moonDayIntensity = 0.2f;
|
|
public float starIntensity = 1.0f;
|
|
public float galaxyIntensity = 1.0f;
|
|
|
|
public float horizonHeight = 0.5f;
|
|
public float horizonScale = 45.0f;
|
|
|
|
public float ambHorizonHeight = 1.0f;
|
|
public float ambHorizonScale = 30.0f;
|
|
|
|
public float lowHorizonHeight = 0.5f;
|
|
public float lowHorizonScale = 1.0f;
|
|
|
|
public Texture2D colorRamp;
|
|
|
|
|
|
AudioClip[] globalSoundFile;
|
|
Vector4[] globalSoundVolDay;
|
|
Vector4[] globalSoundVolYear;
|
|
|
|
Transform cloudPlaneObject;
|
|
Transform cloudSphereObject;
|
|
|
|
public int colorTypeIndex = 0;
|
|
public int weatherTypeIndex = 0;
|
|
public int sunTypeIndex = 0;
|
|
public int moonTypeIndex = 0;
|
|
public int starTypeIndex = 0;
|
|
public int galaxyTypeIndex = 0;
|
|
public int auroraTypeIndex = 0;
|
|
public int galaxyTexIndex = 0;
|
|
|
|
public Texture galaxyTex ;
|
|
public Texture galaxyCubeTex;
|
|
|
|
public Transform useCamera;
|
|
public Camera useCameraCam;
|
|
private Transform saveCamera;
|
|
//private float setSkySize = 20.0f;
|
|
private float setSkyUseSize = 1.0f;
|
|
private Transform worldlightObject;
|
|
|
|
private WindZone tenkokuWindObject;
|
|
private Transform tenkokuWindTrans;
|
|
|
|
public Transform sunlightObject;
|
|
public Transform sunSphereObject;
|
|
private Transform sunObject;
|
|
private Transform eclipseObject;
|
|
private Transform moonSphereObject;
|
|
private Transform moonObject;
|
|
public Transform moonlightObject;
|
|
private Transform skyObject;
|
|
//private Transform ambientObject;
|
|
|
|
public float moonLightAmt;
|
|
public float moonPhase;
|
|
private Quaternion mres;
|
|
|
|
|
|
|
|
|
|
private ParticleStarfieldHandler starRenderSystem;
|
|
private Renderer starParticleSystem;
|
|
private Transform starfieldObject;
|
|
private Transform starGalaxyObject;
|
|
|
|
private Mesh mesh;
|
|
private Vector3[] vertices;
|
|
private Color[] colors;
|
|
private Mesh meshAmb;
|
|
private Vector3[] verticesAmb;
|
|
private Color[] colorsAmb;
|
|
|
|
private Vector3[] verticesLow;
|
|
private Color[] colorsLow;
|
|
|
|
private Tenkoku.Core.TenkokuGlobalSound ambientSoundObject;
|
|
|
|
private Color rayCol;
|
|
|
|
//private var sunFlare : LensFlare;
|
|
|
|
public Color ambientCol = Color.gray;
|
|
public Color colorSun = Color.white;
|
|
public Color colorMoon = Color.white;
|
|
public Color colorSkyBase = Color.white;
|
|
public Color colorSkyBaseLow = Color.white;
|
|
public Color colorHorizon = Color.white;
|
|
public Color colorHorizonLow = Color.white;
|
|
public Color colorSkyAmbient = Color.white;
|
|
public Color colorClouds = Color.white;
|
|
public Color colorHighlightClouds = Color.white;
|
|
public Color colorSkyboxGround = Color.black;
|
|
public Color colorSkyboxMie = Color.white;
|
|
|
|
int stepTime;
|
|
float timeLerp = 0.0f;
|
|
|
|
float calcTimeM = 0.0f;
|
|
float setTimeM = 0.0f;
|
|
int stepTimeM = 0;
|
|
float timeLerpM = 0.0f;
|
|
|
|
|
|
//TIMER VARIABLES
|
|
public string displayTime = "";
|
|
|
|
public bool autoTimeSync = false;
|
|
public bool autoDateSync = false;
|
|
public bool autoTime = false;
|
|
public float timeCompression = 100.0f;
|
|
public int currentSecond = 0;
|
|
private int lastSecond = 0;
|
|
public int currentMinute = 45;
|
|
public int currentHour = 5;
|
|
public int currentDay = 22;
|
|
public int currentMonth = 3;
|
|
public int currentYear = 2013;
|
|
|
|
public bool useAutoTime = false;
|
|
public float useTimeCompression = 100.0f;
|
|
public bool use24Clock = false;
|
|
public AnimationCurve timeCurves;
|
|
public int setHour = 5;
|
|
public float useSecond = 0f;
|
|
public float useMinute = 0f;
|
|
public float displayHour = 0f;
|
|
public float useHour = 0f;
|
|
public float useDay = 0f;
|
|
public float useMonth = 0f;
|
|
public float useYear = 0f;
|
|
|
|
public string hourMode = "";
|
|
|
|
public int moonSecond = 0;
|
|
public int moonMinute = 0;
|
|
public int moonHour = 0;
|
|
public int moonDay = 0;
|
|
public int moonMonth = 0;
|
|
public int moonYear = 0;
|
|
|
|
|
|
public int starSecond = 0;
|
|
public int starMinute = 0;
|
|
public int starHour = 0;
|
|
public int starDay = 0;
|
|
public int starMonth = 0;
|
|
public int starYear = 0;
|
|
|
|
|
|
public bool leapYear = false;
|
|
public int monthFac = 31;
|
|
|
|
public Vector3 moonTime;
|
|
|
|
public float setDay = 22000.0f;
|
|
public float setStar = 22000.0f;
|
|
public float setMoon = 22000.0f;
|
|
public float setMonth = 22000.0f;
|
|
public float setYear = 22000.0f;
|
|
|
|
public float dayValue = 0.5f;
|
|
public float starValue = 0.5f;
|
|
public float moonValue = 0.0f;
|
|
public float monthValue = 0.0f;
|
|
public float yearValue = 0.0f;
|
|
|
|
public float countSecond = 0.0f;
|
|
public float countMinute = 0.0f;
|
|
|
|
public float countSecondStar = 0.0f;
|
|
public float countMinuteStar = 0.0f;
|
|
|
|
public float countSecondMoon = 0.0f;
|
|
public float countMinuteMoon = 0.0f;
|
|
|
|
public bool cloudLinkToTime = false;
|
|
public bool useTemporalAliasing = true;
|
|
public bool useFSAliasing = false;
|
|
public bool useLegacyClouds = false;
|
|
public float cloudQuality = 0.75f;
|
|
public float cloudFreq = 1f;
|
|
public float cloudDetail = 1f;
|
|
public float precipQuality = 1f;
|
|
private float cloudStepTime = 0f;
|
|
//private float prevDeltaTime = 0f;
|
|
|
|
private Transform fillLightObject;
|
|
private Transform nightSkyLightObject;
|
|
private Matrix4x4 MV;
|
|
|
|
public float starPos = 0.0f;
|
|
|
|
public float galaxyPos = 0.0f;
|
|
|
|
|
|
|
|
//Weather Variables
|
|
public int currentWeatherTypeIndex = -1;
|
|
public bool weather_forceUpdate = false;
|
|
|
|
public bool weather_setAuto = false;
|
|
public float weather_qualityCloud = 0.7f;
|
|
public float weather_cloudAltAmt = 1.0f;
|
|
|
|
public float weather_cloudAltoStratusAmt = 0.0f;
|
|
public float weather_cloudCirrusAmt = 0.0f;
|
|
|
|
public float weather_cloudCumulusAmt = 0.2f;
|
|
public float weather_cloudScale = 0.5f;
|
|
public float weather_cloudSpeed = 0.0f;
|
|
|
|
public float weather_OvercastDarkeningAmt = 1.0f;
|
|
private float useOvercastDarkening = 0.5f;
|
|
|
|
public float weather_OvercastAmt = 0.0f;
|
|
public float weather_RainAmt = 0.0f;
|
|
public float weather_SnowAmt = 0.0f;
|
|
public float weather_WindAmt = 0.0f;
|
|
public float weather_WindDir = 0.0f;
|
|
public float weather_FogAmt = 0.0f;
|
|
public float weather_FogHeight = 0.0f;
|
|
|
|
public float weather_autoForecastTime = 5.0f;
|
|
public float weather_PatternTime = 0.0f;
|
|
public float weather_TransitionTime = 1.0f;
|
|
|
|
public float weather_temperature = 75.0f;
|
|
public float weather_humidity = 0.25f;
|
|
public float weather_rainbow = 0.0f;
|
|
public float weather_lightning = 0.0f;
|
|
public float weather_lightningDir = 110.0f;
|
|
public float weather_lightningRange = 180.0f;
|
|
public Color lightningColor = Color.white;
|
|
|
|
|
|
// auto weather variables
|
|
private float w_isCloudy;
|
|
private float w_isOvercast;
|
|
private Vector4 w_cloudAmts;
|
|
private Vector4 w_cloudTgts;
|
|
private float w_cloudAmtCumulus;
|
|
private float w_cloudTgtCumulus;
|
|
private float w_overcastAmt;
|
|
private float w_overcastTgt;
|
|
//private float w_windCAmt;
|
|
private float w_windDir;
|
|
private float w_windAmt;
|
|
//private float w_windCTgt;
|
|
private float w_windDirTgt;
|
|
private float w_windTgt;
|
|
private float w_rainAmt;
|
|
private float w_rainTgt;
|
|
private float w_snowAmt;
|
|
private float w_snowTgt;
|
|
private float w_humidityAmt;
|
|
private float w_humidityTgt;
|
|
private float w_lightningAmt;
|
|
private float w_lightningTgt;
|
|
|
|
private float cAmt;
|
|
|
|
private Tenkoku.Core.TenkokuCalculations calcComponent;
|
|
private Vector2 weather_WindCoords = Vector2.zero;
|
|
private Vector4 weather_CloudCoords = Vector4.zero;
|
|
private Vector2 currCoords = Vector2.zero;
|
|
private ParticleSystem rainSystem;
|
|
private ParticleSystem rainFogSystem;
|
|
private ParticleSystem rainSplashSystem;
|
|
private ParticleSystem snowSystem;
|
|
private ParticleSystem fogSystem;
|
|
|
|
|
|
private Transform planetTransMercury;
|
|
private Transform planetTransVenus;
|
|
private Transform planetTransMars;
|
|
private Transform planetTransJupiter;
|
|
private Transform planetTransSaturn;
|
|
private Transform planetTransUranus;
|
|
private Transform planetTransNeptune;
|
|
|
|
private ParticlePlanetHandler planetObjMercury;
|
|
private ParticlePlanetHandler planetObjVenus;
|
|
private ParticlePlanetHandler planetObjMars;
|
|
private ParticlePlanetHandler planetObjJupiter;
|
|
private ParticlePlanetHandler planetObjSaturn;
|
|
private ParticlePlanetHandler planetObjUranus;
|
|
private ParticlePlanetHandler planetObjNeptune;
|
|
private Renderer planetRendererSaturn;
|
|
private Renderer planetRendererJupiter;
|
|
private Renderer planetRendererNeptune;
|
|
private Renderer planetRendererUranus;
|
|
private Renderer planetRendererMercury;
|
|
private Renderer planetRendererVenus;
|
|
private Renderer planetRendererMars;
|
|
|
|
|
|
private float fillFac;
|
|
private float fillIntensity;
|
|
|
|
private Light lightObjectFill;
|
|
private Light lightObjectNight;
|
|
private Light lightObjectWorld;
|
|
|
|
private Renderer renderObjectMoon;
|
|
private Renderer renderObjectGalaxy;
|
|
|
|
private Renderer renderObjectRain;
|
|
private Renderer renderObjectRainSplash;
|
|
private Renderer renderObjectRainFog;
|
|
private Renderer renderObjectFog;
|
|
private Renderer renderObjectSnow;
|
|
|
|
|
|
private Renderer renderObjectCloudPlane;
|
|
private Renderer renderObjectCloudSphere;
|
|
private Renderer renderObjectAurora;
|
|
private Transform auroraObjectTransform;
|
|
private Material materialObjectCloudSphere;
|
|
|
|
private ParticleSystem particleObjectRainFog;
|
|
private ParticleSystem particleObjectRainSplash;
|
|
private ParticleSystem particleObjectFog;
|
|
|
|
|
|
//collect for GC
|
|
private float setTime;
|
|
private float calcTime;
|
|
private float currClipDistance = 0.0f;
|
|
private float isLin = 0.0f;
|
|
private float currIsLin = -1.0f;
|
|
private bool doWeatherUpdate = false;
|
|
private float chanceOfRain = -1.0f;
|
|
|
|
private float moonApoSize = -1.0f;
|
|
private Color mDCol = Color.black;
|
|
public float ecldiff = -1.0f;
|
|
private Transform tempTrans;
|
|
private Vector3 useVec = new Vector3(0f,0.35f,0.75f);
|
|
private float useMult = -1.0f;
|
|
private float pVisFac = -1.0f;
|
|
private float starAngle = -1.0f;
|
|
private Quaternion starTarget;
|
|
private int aquarialStart = 0;
|
|
private float precRate = -1.0f;
|
|
private float precNudge = -1.0f;
|
|
private float precFactor = -1.0f;
|
|
private float eclipticStarAngle = -1.0f;
|
|
private Color galaxyColor = Color.black;
|
|
private float galaxyVis = -1.0f;
|
|
private Color ambientCloudCol = Color.black;
|
|
private Color setSkyAmbient = Color.black;
|
|
private Color useAlpha = Color.black;
|
|
private Color setAmbCol = Color.black;
|
|
private Color setAmbientColor = Color.black;
|
|
private Color mixColor = Color.black;
|
|
private Color medCol = new Color(0.3f,0.3f,0.3f,1.0f);
|
|
private Color useAmbientColor = Color.black;
|
|
private float useOvercast = -1.0f;
|
|
private float fxUseLight = -1.0f;
|
|
private float lDiff = -1.0f;
|
|
private Color rainCol = Color.black;
|
|
private Color splashCol = Color.black;
|
|
private Color rainfogCol = Color.black;
|
|
private float rainfogFac = -1.0f;
|
|
private Color fogCol = Color.black;
|
|
private Color fogColStart = new Color(.95f,.95f,.95f,.95f);
|
|
private float fogFac = -1.0f;
|
|
private Color snowCol = Color.black;
|
|
//private float timerCloudMod = -1.0f;
|
|
//private Color setCloudFog1 = Color.black;
|
|
private Color setOverallCol = new Color(0f,0f,0f,0f);
|
|
private Color bgSCol = new Color(0f,0f,0f,0f);
|
|
|
|
private float altAdjust = -1.0f;
|
|
public float fogDist = -1.0f;
|
|
private float fogFull = -1.0f;
|
|
private Color skyAmbientCol = Color.black;
|
|
private Color skyHorizonCol = Color.black;
|
|
private Color ambientGI = Color.black;
|
|
private float aurSpan = -1.0f;
|
|
private float aurAmt = -1.0f;
|
|
private float setTimeSpan = -1.0f;
|
|
private float curveVal = 1.0f;
|
|
private string setString = "format";
|
|
private string eon = "";
|
|
private int monthLength = -1;
|
|
private int testMonth = -1;
|
|
private float monthAddition = 0.0f;
|
|
private int aM = 1;
|
|
private float yearDiv = 365.0f;
|
|
private float clampRes = 0.0f;
|
|
private int px = 0;
|
|
private RaycastHit hit;
|
|
private float usePoint = 0.0f;
|
|
private ParticleSystem.Particle[] setParticles;
|
|
private Vector2 dir = Vector2.zero;
|
|
private Vector3 tempAngle = Vector3.zero;
|
|
private Vector2 tempAngleVec2 = Vector2.zero;
|
|
private int texPos = 0;
|
|
private Color returnColor = Color.black;
|
|
private float eclipticoffset;
|
|
|
|
//private float sSDiv = -1.0f;
|
|
private float sunCalcSize = -1.0f;
|
|
private float moonCalcSize;
|
|
|
|
public float atmosphereDensity = 0.55f;
|
|
public float horizonDensity = 2.0f;
|
|
public float horizonDensityHeight = 0.34f;
|
|
private float atmosTime = 1.0f;
|
|
private float setAtmosphereDensity = 0.0f;
|
|
|
|
//public int fogDisperse = 25;
|
|
//public float fogDispersion = 4f;
|
|
public float fogDensity = 0.55f;
|
|
|
|
private bool probeHasUpdated = false;
|
|
public bool enableProbe = true;
|
|
public float reflectionProbeFPS = 1.0f;
|
|
private float useReflectionFPS = 30f;
|
|
|
|
private ReflectionProbe tenkokuReflectionObject;
|
|
private float reflectionTimer = 0.0f;
|
|
|
|
|
|
//sound variables
|
|
public bool enableSoundFX = true;
|
|
public bool enableTimeAdjust = true;
|
|
public float overallVolume = 1.0f;
|
|
public AudioClip audioWind;
|
|
public AudioClip audioRain;
|
|
public AudioClip audioTurb1;
|
|
public AudioClip audioTurb2;
|
|
public AudioClip audioAmbDay;
|
|
public AudioClip audioAmbNight;
|
|
public float volumeWind = 1.0f;
|
|
public float volumeRain = 1.0f;
|
|
public float volumeThunder = 1.0f;
|
|
public float volumeTurb1 = 1.0f;
|
|
public float volumeTurb2 = 1.0f;
|
|
public float volumeAmbDay = 1.0f;
|
|
public float volumeAmbNight = 1.0f;
|
|
|
|
public AnimationCurve curveAmbDay24;
|
|
public AnimationCurve curveAmbDayYR;
|
|
public AnimationCurve curveAmbNight24;
|
|
public AnimationCurve curveAmbNightYR;
|
|
|
|
|
|
public Tenkoku.Core.Random TenRandom;
|
|
public int randSeed;
|
|
System.DateTime sysTime;
|
|
|
|
|
|
|
|
//Transition variables
|
|
float transitionTime = 0.0f;
|
|
bool doTransition = false;
|
|
public bool isDoingTransition = false;
|
|
string transitionStartTime = "";
|
|
string transitionTargetTime;
|
|
string transitionTargetDate;
|
|
float transitionDuration = 5.0f;
|
|
float transitionDirection = 1.0f;
|
|
AnimationCurve transitionCurve;
|
|
bool transitionCallback = false;
|
|
GameObject transitionCallbackObject;
|
|
private int setTransHour;
|
|
private int setTransMinute;
|
|
private int setTransSecond;
|
|
private int startSecond;
|
|
private int startMinute;
|
|
private int startHour;
|
|
private float timeVal;
|
|
private float setTransVal;
|
|
private int endTime = 0;
|
|
private int startTime = 0;
|
|
private bool endTransition = false;
|
|
private Camera fogCameraCam;
|
|
private Tenkoku.Effects.TenkokuSkyBlur fogCameraBlur;
|
|
private string setSun;
|
|
private string lightVals;
|
|
|
|
private Tenkoku.Effects.TenkokuSunShafts sunRayObject;
|
|
private Tenkoku.Effects.TenkokuSkyFog fogObject;
|
|
|
|
private int i;
|
|
private string layerName;
|
|
private Vector4 sunPos = Vector4.zero;
|
|
private Color moonFaceCol;
|
|
private Color cloudSpeeds;
|
|
private Color overcastCol;
|
|
private Color WorldCol;
|
|
|
|
|
|
private string dataString ;
|
|
private string[] dataArray;
|
|
private int pos1;
|
|
private int pos2;
|
|
private int length;
|
|
private string func;
|
|
private string dat;
|
|
//private int xP = 0;
|
|
//private int ax = 0;
|
|
private string dataUpdate;
|
|
private string[] data;
|
|
private string setUpdate;
|
|
private string[] values;
|
|
private GameObject callbackObject;
|
|
|
|
|
|
private float rOC;
|
|
private float mMult;
|
|
private Vector3 delta;
|
|
private Quaternion look;
|
|
private float vertical;
|
|
private Ray mRay;
|
|
private Ray sRay;
|
|
|
|
private Vector3 planeObjectScale = new Vector3(0.5f,0.5f,0.1f);
|
|
private Vector3 galaxyScale = new Vector3(0.5f,0.5f,0.5f);
|
|
private Vector3 setScale = new Vector3(1f,1f,1f);
|
|
private Vector3 setScale2 = Vector3.zero;
|
|
private Vector3 reflectionSize = new Vector3(100f,500f,100f);
|
|
private Vector3 windVector = Vector3.one;
|
|
private Vector3 sunBasePosition = new Vector3(-0.51f,0f,0f);
|
|
private Vector3 sunPosition = Vector3.zero;
|
|
private Vector3 sunScale = Vector3.one;
|
|
private Vector3 moonBasePosition = new Vector3(-0.51f,0f,0f);
|
|
private Vector3 moonPosition = Vector3.zero;
|
|
private Vector3 moonScale = Vector3.one;
|
|
|
|
private Vector3 plMercuryPosition = Vector3.zero;
|
|
private Vector3 plVenusPosition = Vector3.zero;
|
|
private Vector3 plMarsPosition = Vector3.zero;
|
|
private Vector3 plJupiterPosition = Vector3.zero;
|
|
private Vector3 plSaturnPosition = Vector3.zero;
|
|
private Vector3 plUranusPosition = Vector3.zero;
|
|
private Vector3 plNeptunePosition = Vector3.zero;
|
|
|
|
private Vector3 starPosition = Vector3.zero;
|
|
private Vector3 galaxyPosition = Vector3.zero;
|
|
private Vector3 galaxyBasePosition = new Vector3(18.1f,281.87f,338.4f);
|
|
private Vector3 galaxyBaseScale = new Vector3(1f,0.92f,0.98f);
|
|
|
|
private Vector3 cloudPosition = Vector3.zero;
|
|
private Vector3 nightSkyPosition = Vector3.zero;
|
|
private Vector3 eclipsePosition = Vector3.zero;
|
|
private Vector3 particleRayPosition = Vector3.zero;
|
|
private Vector3 particlePosition = Vector3.zero;
|
|
|
|
private Vector2 cloudTexScale = Vector2.zero;
|
|
|
|
private Vector4 windPosition = Vector4.zero;
|
|
|
|
private Color baseGAmbColor = new Color(0.38f,0.6f,0.69f,0.7f);
|
|
private Color baseSkyCol = new Color(0.3f,0.4f,0.5f,1.0f);
|
|
private Color baseHorizonCol = new Color(0.7f,0.8f,0.9f,1.0f);
|
|
private Color baseRainCol = new Color(0.65f,0.75f,0.75f,1.0f);
|
|
private Color baseSnowCol = new Color(0.85f,0.85f,0.85f,1f);
|
|
private Color baseHighlightCloudCol = new Color(0.19f,0.19f,0.19f,1.0f);
|
|
private Color ambientBaseCol = Color.black;
|
|
private Color baseRayCol = Color.black;
|
|
private float mC;
|
|
private Color mCol = new Color(0.25f,0.33f,0.36f,1.0f);
|
|
private Color mColMixCol = new Color(0.25f,0.33f,0.36f,1.0f);
|
|
private float sC;
|
|
private Color sCol = Color.black;
|
|
private Color particleCol = Color.black;
|
|
|
|
public float minimumHeight = 0f;
|
|
private Vector3 lightClampVector = Vector3.one;
|
|
|
|
private float sunsetDegrees;
|
|
private float moonFac;
|
|
private float moonsetFac;
|
|
private float sunFac;
|
|
private float sunsetFac;
|
|
|
|
|
|
//Variables for Unity 5.3+ only
|
|
#if UNITY_5_4_OR_NEWER
|
|
private Vector3 snowPosition = Vector3.zero;
|
|
|
|
private ParticleSystem.MinMaxCurve rainCurve;
|
|
private ParticleSystem.MinMaxCurve rainCurveForceX;
|
|
private ParticleSystem.MinMaxCurve rainCurveForceY;
|
|
private ParticleSystem.MinMaxCurve rainCurveFog;
|
|
private ParticleSystem.MinMaxCurve rainCurveFogForceX;
|
|
private ParticleSystem.MinMaxCurve rainCurveFogForceY;
|
|
private ParticleSystem.MinMaxCurve splashCurve;
|
|
private ParticleSystem.MinMaxCurve fogCurve;
|
|
private ParticleSystem.MinMaxCurve fogCurveForceX;
|
|
private ParticleSystem.MinMaxCurve fogCurveForceY;
|
|
private ParticleSystem.MinMaxCurve snowCurve;
|
|
private ParticleSystem.MinMaxCurve snowCurveForceX;
|
|
private ParticleSystem.MinMaxCurve snowCurveForceY;
|
|
|
|
private ParticleSystem.EmissionModule rainEmission;
|
|
private ParticleSystem.EmissionModule rainFogEmission;
|
|
private ParticleSystem.EmissionModule splashEmission;
|
|
private ParticleSystem.EmissionModule fogEmission;
|
|
private ParticleSystem.EmissionModule snowEmission;
|
|
|
|
private ParticleSystem.ForceOverLifetimeModule rainForces;
|
|
private ParticleSystem.ForceOverLifetimeModule rainFogForces;
|
|
private ParticleSystem.ForceOverLifetimeModule fogForces;
|
|
private ParticleSystem.ForceOverLifetimeModule snowForces;
|
|
#endif
|
|
|
|
|
|
|
|
private Color[] DecodedColors;
|
|
private Color decodeColorSun = Color.black;
|
|
//private Color decodeColorSunray = Color.black;
|
|
private Color decodeColorAmbientcolor = Color.black;
|
|
private Color decodeColorMoon = Color.black;
|
|
private Color decodeColorSkyambient = Color.black;
|
|
private Color decodeColorSkybase = Color.black;
|
|
private Color decodeColorAmbientcloud = Color.black;
|
|
private Color decodeColorColorhorizon = Color.black;
|
|
private Color decodeColorColorcloud = Color.black;
|
|
private Color decodeColorAmbientGI = Color.black;
|
|
|
|
private Color skyAmb = Color.black;
|
|
private Color gAmb = Color.black;
|
|
private Color sAmb = Color.black;
|
|
private Color eAmb = Color.black;
|
|
|
|
|
|
private float csSize;
|
|
private Vector3 cSphereSize;
|
|
|
|
private float _deltaTime;
|
|
//private float _fixedDeltaTime;
|
|
|
|
private ColorSpace _linearSpace;
|
|
private Material skyMaterial;
|
|
|
|
|
|
private float _tempFac;
|
|
private Vector3 _tempVec;
|
|
|
|
private Tenkoku_TemporalReprojection temporalFX;
|
|
private Tenkoku_VelocityBuffer temporalBuffer;
|
|
private bool recompileFlag = false;
|
|
private bool saveLinkToTime = false;
|
|
private float eclipseFactor;
|
|
|
|
private Tenkoku.Core.TenkokuLib libComponent;
|
|
|
|
|
|
|
|
//Oskar-Elek Scatterins Specific
|
|
private RenderTexture _particleDensityLUT = null;
|
|
private RenderTexture _skyboxLUT;
|
|
private RenderTexture _skyboxLUT2;
|
|
private Material _material;
|
|
private float MieG = 0.5f;
|
|
private float MieScatterCoef = 0.5f;
|
|
private float MieExtinctionCoef = 1.0f;
|
|
private float RayleighScatterCoef = 8f;
|
|
private float RayleighExtinctionCoef = 1.25f;
|
|
private float SunIntensity = 0.25f;
|
|
private Color IncomingLight = new Color(4, 4, 4, 4);
|
|
private const float AtmosphereHeight = 80000.0f;
|
|
private const float PlanetRadius = 6371000.0f;
|
|
private readonly Vector4 DensityScale = new Vector4(7994.0f, 1200.0f, 0, 0);
|
|
private readonly Vector4 RayleighSct = new Vector4(5.8f, 13.5f, 33.1f, 0.0f) * 0.000001f;
|
|
private readonly Vector4 MieSct = new Vector4(2.0f, 2.0f, 2.0f, 0.0f) * 0.00001f;
|
|
private Texture nullTexture = null;
|
|
private int cSeconds;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void Awake(){
|
|
//GET CAMERA OBJECT
|
|
if (Application.isPlaying){
|
|
if (mainCamera == null){
|
|
mainCamera = Camera.main.transform;
|
|
}
|
|
}
|
|
|
|
//set custom random generator instance
|
|
randSeed = System.Environment.TickCount;
|
|
TenRandom = new Tenkoku.Core.Random(randSeed);
|
|
|
|
//set System Time
|
|
//systemTime = randSeed * 1f;
|
|
|
|
|
|
|
|
// Manually Set Execution Order
|
|
// This ensures that Tenkoku runs after Update() in other functions which
|
|
// prevents unintended timing issues. This is intended to fix sky/camera
|
|
// stuttering issues when used with some controllers and 3rd party assets.
|
|
#if UNITY_EDITOR
|
|
string scriptName = typeof(Tenkoku.Core.TenkokuModule).Name;
|
|
foreach (MonoScript monoScript in MonoImporter.GetAllRuntimeMonoScripts()){
|
|
if (monoScript.name == scriptName){
|
|
if (MonoImporter.GetExecutionOrder(monoScript) != 1000){
|
|
MonoImporter.SetExecutionOrder(monoScript, 1000);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
probeHasUpdated = false;
|
|
|
|
//set project layer masks
|
|
//#if UNITY_EDITOR
|
|
// tenLayerMasks.Clear();
|
|
// for (i = 0; i < 32; i++){
|
|
// layerName = LayerMask.LayerToName(i);
|
|
// tenLayerMasks.Add(layerName);
|
|
// }
|
|
//#endif
|
|
|
|
//get object references
|
|
LoadObjects();
|
|
|
|
//get color map
|
|
UpdateColorMap();
|
|
|
|
//get decoded colors
|
|
LoadDecodedColors();
|
|
}
|
|
|
|
|
|
|
|
|
|
void Start () {
|
|
|
|
//disconnect object from prefab connection
|
|
#if UNITY_EDITOR
|
|
//PrefabUtility.DisconnectPrefabInstance(this.gameObject);
|
|
#endif
|
|
|
|
|
|
//Set Project Layers data
|
|
if (Application.isPlaying){
|
|
tenLayerMasks.Clear();
|
|
for (i = 0; i < 32; i++){
|
|
layerName = LayerMask.LayerToName(i);
|
|
tenLayerMasks.Add(layerName);
|
|
}
|
|
}
|
|
|
|
|
|
//FORCE SHADER INIT (Oskar-Elek)
|
|
Shader shader = Shader.Find("TENKOKU/Tenkoku_sky_elek_Scatter");
|
|
_material = new Material(shader);
|
|
//CalculateSkyboxData(_material);
|
|
|
|
_material.SetFloat("_AtmosphereHeight", AtmosphereHeight);
|
|
_material.SetFloat("_PlanetRadius", PlanetRadius);
|
|
_material.SetVector("_DensityScaleHeight", DensityScale);
|
|
_material.SetVector("_ScatteringR", RayleighSct * RayleighScatterCoef);
|
|
_material.SetVector("_ScatteringM", MieSct * MieScatterCoef);
|
|
_material.SetVector("_ExtinctionR", RayleighSct * RayleighExtinctionCoef);
|
|
_material.SetVector("_ExtinctionM", MieSct * MieExtinctionCoef);
|
|
_material.SetColor("_IncomingLight", IncomingLight);
|
|
_material.SetFloat("_MieG", MieG);
|
|
_material.SetTexture("_ParticleDensityLUT", _particleDensityLUT);
|
|
_material.SetFloat("_SunIntensity", SunIntensity);
|
|
|
|
//PRECOMPUTE PARTICLE DENSITY
|
|
if (_particleDensityLUT == null)
|
|
{
|
|
_particleDensityLUT = new RenderTexture(1024, 1024, 0, RenderTextureFormat.RGFloat, RenderTextureReadWrite.Linear);
|
|
_particleDensityLUT.name = "ParticleDensityLUT";
|
|
_particleDensityLUT.filterMode = FilterMode.Bilinear;
|
|
_particleDensityLUT.Create();
|
|
}
|
|
|
|
nullTexture = null;
|
|
Graphics.Blit(nullTexture, _particleDensityLUT, _material, 0);
|
|
_material.SetTexture("_ParticleDensityLUT", _particleDensityLUT);
|
|
|
|
useAtmosphereIndex = -1;
|
|
|
|
|
|
|
|
|
|
|
|
|
|
////TURN OFF ANTI ALIASING in forward mode
|
|
if (disableMSA) QualitySettings.antiAliasing = 0;
|
|
|
|
//CACHE COLOR SPACE (for performance)
|
|
_linearSpace = QualitySettings.activeColorSpace;
|
|
|
|
//TURN OFF BUILT-IN FOG
|
|
if (enableFog) UnityEngine.RenderSettings.fog = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void LoadObjects() {
|
|
|
|
//GET TENKOKU OBJECTS
|
|
calcComponent = this.gameObject.GetComponent<Tenkoku.Core.TenkokuCalculations>() as Tenkoku.Core.TenkokuCalculations;
|
|
libComponent = (Tenkoku.Core.TenkokuLib) FindObjectOfType(typeof(Tenkoku.Core.TenkokuLib));
|
|
|
|
//GET WINDZONE OBJECT
|
|
tenkokuWindObject = GameObject.Find("Tenkoku_WindZone").GetComponent<WindZone>();
|
|
tenkokuWindTrans = tenkokuWindObject.gameObject.GetComponent<Transform>();
|
|
|
|
//GET REFLECTION PROBE
|
|
if (GameObject.Find("Tenkoku_ReflectionProbe") != null){
|
|
tenkokuReflectionObject = GameObject.Find("Tenkoku_ReflectionProbe").GetComponent<ReflectionProbe>();
|
|
|
|
//if (tenkokuReflectionObject != null && Application.isPlaying){
|
|
// //handle probe update when set to "scripting"
|
|
// tenkokuReflectionObject.RenderProbe(null);
|
|
|
|
// //update GI environment (ambient lighting)
|
|
// UnityEngine.DynamicGI.UpdateEnvironment();
|
|
//}
|
|
}
|
|
|
|
//SET DEFAULT CURVE PROPERTIES
|
|
#if UNITY_5_4_OR_NEWER
|
|
rainCurve = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
rainCurveForceX = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
rainCurveForceY = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
rainCurveFog = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
rainCurveFogForceX = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
rainCurveFogForceY = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
splashCurve = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
fogCurve = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
fogCurveForceX = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
fogCurveForceY = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
snowCurve = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
snowCurveForceX = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
snowCurveForceY = new ParticleSystem.MinMaxCurve(0.0f, 1.0f);
|
|
#endif
|
|
|
|
|
|
//GET CELESTIAL OBJECTS
|
|
worldlightObject = GameObject.Find("LIGHT_World").GetComponent<Transform>();
|
|
sunlightObject = GameObject.Find("LIGHT_Sun").GetComponent<Transform>();
|
|
sunSphereObject = GameObject.Find("SkySphereSun").GetComponent<Transform>();
|
|
sunObject = GameObject.Find("Sun").GetComponent<Transform>();
|
|
eclipseObject = GameObject.Find("sun_solareclipsefx").GetComponent<Transform>();
|
|
moonSphereObject = GameObject.Find("SkySphereMoon").GetComponent<Transform>();
|
|
moonObject = GameObject.Find("Moon").GetComponent<Transform>();
|
|
moonlightObject = GameObject.Find("LIGHT_Moon").GetComponent<Transform>();
|
|
skyObject = GameObject.Find("SkySphere").GetComponent<Transform>();
|
|
|
|
starfieldObject = GameObject.Find("SkySphereStar").GetComponent<Transform>();
|
|
starGalaxyObject = GameObject.Find("SkySphereGalaxy").GetComponent<Transform>();
|
|
|
|
if (GameObject.Find("StarRenderSystem") != null){
|
|
starRenderSystem = GameObject.Find("StarRenderSystem").GetComponent<Tenkoku.Core.ParticleStarfieldHandler>() as Tenkoku.Core.ParticleStarfieldHandler;
|
|
starParticleSystem = GameObject.Find("StarRenderSystem").GetComponent<Renderer>() as Renderer;
|
|
}
|
|
|
|
if (GameObject.Find("planetMars")) planetObjMars = GameObject.Find("planetMars").gameObject.GetComponent<Tenkoku.Core.ParticlePlanetHandler>() as Tenkoku.Core.ParticlePlanetHandler;
|
|
if (GameObject.Find("planetMercury")) planetObjMercury = GameObject.Find("planetMercury").gameObject.GetComponent<Tenkoku.Core.ParticlePlanetHandler>() as Tenkoku.Core.ParticlePlanetHandler;
|
|
if (GameObject.Find("planetVenus")) planetObjVenus =GameObject.Find("planetVenus").gameObject.GetComponent<Tenkoku.Core.ParticlePlanetHandler>() as Tenkoku.Core.ParticlePlanetHandler;
|
|
if (GameObject.Find("planetJupiter")) planetObjJupiter = GameObject.Find("planetJupiter").gameObject.GetComponent<Tenkoku.Core.ParticlePlanetHandler>() as Tenkoku.Core.ParticlePlanetHandler;
|
|
if (GameObject.Find("planetSaturn")) planetObjSaturn = GameObject.Find("planetSaturn").gameObject.GetComponent<Tenkoku.Core.ParticlePlanetHandler>() as Tenkoku.Core.ParticlePlanetHandler;
|
|
if (GameObject.Find("planetUranus")) planetObjUranus = GameObject.Find("planetUranus").gameObject.GetComponent<Tenkoku.Core.ParticlePlanetHandler>() as Tenkoku.Core.ParticlePlanetHandler;
|
|
if (GameObject.Find("planetNeptune")) planetObjNeptune = GameObject.Find("planetNeptune").gameObject.GetComponent<Tenkoku.Core.ParticlePlanetHandler>() as Tenkoku.Core.ParticlePlanetHandler;
|
|
|
|
if (planetObjSaturn != null) planetRendererSaturn = planetObjSaturn.GetComponent<Renderer>() as Renderer;
|
|
if (planetObjJupiter != null) planetRendererJupiter = planetObjJupiter.GetComponent<Renderer>() as Renderer;
|
|
if (planetObjNeptune != null) planetRendererNeptune = planetObjNeptune.GetComponent<Renderer>() as Renderer;
|
|
if (planetObjUranus != null) planetRendererUranus = planetObjUranus.GetComponent<Renderer>() as Renderer;
|
|
if (planetObjMercury != null) planetRendererMercury = planetObjMercury.GetComponent<Renderer>() as Renderer;
|
|
if (planetObjVenus != null) planetRendererVenus = planetObjVenus.GetComponent<Renderer>() as Renderer;
|
|
if (planetObjMars != null) planetRendererMars = planetObjMars.GetComponent<Renderer>() as Renderer;
|
|
|
|
if (planetObjSaturn != null) planetTransSaturn = planetObjSaturn.GetComponent<Transform>() as Transform;
|
|
if (planetObjJupiter != null) planetTransJupiter = planetObjJupiter.GetComponent<Transform>() as Transform;
|
|
if (planetObjNeptune != null) planetTransNeptune = planetObjNeptune.GetComponent<Transform>() as Transform;
|
|
if (planetObjUranus != null) planetTransUranus = planetObjUranus.GetComponent<Transform>() as Transform;
|
|
if (planetObjMercury != null) planetTransMercury = planetObjMercury.GetComponent<Transform>() as Transform;
|
|
if (planetObjVenus != null) planetTransVenus = planetObjVenus.GetComponent<Transform>() as Transform;
|
|
if (planetObjMars != null) planetTransMars = planetObjMars.GetComponent<Transform>() as Transform;
|
|
|
|
nightSkyLightObject = GameObject.Find("LIGHT_NightSky").GetComponent<Transform>();
|
|
fillLightObject = GameObject.Find("LIGHT_NightFill").GetComponent<Transform>();
|
|
//GET SOUND OBJECT
|
|
ambientSoundObject = GameObject.Find("AMBIENT_SOUNDS").gameObject.GetComponent<Tenkoku.Core.TenkokuGlobalSound>() as Tenkoku.Core.TenkokuGlobalSound;
|
|
|
|
//GET FLARE OBJECTS
|
|
//sunFlare = sunObject.GetComponent(LensFlare);
|
|
|
|
//GET WEATHER OBJECTS
|
|
if (GameObject.Find("fxRain")) rainSystem = GameObject.Find("fxRain").gameObject.GetComponent<ParticleSystem>();
|
|
if (GameObject.Find("fxRainFog")) rainFogSystem = GameObject.Find("fxRainFog").gameObject.GetComponent<ParticleSystem>();
|
|
if (GameObject.Find("fxRainSplash")) rainSplashSystem = GameObject.Find("fxRainSplash").gameObject.GetComponent<ParticleSystem>();
|
|
if (GameObject.Find("fxSnow")) snowSystem = GameObject.Find("fxSnow").gameObject.GetComponent<ParticleSystem>();
|
|
if (GameObject.Find("fxFog")) fogSystem = GameObject.Find("fxFog").gameObject.GetComponent<ParticleSystem>();
|
|
|
|
|
|
|
|
//GET AURORA OBJECTS
|
|
//auroraObjectTransform = GameObject.Find("fxAuroraPlane").gameObject.GetComponent<Transform>();
|
|
//renderObjectAurora = GameObject.Find("fxAuroraPlane").gameObject.GetComponent<Renderer>();
|
|
//renderObjectAurora.enabled = false;
|
|
|
|
auroraObjectTransform = GameObject.Find("fxAuroraSphere").gameObject.GetComponent<Transform>();
|
|
renderObjectAurora = GameObject.Find("fxAuroraSphere").gameObject.GetComponent<Renderer>();
|
|
//renderObjectAurora.enabled = false;
|
|
|
|
|
|
//GET COMPONENT REFERENCES
|
|
lightObjectFill = fillLightObject.gameObject.GetComponent<Light>();
|
|
lightObjectNight = nightSkyLightObject.gameObject.GetComponent<Light>();
|
|
lightObjectWorld = worldlightObject.gameObject.GetComponent<Light>();
|
|
|
|
|
|
renderObjectMoon = moonObject.gameObject.GetComponent<Renderer>();
|
|
renderObjectGalaxy = starGalaxyObject.gameObject.GetComponent<Renderer>();
|
|
|
|
if (Application.isPlaying){
|
|
if (rainSystem) renderObjectRain = rainSystem.GetComponent<Renderer>();
|
|
if (rainSplashSystem) renderObjectRainSplash = rainSplashSystem.GetComponent<Renderer>();
|
|
if (rainFogSystem) renderObjectRainFog = rainFogSystem.GetComponent<Renderer>();
|
|
if (fogSystem) renderObjectFog = fogSystem.GetComponent<Renderer>();
|
|
if (snowSystem) renderObjectSnow = snowSystem.GetComponent<Renderer>();
|
|
|
|
if (rainFogSystem) particleObjectRainFog = rainFogSystem.GetComponent<ParticleSystem>();
|
|
if (rainSplashSystem) particleObjectRainSplash = rainSplashSystem.GetComponent<ParticleSystem>();
|
|
if (fogSystem) particleObjectFog = fogSystem.GetComponent<ParticleSystem>();
|
|
}
|
|
|
|
//Get Cloud Objects
|
|
cloudPlaneObject = GameObject.Find("fxCloudPlane").GetComponent<Transform>();
|
|
renderObjectCloudPlane = cloudPlaneObject.gameObject.GetComponent<Renderer>();
|
|
|
|
#if UNITY_5_4_OR_NEWER || UNITY_5_3_4 || UNITY_5_3_5 || UNITY_5_3_6 || UNITY_5_3_7 || UNITY_5_3_8
|
|
cloudSphereObject = GameObject.Find("fxCloudSphere").GetComponent<Transform>();
|
|
renderObjectCloudSphere = cloudSphereObject.gameObject.GetComponent<Renderer>();
|
|
|
|
if (Application.isPlaying){
|
|
materialObjectCloudSphere = renderObjectCloudSphere.material;
|
|
} else {
|
|
materialObjectCloudSphere = renderObjectCloudSphere.sharedMaterial;
|
|
}
|
|
|
|
#endif
|
|
|
|
fogCameraCam = GameObject.Find("Tenkoku_SkyFog").GetComponent<Camera>();
|
|
fogCameraBlur = GameObject.Find("Tenkoku_SkyFog").GetComponent<Tenkoku.Effects.TenkokuSkyBlur>() as Tenkoku.Effects.TenkokuSkyBlur;
|
|
|
|
|
|
//set default cameras
|
|
if (Application.isPlaying){
|
|
useCamera = null;
|
|
useCameraCam = null;
|
|
}
|
|
|
|
|
|
//Set Default Positions
|
|
if (sunObject != null) sunObject.localPosition = sunBasePosition;
|
|
if (sunSphereObject != null) sunSphereObject.localPosition = Vector3.zero;
|
|
|
|
if (moonObject != null) moonObject.localPosition = moonBasePosition;
|
|
if (moonSphereObject != null) moonSphereObject.localPosition = Vector3.zero;
|
|
|
|
if (planetTransMercury != null) planetTransMercury.localPosition = Vector3.zero;
|
|
if (planetTransVenus != null) planetTransVenus.localPosition = Vector3.zero;
|
|
if (planetTransMars != null) planetTransMars.localPosition = Vector3.zero;
|
|
if (planetTransJupiter != null) planetTransJupiter.localPosition = Vector3.zero;
|
|
if (planetTransSaturn != null) planetTransSaturn.localPosition = Vector3.zero;
|
|
if (planetTransUranus != null) planetTransUranus.localPosition = Vector3.zero;
|
|
if (planetTransNeptune != null) planetTransNeptune.localPosition = Vector3.zero;
|
|
|
|
|
|
UnityEngine.DynamicGI.UpdateEnvironment();
|
|
}
|
|
|
|
|
|
|
|
|
|
void HandleGlobalSound(){
|
|
|
|
|
|
//--------------------------------------
|
|
//--- CALCULATE MASTER VOLUME ----
|
|
//--------------------------------------
|
|
overallVolume = Mathf.Clamp01(overallVolume);
|
|
|
|
|
|
//---------------------------------------
|
|
//--- CALCULATE ELEMENT VOLUME ----
|
|
//---------------------------------------
|
|
ambientSoundObject.volWind = Mathf.Lerp(0.0f,1.5f,weather_WindAmt) * (volumeWind * overallVolume);
|
|
ambientSoundObject.volTurb1 = Mathf.Lerp(0.0f,2.0f,weather_WindAmt) * (volumeTurb1 * overallVolume);
|
|
ambientSoundObject.volTurb2 = Mathf.Lerp(-1.0f,1.5f,weather_WindAmt) * (volumeTurb2 * overallVolume);
|
|
ambientSoundObject.volRain = volumeRain * ((weather_RainAmt*1.5f) * overallVolume);
|
|
|
|
//---------------------------------------------
|
|
//--- CALCULATE AMBIENT AUDIO CURVES ----
|
|
//---------------------------------------------
|
|
ambientSoundObject.volAmbNight = volumeAmbNight * (curveAmbNight24.Evaluate(dayValue) * curveAmbNightYR.Evaluate(yearValue) * overallVolume);
|
|
ambientSoundObject.volAmbDay = volumeAmbDay * (curveAmbDay24.Evaluate(dayValue) * curveAmbDayYR.Evaluate(yearValue) * overallVolume);
|
|
|
|
//-----------------------------------------
|
|
//--- SEND DATA TO SOUND HANDLER ----
|
|
//-----------------------------------------
|
|
ambientSoundObject.enableSounds = enableSoundFX;
|
|
ambientSoundObject.enableTimeAdjust = enableTimeAdjust;
|
|
|
|
if (audioWind != null){
|
|
ambientSoundObject.audioWind = audioWind;
|
|
} else {
|
|
ambientSoundObject.audioWind = null;
|
|
}
|
|
|
|
if (audioTurb1 != null){
|
|
ambientSoundObject.audioTurb1 = audioTurb1;
|
|
} else {
|
|
ambientSoundObject.audioTurb1 = null;
|
|
}
|
|
|
|
if (audioTurb2 != null){
|
|
ambientSoundObject.audioTurb2 = audioTurb2;
|
|
} else {
|
|
ambientSoundObject.audioTurb2 = null;
|
|
}
|
|
|
|
if (audioRain != null){
|
|
ambientSoundObject.audioRain = audioRain;
|
|
} else {
|
|
ambientSoundObject.audioRain = null;
|
|
}
|
|
|
|
if (audioAmbDay != null){
|
|
ambientSoundObject.audioAmbDay = audioAmbDay;
|
|
} else {
|
|
ambientSoundObject.audioAmbDay = null;
|
|
}
|
|
|
|
if (audioAmbNight != null){
|
|
ambientSoundObject.audioAmbNight = audioAmbNight;
|
|
} else {
|
|
ambientSoundObject.audioAmbNight = null;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void UpdatePositions(){
|
|
|
|
// -------------------------------
|
|
// -- SET SKY POSITIONING ---
|
|
// -------------------------------
|
|
if (Application.isPlaying){
|
|
|
|
// track positioning
|
|
if (useCamera != null){
|
|
skyObject.position = useCamera.position;
|
|
|
|
//sky sizing based on camera
|
|
if (useCameraCam != null){
|
|
//if (currClipDistance != useCameraCam.farClipPlane){
|
|
currClipDistance = useCameraCam.farClipPlane;
|
|
|
|
setSkyUseSize = (currClipDistance/20.0f)*2f;
|
|
setScale.x = setSkyUseSize;
|
|
setScale.y = setSkyUseSize;
|
|
setScale.z = setSkyUseSize;
|
|
|
|
setScale2.x = setSkyUseSize * 0.76f;
|
|
setScale2.y = setSkyUseSize * 0.76f;
|
|
setScale2.z = setSkyUseSize * 0.76f;
|
|
|
|
sunSphereObject.localScale = setScale2;
|
|
moonSphereObject.localScale = setScale2;
|
|
starfieldObject.localScale = setScale;
|
|
starRenderSystem.starDistance = currClipDistance;
|
|
starRenderSystem.setSize = starRenderSystem.baseSize * (currClipDistance/800f);
|
|
starGalaxyObject.localScale = galaxyScale;
|
|
|
|
Shader.SetGlobalVector("_TenkokuCameraPos", useCamera.position);
|
|
|
|
//}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void LateUpdate () {
|
|
|
|
//if (Application.isPlaying){
|
|
|
|
//SET VERSION NUMBER
|
|
tenkokuVersionNumber = "1.1.6";
|
|
|
|
|
|
//UPDATE RANDOM NUMBER SETTING
|
|
if (TenRandom == null){
|
|
TenRandom = new Tenkoku.Core.Random(randSeed);
|
|
}
|
|
|
|
|
|
////TURN OFF ANTI ALIASING
|
|
#if UNITY_EDITOR
|
|
if (disableMSA) QualitySettings.antiAliasing = 0;
|
|
#endif
|
|
|
|
|
|
//set project layer masks
|
|
#if UNITY_EDITOR
|
|
if (!Application.isPlaying){
|
|
tenLayerMasks.Clear();
|
|
for (i = 0; i < 32; i++){
|
|
layerName = LayerMask.LayerToName(i);
|
|
tenLayerMasks.Add(layerName);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
// SET SKYBOX DATA
|
|
CalculateSkyboxData(RenderSettings.skybox);
|
|
|
|
|
|
// EDITOR MODE SPECIFIC
|
|
if (!Application.isPlaying){
|
|
|
|
//get objects in editor mode
|
|
LoadObjects();
|
|
|
|
//rotate sun in editor mode
|
|
sunlightObject.LookAt(sunSphereObject);
|
|
worldlightObject.localRotation = sunlightObject.localRotation;
|
|
nightSkyLightObject.localRotation = moonObject.localRotation;
|
|
|
|
//set layers
|
|
if (lightObjectWorld.gameObject.activeInHierarchy){
|
|
lightObjectWorld.cullingMask = lightLayer;
|
|
lightObjectNight.cullingMask = lightLayer;
|
|
lightObjectFill.cullingMask = lightLayer;
|
|
}
|
|
}
|
|
|
|
|
|
//CACHE SYSTEM VARIABLES (for performance)
|
|
_deltaTime = UnityEngine.Time.deltaTime;
|
|
|
|
//Set base transition boolean flag
|
|
isDoingTransition = false;
|
|
|
|
|
|
//UPDATE SYSTEM TIMER
|
|
if (!autoTime) useTimeCompression = 0f;
|
|
|
|
//timerCloudMod = 1f;
|
|
|
|
if (!useAutoTime){
|
|
//timerCloudMod = 0.0f;
|
|
} else {
|
|
cloudStepTime += (_deltaTime * useTimeCompression);
|
|
if (cloudStepTime >= 1f) cloudStepTime += _deltaTime;
|
|
if (lastSecond != currentSecond) cloudStepTime = 0f;
|
|
}
|
|
|
|
|
|
|
|
|
|
#if UNITY_EDITOR
|
|
if (EditorApplication.isCompiling){
|
|
recompileFlag = true;
|
|
cloudLinkToTime = false;
|
|
} else {
|
|
#endif
|
|
|
|
if (enableAutoAdvance){
|
|
systemTime = ((calcComponent.UT * 3600f));// + timerCloudMod * (0.0031f * weather_cloudSpeed);
|
|
}
|
|
|
|
if (cloudLinkToTime){
|
|
Shader.SetGlobalFloat("_tenkokuTimer", systemTime % 60f);
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
//UPDATE TENKOKU SYSTEM TIME
|
|
TimeUpdate();
|
|
|
|
|
|
// UPDATE DECODED COLOR MAP
|
|
// This is only in edit mode and is used for convenience when editing color gradient texture.
|
|
// Keep it on for live editing of color texture. Turn off for improved in-editor performance.
|
|
#if UNITY_EDITOR
|
|
//UpdateColorMap();
|
|
#endif
|
|
|
|
// UPDATE DECODED COLORS
|
|
// This resamples the gradient texture map based on current time of day.
|
|
LoadDecodedColors();
|
|
|
|
|
|
// -----------------------------
|
|
// -- GET CAMERA OBJECTS ---
|
|
// -----------------------------
|
|
// This is put into the main update loop in order to have updating
|
|
// in edit mode, while the scene is not playing.
|
|
if (cameraTypeIndex == 0){
|
|
if (Camera.main != null){
|
|
mainCamera = Camera.main.transform;
|
|
}
|
|
manualCamera = null;
|
|
}
|
|
if (cameraTypeIndex == 1){
|
|
if (manualCamera != null){
|
|
mainCamera = manualCamera;
|
|
} else {
|
|
if (Camera.main != null){
|
|
mainCamera = Camera.main.transform;
|
|
}
|
|
}
|
|
}
|
|
|
|
//if (useCamera != mainCamera){
|
|
// useCamera = mainCamera;
|
|
//}
|
|
|
|
|
|
|
|
if (useCamera != mainCamera && mainCamera != null){
|
|
useCamera = mainCamera;
|
|
useCameraCam = useCamera.GetComponent<Camera>();
|
|
|
|
MV = useCameraCam.worldToCameraMatrix.inverse;
|
|
Shader.SetGlobalMatrix("_Tenkoku_CameraMV",MV);
|
|
useCameraCam.clearFlags = CameraClearFlags.Skybox;
|
|
|
|
if (useAutoFX && Application.isPlaying){
|
|
|
|
fogObject = useCamera.GetComponent<Tenkoku.Effects.TenkokuSkyFog>();
|
|
if (fogObject == null){
|
|
fogObject = useCamera.gameObject.AddComponent<Tenkoku.Effects.TenkokuSkyFog>();
|
|
}
|
|
|
|
sunRayObject = useCamera.GetComponent<Tenkoku.Effects.TenkokuSunShafts>();
|
|
if (sunRayObject == null){
|
|
sunRayObject = useCamera.gameObject.AddComponent<Tenkoku.Effects.TenkokuSunShafts>();
|
|
}
|
|
|
|
if (useTemporalAliasing){
|
|
temporalFX = useCamera.GetComponent<Tenkoku_TemporalReprojection>();
|
|
temporalBuffer = useCamera.GetComponent<Tenkoku_VelocityBuffer>();
|
|
if (temporalFX == null){
|
|
temporalFX = useCamera.gameObject.AddComponent<Tenkoku_TemporalReprojection>();
|
|
temporalBuffer = useCamera.GetComponent<Tenkoku_VelocityBuffer>();
|
|
}
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
if (useAutoFX && useCamera != null && Application.isPlaying){
|
|
if (fogObject == null){
|
|
fogObject = useCamera.GetComponent<Tenkoku.Effects.TenkokuSkyFog>();
|
|
if (fogObject == null){
|
|
fogObject = useCamera.gameObject.AddComponent<Tenkoku.Effects.TenkokuSkyFog>();
|
|
}
|
|
}
|
|
|
|
if (sunRayObject == null){
|
|
sunRayObject = useCamera.GetComponent<Tenkoku.Effects.TenkokuSunShafts>();
|
|
if (sunRayObject == null){
|
|
sunRayObject = useCamera.gameObject.AddComponent<Tenkoku.Effects.TenkokuSunShafts>();
|
|
}
|
|
}
|
|
|
|
if (useTemporalAliasing){
|
|
if (temporalFX == null){
|
|
temporalFX = useCamera.GetComponent<Tenkoku_TemporalReprojection>();
|
|
temporalBuffer = useCamera.GetComponent<Tenkoku_VelocityBuffer>();
|
|
if (temporalFX == null){
|
|
temporalFX = useCamera.gameObject.AddComponent<Tenkoku_TemporalReprojection>();
|
|
temporalBuffer = useCamera.GetComponent<Tenkoku_VelocityBuffer>();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
if (Application.isPlaying){
|
|
if (useCameraCam == null && mainCamera != null){
|
|
useCameraCam = useCamera.GetComponent<Camera>();
|
|
}
|
|
}
|
|
|
|
|
|
|
|
// -----------------------------
|
|
// -- TRACK CAMERA ---
|
|
// -----------------------------
|
|
if (Application.isPlaying){
|
|
UpdatePositions();
|
|
}
|
|
|
|
|
|
//SYNC TIME TO SYSTEM
|
|
if (Application.isPlaying){
|
|
if (autoTimeSync || autoDateSync){
|
|
|
|
sysTime = System.DateTime.Now;
|
|
|
|
if (autoTimeSync){
|
|
currentHour = Mathf.FloorToInt(sysTime.Hour);
|
|
currentMinute = Mathf.FloorToInt(sysTime.Minute);
|
|
currentSecond = Mathf.FloorToInt(sysTime.Second);
|
|
useTimeCompression = 1.0f;
|
|
}
|
|
if (autoDateSync){
|
|
currentYear = Mathf.FloorToInt(sysTime.Year);
|
|
currentMonth = Mathf.FloorToInt(sysTime.Month);
|
|
currentDay = Mathf.FloorToInt(sysTime.Day);
|
|
}
|
|
|
|
} else {
|
|
if (!doTransition){
|
|
useTimeCompression = timeCompression * curveVal;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//SET LIGHTING LAYERS
|
|
if (Application.isPlaying){
|
|
if (lightObjectWorld.gameObject.activeInHierarchy){
|
|
lightObjectWorld.cullingMask = lightLayer;
|
|
lightObjectNight.cullingMask = lightLayer;
|
|
lightObjectFill.cullingMask = lightLayer;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// -------------------------------
|
|
// -- SET REFLECTION PROBE ---
|
|
// -------------------------------
|
|
if (tenkokuReflectionObject != null){
|
|
|
|
if (enableProbe && Application.isPlaying){
|
|
|
|
//enable probe during play mode
|
|
tenkokuReflectionObject.enabled = true;
|
|
tenkokuReflectionObject.mode = UnityEngine.Rendering.ReflectionProbeMode.Realtime;
|
|
tenkokuReflectionObject.refreshMode = UnityEngine.Rendering.ReflectionProbeRefreshMode.ViaScripting;
|
|
//tenkokuReflectionObject.intensity = 1.0f;
|
|
|
|
//set size to world size
|
|
if (useCameraCam != null){
|
|
reflectionSize.x = useCameraCam.farClipPlane*2f;
|
|
reflectionSize.y = useCameraCam.farClipPlane;
|
|
reflectionSize.z = useCameraCam.farClipPlane*2f;
|
|
tenkokuReflectionObject.size = reflectionSize;
|
|
}
|
|
|
|
//handle probe update when set to "scripting"
|
|
if (tenkokuReflectionObject.refreshMode == UnityEngine.Rendering.ReflectionProbeRefreshMode.ViaScripting){
|
|
reflectionTimer += _deltaTime;
|
|
|
|
useReflectionFPS = 10f;
|
|
if (probeHasUpdated) useReflectionFPS = reflectionProbeFPS;
|
|
|
|
if (reflectionTimer >= (1.0f/useReflectionFPS)){
|
|
tenkokuReflectionObject.RenderProbe(null);
|
|
reflectionTimer = 0.0f;
|
|
probeHasUpdated = true;
|
|
|
|
//update GI environment (ambient lighting)
|
|
UnityEngine.DynamicGI.UpdateEnvironment();
|
|
}
|
|
}
|
|
|
|
|
|
} else {
|
|
//disable probe update during scene-mode
|
|
tenkokuReflectionObject.mode = UnityEngine.Rendering.ReflectionProbeMode.Baked;
|
|
tenkokuReflectionObject.refreshMode = UnityEngine.Rendering.ReflectionProbeRefreshMode.OnAwake;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// --------------------
|
|
// -- SET FLAGS ---
|
|
// --------------------
|
|
//Set Linear Mode on Shader
|
|
isLin = 0.0f;
|
|
if (_linearSpace == ColorSpace.Linear) isLin = 1.0f;
|
|
if (isLin != currIsLin){
|
|
currIsLin = isLin;
|
|
}
|
|
Shader.SetGlobalFloat("_tenkokuIsLinear",isLin);
|
|
|
|
|
|
|
|
|
|
|
|
// --------------------------------
|
|
// -- CALCULATE WEATHER ---
|
|
// --------------------------------
|
|
|
|
//RANDOM WEATHER
|
|
if (weatherTypeIndex == 1){
|
|
CalculateWeatherRandom();
|
|
}
|
|
|
|
//ADVANCED WEATHER
|
|
if (weatherTypeIndex == 2){
|
|
//
|
|
}
|
|
|
|
//Handle Temperature setting
|
|
Shader.SetGlobalFloat("_Tenkoku_HeatDistortAmt",Mathf.Lerp(0.0f,0.04f,Mathf.Clamp(weather_temperature-90.0f,0.0f,120.0f)/30.0f));
|
|
|
|
//Handle Rainbow Rendering
|
|
rOC = 1.0f-Mathf.Clamp(weather_OvercastAmt*2f,0.0f,1.0f);
|
|
Shader.SetGlobalFloat("_tenkoku_rainbowFac1",Mathf.Clamp(Mathf.Lerp(0.0f,1.25f,weather_rainbow),0.0f,rOC));
|
|
Shader.SetGlobalFloat("_tenkoku_rainbowFac2",Mathf.Clamp(Mathf.Lerp(-2.0f,1.0f,weather_rainbow),0.0f,rOC));
|
|
|
|
|
|
|
|
// --------------------
|
|
// -- SET SOUND ---
|
|
// --------------------
|
|
HandleGlobalSound();
|
|
|
|
|
|
|
|
|
|
// --------------
|
|
// -- SUN ---
|
|
// --------------
|
|
//sunSphereObject.gameObject.SetActive(true);
|
|
//sunObject.gameObject.SetActive(true);
|
|
//sunlightObject.gameObject.SetActive(true);
|
|
|
|
//solar ecliptic movement
|
|
//calcComponent.CalculateNode(1); //sunstatic
|
|
eclipticoffset = 0.0f;
|
|
|
|
//sun position and light direction based on Solar Day Calculation
|
|
calcComponent.CalculateNode(2); //sun
|
|
sunPosition.x = 0.0f;
|
|
sunPosition.y = 90f+calcComponent.azimuth+setRotation+0.5f;
|
|
sunPosition.z = -180.0f+calcComponent.altitude-0.5f;
|
|
sunSphereObject.localEulerAngles = sunPosition;
|
|
|
|
//sun apparent horizon size
|
|
//due to optical atmospheric refraction as well as relative viusal proportion artifacts
|
|
//at the horizon, the sun appears larger at the horizon than it does while overhead.
|
|
//we're artificially changing the size of the sun to simulate this visual trickery.
|
|
//sSDiv = Mathf.Abs((sunPosition.z-180.0f)/180.0f);
|
|
//if (sSDiv == 0.0f) sSDiv = 1.0f;
|
|
//if (sSDiv < 0.5f && sSDiv > 0.0f) sSDiv = 0.5f + (0.5f - sSDiv);
|
|
//sunCalcSize = sunSize + Mathf.Lerp(0.0f,(sunSize * Mathf.Lerp(-2.0f,2.0f,sSDiv)),Mathf.Lerp(-1.0f,1.0f,sSDiv));
|
|
|
|
|
|
//Calculate moon/horizon atitude
|
|
sunsetDegrees = 20.0f;
|
|
sunFac = sunlightObject.eulerAngles.x;
|
|
if (sunFac > 90.0f) sunFac = 0.0f;
|
|
sunsetFac = Mathf.Clamp01(Mathf.Lerp(-0.5f,1.0f,Mathf.Clamp01(sunFac / sunsetDegrees)));
|
|
|
|
//set explicit size of sun in Custom mode
|
|
sunCalcSize = sunSize*0.5f;
|
|
Shader.SetGlobalFloat("_Tenkoku_SunSize",sunSize+0.005f);
|
|
|
|
//moon horizon size - turned off for now
|
|
//due to optical atmospheric refraction as well as relative viusal proportion artifacts
|
|
//at the horizon, the moon appears larger at the horizon than it does while overhead.
|
|
//we're artificially changing the size of the moon to simulate this visual trickery.
|
|
sunCalcSize *= Mathf.Lerp(1.5f, 1f, sunsetFac);
|
|
|
|
//set sun scale
|
|
sunScale.x = sunCalcSize;
|
|
sunScale.y = sunCalcSize;
|
|
sunScale.z = sunCalcSize;
|
|
sunObject.localScale = sunScale;
|
|
|
|
//solar parhelion
|
|
//models the non-circular orbit of the earth. The sun is not a constant distance
|
|
//varying over the course of the year, this offsets the perceived sunset and
|
|
//sunrise times from where they would be given a perfectly circular orbit.
|
|
//--- no code yet ---
|
|
|
|
//send sun position to shader
|
|
sunPos.x = sunObject.localPosition.x/360.0f;
|
|
sunPos.y = sunObject.localPosition.y/360.0f;
|
|
sunPos.z = sunObject.localPosition.z/360.0f;
|
|
sunPos.w = 0.0f;
|
|
Shader.SetGlobalColor("_Tenkoku_SunPos", sunPos);
|
|
|
|
//set sun color
|
|
colorSun = decodeColorSun;
|
|
|
|
//sun lightsource, point toward camera
|
|
if (useCamera != null){
|
|
sunlightObject.LookAt(useCamera);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ---------------
|
|
// -- MOON ---
|
|
// ---------------
|
|
|
|
if (moonTypeIndex == 2){
|
|
moonIsVisible = false;
|
|
} else {
|
|
moonIsVisible = true;
|
|
}
|
|
|
|
if (!moonIsVisible){
|
|
renderObjectMoon.enabled = false;
|
|
} else {
|
|
renderObjectMoon.enabled = true;
|
|
}
|
|
|
|
|
|
//Moon Simple Movement
|
|
calcComponent.moonPos = -1;
|
|
if (moonTypeIndex == 1){
|
|
calcComponent.moonPos = moonPos;
|
|
}
|
|
|
|
//Calculate Moon Position
|
|
calcComponent.CalculateNode(3);
|
|
moonPosition.x = 0f;
|
|
moonPosition.y = 90f+calcComponent.azimuth+setRotation+0.15f;
|
|
moonPosition.z = -180f+calcComponent.altitude-0.5f;
|
|
moonSphereObject.localEulerAngles = moonPosition;
|
|
|
|
//Calculate Moon Light Coverage
|
|
moonLightAmt = Quaternion.Angle(sunlightObject.rotation,moonlightObject.rotation) / 180.0f;
|
|
|
|
// Manual Quaternion Angle Construction
|
|
// We do this instead of Unity's Quaternion.Angle() function because we don't want it automatically clamped.
|
|
// The moon's phase is a float from 0.0 - 1.0, where 0.5 is a full moon and 1.0/0.0 are new moon.
|
|
mres = moonlightObject.rotation * Quaternion.Inverse(sunlightObject.rotation);
|
|
moonPhase = (Mathf.Acos(mres.w) * 2.0f * 57.2957795f) / 360f;
|
|
|
|
//moon libration (currently disabled)
|
|
//as the moon travels across the lunar month it appears to wobbleback and
|
|
//forth as it transits from one phase to another. This is called "libration"
|
|
//var monthAngle = (monthValue);
|
|
//if (monthAngle == 0.0) monthAngle = 1.0;
|
|
//if (monthAngle < 0.5 && monthAngle > 0.0) monthAngle = 0.5 + (0.5 - monthAngle);
|
|
//moonObject.localEulerAngles.z = 0.0-Mathf.SmoothStep(336.0,384.0,Mathf.Lerp(-1.0,1.0,moonClipAngle));
|
|
|
|
//Calculate moon/horizon atitude
|
|
sunsetDegrees = 20.0f;
|
|
moonFac = nightSkyLightObject.eulerAngles.x;
|
|
if (moonFac > 90.0f) moonFac = 0.0f;
|
|
moonsetFac = Mathf.Clamp01(Mathf.Lerp(-0.5f,1.0f,Mathf.Clamp01(moonFac / sunsetDegrees)));
|
|
Shader.SetGlobalFloat("Tenkoku_MoonHFac",moonsetFac);
|
|
|
|
//set explicit size of moon in Custom mode
|
|
moonCalcSize = moonSize*1.21f;
|
|
|
|
//moon apogee and perigree
|
|
moonApoSize = Mathf.Lerp(1.2f,0.82f,calcComponent.moonApogee);
|
|
moonCalcSize *= moonApoSize;
|
|
|
|
//moon horizon size
|
|
//due to optical atmospheric refraction as well as relative visual proportion artifacts
|
|
//at the horizon, the moon appears larger at the horizon than it does while overhead.
|
|
//we're artificially changing the size of the moon to simulate this visual trickery.
|
|
moonCalcSize *= Mathf.Lerp(1.5f, 1f, moonsetFac);
|
|
|
|
//set final moon scale
|
|
moonScale.x = moonCalcSize;
|
|
moonScale.y = moonCalcSize;
|
|
moonScale.z = moonCalcSize;
|
|
moonObject.localScale = moonScale;
|
|
|
|
//moon color
|
|
colorMoon = decodeColorMoon*1.0f;
|
|
colorSkyAmbient = decodeColorSkyambient;
|
|
|
|
//moon intensity
|
|
moonLightIntensity = Mathf.Clamp(moonLightIntensity,0.0f,1.0f);
|
|
|
|
//moon day fade
|
|
// we apply an extra fade during daylight hours so the moon recedes into the sky.
|
|
// it is still visible, yet it's visiblilty is superceded by the bright atmosphere.
|
|
moonDayIntensity = Mathf.Clamp(moonDayIntensity,0.0f,1.0f);
|
|
mDCol = Color.gray;
|
|
mDCol.a = Mathf.Lerp(1.0f,moonDayIntensity,colorSkyAmbient.r);
|
|
|
|
if (Application.isPlaying){
|
|
renderObjectMoon.material.SetColor("_Color", Color.Lerp(mDCol,(ambientCol*colorSun),ambientCol.r)*mDCol);
|
|
renderObjectMoon.material.SetColor("_AmbientTint",ambientCol);
|
|
} else {
|
|
renderObjectMoon.sharedMaterial.SetColor("_Color", Color.Lerp(mDCol,(ambientCol*colorSun),ambientCol.r)*mDCol);
|
|
renderObjectMoon.sharedMaterial.SetColor("_AmbientTint",ambientCol);
|
|
}
|
|
//set moon face light color
|
|
moonFaceCol = colorMoon*(1.0f-decodeColorAmbientcolor.r);
|
|
Shader.SetGlobalColor("Tenkoku_MoonLightColor",moonFaceCol);
|
|
Shader.SetGlobalColor("Tenkoku_MoonHorizColor",moonHorizColor);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------
|
|
// -- SET DAYLIGHT TIME ---
|
|
// ----------------------------
|
|
calcTime = Vector3.Angle((sunObject.position - skyObject.localPosition),skyObject.up) / 180.0f;
|
|
calcTime = 1.0f-calcTime;
|
|
setTime = calcTime*1.0f*colorRamp.width;
|
|
stepTime = Mathf.FloorToInt(setTime);
|
|
timeLerp = setTime - stepTime;
|
|
|
|
|
|
// ----------------------------
|
|
// -- SET MOONLIGHT TIME ---
|
|
// ----------------------------
|
|
calcTimeM = Vector3.Angle((moonObject.position - skyObject.localPosition),skyObject.up) / 180.0f;
|
|
calcTimeM = 1.0f-calcTimeM;
|
|
setTimeM = calcTimeM*1.0f*colorRamp.width;
|
|
stepTimeM = Mathf.FloorToInt(setTimeM);
|
|
timeLerpM = setTimeM - stepTimeM;
|
|
|
|
|
|
|
|
|
|
|
|
// ------------------
|
|
// -- PLANETS ---
|
|
// ------------------
|
|
useMult = 1.0f;
|
|
pVisFac = Mathf.Lerp(0.75f,0.1f,colorSkyAmbient.r);
|
|
|
|
if (Application.isPlaying){
|
|
|
|
//enable visibility
|
|
if (planetRendererSaturn != null) planetRendererSaturn.enabled = true;
|
|
if (planetRendererJupiter != null) planetRendererJupiter.enabled = true;
|
|
if (planetRendererNeptune != null) planetRendererNeptune.enabled = true;
|
|
if (planetRendererUranus != null) planetRendererUranus.enabled = true;
|
|
if (planetRendererMercury != null) planetRendererMercury.enabled = true;
|
|
if (planetRendererVenus != null) planetRendererVenus.enabled = true;
|
|
if (planetRendererMars != null) planetRendererMars.enabled = true;
|
|
|
|
|
|
//set planetary positions
|
|
if (planetObjMercury){
|
|
calcComponent.CalculateNode(4); //mercury
|
|
plMercuryPosition.x = 0f;
|
|
plMercuryPosition.y = 90.0f+calcComponent.azimuth+setRotation;
|
|
plMercuryPosition.z = -180.0f+calcComponent.altitude-0.5f;
|
|
planetTransMercury.localEulerAngles = plMercuryPosition;
|
|
tempTrans = planetTransMercury;
|
|
tempTrans.localPosition = Vector3.zero;
|
|
tempTrans.Translate(useVec * (eclipticoffset*useMult), Space.World);
|
|
planetObjMercury.planetOffset = tempTrans.localPosition;
|
|
planetObjMercury.planetVis = pVisFac * planetIntensity;
|
|
}
|
|
|
|
if (planetObjVenus){
|
|
calcComponent.CalculateNode(5); //venus
|
|
plVenusPosition.x = 0f;
|
|
plVenusPosition.y = 90.0f+calcComponent.azimuth+setRotation;
|
|
plVenusPosition.z = -180.0f+calcComponent.altitude-0.5f;
|
|
planetTransVenus.localEulerAngles = plVenusPosition;
|
|
tempTrans = planetTransVenus;
|
|
tempTrans.localPosition = Vector3.zero;
|
|
tempTrans.Translate(useVec * (eclipticoffset*useMult), Space.World);
|
|
planetObjVenus.planetOffset = tempTrans.localPosition;
|
|
planetObjVenus.planetVis = Mathf.Clamp(pVisFac,0.1f,1.0f) * planetIntensity;
|
|
}
|
|
|
|
if (planetObjMars){
|
|
calcComponent.CalculateNode(6); //mars
|
|
plMarsPosition.x = 0f;
|
|
plMarsPosition.y = 90.0f+calcComponent.azimuth+setRotation;
|
|
plMarsPosition.z = -180.0f+calcComponent.altitude-0.5f;
|
|
planetTransMars.localEulerAngles = plMarsPosition;
|
|
tempTrans = planetTransMars;
|
|
tempTrans.localPosition = Vector3.zero;
|
|
tempTrans.Translate(useVec * (eclipticoffset*useMult), Space.World);
|
|
planetObjMars.planetOffset = tempTrans.localPosition;
|
|
planetObjMars.planetVis = Mathf.Clamp(pVisFac,0.02f,1.0f) * planetIntensity;
|
|
}
|
|
|
|
if (planetObjJupiter){
|
|
calcComponent.CalculateNode(7); //jupiter
|
|
plJupiterPosition.x = 0f;
|
|
plJupiterPosition.y = 90.0f+calcComponent.azimuth+setRotation;
|
|
plJupiterPosition.z = -180.0f+calcComponent.altitude-0.5f;
|
|
planetTransJupiter.localEulerAngles = plJupiterPosition;
|
|
tempTrans = planetTransJupiter;
|
|
tempTrans.localPosition = Vector3.zero;
|
|
tempTrans.Translate(useVec * (eclipticoffset*useMult), Space.World);
|
|
planetObjJupiter.planetOffset = tempTrans.localPosition;
|
|
planetObjJupiter.planetVis = Mathf.Clamp(pVisFac,0.05f,1.0f) * planetIntensity;
|
|
}
|
|
|
|
if (planetObjSaturn){
|
|
calcComponent.CalculateNode(8); //saturn
|
|
plSaturnPosition.x = 0f;
|
|
plSaturnPosition.y = 90.0f+calcComponent.azimuth+setRotation;
|
|
plSaturnPosition.z = -180.0f+calcComponent.altitude-0.5f;
|
|
planetTransSaturn.localEulerAngles = plSaturnPosition;
|
|
tempTrans = planetTransSaturn;
|
|
tempTrans.localPosition = Vector3.zero;
|
|
tempTrans.Translate(useVec * (eclipticoffset*useMult), Space.World);
|
|
planetObjSaturn.planetOffset = tempTrans.localPosition;
|
|
planetObjSaturn.planetVis = pVisFac * planetIntensity;
|
|
}
|
|
|
|
if (planetObjUranus){
|
|
calcComponent.CalculateNode(9); //uranus
|
|
plUranusPosition.x = 0f;
|
|
plUranusPosition.y = 90.0f+calcComponent.azimuth+setRotation;
|
|
plUranusPosition.z = -180.0f+calcComponent.altitude-0.5f;
|
|
planetTransUranus.localEulerAngles = plUranusPosition;
|
|
tempTrans = planetTransUranus;
|
|
tempTrans.localPosition = Vector3.zero;
|
|
tempTrans.Translate(useVec * (eclipticoffset*useMult), Space.World);
|
|
planetObjUranus.planetOffset = tempTrans.localPosition;
|
|
planetObjUranus.planetVis = pVisFac * planetIntensity;
|
|
}
|
|
|
|
if (planetObjNeptune){
|
|
calcComponent.CalculateNode(10); //neptune
|
|
plNeptunePosition.x = 0f;
|
|
plNeptunePosition.y = 90.0f+calcComponent.azimuth+setRotation;
|
|
plNeptunePosition.z = -180.0f+calcComponent.altitude-0.5f;
|
|
planetTransNeptune.localEulerAngles = plNeptunePosition;
|
|
tempTrans = planetTransNeptune;
|
|
tempTrans.localPosition = Vector3.zero;
|
|
tempTrans.Translate(useVec * (eclipticoffset*useMult), Space.World);
|
|
planetObjNeptune.planetOffset = tempTrans.localPosition;
|
|
planetObjNeptune.planetVis = pVisFac * planetIntensity;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
// ----------------
|
|
// -- STARS ---
|
|
// ----------------
|
|
|
|
//SIDEAREAL DAY CALCULATION
|
|
//The sideareal day is more accurate than the solar day, and is
|
|
//the actual determining calculation for the passage of a full year.
|
|
if (starTypeIndex == 0 || starTypeIndex == 2){
|
|
|
|
starAngle = -1.0f;
|
|
starTarget = Quaternion.Euler((setLatitude), 183.0f, -starAngle);
|
|
starfieldObject.rotation = starTarget;
|
|
starPosition.x = starfieldObject.eulerAngles.x;
|
|
starPosition.y = starfieldObject.eulerAngles.y;
|
|
starPosition.z = -(((calcComponent.UT/23.99972f))*360.0f) + ((setLongitude)-95.0f) + (calcComponent.tzOffset*15f) - (calcComponent.dstOffset*15f) - (360.0f*Mathf.Abs(Mathf.Floor(calcComponent.day/365.25f)-(calcComponent.day/365.25f)));
|
|
|
|
//CALCULATE PRECESSIONAL MOVEMENT
|
|
//precessional movement occurs at a rate of 1 degree every 71.666 years, thus each precessional epoch
|
|
//takes up exactly 32 degrees on the spherical celestial star plane. this is calculated on the
|
|
//assumption that the Aquarial age begins in the year 2600ad. if you disagree and would like to
|
|
//see other aquarian start calibrations (year 2148 for example), simply change the 'aquarialStart' variable.
|
|
aquarialStart = 2600;
|
|
precRate = 71.6f;
|
|
precNudge = 258.58f; //this value simply helps set the exact position of the star sphere.
|
|
precFactor = ((aquarialStart/precRate)*(aquarialStart))+((aquarialStart-currentYear)/precRate)+precNudge;
|
|
starPosition.z = starPosition.z-precFactor-4.0f;
|
|
|
|
} else {
|
|
starPosition.x = starfieldObject.eulerAngles.x;
|
|
starPosition.y = starfieldObject.eulerAngles.y;
|
|
starPosition.z = starPos;
|
|
}
|
|
|
|
//Set final star position
|
|
starPosition.y = setRotation;
|
|
starfieldObject.eulerAngles = starPosition;
|
|
|
|
|
|
//solar ecliptic movement
|
|
eclipticStarAngle = (starValue);
|
|
if (eclipticStarAngle == 0.0) eclipticStarAngle = 1.0f;
|
|
if (eclipticStarAngle < 0.5f && eclipticStarAngle > 0.0f) eclipticStarAngle = 0.5f + (0.5f - eclipticStarAngle);
|
|
eclipticStarAngle += 1.35f;
|
|
|
|
|
|
//GALAXY / Skybox Rendering
|
|
renderObjectGalaxy.enabled = true;
|
|
//useGalaxyIntensity = galaxyIntensity;
|
|
if (galaxyTypeIndex == 2 && starTypeIndex == 2){
|
|
renderObjectGalaxy.enabled = false;
|
|
} else {
|
|
renderObjectGalaxy.enabled = true;
|
|
|
|
// Realistic Galaxy Rotation (match star positions)
|
|
if (galaxyTypeIndex == 0 || galaxyTypeIndex == 2){
|
|
starGalaxyObject.localEulerAngles = galaxyBasePosition;
|
|
starGalaxyObject.localScale = galaxyBaseScale;
|
|
}
|
|
|
|
// Custom Galaxy Rotation
|
|
if (galaxyTypeIndex == 1){
|
|
galaxyPosition.x = starPosition.x;
|
|
galaxyPosition.y = starPosition.y;
|
|
galaxyPosition.z = galaxyPos;
|
|
starGalaxyObject.localEulerAngles = galaxyPosition;
|
|
}
|
|
|
|
}
|
|
galaxyColor = Color.white;
|
|
galaxyVis = (1.0f-(colorSkyAmbient.r*1.0f)) * galaxyIntensity;
|
|
|
|
if (Application.isPlaying){
|
|
|
|
renderObjectGalaxy.material.SetFloat("_GIntensity",galaxyVis);
|
|
renderObjectGalaxy.material.SetColor("_Color",galaxyColor);
|
|
renderObjectGalaxy.material.SetFloat("_useGlxy",galaxyTypeIndex*1.0f);
|
|
renderObjectGalaxy.material.SetTexture("_GTex",galaxyTex);
|
|
renderObjectGalaxy.material.SetFloat("_useCube",galaxyTexIndex*1.0f);
|
|
renderObjectGalaxy.material.SetTexture("_CubeTex",galaxyCubeTex);
|
|
renderObjectGalaxy.material.SetFloat("_useStar",starTypeIndex*1.0f);
|
|
renderObjectGalaxy.material.SetFloat("_SIntensity",starIntensity);
|
|
|
|
} else {
|
|
renderObjectGalaxy.sharedMaterial.SetFloat("_GIntensity",galaxyVis);
|
|
renderObjectGalaxy.sharedMaterial.SetColor("_Color",galaxyColor);
|
|
renderObjectGalaxy.sharedMaterial.SetFloat("_useGlxy",galaxyTypeIndex*1.0f);
|
|
renderObjectGalaxy.sharedMaterial.SetTexture("_GTex",galaxyTex);
|
|
renderObjectGalaxy.sharedMaterial.SetFloat("_useCube",galaxyTexIndex*1.0f);
|
|
renderObjectGalaxy.sharedMaterial.SetTexture("_CubeTex",galaxyCubeTex);
|
|
renderObjectGalaxy.sharedMaterial.SetFloat("_useStar",starTypeIndex*1.0f);
|
|
renderObjectGalaxy.sharedMaterial.SetFloat("_SIntensity",starIntensity);
|
|
}
|
|
|
|
if (starRenderSystem != null){
|
|
if (starTypeIndex == 2){
|
|
if (starParticleSystem.enabled) starParticleSystem.enabled = false;
|
|
} else {
|
|
if (!starParticleSystem.enabled) starParticleSystem.enabled = true;
|
|
starRenderSystem.starBrightness.a = starIntensity;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
// ---------------------------------
|
|
// -- LIGHTNING HANDLING ---
|
|
// ---------------------------------
|
|
|
|
//SET SKY CAMERA POSITIONS
|
|
if (useCamera != null){
|
|
//set global shader for camera forward direction
|
|
Shader.SetGlobalVector("Tenkoku_Vec_CameraFwd", useCamera.forward);
|
|
Shader.SetGlobalVector("Tenkoku_Vec_SunFwd", -sunlightObject.forward);
|
|
Shader.SetGlobalVector("Tenkoku_Vec_MoonFwd", -moonlightObject.forward);
|
|
}
|
|
|
|
|
|
|
|
|
|
// --------------
|
|
// -- SKY ---
|
|
//---------------
|
|
//get ramp colors
|
|
ambientShift = Mathf.Clamp(ambientShift,0.0f,1.0f);
|
|
colorSkyBase = decodeColorSkybase;
|
|
ambientCol = decodeColorSkyambient;
|
|
ambientCloudCol = decodeColorAmbientcloud;
|
|
|
|
setSkyAmbient = colorSkyAmbient;
|
|
setSkyAmbient.r += ambientShift;
|
|
setSkyAmbient.g += ambientShift;
|
|
setSkyAmbient.b += ambientShift;
|
|
|
|
useAlpha.r = 1f;
|
|
useAlpha.g = 1f;
|
|
useAlpha.b = 1f;
|
|
useAlpha.a = (1.0f-setSkyAmbient.r);
|
|
|
|
setAmbCol = useAlpha;
|
|
setAmbCol.a = useAlpha.a*0.75f;
|
|
setAmbCol.a = useAlpha.a*1.5f;
|
|
if (setAmbCol.a > 1.0f) setAmbCol.a = 1.0f;
|
|
|
|
colorSkyBaseLow = colorSkyBase;
|
|
colorHorizonLow = colorHorizon;
|
|
|
|
colorSkyBase = (colorSkyBase * 0.8f);
|
|
colorHorizon = Color.Lerp(colorHorizon,(colorSkyBase),0.9f)*1.1f;
|
|
|
|
|
|
|
|
|
|
|
|
// ------------------
|
|
// -- AMBIENT ---
|
|
//-------------------
|
|
mixColor = colorSun;
|
|
setAmbientColor.r = 1.0f-mixColor.r;
|
|
setAmbientColor.g = 1.0f-mixColor.g;
|
|
setAmbientColor.b = 1.0f-mixColor.b;
|
|
|
|
useAmbientColor = Color.Lerp((Color.Lerp(colorSkyBase,setAmbientColor,0.7f)),Color.black,0.12f);
|
|
useAmbientColor = Color.Lerp(useAmbientColor,medCol,0.5f) * colorSkyAmbient;
|
|
useAmbientColor *= (sunBright) * skyBrightness;
|
|
|
|
//HORIZON
|
|
colorHorizon = decodeColorColorhorizon*1.2f;
|
|
|
|
//Set Overcast
|
|
useOvercastDarkening = weather_OvercastDarkeningAmt * weather_OvercastAmt;
|
|
|
|
//Set Ambient
|
|
if (useAmbient){
|
|
useAmbientColor = decodeColorAmbientcolor;
|
|
useColorAmbient = colorAmbient;
|
|
//useColorAmbient.a = colorAmbient.a * Mathf.Lerp(1.0f,0.0f,weather_OvercastAmt*4f);
|
|
useColorAmbient.a = colorAmbient.a * Mathf.Lerp(1.0f,0.0f,useOvercastDarkening*4f);
|
|
|
|
|
|
useAmbientColor = Color.Lerp(useAmbientColor,Color.gray,useOvercastDarkening*3f);
|
|
useAmbientColor = Color.Lerp(useAmbientColor,useAmbientColor*colorAmbient,useColorAmbient.a);
|
|
|
|
skyAmb = decodeColorAmbientcolor*0.6f;
|
|
skyAmb = Color.Lerp(skyAmb, Color.white * Mathf.Lerp(0.25f,1.75f,nightBrightness*setSkyAmbient.r), useOvercastDarkening*2f);
|
|
|
|
gAmb = Color.Lerp( (baseGAmbColor*(nightBrightness*0.5f)), useAmbientColor, setSkyAmbient.r);
|
|
gAmb = Color.Lerp(gAmb, gAmb * useColorAmbient, useColorAmbient.a);
|
|
|
|
sAmb = skyAmb*(Mathf.Lerp( nightBrightness+Mathf.Lerp(0.25f,1.75f,nightBrightness),1f, setSkyAmbient.r));
|
|
sAmb = Color.Lerp(sAmb, sAmb * useColorAmbient, useColorAmbient.a);
|
|
|
|
eAmb = Color.Lerp(gAmb,sAmb,0.25f);
|
|
eAmb = Color.Lerp(eAmb, eAmb * useColorAmbient, useColorAmbient.a);
|
|
|
|
float eFac = Mathf.Lerp(0.1f,1.0f, eclipseFactor);
|
|
if (ambientTypeIndex == 0){
|
|
UnityEngine.RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Skybox;
|
|
|
|
useAmbientIntensity = Mathf.Lerp(ambientNightAmt, ambientDayAmt, lightObjectWorld.intensity);
|
|
|
|
if (adjustOvercastAmbient){
|
|
useAmbientIntensity *= Mathf.Lerp(1f, 2.5f, weather_OvercastAmt * 2f);
|
|
}
|
|
|
|
UnityEngine.RenderSettings.ambientIntensity = useAmbientIntensity;
|
|
|
|
} else if (ambientTypeIndex == 1){
|
|
UnityEngine.RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Trilight;
|
|
UnityEngine.RenderSettings.ambientSkyColor = sAmb * eFac;
|
|
UnityEngine.RenderSettings.ambientGroundColor = gAmb * eFac;
|
|
UnityEngine.RenderSettings.ambientEquatorColor = eAmb * eFac;
|
|
|
|
}else if (ambientTypeIndex == 2){
|
|
UnityEngine.RenderSettings.ambientMode = UnityEngine.Rendering.AmbientMode.Flat;
|
|
UnityEngine.RenderSettings.ambientSkyColor = sAmb * eFac;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------------
|
|
// -- LENS FLARE EFFECTS --
|
|
// -----------------------------------
|
|
if (useSunFlare && flareObject != null){
|
|
lightObjectWorld.flare = flareObject;
|
|
} else {
|
|
lightObjectWorld.flare = null;
|
|
}
|
|
|
|
//set default flare
|
|
//sunFlare.color = Color.white;
|
|
|
|
//fade flare based on overcast
|
|
//sunFlare.color = Color.Lerp(sunFlare.color,new Color(0f,0f,0f,0f),weather_OvercastAmt*2.0f);
|
|
//sunFlare.brightness = Mathf.Lerp(1.0f,0.0f,weather_OvercastAmt*2.0);
|
|
|
|
//fade flare based on gamma
|
|
//sunFlare.color *= Mathf.Lerp(0.25f,1.0f,isLin);
|
|
//sunFlare.brightness *= Mathf.Lerp(0.25f,1.0f,isLin);
|
|
|
|
//fade flare based on brightness
|
|
//sunFlare.color *= Mathf.Lerp(0.0f,1.0f,sunBright*0.6f);
|
|
//sunFlare.brightness *= Mathf.Lerp(0.0f,1.0f,sunBright*0.6f);
|
|
|
|
//fade flare based on occlusion
|
|
//(soon)
|
|
|
|
|
|
|
|
|
|
|
|
// --------------------------------
|
|
// -- WEATHER EFFECTS --
|
|
// --------------------------------
|
|
if (Application.isPlaying){
|
|
|
|
//manage particle systems
|
|
if (rainSystem != null){
|
|
|
|
#if UNITY_5_4_OR_NEWER
|
|
rainEmission = rainSystem.emission;
|
|
rainEmission.enabled = true;
|
|
rainCurve.constant = Mathf.Lerp(2,5000*precipQuality,weather_RainAmt);
|
|
|
|
#if UNITY_5_5_OR_NEWER
|
|
rainEmission.rateOverTime = rainCurve;
|
|
#else
|
|
rainEmission.rate = rainCurve;
|
|
#endif
|
|
|
|
if (rainSystem.particleCount <= 10){
|
|
renderObjectRain.enabled = false;
|
|
} else {
|
|
renderObjectRain.enabled = true;
|
|
}
|
|
//add force
|
|
rainForces = rainSystem.forceOverLifetime;
|
|
rainForces.enabled = true;
|
|
rainCurveForceX.constant = -weather_WindCoords.x * (weather_WindAmt*46f);
|
|
rainForces.x = rainCurveForceX;
|
|
rainCurveForceY.constant = weather_WindCoords.y * (weather_WindAmt*46f);
|
|
rainForces.y = rainCurveForceY;
|
|
#else
|
|
renderObjectRain.enabled = true;
|
|
rainSystem.enableEmission = true;
|
|
rainSystem.emissionRate = Mathf.FloorToInt(Mathf.Lerp(0,5000*precipQuality,weather_RainAmt));
|
|
#endif
|
|
}
|
|
|
|
if (rainFogSystem != null){
|
|
|
|
#if UNITY_5_4_OR_NEWER
|
|
rainFogEmission = rainFogSystem.emission;
|
|
rainFogEmission.enabled = true;
|
|
rainCurveFog.constant = Mathf.Lerp(2,800*precipQuality,weather_RainAmt);
|
|
|
|
#if UNITY_5_5_OR_NEWER
|
|
rainFogEmission.rateOverTime = rainCurveFog;
|
|
#else
|
|
rainFogEmission.rate = rainCurveFog;
|
|
#endif
|
|
|
|
if (rainFogSystem.particleCount <= 20){
|
|
renderObjectRainFog.enabled = false;
|
|
} else {
|
|
renderObjectRainFog.enabled = true;
|
|
}
|
|
//add force
|
|
rainFogForces = rainFogSystem.forceOverLifetime;
|
|
rainFogForces.enabled = true;
|
|
rainCurveFogForceX.constant = -weather_WindCoords.x * (weather_WindAmt*4f);
|
|
rainFogForces.x = rainCurveFogForceX;
|
|
rainCurveFogForceY.constant = weather_WindCoords.y * (weather_WindAmt*4f);
|
|
rainFogForces.y = rainCurveFogForceY;
|
|
#else
|
|
rainFogSystem.enableEmission = true;
|
|
renderObjectRainFog.enabled = true;
|
|
rainFogSystem.emissionRate = Mathf.FloorToInt(Mathf.Lerp(0,800*precipQuality,weather_RainAmt));
|
|
#endif
|
|
}
|
|
|
|
|
|
if (rainSplashSystem != null){
|
|
|
|
#if UNITY_5_4_OR_NEWER
|
|
splashEmission = rainSplashSystem.emission;
|
|
splashEmission.enabled = true;
|
|
splashCurve.constant = Mathf.Lerp(50,800*precipQuality,weather_RainAmt);
|
|
|
|
#if UNITY_5_5_OR_NEWER
|
|
splashEmission.rateOverTime = splashCurve;
|
|
#else
|
|
splashEmission.rate = splashCurve;
|
|
#endif
|
|
|
|
if (rainSplashSystem.particleCount <= 10){
|
|
renderObjectRainSplash.enabled = false;
|
|
} else {
|
|
renderObjectRainSplash.enabled = true;
|
|
}
|
|
#else
|
|
rainSplashSystem.enableEmission = true;
|
|
renderObjectRainSplash.enabled = true;
|
|
rainSplashSystem.emissionRate = Mathf.FloorToInt(Mathf.Lerp(0,800*precipQuality,weather_RainAmt));
|
|
#endif
|
|
}
|
|
|
|
|
|
if (fogSystem != null){
|
|
|
|
#if UNITY_5_4_OR_NEWER
|
|
fogEmission = fogSystem.emission;
|
|
fogEmission.enabled = true;
|
|
fogCurve.constant = Mathf.Lerp(2,1200*precipQuality,weather_FogAmt);
|
|
|
|
#if UNITY_5_5_OR_NEWER
|
|
fogEmission.rateOverTime = fogCurve;
|
|
#else
|
|
fogEmission.rate = fogCurve;
|
|
#endif
|
|
|
|
if (fogSystem.particleCount <= 10){
|
|
renderObjectFog.enabled = false;
|
|
} else {
|
|
renderObjectFog.enabled = true;
|
|
}
|
|
//add force
|
|
fogForces = fogSystem.forceOverLifetime;
|
|
fogForces.enabled = true;
|
|
fogCurveForceX.constant = -weather_WindCoords.x * (weather_WindAmt*6);
|
|
fogForces.x = fogCurveForceX;
|
|
fogCurveForceY.constant = weather_WindCoords.y * (weather_WindAmt*6);
|
|
fogForces.y = fogCurveForceY;
|
|
#else
|
|
fogSystem.enableEmission = true;
|
|
renderObjectFog.enabled = true;
|
|
fogSystem.emissionRate = Mathf.FloorToInt(Mathf.Lerp(0,1200*precipQuality,weather_FogAmt));
|
|
#endif
|
|
}
|
|
|
|
if (snowSystem != null){
|
|
|
|
#if UNITY_5_4_OR_NEWER
|
|
snowEmission = snowSystem.emission;
|
|
snowEmission.enabled = true;
|
|
snowCurve.constant = Mathf.Lerp(2,1500*precipQuality,weather_SnowAmt);
|
|
|
|
#if UNITY_5_5_OR_NEWER
|
|
snowEmission.rateOverTime = snowCurve;
|
|
#else
|
|
snowEmission.rate = snowCurve;
|
|
#endif
|
|
|
|
if (snowSystem.particleCount <= 10){
|
|
renderObjectSnow.enabled = false;
|
|
} else {
|
|
renderObjectSnow.enabled = true;
|
|
}
|
|
//add force
|
|
snowPosition.x = 0f;
|
|
snowPosition.y = Mathf.Lerp(0.24f,0.14f,weather_WindAmt);
|
|
snowPosition.z = 0f;
|
|
|
|
snowForces = snowSystem.forceOverLifetime;
|
|
snowForces.enabled = true;
|
|
snowCurveForceX.constant = -weather_WindCoords.x * (weather_WindAmt*2f);
|
|
snowForces.x = snowCurveForceX;
|
|
snowCurveForceY.constant = weather_WindCoords.y * (weather_WindAmt*2f);
|
|
snowForces.y = snowCurveForceY;
|
|
#else
|
|
snowSystem.enableEmission = true;
|
|
renderObjectSnow.enabled = true;
|
|
snowSystem.emissionRate = Mathf.FloorToInt(Mathf.Lerp(0,1500*precipQuality,weather_SnowAmt));
|
|
#endif
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//Overcast Calculations
|
|
useOvercast = Mathf.Clamp(Mathf.Lerp(-1.0f,1.0f,useOvercastDarkening),0.0f,1.0f);
|
|
colorSkyBase = Color.Lerp(colorSkyBase,baseSkyCol*ambientCol.r,useOvercast);
|
|
colorHorizon = Color.Lerp(colorHorizon,baseHorizonCol*ambientCol.r,useOvercast);
|
|
|
|
|
|
|
|
//apply color and lighting
|
|
//fxUseLight = 0.8f;//Mathf.Clamp(4.0f,0.1f,0.8f);
|
|
lDiff = ((lightObjectWorld.intensity - 0.0f)/0.68f);
|
|
lDiff += Mathf.Lerp(0.0f,0.8f,useOvercast);
|
|
fxUseLight = Mathf.Lerp(0.0f,lightObjectWorld.intensity,lDiff);
|
|
|
|
rainCol = baseRainCol * fxUseLight;
|
|
rainCol.a = 0.12f;
|
|
|
|
splashCol = Color.white * fxUseLight;
|
|
splashCol.a = 0.65f;
|
|
|
|
rainfogCol = Color.white * fxUseLight;
|
|
rainfogFac = Mathf.Lerp(0.004f,0.025f,Mathf.Clamp01((weather_RainAmt-0.5f)*2.0f));
|
|
rainfogCol.a = rainfogFac;
|
|
|
|
fogCol = fogColStart * fxUseLight;
|
|
fogFac = Mathf.Lerp(0.0f,0.04f,Mathf.Clamp01(weather_FogAmt));
|
|
fogCol.a = fogFac;
|
|
|
|
snowCol = baseSnowCol * fxUseLight;
|
|
snowCol.a = 0.45f;
|
|
|
|
if (Application.isPlaying){
|
|
if (renderObjectRainSplash) renderObjectRain.material.SetColor("_TintColor", rainCol * Mathf.Lerp(0.35f,1.0f,ambientCol.r));
|
|
if (renderObjectRainSplash) renderObjectRainSplash.material.SetColor("_TintColor", splashCol);
|
|
if (renderObjectRainFog) renderObjectRainFog.material.SetColor("_TintColor", rainfogCol);
|
|
if (renderObjectFog) renderObjectFog.material.SetColor("_TintColor",fogCol);
|
|
if (renderObjectSnow) renderObjectSnow.material.SetColor("_TintColor",snowCol);
|
|
} else {
|
|
if (renderObjectRainSplash) renderObjectRain.sharedMaterial.SetColor("_TintColor", rainCol * Mathf.Lerp(0.35f,1.0f,ambientCol.r));
|
|
if (renderObjectRainSplash) renderObjectRainSplash.sharedMaterial.SetColor("_TintColor", splashCol);
|
|
if (renderObjectRainFog) renderObjectRainFog.sharedMaterial.SetColor("_TintColor", rainfogCol);
|
|
if (renderObjectFog) renderObjectFog.sharedMaterial.SetColor("_TintColor",fogCol);
|
|
if (renderObjectSnow) renderObjectSnow.sharedMaterial.SetColor("_TintColor",snowCol);
|
|
}
|
|
|
|
//clamp weather systems
|
|
if (particleObjectRainFog != null){
|
|
//if (particleObjectRainFog.particleCount > 0.0f) ClampParticle("rain fog");
|
|
}
|
|
if (particleObjectRainSplash != null){
|
|
if (particleObjectRainSplash.particleCount > 0.0f) ClampParticle("rain splash");
|
|
}
|
|
if (particleObjectFog != null){
|
|
//if (particleObjectFog.particleCount > 0.0f) ClampParticle("fog");
|
|
}
|
|
|
|
|
|
|
|
// --------------
|
|
// -- FOG ---
|
|
//---------------
|
|
if (enableFog){
|
|
|
|
|
|
//Calculate Auto Fog (Humidity Settings)
|
|
if (autoFog && useCameraCam != null){
|
|
|
|
|
|
float camDist = useCameraCam.farClipPlane;
|
|
|
|
fogDistance = Mathf.Lerp(camDist, 500f, Mathf.Clamp01(weather_humidity*1f));
|
|
fogAtmosphere = Mathf.Clamp(fogDistance * Mathf.Lerp(0.3f, 0.125f, weather_humidity), 40f, 5000f);
|
|
fogDensity = Mathf.Clamp01(Mathf.Lerp(0.5f,1.25f, weather_humidity));
|
|
fadeDistance = 1.0f - Mathf.Clamp01(weather_humidity * 4.0f);
|
|
fogObscurance = Mathf.Clamp01(Mathf.Lerp(-0.75f, 1.25f, weather_humidity));
|
|
|
|
}
|
|
|
|
|
|
//Set Fog Settings
|
|
Shader.SetGlobalFloat("_Tenkoku_FogStart",fogAtmosphere);
|
|
Shader.SetGlobalFloat("_Tenkoku_FogEnd",fogDistance);
|
|
Shader.SetGlobalFloat("_Tenkoku_FogDensity",fogDensity);
|
|
|
|
if (useCameraCam != null){
|
|
//Shader.SetGlobalFloat("_Tenkoku_shaderDepth",fogDistance/useCameraCam.farClipPlane);
|
|
Shader.SetGlobalColor("_Tenkoku_FogColor", colorFog);
|
|
Shader.SetGlobalFloat("_Tenkoku_shaderDepth", useCameraCam.farClipPlane);
|
|
Shader.SetGlobalFloat("_Tenkoku_FadeDistance", fadeDistance);
|
|
Shader.SetGlobalFloat("_Tenkoku_FogObscurance", fogObscurance);
|
|
}
|
|
|
|
|
|
} else {
|
|
Shader.SetGlobalFloat("_Tenkoku_FogDensity",0.0f);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// -------------------------------------
|
|
// -- CALCULATE WIND COORDINATES ---
|
|
// -------------------------------------
|
|
weather_WindCoords = TenkokuConvertAngleToVector(weather_WindDir);
|
|
|
|
windVector.x = tenkokuWindTrans.eulerAngles.x;
|
|
windVector.y = weather_WindDir;
|
|
windVector.z = tenkokuWindTrans.eulerAngles.z;
|
|
|
|
tenkokuWindTrans.eulerAngles = windVector;
|
|
|
|
tenkokuWindObject.windMain = weather_WindAmt;
|
|
tenkokuWindObject.windTurbulence = Mathf.Lerp(0.0f,0.4f,weather_WindAmt);
|
|
tenkokuWindObject.windPulseMagnitude = Mathf.Lerp(0.0f,2.0f,weather_WindAmt);
|
|
tenkokuWindObject.windPulseFrequency = Mathf.Lerp(0.0f,0.4f,weather_WindAmt);
|
|
|
|
|
|
|
|
|
|
|
|
// ------------------------
|
|
// -- CLOUD SETTINGS ---
|
|
//-------------------------
|
|
|
|
|
|
//set legacy clouds
|
|
#if UNITY_5_4_OR_NEWER || UNITY_5_3_4 || UNITY_5_3_5 || UNITY_5_3_6 || UNITY_5_3_7 || UNITY_5_3_8
|
|
|
|
#else
|
|
useLegacyClouds = true;
|
|
#endif
|
|
|
|
|
|
//GLOBAL CLOUD SETTINGS -----
|
|
colorClouds = decodeColorColorcloud;
|
|
colorClouds = Color.Lerp(colorClouds,colorClouds*colorOverlay,colorOverlay.a);
|
|
|
|
temperatureColor = temperatureGradient.Evaluate( weather_temperature / 120f );
|
|
colorClouds = Color.Lerp(colorClouds,colorClouds*temperatureColor,temperatureColor.a);
|
|
|
|
|
|
|
|
|
|
|
|
|
|
colorHighlightClouds = decodeColorAmbientcloud;
|
|
colorHighlightClouds = Color.Lerp(colorHighlightClouds, baseHighlightCloudCol ,useOvercastDarkening*2.0f) * skyAmbientCol;
|
|
colorHighlightClouds = Color.Lerp(colorHighlightClouds,colorHighlightClouds*colorOverlay,colorOverlay.a);
|
|
|
|
colorHighlightClouds = Color.Lerp(colorHighlightClouds,colorHighlightClouds*temperatureColor,temperatureColor.a);
|
|
|
|
|
|
|
|
Shader.SetGlobalColor("_TenkokuCloudColor",colorClouds);
|
|
Shader.SetGlobalColor("_TenkokuCloudAmbientColor",colorHighlightClouds);
|
|
|
|
//Set Temporal FX
|
|
if (Application.platform == RuntimePlatform.OSXEditor){
|
|
useTemporalAliasing = false;
|
|
}
|
|
if (temporalFX != null){
|
|
|
|
temporalFX.enabled = useTemporalAliasing;
|
|
|
|
if (temporalBuffer != null){
|
|
temporalBuffer.enabled = useTemporalAliasing;
|
|
}
|
|
}
|
|
Shader.SetGlobalFloat("fullScreenTemporal", useFSAliasing ? 1.0f : 0.0f);
|
|
|
|
|
|
//LEGACY CLOUD SETTINGS -----
|
|
if (useLegacyClouds){
|
|
if (renderObjectCloudPlane != null) renderObjectCloudPlane.enabled = true;
|
|
#if UNITY_5_4_OR_NEWER || UNITY_5_3_4 || UNITY_5_3_5 || UNITY_5_3_6 || UNITY_5_3_7 || UNITY_5_3_8
|
|
if (renderObjectCloudSphere != null) renderObjectCloudSphere.enabled = false;
|
|
#endif
|
|
|
|
|
|
if (renderObjectCloudPlane != null){
|
|
|
|
|
|
|
|
if (cloudLinkToTime){
|
|
|
|
currCoords.x = (systemTime * weather_WindCoords.x * 0.1f);
|
|
currCoords.y = (systemTime * weather_WindCoords.y * 0.1f);
|
|
|
|
windPosition.x = currCoords.x;
|
|
windPosition.y = currCoords.y;
|
|
windPosition.z = 0f;
|
|
windPosition.w = 0f;
|
|
Shader.SetGlobalColor("windCoords", windPosition);
|
|
|
|
cloudOverRot += (systemTime * cloudRotSpeed * 2.1f);
|
|
cloudOverRot = Mathf.Clamp(cloudOverRot,0.0f,1.0f);
|
|
|
|
cloudSpeeds.r = 0.1f * cloudOverRot; //altostratus
|
|
cloudSpeeds.g = 0.7f * cloudOverRot; //Cirrus
|
|
cloudSpeeds.b = 1.0f * cloudOverRot; //cumulus
|
|
cloudSpeeds.a = 2.0f * cloudOverRot; //overcast
|
|
|
|
cloudTexScale.x = cloudSc;
|
|
cloudTexScale.y = cloudSc;
|
|
|
|
} else {
|
|
|
|
Vector4 _CloudCoords = CloudsConvertAngleToVector(weather_WindDir);
|
|
float cSpd = Mathf.Lerp(0.0f,0.001f, weather_cloudSpeed) * UnityEngine.Time.timeScale;
|
|
|
|
currCoords.x = currCoords.x + (_CloudCoords.x * cSpd);
|
|
currCoords.y = currCoords.y + (_CloudCoords.z * cSpd);
|
|
|
|
windPosition.x = currCoords.x;
|
|
windPosition.y = currCoords.y;
|
|
windPosition.z = 0f;
|
|
windPosition.w = 0f;
|
|
Shader.SetGlobalColor("windCoords", windPosition);
|
|
|
|
cloudSpeeds.r = 0.1f;// * cloudOverRot; //altostratus
|
|
cloudSpeeds.g = 0.7f;// * cloudOverRot; //Cirrus
|
|
cloudSpeeds.b = 1.0f;// * cloudOverRot; //cumulus
|
|
cloudSpeeds.a = 2.0f;// * cloudOverRot; //overcast
|
|
|
|
cloudTexScale.x = cloudSc;
|
|
cloudTexScale.y = cloudSc;
|
|
}
|
|
|
|
|
|
|
|
if (Application.isPlaying){
|
|
renderObjectCloudPlane.material.SetColor("_cloudSpd",cloudSpeeds);
|
|
renderObjectCloudPlane.material.SetTextureScale("_MainTex", cloudTexScale);
|
|
renderObjectCloudPlane.material.SetTextureScale("_CloudTexB", cloudTexScale);
|
|
if (useCameraCam != null && renderObjectCloudPlane != null){
|
|
renderObjectCloudPlane.material.SetFloat("_TenkokuDist",1200f);
|
|
}
|
|
renderObjectCloudPlane.material.SetFloat("_sizeCloud",weather_cloudCumulusAmt);
|
|
renderObjectCloudPlane.material.SetFloat("_amtCloudS",weather_cloudAltoStratusAmt);
|
|
renderObjectCloudPlane.material.SetFloat("_amtCloudC",weather_cloudCirrusAmt);
|
|
renderObjectCloudPlane.material.SetFloat("_amtCloudO",Mathf.Clamp01(weather_OvercastAmt*2.0f));
|
|
renderObjectCloudPlane.material.SetFloat("_cloudHeight",Mathf.Lerp(10.0f,70.0f,weather_cloudCumulusAmt));
|
|
} else {
|
|
renderObjectCloudPlane.sharedMaterial.SetColor("_cloudSpd",cloudSpeeds);
|
|
renderObjectCloudPlane.sharedMaterial.SetTextureScale("_MainTex", cloudTexScale);
|
|
renderObjectCloudPlane.sharedMaterial.SetTextureScale("_CloudTexB", cloudTexScale);
|
|
if (useCameraCam != null && renderObjectCloudPlane != null){
|
|
renderObjectCloudPlane.sharedMaterial.SetFloat("_TenkokuDist",1200f);
|
|
}
|
|
renderObjectCloudPlane.sharedMaterial.SetFloat("_sizeCloud",weather_cloudCumulusAmt);
|
|
renderObjectCloudPlane.sharedMaterial.SetFloat("_amtCloudS",weather_cloudAltoStratusAmt);
|
|
renderObjectCloudPlane.sharedMaterial.SetFloat("_amtCloudC",weather_cloudCirrusAmt);
|
|
renderObjectCloudPlane.sharedMaterial.SetFloat("_amtCloudO",Mathf.Clamp01(weather_OvercastAmt*2.0f));
|
|
renderObjectCloudPlane.sharedMaterial.SetFloat("_cloudHeight",Mathf.Lerp(10.0f,70.0f,weather_cloudCumulusAmt));
|
|
}
|
|
|
|
//set cloud scale
|
|
planeObjectScale.x = setSkyUseSize * 0.01f;
|
|
planeObjectScale.y = setSkyUseSize * 0.01f;
|
|
planeObjectScale.z = 0.1f;
|
|
|
|
cloudPlaneObject.localScale = planeObjectScale;
|
|
cloudPosition.x = cloudPlaneObject.localPosition.x;
|
|
cloudPosition.y = -1.0f;
|
|
cloudPosition.z = cloudPlaneObject.localPosition.z;
|
|
cloudPlaneObject.localPosition = cloudPosition;
|
|
cloudSc = weather_cloudScale * 6f;
|
|
|
|
if (Application.isPlaying){
|
|
renderObjectCloudPlane.material.SetFloat("_amtCloudS",weather_cloudAltoStratusAmt);
|
|
renderObjectCloudPlane.material.SetFloat("_amtCloudC",weather_cloudCirrusAmt);
|
|
renderObjectCloudPlane.material.SetFloat("_amtCloudO",Mathf.Clamp01(weather_OvercastAmt*2.0f));
|
|
renderObjectCloudPlane.material.SetFloat("_cloudHeight",Mathf.Lerp(10.0f,70.0f,weather_cloudCumulusAmt));
|
|
} else {
|
|
renderObjectCloudPlane.sharedMaterial.SetFloat("_amtCloudS",weather_cloudAltoStratusAmt);
|
|
renderObjectCloudPlane.sharedMaterial.SetFloat("_amtCloudC",weather_cloudCirrusAmt);
|
|
renderObjectCloudPlane.sharedMaterial.SetFloat("_amtCloudO",Mathf.Clamp01(weather_OvercastAmt*2.0f));
|
|
renderObjectCloudPlane.sharedMaterial.SetFloat("_cloudHeight",Mathf.Lerp(10.0f,70.0f,weather_cloudCumulusAmt));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//ADVANCED CLOUD SETTINGS (Requires Unity 5.3.4+) -----
|
|
#if UNITY_5_4_OR_NEWER || UNITY_5_3_4 || UNITY_5_3_5 || UNITY_5_3_6 || UNITY_5_3_7 || UNITY_5_3_8
|
|
if (!useLegacyClouds){
|
|
|
|
//Force Aurora object to off.
|
|
//if (renderObjectAurora != null) renderObjectAurora.enabled = false;
|
|
|
|
if (renderObjectCloudPlane != null) renderObjectCloudPlane.enabled = false;
|
|
if (renderObjectCloudSphere != null) renderObjectCloudSphere.enabled = true;
|
|
|
|
if (materialObjectCloudSphere != null){
|
|
|
|
//set sphere size based on camera distance
|
|
if (useCameraCam != null){
|
|
csSize = ((useCameraCam.farClipPlane / 20f) * 1.75f);
|
|
cSphereSize.x = csSize;
|
|
cSphereSize.y = csSize;
|
|
cSphereSize.z = csSize;
|
|
cloudSphereObject.localScale = cSphereSize;
|
|
}
|
|
|
|
//set sphere shader attributes
|
|
cAmt = Mathf.Max(Mathf.Lerp(0.0f,0.75f,weather_cloudCumulusAmt), weather_OvercastAmt*4f);
|
|
|
|
//Quality Settings
|
|
materialObjectCloudSphere.SetFloat("_SampleCount0", Mathf.Lerp(32f, 8f, cAmt) * cloudQuality );
|
|
materialObjectCloudSphere.SetFloat("_SampleCount1", Mathf.Lerp(32f, 8f, cAmt) * cloudQuality );
|
|
materialObjectCloudSphere.SetFloat("_SampleCountL", Mathf.Lerp(8f, 4f, cAmt) * cloudQuality );
|
|
materialObjectCloudSphere.SetFloat("_FarDist", Mathf.Lerp(5000f, 20000f, cloudQuality) );
|
|
materialObjectCloudSphere.SetFloat("_Edge", Mathf.Lerp(0.95f, 0.5f, cloudQuality) );
|
|
materialObjectCloudSphere.SetFloat("quality", cloudQuality );
|
|
|
|
//Cloud Height
|
|
materialObjectCloudSphere.SetFloat("_Altitude0",Mathf.Lerp(1400f,900f,cAmt));
|
|
materialObjectCloudSphere.SetFloat("_Altitude1", Mathf.Lerp(1400f,3000f,cAmt));
|
|
materialObjectCloudSphere.SetFloat("_Altitude2", 3500f);
|
|
materialObjectCloudSphere.SetFloat("_Altitude3", 4000f);
|
|
materialObjectCloudSphere.SetFloat("_Altitude4", 6500f);
|
|
materialObjectCloudSphere.SetFloat("_Altitude5", 7000f);
|
|
|
|
//Cloud Frequency
|
|
materialObjectCloudSphere.SetFloat("_NoiseFreq1", Mathf.Lerp(1.0f*cloudFreq,5.5f*cloudFreq,cAmt));
|
|
materialObjectCloudSphere.SetFloat("_NoiseFreq2", Mathf.Lerp(30f*cloudDetail,15f*cloudDetail,cAmt));
|
|
|
|
//Cloud Scattering
|
|
materialObjectCloudSphere.SetFloat("_Scatter", Mathf.Lerp(0.1f,0.5f,cAmt)); //0.07
|
|
materialObjectCloudSphere.SetFloat("_HGCoeff", 0.0f); //0.3
|
|
materialObjectCloudSphere.SetFloat("_Extinct", Mathf.Lerp(0.005f,0.005f,cAmt)); //0.003
|
|
|
|
//Cloud Amount
|
|
materialObjectCloudSphere.SetFloat("_NoiseBias", Mathf.Max(cAmt, weather_OvercastAmt*4f));
|
|
materialObjectCloudSphere.SetFloat("_NoiseBias2", weather_cloudCirrusAmt);
|
|
materialObjectCloudSphere.SetFloat("_NoiseBias3", weather_cloudAltoStratusAmt);
|
|
|
|
|
|
|
|
//set direction and scale
|
|
if (cloudLinkToTime){
|
|
|
|
#if UNITY_EDITOR
|
|
if (!EditorApplication.isCompiling){
|
|
#endif
|
|
|
|
Vector4 _CloudCoords = CloudsConvertAngleToVector(weather_WindDir);
|
|
float cSpd = Mathf.Lerp(0.0f,0.05f, weather_cloudSpeed);
|
|
|
|
_CloudCoords.x += _CloudCoords.x * (cSpd * systemTime);
|
|
_CloudCoords.z += _CloudCoords.z * (cSpd * systemTime);
|
|
|
|
materialObjectCloudSphere.SetVector("_Scroll1", _CloudCoords * 0.5f);
|
|
materialObjectCloudSphere.SetVector("_Scroll2", _CloudCoords * 2f);
|
|
|
|
#if UNITY_EDITOR
|
|
}
|
|
#endif
|
|
|
|
} else {
|
|
|
|
Vector4 _CloudCoords = CloudsConvertAngleToVector(weather_WindDir);
|
|
float cSpd = Mathf.Lerp(0.0f,0.001f, weather_cloudSpeed) * UnityEngine.Time.timeScale;
|
|
|
|
weather_CloudCoords.x = weather_CloudCoords.x + (_CloudCoords.x * cSpd);
|
|
weather_CloudCoords.z = weather_CloudCoords.z + (_CloudCoords.z * cSpd);
|
|
|
|
materialObjectCloudSphere.SetFloat("_tenkokuTimer", 1f);
|
|
materialObjectCloudSphere.SetVector("_Scroll1", weather_CloudCoords * 0.5f);
|
|
materialObjectCloudSphere.SetVector("_Scroll2", weather_CloudCoords * 2f);
|
|
|
|
|
|
}
|
|
|
|
//Set Noise Timer
|
|
// We do this in order to ensure the noise optimizations on the cloud shader do not
|
|
// stop calculating if the Unity.timeScale is set to 0.
|
|
materialObjectCloudSphere.SetFloat("_tenkokuNoiseTimer", UnityEngine.Time.realtimeSinceStartup);
|
|
|
|
|
|
|
|
#if UNITY_EDITOR
|
|
if (!EditorApplication.isCompiling){
|
|
if (recompileFlag){
|
|
recompileFlag = false;
|
|
cloudLinkToTime = saveLinkToTime;
|
|
} else {
|
|
saveLinkToTime = cloudLinkToTime;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
|
|
Shader.SetGlobalFloat("_cS",weather_cloudScale/8);
|
|
|
|
|
|
//Darkness
|
|
materialObjectCloudSphere.SetFloat("_Darkness", Mathf.Clamp(Mathf.Lerp(0.5f,0.5f,cAmt),0f,1f)); //2
|
|
}
|
|
|
|
|
|
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
// -------------------------------
|
|
// -- Set Global Tint Color --
|
|
// -------------------------------
|
|
Shader.SetGlobalColor("_TenkokuSkyColor", decodeColorSkybase);
|
|
Shader.SetGlobalColor("tenkoku_globalTintColor",colorOverlay * Color.Lerp(Color.white, temperatureColor, temperatureColor.a));
|
|
Shader.SetGlobalColor("tenkoku_globalSkyColor",colorSky);
|
|
|
|
|
|
// -------------------------------
|
|
// -- Altitude Adjustment --
|
|
// -------------------------------
|
|
// adjust colors and alpha based on altitude height attributes.
|
|
// can simulate entering and leaving planet atmosphere;
|
|
altAdjust = 5000.0f;
|
|
Shader.SetGlobalFloat("tenkoku_altitudeAdjust",altAdjust);
|
|
|
|
|
|
|
|
// -------------------------
|
|
// -- BRDF Sky Object --
|
|
// -------------------------
|
|
if (useCamera != null){
|
|
if (useCameraCam != null){
|
|
fogDist = (1.0f/useCameraCam.farClipPlane)*(0.9f + fogDistance);
|
|
fogFull = useCameraCam.farClipPlane;
|
|
}
|
|
}
|
|
colorHorizon = Color.Lerp(colorHorizon,colorHorizon*0.5f,useOvercastDarkening);
|
|
skyAmbientCol = ambientCol * Mathf.Lerp(1.0f,0.7f,useOvercast);
|
|
skyHorizonCol = colorHorizon * Mathf.Lerp(1.0f,0.8f,useOvercast);
|
|
|
|
Shader.SetGlobalColor("_Tenkoku_SkyHorizonColor",skyHorizonCol);
|
|
Shader.SetGlobalFloat("_tenkokufogFull",floatRound(fogFull));
|
|
Shader.SetGlobalFloat("_tenkokufogStretch",floatRound(fogDist));
|
|
Shader.SetGlobalFloat("_tenkokufogAtmospheric",floatRound(fogAtmosphere));
|
|
Shader.SetGlobalFloat("_Tenkoku_SkyBright",floatRound(useSkyBright));
|
|
Shader.SetGlobalFloat("_Tenkoku_NightBright",floatRound(nightBrightness));
|
|
Shader.SetGlobalColor("_TenkokuAmbientColor",skyAmbientCol);
|
|
|
|
//adjust and set atmospheric density based on day factor
|
|
atmosTime = calcTime;
|
|
atmosTime = Mathf.Clamp(Mathf.Lerp(-0.75f,1.75f,(atmosTime)),0.0f,0.5f);
|
|
|
|
atmosphereDensity = Mathf.Clamp(atmosphereDensity,0.5f,4.0f);
|
|
setAtmosphereDensity = (horizonDensity * 2.0f * atmosTime);
|
|
|
|
//if (atmosphereModelTypeIndex == 0){
|
|
Shader.SetGlobalFloat("_Tenkoku_AtmosphereDensity",floatRound(atmosphereDensity));
|
|
Shader.SetGlobalFloat("_Tenkoku_HorizonDensity",floatRound(setAtmosphereDensity));
|
|
Shader.SetGlobalFloat("_Tenkoku_HorizonHeight",floatRound(horizonDensityHeight));
|
|
//}
|
|
|
|
|
|
if (enableFog){
|
|
Shader.SetGlobalFloat("_Tenkoku_FogDensity",floatRound(fogDensity));
|
|
}
|
|
|
|
//overcast color
|
|
overcastCol = decodeColorSkyambient;//decodeColorAmbientcolor;
|
|
overcastCol.a = useOvercastDarkening;
|
|
Shader.SetGlobalColor("_Tenkoku_overcastColor", overcastCol);
|
|
Shader.SetGlobalFloat("_Tenkoku_overcastAmt",weather_OvercastAmt);
|
|
|
|
|
|
// assign colors
|
|
if (useCamera != null){
|
|
if (useCameraCam != null){
|
|
useCameraCam.backgroundColor = decodeColorSkybase*Color.Lerp(Color.white,Color.black,atmosphereDensity*0.25f);
|
|
useCameraCam.backgroundColor = Color.Lerp(Color.black,useCameraCam.backgroundColor,Mathf.Clamp(atmosphereDensity*2f,0.0f,1.0f));
|
|
useCameraCam.backgroundColor *= Mathf.Clamp(skyBrightness,0.0f,1.0f);
|
|
}
|
|
nightSkyPosition.x = 60.0f;
|
|
nightSkyPosition.y = useCamera.eulerAngles.y;
|
|
nightSkyPosition.z = useCamera.eulerAngles.z;
|
|
nightSkyLightObject.eulerAngles = nightSkyPosition;
|
|
}
|
|
|
|
if (fogCameraCam != null){
|
|
fogCameraCam.backgroundColor = decodeColorSkybase*Color.Lerp(Color.white,Color.black,atmosphereDensity*0.25f);
|
|
fogCameraCam.backgroundColor = Color.Lerp(Color.black,fogCameraCam.backgroundColor,Mathf.Clamp(atmosphereDensity*2f,0.0f,1.0f));
|
|
fogCameraCam.backgroundColor *= Mathf.Clamp(skyBrightness,0.0f,1.0f);
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
setOverallCol = colorSun*ambientCol*Color.Lerp(Color.white,colorOverlay,colorOverlay.a);
|
|
setOverallCol = Color.Lerp(setOverallCol,setOverallCol * temperatureColor,temperatureColor.a);
|
|
|
|
|
|
|
|
Shader.SetGlobalColor("_overallCol",setOverallCol);
|
|
|
|
bgSCol = skyHorizonCol;
|
|
// convert camera color to linear space when appropriate
|
|
// the scene camera does not render background colors in linear space, so we need to
|
|
// convert the background color to linear before assigning to in-scene shaders.
|
|
if (_linearSpace == ColorSpace.Linear){
|
|
bgSCol.r = Mathf.GammaToLinearSpace(bgSCol.r);
|
|
bgSCol.g = Mathf.GammaToLinearSpace(bgSCol.g);
|
|
bgSCol.b = Mathf.GammaToLinearSpace(bgSCol.b);
|
|
}
|
|
Shader.SetGlobalColor("tenkoku_backgroundColor",bgSCol);
|
|
|
|
|
|
//set GI Ambient
|
|
ambientGI = decodeColorAmbientGI;
|
|
|
|
|
|
//handle gamma brightness
|
|
useSkyBright = skyBrightness;
|
|
if (_linearSpace != ColorSpace.Linear){
|
|
useSkyBright *= 0.42f;
|
|
}
|
|
|
|
//assign blur settings
|
|
if (fogCameraBlur != null){
|
|
fogCameraBlur.blurSpread = 1;//0.1f;
|
|
}
|
|
|
|
useSkyBright = useSkyBright * Mathf.Lerp(1.0f,10.0f,ambientGI.r);
|
|
|
|
// ------------------------
|
|
// -- Cloud Objects --
|
|
// ------------------------
|
|
Shader.SetGlobalColor("_TenkokuCloudColor",colorClouds);
|
|
Shader.SetGlobalColor("_TenkokuCloudHighlightColor",colorHighlightClouds);
|
|
|
|
//set cloud effect distance color
|
|
Shader.SetGlobalFloat("_fogStretch",floatRound(fogDist));
|
|
Shader.SetGlobalColor("_Tenkoku_SkyColor",colorSkyBase*ambientCloudCol.r*setOverallCol*useSkyBright);
|
|
Shader.SetGlobalColor("_Tenkoku_HorizonColor",colorHorizon*setOverallCol*useSkyBright);
|
|
Shader.SetGlobalFloat("_Tenkoku_Ambient",ambientCloudCol.r);
|
|
Shader.SetGlobalFloat("_Tenkoku_AmbientGI",ambientGI.r);
|
|
|
|
//set aurora settings
|
|
auroraIsVisible = false;
|
|
if (auroraTypeIndex == 0){
|
|
auroraIsVisible = true;
|
|
}
|
|
|
|
|
|
if (!auroraIsVisible || auroraLatitude > Mathf.Abs(setLatitude)){
|
|
if (Application.isPlaying){
|
|
renderObjectAurora.enabled = false;
|
|
}
|
|
} else {
|
|
|
|
//if (useLegacyClouds){
|
|
renderObjectAurora.enabled = true;
|
|
//}
|
|
|
|
//csSize = ((useCameraCam.farClipPlane / 20f) * 1.75f);
|
|
//cSphereSize.x = csSize;
|
|
//cSphereSize.y = csSize;
|
|
//cSphereSize.z = csSize;
|
|
//cloudSphereObject.localScale = cSphereSize;
|
|
|
|
|
|
|
|
|
|
Vector3 auroraScale = Vector3.zero;
|
|
Vector3 auroraPos = Vector3.zero;
|
|
//if (!useLegacyClouds){
|
|
// auroraPos.y = 3f;
|
|
// auroraScale.x = 0.6f;
|
|
// auroraScale.y = 0.6f;
|
|
// auroraScale.z = 0.1f;
|
|
|
|
//} else {
|
|
// auroraPos.y = 3f;
|
|
// auroraScale.x = 0.6f;
|
|
// auroraScale.y = 0.6f;
|
|
// auroraScale.z = 0.1f;
|
|
//}
|
|
|
|
if (useCameraCam != null){
|
|
csSize = ((useCameraCam.farClipPlane / 20f) * 1.75f);
|
|
auroraScale.x = csSize + 1.0f;
|
|
auroraScale.y = csSize + 1.0f;
|
|
auroraScale.z = csSize + 1.0f;
|
|
}
|
|
|
|
auroraObjectTransform.localPosition = auroraPos;
|
|
auroraObjectTransform.localScale = auroraScale;
|
|
|
|
}
|
|
|
|
aurSpan = 30.0f;
|
|
aurAmt = Mathf.Lerp(0.0f,1.0f,Mathf.Clamp((Mathf.Abs(setLatitude)-auroraLatitude)/aurSpan,0.0f,1.0f));
|
|
Shader.SetGlobalFloat("_Tenkoku_AuroraSpd",auroraSpeed);
|
|
Shader.SetGlobalFloat("_Tenkoku_AuroraAmt",auroraIntensity*aurAmt);
|
|
|
|
|
|
|
|
// ----------------------------
|
|
// -- WORLD LIGHT OBJECT --
|
|
// ----------------------------
|
|
worldlightObject.rotation = sunlightObject.rotation;
|
|
|
|
//Clamp light height
|
|
if (minimumHeight > 0f){
|
|
if (worldlightObject.eulerAngles.x < minimumHeight){
|
|
lightClampVector = worldlightObject.eulerAngles;
|
|
lightClampVector.x = minimumHeight;
|
|
worldlightObject.eulerAngles = lightClampVector;
|
|
}
|
|
}
|
|
|
|
ambientBaseCol.r = ambientCol.r;
|
|
ambientBaseCol.g = ambientCol.r;
|
|
ambientBaseCol.b = ambientCol.r;
|
|
ambientBaseCol.a = 1f;
|
|
WorldCol = Color.Lerp(decodeColorSun * ambientCol.r, ambientBaseCol*0.7f,Mathf.Clamp01(useOvercastDarkening*2.0f));
|
|
|
|
//tint light color with overall color
|
|
WorldCol = WorldCol * Color.Lerp(Color.white,colorOverlay,colorOverlay.a);
|
|
WorldCol = WorldCol * Color.Lerp(Color.white,Color.Lerp(Color.white,temperatureColor,0.5f),temperatureColor.a);
|
|
|
|
|
|
sC = WorldCol.grayscale;
|
|
sCol.r = sC;
|
|
sCol.g = sC;
|
|
sCol.b = sC;
|
|
sCol.a = WorldCol.a;
|
|
WorldCol = Color.Lerp(sCol, WorldCol, sunSat);
|
|
|
|
//lightObjectWorld.color = WorldCol;
|
|
lightObjectWorld.intensity = 2.0f * (sunBright*0.68f) * ambientCol.r;
|
|
//lightObjectWorld.shadowStrength = Mathf.Lerp(1.0f,0.25f,weather_OvercastAmt);
|
|
|
|
//WorldCol.a = lightObjectWorld.intensity;
|
|
lightObjectWorld.intensity = WorldCol.a * 2.0f * (sunBright*0.68f) * ambientCol.r;
|
|
lightObjectWorld.color = WorldCol;
|
|
Shader.SetGlobalColor("_TenkokuSunColor",WorldCol);
|
|
|
|
|
|
|
|
|
|
|
|
// ------------------------------
|
|
// -- HANDLE SUN RAY EFFECTS --
|
|
// ------------------------------
|
|
if (useCamera != null){
|
|
|
|
rayCol = colorSun;
|
|
baseRayCol.r = rayCol.r;
|
|
baseRayCol.g = rayCol.r;
|
|
baseRayCol.b = rayCol.r;
|
|
baseRayCol.a = rayCol.a;
|
|
rayCol = Color.Lerp(rayCol,baseRayCol, Mathf.Clamp01(weather_OvercastAmt*2f));
|
|
|
|
if (sunRayObject != null){
|
|
sunRayObject.enabled = useSunRays;
|
|
sunRayObject.sunTransform = sunlightObject;
|
|
sunRayObject.sunColor = rayCol;
|
|
//sunRayObject.tintColor = rayCol;
|
|
sunRayObject.sunShaftIntensity = Mathf.Lerp(0.0f,20.0f,sunRayIntensity) * eclipseFactor;
|
|
sunRayObject.maxRadius = sunRayLength * eclipseFactor;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// ----------------------------
|
|
// -- NIGHT LIGHT OBJECT --
|
|
// ----------------------------
|
|
nightSkyLightObject.rotation = moonlightObject.rotation;
|
|
|
|
//Clamp light height
|
|
if (minimumHeight > 0f){
|
|
if (nightSkyLightObject.eulerAngles.x < minimumHeight){
|
|
lightClampVector = nightSkyLightObject.eulerAngles;
|
|
lightClampVector.x = minimumHeight;
|
|
nightSkyLightObject.eulerAngles = lightClampVector;
|
|
}
|
|
}
|
|
|
|
//Set night Color
|
|
mC = mCol.grayscale;
|
|
mCol.r = mC;
|
|
mCol.g = mC;
|
|
mCol.b = mC;
|
|
|
|
lightObjectNight.color = Color.Lerp(mCol, mColMixCol, moonSat);
|
|
|
|
|
|
//Set base night intensity
|
|
lightObjectNight.intensity = Mathf.Lerp(0.0f,1.0f,(nightBrightness)*1.2f)+(moonBright) * (1.0f-useOvercastDarkening);
|
|
|
|
|
|
//modulate night intensity based on altitude
|
|
if (lightObjectNight != null && moonSphereObject != null){
|
|
|
|
//find the light factor based on the rotation of the light
|
|
delta = moonSphereObject.localPosition - moonObject.position;
|
|
look = Quaternion.LookRotation(delta);
|
|
vertical = look.eulerAngles.x;
|
|
|
|
if (vertical > 90.0f) vertical = 90f - (vertical-90.0f);
|
|
vertical = Mathf.Clamp01((vertical) / 10.0f); //degrees
|
|
|
|
//set the light intensity
|
|
lightObjectNight.intensity = lightObjectNight.intensity * Mathf.Lerp(0.0f,1.0f,vertical);
|
|
|
|
}
|
|
|
|
//modulate night intensity based on lunar phase
|
|
//moon phase 0.0 = new moon, 0.5 = full moon, 1.0 = new moon.
|
|
if (lightObjectNight != null && moonSphereObject != null){
|
|
lightObjectNight.intensity = Mathf.Clamp(lightObjectNight.intensity * Mathf.Lerp(2.0f, -0.3f, Mathf.Clamp01(Mathf.Sin(moonPhase))), 0f, lightObjectNight.intensity);
|
|
}
|
|
|
|
//modulate night intensity based on sun intensity
|
|
if (lightObjectNight != null && lightObjectWorld != null){
|
|
lightObjectNight.intensity = lightObjectNight.intensity * Mathf.Clamp01(Mathf.Lerp(2.0f,0.0f,lightObjectWorld.intensity));
|
|
}
|
|
|
|
|
|
|
|
|
|
// ----------------------------
|
|
// -- FILL LIGHT OBJECT --
|
|
// ----------------------------
|
|
fillFac = worldlightObject.eulerAngles.x / 90f;
|
|
if (fillFac > 1f) fillFac = 0f;
|
|
|
|
fillIntensity = Mathf.Lerp(0.0f, 3.0f, nightBrightness);
|
|
|
|
lightObjectFill.intensity = Mathf.Clamp01(Mathf.Lerp(fillIntensity, -2.0f, fillFac));
|
|
if (lightObjectFill.intensity > 0f){
|
|
lightObjectFill.enabled = true;
|
|
} else {
|
|
lightObjectFill.enabled = false;
|
|
}
|
|
|
|
|
|
|
|
|
|
// --------------------------
|
|
// -- DAY LIGHT OBJECT --
|
|
// --------------------------
|
|
//modulate day intensity based on altitude
|
|
if (lightObjectWorld != null && sunSphereObject != null){
|
|
|
|
//find the light factor based on the rotation of the light
|
|
delta = sunSphereObject.localPosition - sunObject.position;
|
|
look = Quaternion.LookRotation(delta);
|
|
vertical = look.eulerAngles.x;
|
|
|
|
if (vertical > 90.0f) vertical = 90f - (vertical-90.0f);
|
|
vertical = Mathf.Clamp01(vertical / 2.0f); //degrees
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ---------------------------------
|
|
// -- SOLAR ECLIPSE HANDLING ---
|
|
// ---------------------------------
|
|
ecldiff = 0.0f;
|
|
if (useCamera != null){
|
|
mRay = new Ray(useCamera.position,moonObject.position);
|
|
sRay = new Ray(useCamera.position,sunObject.position);
|
|
ecldiff = (Vector3.Angle(sRay.direction,mRay.direction));
|
|
ecldiff = 1.0f-(ecldiff);
|
|
}
|
|
|
|
eclipseFactor = Mathf.Clamp01(Mathf.Lerp(1.0f,0.0f,Mathf.Clamp01(ecldiff*1.1f)));
|
|
Shader.SetGlobalFloat("_Tenkoku_EclipseFactor", eclipseFactor);
|
|
lightObjectWorld.intensity *= eclipseFactor;
|
|
if (eclipseObject != null && ecldiff > 0.0f){
|
|
eclipsePosition.x = eclipseObject.eulerAngles.x;
|
|
eclipsePosition.y = eclipseObject.eulerAngles.y;
|
|
eclipsePosition.z = eclipseObject.eulerAngles.z+_deltaTime*4.0f;
|
|
eclipseObject.eulerAngles = eclipsePosition;
|
|
|
|
_tempFac = Mathf.Lerp(1f,7f,ecldiff);
|
|
_tempVec.x = _tempFac;
|
|
_tempVec.y = _tempFac;
|
|
_tempVec.z = _tempFac;
|
|
eclipseObject.localScale = _tempVec;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//handle gamma world lighting brightness
|
|
if (_linearSpace != ColorSpace.Linear){
|
|
lightObjectWorld.intensity = lightObjectWorld.intensity*0.8f;
|
|
}
|
|
|
|
|
|
|
|
|
|
//Handle Multi-Lighting
|
|
if (allowMultiLights){
|
|
lightObjectWorld.intensity = Mathf.Clamp(lightObjectWorld.intensity,0.001f,8.0f);
|
|
lightObjectWorld.renderMode = LightRenderMode.ForcePixel;
|
|
lightObjectNight.renderMode = LightRenderMode.ForcePixel;
|
|
//lightObjectNight.shadows = LightShadows.Soft;
|
|
|
|
//enable/disable lights
|
|
if (lightObjectWorld.intensity <= 0.001f){
|
|
lightObjectWorld.enabled = false;
|
|
} else {
|
|
lightObjectWorld.enabled = true;
|
|
}
|
|
//lightObjectWorld.enabled = true;
|
|
|
|
if (lightObjectNight.intensity <= 0.05f){
|
|
lightObjectNight.enabled = false;
|
|
} else {
|
|
lightObjectNight.enabled = true;
|
|
}
|
|
|
|
|
|
} else {
|
|
|
|
lightObjectWorld.intensity = Mathf.Clamp(lightObjectWorld.intensity,0.001f,8.0f);
|
|
lightObjectWorld.renderMode = LightRenderMode.ForcePixel;
|
|
lightObjectNight.renderMode = LightRenderMode.ForcePixel;
|
|
//lightObjectNight.shadows = LightShadows.Soft;
|
|
|
|
//enable/disable lights
|
|
if (lightObjectWorld.intensity <= 0.8f){
|
|
lightObjectWorld.enabled = false;
|
|
} else {
|
|
lightObjectWorld.enabled = true;
|
|
}
|
|
|
|
if (lightObjectWorld.enabled){
|
|
lightObjectNight.enabled = false;
|
|
} else {
|
|
lightObjectNight.enabled = true;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
Shader.SetGlobalColor("_Tenkoku_Daylight",lightObjectWorld.color * (lightObjectWorld.intensity*0.5f) * (calcTime));
|
|
Shader.SetGlobalColor("_Tenkoku_Nightlight",lightObjectNight.color * (lightObjectNight.intensity + nightBrightness) * (1.0f-calcTime) * 2f);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void CalculateWeatherRandom(){
|
|
|
|
//calculate weather pattern timer and initialize update
|
|
doWeatherUpdate = false;
|
|
weather_PatternTime += _deltaTime;
|
|
|
|
//inherit variables
|
|
if (currentWeatherTypeIndex != weatherTypeIndex ){
|
|
currentWeatherTypeIndex = weatherTypeIndex;
|
|
doWeatherUpdate = true;
|
|
}
|
|
|
|
//check for weather update
|
|
weather_autoForecastTime = Mathf.Max(weather_autoForecastTime,0.01f);
|
|
weather_TransitionTime = Mathf.Max(weather_TransitionTime, 0.001f);
|
|
if (weather_PatternTime > (weather_autoForecastTime*60.0f) && weather_autoForecastTime >= 0.05f) doWeatherUpdate = true;
|
|
if (weather_forceUpdate) doWeatherUpdate = true;
|
|
|
|
if (doWeatherUpdate){
|
|
weather_forceUpdate = false;
|
|
weather_PatternTime = 0.0f;
|
|
|
|
//determine next random weather pattern
|
|
w_isCloudy = Mathf.Clamp(TenRandom.Next(-0.25f,1.5f),0.0f,1.0f);
|
|
|
|
//record current weather
|
|
w_cloudAmts.y = weather_cloudAltoStratusAmt;
|
|
w_cloudAmts.z = weather_cloudCirrusAmt;
|
|
w_cloudAmtCumulus = weather_cloudCumulusAmt;
|
|
w_overcastAmt = weather_OvercastAmt;
|
|
//w_windCAmt = weather_cloudSpeed;
|
|
w_windAmt = weather_WindAmt;
|
|
w_rainAmt = weather_RainAmt;
|
|
w_humidityAmt = weather_humidity;
|
|
w_lightningAmt = weather_lightning;
|
|
|
|
//set clear weather default
|
|
w_cloudTgts = Vector4.zero;
|
|
w_cloudTgtCumulus = 0.0f;
|
|
w_overcastTgt = 0.0f;
|
|
//w_windCTgt = 0.0f;
|
|
w_windTgt = 0.0f;
|
|
w_rainTgt = 0.0f;
|
|
w_humidityTgt = 0.0f;
|
|
w_lightningTgt = 0.0f;
|
|
|
|
//set clouds
|
|
w_cloudTgts.y = Mathf.Clamp(Mathf.Lerp(0.0f,TenRandom.Next(0.0f,0.4f),w_isCloudy),0.0f,0.4f); //AltoCumulus
|
|
w_cloudTgts.z = Mathf.Clamp(Mathf.Lerp(0.0f,TenRandom.Next(0.0f,0.8f),w_isCloudy),0.0f,0.8f); //Cirrus
|
|
w_cloudTgtCumulus = Mathf.Clamp(Mathf.Lerp(0.0f,TenRandom.Next(0.1f,1.25f),w_isCloudy),0.0f,1.0f); // Cumulus
|
|
if (w_cloudTgtCumulus > 0.8f){
|
|
w_overcastTgt = Mathf.Clamp(Mathf.Lerp(0.0f,TenRandom.Next(-1.0f,1.0f),w_isCloudy),0.0f,1.0f); // overcast amount
|
|
}
|
|
|
|
//set weather
|
|
chanceOfRain = Mathf.Clamp01(TenRandom.Next(-1.0f,1.0f));
|
|
w_humidityTgt = Mathf.Clamp01(TenRandom.Next(0.0f,1.0f));
|
|
w_rainTgt = Mathf.Lerp(0.0f,TenRandom.Next(0.2f,1.4f),w_overcastTgt*chanceOfRain);
|
|
w_lightningTgt = Mathf.Lerp(0.0f,TenRandom.Next(0.0f,0.6f),w_overcastTgt*chanceOfRain);
|
|
|
|
//set wind
|
|
//w_windCTgt = TenRandom.Next(0.1f,0.3f)*0.1f;
|
|
w_windTgt = TenRandom.Next(0.1f,0.5f)+Mathf.Lerp(0.0f,0.5f,weather_OvercastAmt);
|
|
|
|
}
|
|
|
|
//set weather systems
|
|
weather_cloudAltoStratusAmt = Mathf.SmoothStep(w_cloudAmts.y,w_cloudTgts.y,(weather_PatternTime/(weather_TransitionTime*60.0f)));
|
|
weather_cloudCirrusAmt = Mathf.SmoothStep(w_cloudAmts.z,w_cloudTgts.z,(weather_PatternTime/(weather_TransitionTime*60.0f)));
|
|
weather_cloudCumulusAmt = Mathf.SmoothStep(w_cloudAmtCumulus,w_cloudTgtCumulus,(weather_PatternTime/(weather_TransitionTime*60.0f)));
|
|
weather_OvercastAmt = Mathf.SmoothStep(w_overcastAmt,w_overcastTgt,(weather_PatternTime/(weather_TransitionTime*60.0f)));
|
|
//weather_cloudSpeed = Mathf.SmoothStep(w_windCAmt,w_windCTgt,(weather_PatternTime/(weather_TransitionTime*60.0f)));
|
|
weather_WindAmt = Mathf.SmoothStep(w_windAmt,w_windTgt,(weather_PatternTime/(weather_TransitionTime*60.0f)));
|
|
weather_RainAmt = Mathf.SmoothStep(w_rainAmt,w_rainTgt,(weather_PatternTime/(weather_TransitionTime*60.0f))*2.0f);
|
|
weather_lightning = Mathf.SmoothStep(w_lightningAmt,w_lightningTgt,(weather_PatternTime/(weather_TransitionTime*60.0f))*2.0f);
|
|
weather_humidity = Mathf.SmoothStep(w_humidityAmt,w_humidityTgt,(weather_PatternTime/(weather_TransitionTime*60.0f))*2.0f);
|
|
|
|
//extra modifiers: OVERCAST
|
|
weather_RainAmt *= Mathf.Lerp(-1.0f,1.0f,weather_OvercastAmt);
|
|
weather_lightning *= Mathf.Lerp(-3.0f,0.5f,weather_OvercastAmt);
|
|
volumeAmbDay = Mathf.Lerp(1.0f,-2.0f,weather_OvercastAmt);
|
|
|
|
//Humidity
|
|
weather_humidity = Mathf.Max(weather_humidity, weather_RainAmt);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void TimeUpdate(){
|
|
|
|
//------------------------------
|
|
//--- CALCULATE TIMER ----
|
|
//------------------------------
|
|
|
|
|
|
//TRANSITION TIME
|
|
if (doTransition){
|
|
Tenkoku_TransitionTime();
|
|
}
|
|
|
|
|
|
//RECALCULATE DATE and TIME
|
|
RecalculateTime();
|
|
|
|
|
|
//AUTO INCREASE TIME
|
|
if (useAutoTime && !autoTimeSync && Application.isPlaying){
|
|
|
|
//calculate time compression curve
|
|
curveVal = timeCurves.Evaluate(dayValue);
|
|
|
|
setTimeSpan = (_deltaTime * useTimeCompression);
|
|
countSecond += setTimeSpan;
|
|
countSecondMoon += Mathf.FloorToInt(setTimeSpan*0.92068f);
|
|
countSecondStar += Mathf.FloorToInt(setTimeSpan*0.9333342f);
|
|
|
|
}
|
|
|
|
|
|
if (Mathf.Abs(countSecond) >= 1.0f){
|
|
cSeconds = (int)countSecond;
|
|
currentSecond += cSeconds;
|
|
countSecond -= cSeconds;
|
|
}
|
|
if (Mathf.Abs(countMinute) >= 1.0f){
|
|
currentMinute += Mathf.FloorToInt(countMinute);
|
|
countMinute = 0.0f;
|
|
}
|
|
|
|
if (Mathf.Abs(countSecondMoon) >= 1.0f){
|
|
moonSecond += Mathf.FloorToInt(countSecondMoon);
|
|
countSecondMoon = 0.0f;
|
|
}
|
|
if (Mathf.Abs(countMinuteMoon) >= 1.0f){
|
|
moonMinute += Mathf.FloorToInt(countMinuteMoon);
|
|
countMinuteMoon = 0.0f;
|
|
}
|
|
|
|
if (Mathf.Abs(countSecondStar) >= 1.0f){
|
|
starSecond += Mathf.FloorToInt(countSecondStar);
|
|
countSecondStar = 0.0f;
|
|
}
|
|
if (Mathf.Abs(countMinuteStar) >= 1.0f){
|
|
starMinute += Mathf.FloorToInt(countMinuteStar);
|
|
countMinuteStar = 0.0f;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//SET DISPLAY TIME
|
|
#if UNITY_EDITOR
|
|
displayTime = DisplayTime("[ hh:mm:ss am] [ M/D/Y ad]");
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public string DisplayTime( string format ){
|
|
|
|
//format string examples:
|
|
// "M/D/Y H:M:S"
|
|
setString = format;
|
|
eon = "ad";
|
|
useHour = setHour;
|
|
|
|
displayHour = setHour;
|
|
if (use24Clock){
|
|
hourMode = "AM";
|
|
if (useHour > 12){
|
|
displayHour -= 12;
|
|
hourMode = "PM";
|
|
}
|
|
} else {
|
|
hourMode = "";
|
|
}
|
|
|
|
if (currentYear < 0) eon = "bc";
|
|
setString = setString.Replace("hh",useHour.ToString("00"));
|
|
setString = setString.Replace("mm",currentMinute.ToString("00"));
|
|
setString = setString.Replace("ss",currentSecond.ToString("00"));
|
|
setString = setString.Replace("Y",Mathf.Abs(currentYear).ToString());
|
|
setString = setString.Replace("M",currentMonth.ToString());
|
|
setString = setString.Replace("D",currentDay.ToString());
|
|
setString = setString.Replace("ad",eon.ToString());
|
|
|
|
if (use24Clock){
|
|
setString = setString.Replace("am",hourMode.ToString());
|
|
} else {
|
|
setString = setString.Replace("am","");
|
|
}
|
|
|
|
return setString;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public int RecalculateLeapYear( int checkMonth, int checkYear){
|
|
|
|
//check for leap Year (by div 4 method)
|
|
leapYear = false;
|
|
if ( (checkYear / 4.0f) == Mathf.FloorToInt(checkYear / 4.0f) ) leapYear = true;
|
|
|
|
//double check for leap Year (by div 100 + div 400 method)
|
|
if ((checkYear / 100.0f) == Mathf.FloorToInt(checkYear / 100.0f)){
|
|
if ((checkYear / 400.0f) != Mathf.FloorToInt(checkYear / 400.0f)) leapYear = false;
|
|
}
|
|
|
|
//calculate month length
|
|
monthLength = 31;
|
|
testMonth = Mathf.FloorToInt(checkMonth);
|
|
if (testMonth == 4 || testMonth == 6 || testMonth == 9 || testMonth == 11) monthLength = 30;
|
|
if (testMonth == 2 && !leapYear) monthLength = 28;
|
|
if (testMonth == 2 && leapYear) monthLength = 29;
|
|
|
|
return monthLength;
|
|
}
|
|
|
|
|
|
|
|
|
|
void RecalculateTime(){
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
//getLeapYear
|
|
monthFac = RecalculateLeapYear(currentMonth,currentYear);
|
|
|
|
//clamp and pass all values
|
|
if (currentSecond > 59 || currentSecond < 0) currentMinute += Mathf.FloorToInt(currentSecond/60.0f);
|
|
if (currentSecond > 59) currentSecond = 0;
|
|
if (currentSecond < 0) currentSecond = 59;
|
|
if (currentMinute > 59 || currentMinute < 0.0) currentHour += Mathf.FloorToInt(currentMinute/60.0f);
|
|
if (currentMinute > 59) currentMinute = 0;
|
|
if (currentMinute < 0) currentMinute = 59;
|
|
|
|
if (currentHour > 23 || currentHour < 0) currentDay += Mathf.CeilToInt((currentHour/24.0f));
|
|
if (currentHour > 23) currentHour = 0;
|
|
if (currentHour < 0) currentHour = 23;
|
|
|
|
if (currentDay > monthFac || currentDay < 1) currentMonth += Mathf.CeilToInt((currentDay/(monthFac*1.0f))-1.0f);
|
|
if (currentDay > monthFac) currentDay = 1;
|
|
if (currentDay < 1) currentDay = RecalculateLeapYear(currentMonth-1,currentYear);
|
|
if (currentMonth > 12 || currentMonth < 1) currentYear += Mathf.CeilToInt((currentMonth/12.0f)-1f);
|
|
if (currentMonth > 12) currentMonth = 1;
|
|
if (currentMonth < 1) currentMonth = 12;
|
|
if (currentYear == 0) currentYear = 1;
|
|
|
|
//clamp and pass all moon values
|
|
if (moonSecond > 59 || moonSecond < 0) moonMinute += Mathf.FloorToInt(moonSecond/60.0f);
|
|
if (moonSecond > 59) moonSecond = 0;
|
|
if (moonSecond < 0) moonSecond = 59;
|
|
if (moonMinute > 59 || moonMinute < 0.0) moonHour += Mathf.FloorToInt(moonMinute/60.0f);
|
|
if (moonMinute > 59) moonMinute = 0;
|
|
if (moonMinute < 0) moonMinute = 59;
|
|
if (moonHour > 24 || moonHour < 1) moonDay += Mathf.CeilToInt((moonHour/24.0f)-1f);
|
|
if (moonHour > 24) moonHour = 1;
|
|
if (moonHour < 1) moonHour = 24;
|
|
if (moonDay > monthFac || moonDay < 1) moonMonth += Mathf.CeilToInt((moonDay/(monthFac*1.0f))-1.0f);
|
|
if (moonDay > monthFac) moonDay = 1;
|
|
if (moonDay < 1) moonDay = RecalculateLeapYear(moonMonth-1,currentYear);
|
|
if (moonMonth > 12 || moonMonth < 1) moonYear += Mathf.CeilToInt((moonMonth/12.0f)-1f);
|
|
if (moonMonth > 12) moonMonth = 1;
|
|
if (moonMonth < 1) moonMonth = 12;
|
|
|
|
//clamp and pass all star values
|
|
if (starSecond > 59 || starSecond < 0) starMinute += Mathf.FloorToInt(starSecond/60.0f);
|
|
if (starSecond > 59) starSecond = 0;
|
|
if (starSecond < 0) starSecond = 59;
|
|
if (starMinute > 59 || starMinute < 0.0) starHour += Mathf.FloorToInt(starMinute/60.0f);
|
|
if (starMinute > 59) starMinute = 0;
|
|
if (starMinute < 0) starMinute = 59;
|
|
if (starHour > 24 || starHour < 1) starDay += Mathf.CeilToInt((starHour/24.0f)-1f);
|
|
if (starHour > 24) starHour = 1;
|
|
if (starHour < 1) starHour = 24;
|
|
if (starDay > monthFac || starDay < 1) starMonth += Mathf.CeilToInt((starDay/(monthFac*1.0f))-1.0f);
|
|
if (starDay > monthFac) starDay = 1;
|
|
if (starDay < 1) starDay = RecalculateLeapYear(starMonth-1,currentYear);
|
|
if (starMonth > 12 || starMonth < 1) starYear += Mathf.CeilToInt((starMonth/12.0f)-1f);
|
|
if (starMonth > 12) starMonth = 1;
|
|
if (starMonth < 1) starMonth = 12;
|
|
|
|
|
|
if (!use24Clock && setHour > 12){
|
|
setHour = currentHour + 12;
|
|
} else {
|
|
setHour = currentHour;
|
|
}
|
|
setHour = currentHour;
|
|
|
|
|
|
|
|
|
|
//CALCULATE TIMERS
|
|
setDay = ((setHour-1) * 3600.0f) + (currentMinute * 60.0f) + (currentSecond * 1.0f);
|
|
setStar = ((starHour-1) * 3600.0f) + (starMinute * 60.0f) + (starSecond * 1.0f);
|
|
monthAddition = 0.0f;
|
|
|
|
for (aM = 1; aM < currentMonth; aM++){
|
|
monthAddition += (RecalculateLeapYear( aM, currentYear) * 1.0f);
|
|
}
|
|
setYear = monthAddition+(currentDay-1f)+((currentSecond + (currentMinute*60f) + (setHour*3600f))/86400.0f);
|
|
setMonth = (Mathf.Floor(moonDay-1)*86400.0f) + (Mathf.Floor(moonHour-1) * 3600.0f) + (Mathf.Floor(moonMinute) * 60.0f) + (Mathf.Floor(moonSecond) * 1.0f);
|
|
setMoon = (Mathf.Floor(moonDay-1)*86400.0f)+(Mathf.Floor(moonHour-1f) * 3600.0f) + (Mathf.Floor(moonMinute) * 60.0f) + (Mathf.Floor(moonSecond) * 1.0f);
|
|
setStar = (Mathf.Floor(starMonth-1)*30.41666f)+Mathf.Floor(starDay-1f)+(Mathf.Floor((starSecond) + (Mathf.Floor(starMinute)*60f) + (Mathf.Floor(starHour-1)*3600f))/86400.0f);
|
|
|
|
|
|
//CLAMP VALUES
|
|
yearDiv = 365.0f;
|
|
if (leapYear) yearDiv = 366.0f;
|
|
if (setYear > (86400.0f * yearDiv)) setYear = 0.0f;
|
|
if (setYear < 0.0f) setYear = (86400.0f * yearDiv);
|
|
|
|
|
|
//CALCULATE VALUES
|
|
dayValue = setDay / 86400.0f;
|
|
monthValue = setMonth / (86400.0f * 29.530589f);
|
|
yearValue = setYear / yearDiv;
|
|
starValue = setDay / 86400.0f;
|
|
starValue -= (setStar / 365.0f);
|
|
moonValue = setDay / 86400.0f;
|
|
moonValue -= setMoon / ((86400.0f) * 29.6666f);
|
|
|
|
//SEND TIME TO CALCULATIONS COMPONENT
|
|
calcComponent.y = currentYear;
|
|
calcComponent.m = currentMonth;
|
|
calcComponent.D = currentDay;
|
|
|
|
|
|
|
|
|
|
calcComponent.UT = (float)((currentHour-1)+(currentMinute/60.0f)+(((currentSecond + cloudStepTime)/60.0f)/60.0f));
|
|
lastSecond = currentSecond;
|
|
|
|
calcComponent.local_latitude = setLatitude;
|
|
calcComponent.local_longitude = -setLongitude;
|
|
calcComponent.tzOffset = -setTZOffset;
|
|
calcComponent.dstOffset = enableDST ? 1 : 0;
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
public float floatRound(float inFloat){
|
|
//var retFloat : float = 0.0f;
|
|
//retFloat = Mathf.Round(inFloat*1000.0f)/1000.0f;
|
|
//return retFloat;
|
|
return inFloat;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
void ClampParticle( string px_system ){
|
|
|
|
clampRes = 0.0f;
|
|
px = 0;
|
|
usePoint = 0.0f;
|
|
|
|
//clamp rain fog particles to ground (raycast)
|
|
if (px_system == "rain fog"){
|
|
clampRes = 1.0f;
|
|
setParticles = new ParticleSystem.Particle[particleObjectRainFog.particleCount];
|
|
particleObjectRainFog.GetParticles(setParticles);
|
|
for (px = 0; px < particleObjectRainFog.particleCount; px++){
|
|
if (setParticles[px].remainingLifetime >= 2.5f){
|
|
if ((px/clampRes) == (Mathf.Floor(px/clampRes))*1.0f){
|
|
particleRayPosition.x = setParticles[px].position.x;
|
|
particleRayPosition.y = 5000.0f;
|
|
particleRayPosition.z = setParticles[px].position.z;
|
|
if (Physics.Raycast(particleRayPosition, -Vector3.up, out hit, 10000.0f)){
|
|
if (!hit.collider.isTrigger){
|
|
usePoint = hit.point.y;
|
|
}
|
|
}
|
|
}
|
|
|
|
particlePosition.x = setParticles[px].position.x;
|
|
particlePosition.y = usePoint;
|
|
particlePosition.z = setParticles[px].position.z;
|
|
setParticles[px].position = particlePosition;
|
|
}
|
|
}
|
|
particleObjectRainFog.SetParticles(setParticles,setParticles.Length);
|
|
particleObjectRainFog.Play();
|
|
}
|
|
|
|
|
|
|
|
|
|
//clamp rain fog particles to ground (raycast)
|
|
if (px_system == "rain splash"){
|
|
clampRes = 1.0f;
|
|
setParticles = new ParticleSystem.Particle[particleObjectRainSplash.particleCount];
|
|
particleObjectRainSplash.GetParticles(setParticles);
|
|
for (px = 0; px < particleObjectRainSplash.particleCount; px++){
|
|
|
|
#if UNITY_5_4_OR_NEWER || UNITY_5_3_4 || UNITY_5_3_5 || UNITY_5_3_6 || UNITY_5_3_7 || UNITY_5_3_8
|
|
particleCol.r = setParticles[px].startColor.r;
|
|
particleCol.g = setParticles[px].startColor.g;
|
|
particleCol.b = setParticles[px].startColor.b;
|
|
particleCol.a = 0f;
|
|
setParticles[px].startColor = particleCol;
|
|
#else
|
|
particleCol.r = setParticles[px].color.r;
|
|
particleCol.g = setParticles[px].color.g;
|
|
particleCol.b = setParticles[px].color.b;
|
|
particleCol.a = 0f;
|
|
setParticles[px].color = particleCol;
|
|
#endif
|
|
|
|
if (setParticles[px].remainingLifetime >= 0.05f){
|
|
if ((px/clampRes) == (Mathf.Floor(px/clampRes))*1.0f){
|
|
particleRayPosition.x = setParticles[px].position.x;
|
|
particleRayPosition.y = 5000.0f;
|
|
particleRayPosition.z = setParticles[px].position.z;
|
|
if (Physics.Raycast(particleRayPosition, -Vector3.up, out hit, 10000.0f)){
|
|
if (!hit.collider.isTrigger){
|
|
usePoint = hit.point.y;
|
|
}
|
|
}
|
|
}
|
|
|
|
particlePosition.x = setParticles[px].position.x;
|
|
particlePosition.y = usePoint;
|
|
particlePosition.z = setParticles[px].position.z;
|
|
setParticles[px].position = particlePosition;
|
|
|
|
#if UNITY_5_4_OR_NEWER || UNITY_5_3_4 || UNITY_5_3_5 || UNITY_5_3_6 || UNITY_5_3_7 || UNITY_5_3_8
|
|
particleCol.r = setParticles[px].startColor.r;
|
|
particleCol.g = setParticles[px].startColor.g;
|
|
particleCol.b = setParticles[px].startColor.b;
|
|
particleCol.a = TenRandom.Next(25.0f,150.0f);
|
|
setParticles[px].startColor = particleCol;
|
|
#else
|
|
particleCol.r = setParticles[px].color.r;
|
|
particleCol.g = setParticles[px].color.g;
|
|
particleCol.b = setParticles[px].color.b;
|
|
particleCol.a = TenRandom.Next(25.0f,150.0f);
|
|
setParticles[px].color = particleCol;
|
|
#endif
|
|
}
|
|
}
|
|
particleObjectRainSplash.SetParticles(setParticles,setParticles.Length);
|
|
particleObjectRainSplash.Play();
|
|
}
|
|
|
|
|
|
//clamp fog particles to ground (raycast)
|
|
if (px_system == "fog"){
|
|
clampRes = 1.0f;
|
|
setParticles = new ParticleSystem.Particle[particleObjectFog.particleCount];
|
|
particleObjectFog.GetParticles(setParticles);
|
|
for (px = 0; px < particleObjectFog.particleCount; px++){
|
|
if (setParticles[px].remainingLifetime >= 4.8f){
|
|
if ((px/clampRes) == (Mathf.Floor(px/clampRes))*1.0f){
|
|
particleRayPosition.x = setParticles[px].position.x;
|
|
particleRayPosition.y = 5000.0f;
|
|
particleRayPosition.z = setParticles[px].position.z;
|
|
if (Physics.Raycast(particleRayPosition, -Vector3.up, out hit, 10000.0f)){
|
|
if (!hit.collider.isTrigger){
|
|
usePoint = hit.point.y;
|
|
}
|
|
}
|
|
}
|
|
if (usePoint > weather_FogHeight) usePoint = weather_FogHeight;
|
|
|
|
particlePosition.x = setParticles[px].position.x;
|
|
particlePosition.y = usePoint;
|
|
particlePosition.z = setParticles[px].position.z;
|
|
setParticles[px].position = particlePosition;
|
|
}
|
|
}
|
|
particleObjectFog.SetParticles(setParticles,setParticles.Length);
|
|
particleObjectFog.Play();
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
public Vector2 TenkokuConvertAngleToVector(float convertAngle) {
|
|
|
|
dir = Vector3.zero;
|
|
tempAngle = Vector3.zero;
|
|
if (convertAngle <= 180.0f){
|
|
tempAngle = Vector3.Slerp(Vector3.forward,-Vector3.forward,(convertAngle)/180.0f);
|
|
tempAngleVec2.x = tempAngle.x;
|
|
tempAngleVec2.y = -tempAngle.z;
|
|
dir = tempAngleVec2;
|
|
}
|
|
if (convertAngle > 180.0f){
|
|
tempAngle = Vector3.Slerp(-Vector3.forward,Vector3.forward,(convertAngle-180.0f)/180.0f);
|
|
tempAngleVec2.x = -tempAngle.x;
|
|
tempAngleVec2.y = -tempAngle.z;
|
|
dir = tempAngleVec2;
|
|
}
|
|
|
|
return dir;
|
|
}
|
|
|
|
|
|
|
|
public Vector4 CloudsConvertAngleToVector(float convertAngle) {
|
|
Vector4 dir = Vector4.zero;
|
|
Vector3 tempAngle = Vector3.zero;
|
|
if (convertAngle <= 180.0f){
|
|
tempAngle = Vector3.Slerp(Vector3.forward,-Vector3.forward,(convertAngle)/180.0f);
|
|
dir.x = tempAngle.x;
|
|
dir.z = -tempAngle.z;
|
|
}
|
|
if (convertAngle > 180.0f){
|
|
tempAngle = Vector3.Slerp(-Vector3.forward,Vector3.forward,(convertAngle-180.0f)/180.0f);
|
|
dir.x = -tempAngle.x;
|
|
dir.z = -tempAngle.z;
|
|
}
|
|
dir.y = -0.25f;
|
|
dir.w = 0f;
|
|
|
|
return dir;
|
|
}
|
|
|
|
|
|
|
|
public void LoadDecodedColors(){
|
|
|
|
decodeColorSun = DecodeColorKey(0);
|
|
//decodeColorSunray = DecodeColorKey(1);
|
|
decodeColorAmbientcolor = DecodeColorKey(2);
|
|
decodeColorMoon = DecodeColorKey(3);
|
|
decodeColorSkyambient = DecodeColorKey(4);
|
|
decodeColorSkybase = DecodeColorKey(5);
|
|
decodeColorAmbientcloud = DecodeColorKey(6);
|
|
decodeColorColorhorizon = DecodeColorKey(7);
|
|
decodeColorColorcloud = DecodeColorKey(8);
|
|
decodeColorAmbientGI = DecodeColorKey(9);
|
|
}
|
|
|
|
|
|
|
|
public void UpdateColorMap(){
|
|
DecodedColors = colorRamp.GetPixels(0);
|
|
}
|
|
|
|
|
|
|
|
public Color DecodeColorKey( int position ) {
|
|
|
|
returnColor = Color.black;
|
|
|
|
//DECODE TEXTURE
|
|
if (colorTypeIndex == 0){
|
|
|
|
//positions
|
|
texPos = 0;
|
|
if (position == 0) texPos = 144; //sun
|
|
if (position == 1) texPos = 144; //sunray
|
|
if (position == 2) texPos = 81; //ambientcolor
|
|
if (position == 3) texPos = 59; //moon
|
|
if (position == 4) texPos = 37; //skyambient
|
|
if (position == 5) texPos = 100; //skybase
|
|
if (position == 6) texPos = 186; //ambientcloud
|
|
if (position == 7) texPos = 121; //colorhorizon
|
|
if (position == 8) texPos = 166; //colorcloud
|
|
if (position == 9) texPos = 15; //ambientGI
|
|
|
|
|
|
//decode texture
|
|
if (colorRamp != null){
|
|
|
|
//decode textures
|
|
if (DecodedColors != null){
|
|
returnColor = Color.Lerp(
|
|
DecodedColors[(stepTime + (texPos * colorRamp.width))],
|
|
DecodedColors[(stepTime + 1 + (texPos * colorRamp.width))],
|
|
timeLerp);
|
|
}
|
|
|
|
//moon
|
|
if (position == 3 && DecodedColors != null){
|
|
returnColor = Color.Lerp(
|
|
DecodedColors[(stepTimeM + (texPos * colorRamp.width))],
|
|
DecodedColors[(stepTimeM + 1 + (texPos * colorRamp.width))],
|
|
timeLerpM);
|
|
}
|
|
|
|
//sunray
|
|
if (position == 1){
|
|
returnColor.r = Mathf.Pow(returnColor.r,3.2f);
|
|
returnColor.g = Mathf.Pow(returnColor.g,3.2f);
|
|
returnColor.b = Mathf.Pow(returnColor.b,3.2f);
|
|
}
|
|
|
|
|
|
//linear and gamma conversion
|
|
if (_linearSpace != ColorSpace.Linear){
|
|
|
|
//specific color shift
|
|
if (position == 5){ //skybase
|
|
returnColor.r *= 0.4646f;
|
|
returnColor.g *= 0.4646f;
|
|
returnColor.b *= 0.4646f;
|
|
}
|
|
}
|
|
|
|
//if (position == 5) returnColor = Color.black;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//DECODE GRADIENT
|
|
if (colorTypeIndex == 1){
|
|
|
|
if (position == 0) returnColor = sunGradient.Evaluate( calcTime ); //sun
|
|
if (position == 1) returnColor = sunGradient.Evaluate( calcTime ); //sunray
|
|
if (position == 2) returnColor = ambColorGradient.Evaluate( calcTime ); //ambientcolor
|
|
if (position == 3) returnColor = moonGradient.Evaluate( calcTimeM ); //moon
|
|
if (position == 4) returnColor = ambDayGradient.Evaluate( calcTime ); //skyDay
|
|
if (position == 5) returnColor = skyGradient.Evaluate( calcTime ); //skybase
|
|
if (position == 6) returnColor = cloudGradient.Evaluate( calcTime ); //ambientcloud
|
|
if (position == 7) returnColor = horizGradient.Evaluate( calcTime ); //colorhorizon
|
|
if (position == 8) returnColor = cloudAmbGradient.Evaluate( calcTime ); //colorcloud
|
|
if (position == 9) returnColor = ambLightGradient.Evaluate( calcTime ); //ambientGI
|
|
|
|
|
|
|
|
//sunray
|
|
if (position == 1){
|
|
returnColor.r = Mathf.Pow(returnColor.r,3.2f);
|
|
returnColor.g = Mathf.Pow(returnColor.g,3.2f);
|
|
returnColor.b = Mathf.Pow(returnColor.b,3.2f);
|
|
}
|
|
|
|
//if (position == 9) returnColor = returnColor * 0.5f;
|
|
|
|
//if (position == 5 || position == 0){
|
|
// returnColor.r *= 0.65f;
|
|
// returnColor.g *= 0.65f;
|
|
// returnColor.b *= 0.65f;
|
|
//}
|
|
|
|
//linear and gamma conversion
|
|
//if (_linearSpace != ColorSpace.Linear){
|
|
|
|
//specific color shift
|
|
//if (position == 5){ //skybase
|
|
// returnColor.r *= 0.4646f;
|
|
// returnColor.g *= 0.4646f;
|
|
// returnColor.b *= 0.4646f;
|
|
//}
|
|
//}
|
|
|
|
}
|
|
|
|
|
|
|
|
return returnColor;
|
|
}
|
|
|
|
|
|
|
|
|
|
// ENCODE SETTINGS TO STRING
|
|
// this is useful to quickly encode
|
|
// Tenkoku settings over a server.
|
|
public string Tenkoku_EncodeData() {
|
|
|
|
//run functions
|
|
dataString = currentYear.ToString()+",";
|
|
dataString += currentMonth.ToString()+",";
|
|
dataString += currentDay.ToString()+",";
|
|
dataString += currentHour.ToString()+",";
|
|
dataString += currentMinute.ToString()+",";
|
|
dataString += currentSecond.ToString()+",";
|
|
|
|
dataString += setLatitude.ToString()+",";
|
|
dataString += setLongitude.ToString()+",";
|
|
|
|
dataString += weather_cloudAltoStratusAmt.ToString()+",";
|
|
dataString += weather_cloudCirrusAmt.ToString()+",";
|
|
dataString += weather_cloudCumulusAmt.ToString()+",";
|
|
dataString += weather_OvercastAmt.ToString()+",";
|
|
dataString += weather_OvercastDarkeningAmt.ToString()+",";
|
|
dataString += weather_cloudScale.ToString()+",";
|
|
dataString += weather_cloudSpeed.ToString()+",";
|
|
dataString += weather_RainAmt.ToString()+",";
|
|
dataString += weather_SnowAmt.ToString()+",";
|
|
dataString += weather_FogAmt.ToString()+",";
|
|
dataString += weather_WindAmt.ToString()+",";
|
|
dataString += weather_WindDir.ToString()+",";
|
|
|
|
dataString += weatherTypeIndex.ToString()+",";
|
|
dataString += weather_autoForecastTime.ToString()+",";
|
|
dataString += weather_TransitionTime.ToString()+",";
|
|
|
|
dataUpdate = weather_forceUpdate ? "1" : "0";
|
|
dataString += dataUpdate+",";
|
|
|
|
dataString += weather_temperature.ToString()+",";
|
|
dataString += weather_humidity.ToString()+",";
|
|
dataString += weather_rainbow.ToString()+",";
|
|
dataString += weather_lightning.ToString()+",";
|
|
dataString += weather_lightningDir.ToString()+",";
|
|
dataString += weather_lightningRange.ToString()+",";
|
|
|
|
//save random marker
|
|
dataString += randSeed.ToString()+",";
|
|
|
|
//current cloud coordinates
|
|
dataString += currCoords.x.ToString()+",";
|
|
dataString += currCoords.y.ToString();
|
|
|
|
|
|
return dataString;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// DECODE SETTINGS FROM STRING
|
|
// this is useful to quickly decode
|
|
// Tenkoku settings over a server.
|
|
public void Tenkoku_DecodeData( string dataString ){
|
|
|
|
data = dataString.Split(","[0]);
|
|
|
|
//set functions
|
|
currentYear = int.Parse(data[0]);
|
|
currentMonth = int.Parse(data[1]);
|
|
currentDay = int.Parse(data[2]);
|
|
currentHour = int.Parse(data[3]);
|
|
currentMinute = int.Parse(data[4]);
|
|
currentSecond = int.Parse(data[5]);
|
|
|
|
setLatitude = float.Parse(data[6]);
|
|
setLongitude = float.Parse(data[7]);
|
|
|
|
weather_cloudAltoStratusAmt = float.Parse(data[8]);
|
|
weather_cloudCirrusAmt = float.Parse(data[9]);
|
|
weather_cloudCumulusAmt = float.Parse(data[10]);
|
|
weather_OvercastAmt = float.Parse(data[11]);
|
|
weather_OvercastDarkeningAmt = float.Parse(data[12]);
|
|
weather_cloudScale = float.Parse(data[13]);
|
|
weather_cloudSpeed = float.Parse(data[14]);
|
|
weather_RainAmt = float.Parse(data[15]);
|
|
weather_SnowAmt = float.Parse(data[16]);
|
|
weather_FogAmt = float.Parse(data[17]);
|
|
weather_WindAmt = float.Parse(data[18]);
|
|
weather_WindDir = float.Parse(data[19]);
|
|
|
|
weatherTypeIndex = int.Parse(data[20]);
|
|
weather_autoForecastTime = float.Parse(data[21]);
|
|
weather_TransitionTime = float.Parse(data[22]);
|
|
|
|
setUpdate = data[23];
|
|
if (setUpdate == "1"){
|
|
weather_forceUpdate = true;
|
|
} else {
|
|
weather_forceUpdate = false;
|
|
}
|
|
|
|
weather_temperature = float.Parse(data[24]);
|
|
weather_humidity = float.Parse(data[25]);
|
|
|
|
weather_rainbow = float.Parse(data[26]);
|
|
weather_lightning = float.Parse(data[27]);
|
|
weather_lightningDir = float.Parse(data[28]);
|
|
weather_lightningRange = float.Parse(data[29]);
|
|
|
|
//decode random marker
|
|
randSeed = int.Parse(data[30]);
|
|
TenRandom = new Tenkoku.Core.Random( randSeed );
|
|
|
|
//current cloud coordinates
|
|
currCoords.x = float.Parse(data[31]);
|
|
currCoords.y = float.Parse(data[32]);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
// -------------------------------------------------------
|
|
// -- CALCULATE SKYBOX MATERIAL AND UPDATE SETTINGS --
|
|
// -------------------------------------------------------
|
|
void CalculateSkyboxData(Material material){
|
|
|
|
|
|
//update Sky Model
|
|
if (atmosphereModelTypeIndex != useAtmosphereIndex){
|
|
|
|
//if (skyMaterial == null){
|
|
//skyMaterial = new Material(Shader.Find("TENKOKU/Tenkoku_Sky_Elek"));
|
|
//if (libComponent != null){
|
|
// skyMaterial = libComponent.skyMaterial;
|
|
//RenderSettings.skybox = skyMaterial;
|
|
//}
|
|
//}
|
|
|
|
if (libComponent != null){
|
|
if (atmosphereModelTypeIndex == 0){
|
|
//material = null;
|
|
//material = new Material(Shader.Find("TENKOKU/Tenkoku_Sky_Legacy"));
|
|
material = libComponent.skyMaterialLegacy;
|
|
}
|
|
|
|
if (atmosphereModelTypeIndex == 1){
|
|
//material = null;
|
|
//material = new Material(Shader.Find("TENKOKU/Tenkoku_Sky_Elek"));
|
|
material = libComponent.skyMaterialElek;
|
|
}
|
|
|
|
UnityEngine.RenderSettings.skybox = material;
|
|
useAtmosphereIndex = atmosphereModelTypeIndex;
|
|
}
|
|
}
|
|
|
|
|
|
//if (material != null){
|
|
|
|
//Update Legacy Sky Settings
|
|
if (atmosphereModelTypeIndex == 0){
|
|
material.SetColor("_GroundColor",colorSkyboxGround);
|
|
material.SetColor("_MieColor",colorSkyboxMie);
|
|
material.SetFloat("_Tenkoku_MieAmt",mieAmount);
|
|
material.SetFloat("_Tenkoku_MnMieAmt",mieMnAmount);
|
|
Shader.SetGlobalFloat("_Tenkoku_UseElek", 0.0f);
|
|
}
|
|
|
|
//Update Oskar-Elek Sky Settings
|
|
if (atmosphereModelTypeIndex == 1){
|
|
material.SetFloat("_AtmosphereHeight", Mathf.Lerp(0f,160000f,atmosphereDensity));
|
|
material.SetFloat("_PlanetRadius", PlanetRadius);
|
|
material.SetVector("_DensityScaleHeight", DensityScale);
|
|
material.SetVector("_ScatteringR", RayleighSct * RayleighScatterCoef);
|
|
material.SetVector("_ScatteringM", MieSct * MieScatterCoef);
|
|
material.SetVector("_ExtinctionR", RayleighSct * RayleighExtinctionCoef);
|
|
material.SetVector("_ExtinctionM", MieSct * MieExtinctionCoef);
|
|
|
|
material.SetColor("_IncomingLight", IncomingLight);
|
|
material.SetFloat("_MieG", MieG);
|
|
|
|
material.SetTexture("_ParticleDensityLUT", _particleDensityLUT);
|
|
|
|
material.SetFloat("_SunIntensity", SunIntensity);
|
|
|
|
material.SetColor("_GroundColor",colorSkyboxGround);
|
|
material.SetColor("_MieColor",colorSkyboxMie);
|
|
material.SetFloat("_Tenkoku_MieAmt",mieAmount);
|
|
material.SetFloat("_Tenkoku_MnMieAmt",mieMnAmount);
|
|
material.SetFloat("_Tenkoku_MnIntensity", lightObjectNight.intensity);
|
|
|
|
Shader.SetGlobalFloat("_Tenkoku_UseElek", 1.0f);
|
|
|
|
}
|
|
//}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
// TRANSITION TIME CAPTURE (MULTI INPUT FUNCTIONS)
|
|
public void Tenkoku_SetTransition(string startTime, string targetTime, int duration, float direction){
|
|
Debug.Log("Tenkoku_SetTransition: Note that (string, string, int, float) format will soon be deprecated. Please change duration value to float instead of int.");
|
|
transitionStartTime = startTime;
|
|
transitionTargetTime = targetTime;
|
|
transitionDuration = duration;
|
|
transitionDirection = direction;
|
|
transitionCurve = null;
|
|
doTransition = true;
|
|
}
|
|
public void Tenkoku_SetTransition(string startTime, string targetTime, float duration, float direction){
|
|
transitionStartTime = startTime;
|
|
transitionTargetTime = targetTime;
|
|
transitionDuration = duration;
|
|
transitionDirection = direction;
|
|
transitionCurve = null;
|
|
doTransition = true;
|
|
}
|
|
public void Tenkoku_SetTransition(string startTime, string targetTime, float duration, float direction, AnimationCurve curve){
|
|
transitionStartTime = startTime;
|
|
transitionTargetTime = targetTime;
|
|
transitionDuration = duration;
|
|
transitionDirection = direction;
|
|
transitionCurve = curve;
|
|
doTransition = true;
|
|
}
|
|
|
|
|
|
|
|
|
|
public void Tenkoku_SetTransition(string startTime, string targetTime, int duration, float direction, GameObject callbackObject){
|
|
Debug.Log("Tenkoku_SetTransition: Note that (string, string, int, float, gameObject) format will soon be deprecated. Please change duration value to float instead of int.");
|
|
transitionStartTime = startTime;
|
|
transitionTargetTime = targetTime;
|
|
transitionDuration = duration;
|
|
transitionDirection = direction;
|
|
transitionCurve = null;
|
|
if (callbackObject != null){
|
|
transitionCallbackObject = callbackObject;
|
|
transitionCallback = true;
|
|
}
|
|
doTransition = true;
|
|
}
|
|
public void Tenkoku_SetTransition(string startTime, string targetTime, float duration, float direction, GameObject callbackObject){
|
|
transitionStartTime = startTime;
|
|
transitionTargetTime = targetTime;
|
|
transitionDuration = duration;
|
|
transitionDirection = direction;
|
|
transitionCurve = null;
|
|
if (callbackObject != null){
|
|
transitionCallbackObject = callbackObject;
|
|
transitionCallback = true;
|
|
}
|
|
doTransition = true;
|
|
}
|
|
public void Tenkoku_SetTransition(string startTime, string targetTime, float duration, float direction, GameObject callbackObject, AnimationCurve curve){
|
|
transitionStartTime = startTime;
|
|
transitionTargetTime = targetTime;
|
|
transitionDuration = duration;
|
|
transitionDirection = direction;
|
|
transitionCurve = curve;
|
|
if (callbackObject != null){
|
|
transitionCallbackObject = callbackObject;
|
|
transitionCallback = true;
|
|
}
|
|
doTransition = true;
|
|
}
|
|
|
|
|
|
|
|
//---------------------------------------------------------------------------------------------------------------
|
|
|
|
|
|
|
|
|
|
// DO TIME TRANSITIONS
|
|
void Tenkoku_TransitionTime(){
|
|
|
|
//Initialize
|
|
if (transitionTime <= 0.0f){
|
|
|
|
//clamp direction
|
|
if (transitionDirection > 0.0f) transitionDirection = 1.0f;
|
|
if (transitionDirection < 0.0f) transitionDirection = -1.0f;
|
|
|
|
//calculate ending time
|
|
setTransHour = Mathf.Clamp(System.Int32.Parse(transitionTargetTime.Substring(0,2)),0,23);
|
|
setTransMinute = Mathf.Clamp(System.Int32.Parse(transitionTargetTime.Substring(3,2)),0,59);
|
|
setTransSecond = Mathf.Clamp(System.Int32.Parse(transitionTargetTime.Substring(6,2)),0,59);
|
|
endTime = setTransSecond + (setTransMinute*60) + (setTransHour*3600);
|
|
|
|
//calculate starting time
|
|
if (transitionStartTime == null || transitionStartTime == ""){
|
|
startHour = currentHour;
|
|
startMinute = currentMinute;
|
|
startSecond = currentSecond;
|
|
} else {
|
|
startHour = Mathf.Clamp(System.Int32.Parse(transitionStartTime.Substring(0,2)),0,23);
|
|
startMinute = Mathf.Clamp(System.Int32.Parse(transitionStartTime.Substring(3,2)),0,59);
|
|
startSecond = Mathf.Clamp(System.Int32.Parse(transitionStartTime.Substring(6,2)),0,59);
|
|
currentHour = startHour;
|
|
currentMinute = startMinute;
|
|
currentSecond = startSecond;
|
|
}
|
|
startTime = startSecond + (startMinute*60) + (startHour*3600);
|
|
|
|
//fudge numbers if they are the same
|
|
if (startTime == endTime){
|
|
if (transitionDirection == 1.0f) startTime = startTime + 1;
|
|
if (transitionDirection == -1.0f) startTime = startTime - 1;
|
|
}
|
|
|
|
}
|
|
|
|
//check for transition end
|
|
endTransition = false;
|
|
if (transitionTime >= transitionDuration) endTransition = true;
|
|
|
|
//END TRANSITION
|
|
if (endTransition){
|
|
|
|
//useAutoTime = false;
|
|
doTransition = false;
|
|
transitionTime = 0.0f;
|
|
|
|
//Send Callback (optional)
|
|
if (transitionCallback){
|
|
if (transitionCallbackObject != null){
|
|
transitionCallbackObject.SendMessage("CaptureTenkokuCallback",SendMessageOptions.DontRequireReceiver);
|
|
}
|
|
}
|
|
transitionCallbackObject = null;
|
|
transitionCallback = false;
|
|
isDoingTransition = false;
|
|
|
|
//DO TRANSITION
|
|
} else {
|
|
//useAutoTime = true;
|
|
transitionTime += _deltaTime;
|
|
|
|
float transTime = 0f;
|
|
float transFac = transitionTime / transitionDuration;
|
|
if (transitionCurve != null){
|
|
transFac = transitionCurve.Evaluate(transFac);
|
|
}
|
|
if (transitionDirection == 1.0f && endTime > startTime) transTime = Mathf.SmoothStep(startTime, endTime, transFac);
|
|
if (transitionDirection == -1.0f && endTime < startTime) transTime = Mathf.SmoothStep(startTime, endTime, transFac);
|
|
if (transitionDirection == 1.0f && endTime < startTime){
|
|
transTime = Mathf.SmoothStep(startTime, (endTime + 86400f), transFac) % 86400f;
|
|
}
|
|
if (transitionDirection == -1.0f && endTime > startTime){
|
|
transTime = Mathf.SmoothStep(startTime, (endTime - 86400f), transFac);
|
|
if (transTime < 0) transTime = 86400f - Mathf.Abs(transTime);
|
|
}
|
|
currentHour = (int)(transTime / 3600);
|
|
currentMinute = (int)((transTime - (currentHour * 3600)) / 60);
|
|
currentSecond = (int)((transTime - (currentHour * 3600) - (currentMinute * 60)));
|
|
|
|
isDoingTransition = true;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
}
|
|
} |