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;
}
}
}
}