You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1760 lines
72 KiB
C#
1760 lines
72 KiB
C#
using UnityEngine;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.IO;
|
|
|
|
#if UNITY_EDITOR
|
|
using UnityEditor;
|
|
#endif
|
|
|
|
|
|
|
|
namespace Suimono.Core
|
|
{
|
|
|
|
[ExecuteInEditMode]
|
|
public class SuimonoObject : MonoBehaviour {
|
|
|
|
|
|
public float systemTime = 0.0f;
|
|
public float systemLocalTime = 0.0f;
|
|
public float flowSpeed = 0.1f;
|
|
public float flowDirection = 180.0f;
|
|
public bool useBeaufortScale = false;
|
|
public float beaufortScale = 1.0f;
|
|
public float turbulenceFactor = 1.0f;
|
|
public float waveScale = 0.5f;
|
|
public float lgWaveHeight = 0.0f;
|
|
public float lgWaveScale = 1.0f;
|
|
public float waveHeight = 1.0f;
|
|
public float heightProjection = 1.0f;
|
|
public float useHeightProjection = 1.0f;
|
|
public float refractStrength = 1.0f;
|
|
public float reflectProjection = 1.0f;
|
|
public float reflectBlur = 0.0f;
|
|
public float aberrationScale = 0.1f;
|
|
public float specularPower = 1f;
|
|
public float roughness = 0.1f;
|
|
public float roughness2 = 0.35f;
|
|
public float reflectTerm = 0.0255f;
|
|
public float reflectSharpen = 0.0f;
|
|
public bool showDepthMask = false;
|
|
public bool showWorldMask = false;
|
|
public float cameraDistance = 1000.0f;
|
|
public float underwaterDepth = 5f;
|
|
|
|
//DX9 version
|
|
public bool useDX9Settings = false;
|
|
|
|
|
|
//objects
|
|
public Suimono.Core.SuimonoModule moduleObject;
|
|
private Suimono.Core.SuimonoModuleLib suimonoModuleLibrary;
|
|
private GameObject suimonoObject;
|
|
private Renderer surfaceRenderer;
|
|
private MeshFilter surfaceMesh;
|
|
private MeshCollider surfaceCollider;
|
|
private Suimono.Core.cameraTools surfaceReflections;
|
|
private Suimono.Core.Suimono_DistanceBlur surfaceReflBlur;
|
|
private GameObject scaleObject;
|
|
private Renderer scaleRenderer;
|
|
private MeshCollider scaleCollider;
|
|
private MeshFilter scaleMesh;
|
|
private Renderer surfaceVolume;
|
|
|
|
//materials
|
|
private Material tempMaterial;
|
|
|
|
//type and options
|
|
public string suimonoVersionNumber;
|
|
public bool showGeneral = false;
|
|
public int typeIndex = 1;
|
|
[System.NonSerialized] public List<string> typeOptions = new List<string>(){"Infinite 3D Ocean", "3D Waves", "Flat Plane"};
|
|
public int editorIndex = 1;
|
|
public int editorUseIndex = 1;
|
|
[System.NonSerialized] public List<string> editorOptions = new List<string>(){"Simple","Advanced"};
|
|
|
|
|
|
//mesh and lod
|
|
public bool enableCustomMesh = false;
|
|
public float cmScaleX = 1f;
|
|
public float cmScaleY = 1f;
|
|
public int lodIndex;
|
|
public int useLodIndex;
|
|
[System.NonSerialized] public List<string> lodOptions = new List<string>(){"High Detail","Medium Detail","Low Detail","Single Quad"};
|
|
public Mesh customMesh;
|
|
public float oceanScale = 2.0f;
|
|
private bool meshWasSet = false;
|
|
|
|
//casutics
|
|
public bool enableCausticFX = true;
|
|
public float causticsFade = 0.55f;
|
|
public Color causticsColor = new Color(1f,1f,1f,1f);
|
|
|
|
//tessellation
|
|
public bool enableTess = true;
|
|
public bool useEnableTess = true;
|
|
public float waveTessAmt = 8.0f;
|
|
public float waveTessMin = 0.0f;
|
|
public float waveTessSpread = 0.08f;
|
|
|
|
//interaction
|
|
public bool enableInteraction = true;
|
|
|
|
//reflections
|
|
public float dynamicReflectFlag = 1.0f;
|
|
public bool enableReflections = true;
|
|
public bool enableDynamicReflections = true;
|
|
|
|
public bool useEnableReflections = true;
|
|
public bool useEnableDynamicReflections = true;
|
|
|
|
public bool useReflections = true;
|
|
public bool useDynReflections = true;
|
|
public int reflectLayer = 0;
|
|
public int reflectResolution = 4;
|
|
public LayerMask reflectLayerMask;
|
|
public float reflectionDistance = 1000.0f;
|
|
|
|
[System.NonSerialized] public List<string> suiLayerMasks = new List<string>();
|
|
|
|
[System.NonSerialized] public List<string> resOptions = new List<string>(){"4096","2048","1024","512","256","128","64","32","16","8"};
|
|
[System.NonSerialized] public List<int> resolutions = new List<int>(){4096,2048,1024,512,256,128,64,32,16,8};
|
|
public int reflectFallback = 1;
|
|
[System.NonSerialized] public List<string> resFallbackOptions = new List<string>(){"None","skybox","Custom Cubemap","Color"};
|
|
public Texture customRefCubemap;
|
|
public Color customRefColor = new Color(0.9f,0.9f,0.9f,1.0f);
|
|
public Color reflectionColor = new Color(1f,1f,1f,1f);
|
|
|
|
//custom textures
|
|
public bool enableCustomTextures = false;
|
|
public Texture2D customTexNormal1;
|
|
//public Texture2D customTexHeight1;
|
|
public Texture2D customTexNormal2;
|
|
//public Texture2D customTexHeight2;
|
|
public Texture2D customTexNormal3;
|
|
//public Texture2D customTexHeight3;
|
|
public Texture2D useTexNormal1;
|
|
//public Texture2D useTexHeight1;
|
|
public Texture2D useTexNormal2;
|
|
//public Texture2D useTexHeight2;
|
|
public Texture2D useTexNormal3;
|
|
//public Texture2D useTexHeight3;
|
|
|
|
//waves
|
|
public bool showWaves = false;
|
|
public bool customWaves = false;
|
|
public float localTime = 0.0f;
|
|
private Vector2 flow_dir = new Vector2(0f,0f);
|
|
private Vector3 tempAngle;
|
|
public float beaufortVal = 1.0f;
|
|
|
|
//shorelines
|
|
public bool showShore = false;
|
|
public float shorelineHeight = 0.75f;
|
|
public float shorelineFreq = 0.5f;
|
|
public float shorelineScale = 0.15f;
|
|
public float shorelineSpeed = 2.5f;
|
|
public float shorelineNorm = 0.5f;
|
|
|
|
//surface
|
|
public bool showSurface = false;
|
|
public float overallBright = 1.0f;
|
|
public float overallTransparency = 1.0f;
|
|
public float depthAmt = 0.1f;
|
|
public float shallowAmt = 0.1f;
|
|
public Color depthColor;
|
|
public Color shallowColor;
|
|
public float edgeAmt = 0.1f;
|
|
public Color specularColor;
|
|
public Color sssColor;
|
|
public Color blendColor;
|
|
public Color overlayColor;
|
|
|
|
//foam
|
|
public bool showFoam = false;
|
|
public bool enableFoam = true;
|
|
public Color foamColor = new Color(0.9f,0.9f,0.9f,1.0f);
|
|
public float foamScale = 40.0f;
|
|
public float foamSpeed = 0.1f;
|
|
public float edgeFoamAmt = 0.5f;
|
|
public float shallowFoamAmt = 1.0f;
|
|
public float hFoamHeight = 1.0f;
|
|
public float hFoamSpread = 1.0f;
|
|
public float heightFoamAmt = 0.5f;
|
|
|
|
//underwater
|
|
public bool showUnderwater = false;
|
|
public Color underwaterColor = new Color(1f,0f,0f,1f);
|
|
public float underLightFactor = 1.0f;
|
|
public float underRefractionAmount = 0.005f;
|
|
public float underRefractionScale = 1.5f;
|
|
public float underRefractionSpeed = 0.5f;
|
|
public float underwaterFogDist = 20.0f;
|
|
public float underwaterFogSpread = 0.0f;
|
|
public bool enableUnderwater = true;
|
|
public bool enableUnderDebris = false;
|
|
public float underBlurAmount = 1.0f;
|
|
public float underDarkRange = 40.0f;
|
|
|
|
//scaling
|
|
public float setScale = 1.0f;
|
|
public Vector3 currentAngles = new Vector3(0f,0f,0f);
|
|
public Vector3 currentPosition = new Vector3(0f,0f,0f);
|
|
public Vector3 newPos = new Vector3(0f,0f,0f);
|
|
public float spacer = 0.0f;
|
|
public float setScaleX = 0.0f;
|
|
public float setScaleZ = 0.0f;
|
|
public float offamt = 0.0f;
|
|
public Vector2 savePos = new Vector2(0f,0f);
|
|
public Vector2 recPos = new Vector2(0f,0f);
|
|
public Vector2 _suimono_uv = new Vector2(0f,0f);
|
|
|
|
//editor
|
|
public bool showSimpleEditor = false;
|
|
|
|
//shaders
|
|
public Shader useShader;
|
|
public Shader currUseShader;
|
|
public Shader shader_Surface;
|
|
public Shader shader_Scale;
|
|
public Shader shader_Under;
|
|
|
|
//presets
|
|
[System.NonSerialized] public List<string> presetDirs;
|
|
public string[] presetFiles;
|
|
public int presetIndex = -1;
|
|
public int presetUseIndex = -1;
|
|
public int presetFileIndex = 0;
|
|
public int presetFileUseIndex = 0;
|
|
public string[] presetOptions;
|
|
public bool showPresets = false;
|
|
public bool presetStartTransition = false;
|
|
public float presetTimer = 1f;
|
|
public string currentPresetFolder = "Built-In Presets";
|
|
public string currentPresetName = "";
|
|
public int presetTransitionCurrent = 0;
|
|
public float presetTransitionTime = 1.0f;
|
|
public int presetTransIndexFrm = 0;
|
|
public int presetTransIndexTo = 0;
|
|
public bool presetToggleSave = false;
|
|
public bool presetsLoaded = false;
|
|
public string[] presetDataArray;
|
|
public string presetDataString;
|
|
public string dir = "";
|
|
public string baseDir = "SUIMONO - WATER SYSTEM 2/RESOURCES/";
|
|
public string presetSaveName = "my custom preset";
|
|
public string presetFile = "";
|
|
public string workData;
|
|
public string workData2;
|
|
|
|
|
|
//temporary preset data
|
|
Color temp_depthColor;
|
|
Color temp_shallowColor;
|
|
Color temp_blendColor;
|
|
Color temp_overlayColor;
|
|
Color temp_causticsColor;
|
|
Color temp_reflectionColor;
|
|
Color temp_specularColor;
|
|
Color temp_sssColor;
|
|
Color temp_foamColor;
|
|
Color temp_underwaterColor;
|
|
float temp_beaufortScale;
|
|
float temp_flowDirection;
|
|
float temp_flowSpeed;
|
|
float temp_waveScale;
|
|
float temp_waveHeight;
|
|
float temp_heightProjection;
|
|
float temp_turbulenceFactor;
|
|
float temp_lgWaveHeight;
|
|
float temp_lgWaveScale;
|
|
float temp_shorelineHeight;
|
|
float temp_shorelineFreq;
|
|
float temp_shorelineScale;
|
|
float temp_shorelineSpeed;
|
|
float temp_shorelineNorm;
|
|
float temp_overallBright;
|
|
float temp_overallTransparency;
|
|
float temp_edgeAmt;
|
|
float temp_depthAmt;
|
|
float temp_shallowAmt;
|
|
float temp_refractStrength;
|
|
float temp_aberrationScale;
|
|
float temp_causticsFade;
|
|
float temp_reflectProjection;
|
|
float temp_reflectBlur;
|
|
float temp_reflectTerm;
|
|
float temp_reflectSharpen;
|
|
float temp_roughness;
|
|
float temp_roughness2;
|
|
float temp_foamScale;
|
|
float temp_foamSpeed;
|
|
float temp_edgeFoamAmt;
|
|
float temp_shallowFoamAmt;
|
|
float temp_heightFoamAmt;
|
|
float temp_hFoamHeight;
|
|
float temp_hFoamSpread;
|
|
float temp_underLightFactor;
|
|
float temp_underRefractionAmount;
|
|
float temp_underRefractionScale;
|
|
float temp_underRefractionSpeed;
|
|
float temp_underBlurAmount;
|
|
float temp_underwaterFogDist;
|
|
float temp_underwaterFogSpread;
|
|
float temp_underDarkRange;
|
|
|
|
|
|
public string materialPath;
|
|
public float oceanUseScale;
|
|
public float useSc;
|
|
public Vector2 setSc;
|
|
public Vector2 scaleOff;
|
|
public int i;
|
|
public string layerName;
|
|
public Material skybox;
|
|
|
|
[System.NonSerialized] public List<string> presetDirsArr = new List<string>();
|
|
public int d;
|
|
public int dn;
|
|
[System.NonSerialized] public List<string> presetFilesArr = new List<string>();
|
|
public string pdir;
|
|
public FileInfo[] fileInfo;
|
|
public int f = 0;
|
|
public int px = 0;
|
|
public int nx = 0;
|
|
public int ax = 0;
|
|
public int n = 0;
|
|
|
|
[System.NonSerialized] public List<string> tempPresetDirsArr = new List<string>();
|
|
public FileInfo[] dirInfo;
|
|
public string[] tempPresetDirs;
|
|
[System.NonSerialized] public List<string> tempPresetFilesArr = new List<string>();
|
|
public string[] tempPresetFiles;
|
|
public string oldName;
|
|
public string moveName;
|
|
public int setNum;
|
|
|
|
public StreamWriter sw;
|
|
public StreamReader sr;
|
|
public string key;
|
|
public string dat;
|
|
public int pFrom;
|
|
public int pTo;
|
|
public int dx;
|
|
public TextAsset datFile;
|
|
public string[] dataS;
|
|
public string retData;
|
|
public bool retVal;
|
|
|
|
private float suimono_refl_off = 0.0f;
|
|
private float suimono_refl_sky = 0.0f;
|
|
private float suimono_refl_cube = 0.0f;
|
|
private float suimono_refl_color = 0.0f;
|
|
|
|
private static bool reloadData = false;
|
|
|
|
|
|
void Start(){
|
|
|
|
//DISCONNECT FROM PREFAB
|
|
#if UNITY_EDITOR
|
|
#if !UNITY_2018_3_OR_NEWER
|
|
PrefabUtility.DisconnectPrefabInstance(this.gameObject);
|
|
#endif
|
|
#endif
|
|
|
|
|
|
//get Suimono objects
|
|
if (GameObject.Find("SUIMONO_Module") != null){
|
|
|
|
moduleObject = (Suimono.Core.SuimonoModule) FindObjectOfType(typeof(Suimono.Core.SuimonoModule));
|
|
//moduleObject = GameObject.Find("SUIMONO_Module").GetComponent<Suimono.Core.SuimonoModule>() as Suimono.Core.SuimonoModule;
|
|
if (moduleObject != null) suimonoModuleLibrary = moduleObject.GetComponent<Suimono.Core.SuimonoModuleLib>() as Suimono.Core.SuimonoModuleLib;
|
|
}
|
|
|
|
|
|
|
|
//SET PRESET DIRECTORIES
|
|
#if UNITY_EDITOR
|
|
|
|
// Original Find Resources
|
|
baseDir = "SUIMONO - WATER SYSTEM 2/RESOURCES/";
|
|
|
|
// Find Presets regardless of moved directory
|
|
/*
|
|
string basePath = AssetDatabase.GetAssetPath(moduleObject.suimonoModuleLibrary.surfaceObject);
|
|
basePath = basePath.Replace("Assets/", "");
|
|
string[] splitstring = basePath.Split(new string[] {"/PREFABS"}, System.StringSplitOptions.None);
|
|
baseDir = splitstring[0] + "/RESOURCES/";
|
|
*/
|
|
|
|
#else
|
|
baseDir = "Resources/";
|
|
#endif
|
|
|
|
dir = Path.Combine(Application.dataPath, baseDir);
|
|
|
|
|
|
|
|
//get surface objects
|
|
suimonoObject = this.transform.Find("Suimono_Object").gameObject;
|
|
surfaceRenderer = transform.Find("Suimono_Object").gameObject.GetComponent<Renderer>();
|
|
surfaceMesh = transform.Find("Suimono_Object").GetComponent<MeshFilter>();
|
|
surfaceCollider = transform.Find("Suimono_Object").GetComponent<MeshCollider>();
|
|
surfaceReflections = transform.Find("cam_LocalReflections").gameObject.GetComponent<Suimono.Core.cameraTools>() as Suimono.Core.cameraTools;
|
|
surfaceReflBlur = transform.Find("cam_LocalReflections").gameObject.GetComponent<Suimono.Core.Suimono_DistanceBlur>() as Suimono.Core.Suimono_DistanceBlur;
|
|
|
|
//get scale object (infinite ocean)
|
|
scaleObject = this.transform.Find("Suimono_ObjectScale").gameObject;
|
|
scaleRenderer = transform.Find("Suimono_ObjectScale").gameObject.GetComponent<Renderer>();
|
|
scaleCollider = transform.Find("Suimono_ObjectScale").gameObject.GetComponent<MeshCollider>();
|
|
if (scaleCollider == null){
|
|
scaleCollider = transform.Find("Suimono_ObjectScale").gameObject.AddComponent<MeshCollider>();
|
|
}
|
|
scaleMesh = transform.Find("Suimono_ObjectScale").GetComponent<MeshFilter>();
|
|
|
|
//Store Shader References
|
|
shader_Surface = Shader.Find("Suimono2/surface");
|
|
shader_Scale = Shader.Find("Suimono2/surface_scale");
|
|
shader_Under = Shader.Find("Suimono2/surface_under");
|
|
|
|
//save material if not already saved
|
|
//#if UNITY_EDITOR
|
|
//materialPath = "Assets/SUIMONO - WATER SYSTEM 2/Resources/mat_" + this.gameObject.name + ".mat";
|
|
//if (AssetDatabase.LoadAssetAtPath(materialPath,Material) == null){
|
|
// tempMaterial = new Material(suimonoObject.GetComponent<Renderer>().sharedMaterial);
|
|
// AssetDatabase.CreateAsset(tempMaterial, materialPath);
|
|
//}
|
|
//tempMaterial = AssetDatabase.LoadAssetAtPath(materialPath,Material);
|
|
//#else
|
|
//tempMaterial = new Material(suimonoObject.GetComponent<Renderer>().sharedMaterial);
|
|
tempMaterial = new Material(suimonoModuleLibrary.materialSurface);
|
|
//#endif
|
|
|
|
//setup custom material surface
|
|
if (suimonoObject != null){
|
|
tempMaterial.shader = shader_Surface;
|
|
suimonoObject.GetComponent<Renderer>().sharedMaterial = tempMaterial;
|
|
surfaceRenderer = transform.Find("Suimono_Object").gameObject.GetComponent<Renderer>();
|
|
}
|
|
|
|
//Load initial scene data
|
|
ReloadData();
|
|
}
|
|
|
|
|
|
|
|
|
|
#if UNITY_EDITOR
|
|
//Check for scene reload and set flag
|
|
[UnityEditor.Callbacks.DidReloadScripts]
|
|
private static void ReloadDataFlag(){
|
|
reloadData = true;
|
|
}
|
|
#endif
|
|
|
|
|
|
void OnEnable()
|
|
{
|
|
if (Application.isPlaying){
|
|
if (moduleObject == null){
|
|
moduleObject = (Suimono.Core.SuimonoModule) FindObjectOfType(typeof(Suimono.Core.SuimonoModule));
|
|
}
|
|
if (moduleObject != null){
|
|
moduleObject.RegisterSurface(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnDisable()
|
|
{
|
|
if (Application.isPlaying){
|
|
if (moduleObject == null){
|
|
moduleObject = (Suimono.Core.SuimonoModule) FindObjectOfType(typeof(Suimono.Core.SuimonoModule));
|
|
}
|
|
if (moduleObject != null){
|
|
moduleObject.DeregisterSurface(this);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
void ReloadData(){
|
|
reloadData = false;
|
|
|
|
//Set Layer Masks
|
|
#if UNITY_EDITOR
|
|
suiLayerMasks = new List<string>();
|
|
for (i = 0; i < 32; i++){
|
|
layerName = LayerMask.LayerToName(i);
|
|
suiLayerMasks.Add(layerName);
|
|
}
|
|
#endif
|
|
|
|
//Init Presets
|
|
#if !UNITY_WEBPLAYER && UNITY_EDITOR
|
|
PresetInit();
|
|
PresetLoad(presetIndex);
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
void LateUpdate () {
|
|
|
|
if (moduleObject != null){
|
|
|
|
//-------------------------------------------------------
|
|
//### SET SUIMONO VERSION ###
|
|
//-------------------------------------------------------
|
|
//inherit suimono version number from module object for display in UI elements
|
|
suimonoVersionNumber = moduleObject.suimonoVersionNumber;
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### RELOAD TEMPORARY DATA ###
|
|
//-------------------------------------------------------
|
|
if (reloadData) ReloadData();
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### SET LOCAL TIME AND DIRECTION ###
|
|
//-------------------------------------------------------
|
|
systemLocalTime = moduleObject.systemTime;
|
|
localTime = systemLocalTime * flowSpeed * (1.0f/waveScale);
|
|
flow_dir = SuimonoConvertAngleToVector(flowDirection);
|
|
|
|
if (surfaceRenderer != null){
|
|
surfaceRenderer.sharedMaterial.SetVector("_suimono_Dir",new Vector4(flow_dir.x,1.0f,flow_dir.y,localTime));
|
|
}
|
|
|
|
//-------------------------------------------------------
|
|
//### SET LAYER MASK ###
|
|
//-------------------------------------------------------
|
|
if (moduleObject.autoSetLayers){
|
|
gameObject.layer = moduleObject.layerWaterNum;
|
|
if (suimonoObject != null) suimonoObject.layer = moduleObject.layerWaterNum;
|
|
if (scaleObject != null) scaleObject.layer = moduleObject.layerWaterNum;
|
|
if (surfaceReflections != null) surfaceReflections.gameObject.layer = moduleObject.layerWaterNum;
|
|
}
|
|
|
|
//-------------------------------------------------------
|
|
//### FORCE SIZING ###
|
|
//-------------------------------------------------------
|
|
if (underwaterDepth < 0.1f) underwaterDepth = 0.1f;
|
|
if (!enableCustomMesh){
|
|
transform.localScale = new Vector3(transform.localScale.x, 1.0f, transform.localScale.z);
|
|
}
|
|
if (typeIndex == 0){
|
|
suimonoObject.transform.localScale = new Vector3(suimonoObject.transform.localScale.x, 1.0f, suimonoObject.transform.localScale.z);
|
|
scaleObject.transform.localScale = new Vector3(scaleObject.transform.localScale.x, 1.0f, scaleObject.transform.localScale.z);
|
|
surfaceReflections.transform.localScale = new Vector3(surfaceReflections.transform.localScale.x, 1.0f, surfaceReflections.transform.localScale.z);
|
|
}
|
|
|
|
//-------------------------------------------------------
|
|
//### CALCULATE BEAUFORT SCALE ###
|
|
//-------------------------------------------------------
|
|
useBeaufortScale = !customWaves;
|
|
if (useBeaufortScale){
|
|
beaufortVal = beaufortScale/12.0f;
|
|
turbulenceFactor = Mathf.Clamp(Mathf.Lerp(-0.1f,2.1f,beaufortVal)*0.9f,0.0f,0.75f);
|
|
waveHeight = Mathf.Clamp(Mathf.Lerp(0.0f,5.0f,beaufortVal),0.0f,0.65f);
|
|
waveHeight = waveHeight - Mathf.Clamp(Mathf.Lerp(-1.5f,1.0f,beaufortVal),0.0f,0.5f);
|
|
lgWaveHeight = Mathf.Clamp(Mathf.Lerp(-0.2f,1.1f,beaufortVal)*2.8f,0.0f,3.0f);
|
|
|
|
//freeze scale for ocean
|
|
if (typeIndex == 0){
|
|
waveScale = 0.5f;
|
|
lgWaveScale = 0.03125f;
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### LOAD PRESET CHANGES ###
|
|
//-------------------------------------------------------
|
|
#if UNITY_EDITOR
|
|
// detect changes to preset and run update when applicable
|
|
if (presetUseIndex != presetIndex){
|
|
presetUseIndex = presetIndex;
|
|
PresetLoad(presetIndex);
|
|
}
|
|
// reload preset settings when editor mode is switched between simple and advanced.
|
|
if (editorUseIndex != editorIndex){
|
|
editorUseIndex = editorIndex;
|
|
PresetLoad(presetIndex);
|
|
}
|
|
#endif
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### HANDLE PRESET TRANSITIONS ###
|
|
//-------------------------------------------------------
|
|
if (presetStartTransition){
|
|
if (presetTimer >= 1.0f){
|
|
presetStartTransition = false;
|
|
} else {
|
|
presetTimer += (Time.deltaTime / presetTransitionTime);
|
|
PresetLoadBuild(currentPresetFolder,currentPresetName);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### SET MESH LOD LEVEL ###
|
|
//-------------------------------------------------------
|
|
// change the surface mesh based on the selected level of detail
|
|
if (typeIndex == 0) useLodIndex = 0; //infinite ocean requires high detail mesh
|
|
if (typeIndex == 1) useLodIndex = lodIndex; //3d waves setting picks mesh set in UI
|
|
if (typeIndex == 2) useLodIndex = 3; // flat surface forces single quad mesh
|
|
|
|
if (typeIndex == 0) enableCustomMesh = false; // force custom mesh off when using infinite ocean
|
|
if (enableCustomMesh == false){
|
|
if (suimonoModuleLibrary && !meshWasSet){
|
|
if (suimonoModuleLibrary.texNormalC && surfaceMesh != null) surfaceMesh.mesh = suimonoModuleLibrary.meshLevel[useLodIndex];
|
|
if (suimonoModuleLibrary.texNormalC && surfaceCollider != null) surfaceCollider.sharedMesh = suimonoModuleLibrary.meshLevel[3];
|
|
meshWasSet = true;
|
|
} else {
|
|
meshWasSet = false;
|
|
}
|
|
} else {
|
|
if (customMesh != null){
|
|
if (surfaceMesh != null) surfaceMesh.mesh = customMesh;
|
|
if (surfaceCollider != null) surfaceCollider.sharedMesh = customMesh;
|
|
} else {
|
|
if (suimonoModuleLibrary.texNormalC && surfaceMesh != null) surfaceMesh.mesh = suimonoModuleLibrary.meshLevel[useLodIndex];
|
|
if (suimonoModuleLibrary.texNormalC && surfaceCollider != null) surfaceCollider.sharedMesh = suimonoModuleLibrary.meshLevel[3];
|
|
meshWasSet = false;
|
|
}
|
|
}
|
|
if (useLodIndex == 3){
|
|
useHeightProjection = 0.0f;
|
|
useEnableTess = false;
|
|
} else {
|
|
useHeightProjection = heightProjection;
|
|
useEnableTess = enableTess;
|
|
}
|
|
|
|
//set mesh UV scale
|
|
Shader.SetGlobalFloat("cmScaleX", enableCustomMesh ? cmScaleX : 1f);
|
|
Shader.SetGlobalFloat("cmScaleY", enableCustomMesh ? cmScaleY : 1f);
|
|
|
|
//set scale mesh
|
|
if (suimonoModuleLibrary != null && suimonoModuleLibrary.texNormalC && scaleMesh != null) scaleMesh.mesh = suimonoModuleLibrary.meshLevel[1];
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### Set Custom Textures ###
|
|
//-------------------------------------------------------
|
|
if (enableCustomTextures){
|
|
if (customTexNormal1 != null){
|
|
useTexNormal1 = customTexNormal1;
|
|
} else {
|
|
useTexNormal1 = suimonoModuleLibrary.texNormalC;
|
|
}
|
|
//if (customTexHeight1 != null){
|
|
// useTexHeight1 = customTexHeight1;
|
|
// } else {
|
|
// useTexHeight1 = suimonoModuleLibrary.texHeightC;
|
|
// }
|
|
if (customTexNormal2 != null){
|
|
useTexNormal2 = customTexNormal2;
|
|
} else {
|
|
useTexNormal2 = suimonoModuleLibrary.texNormalT;
|
|
}
|
|
//if (customTexHeight2 != null){
|
|
// useTexHeight2 = customTexHeight2;
|
|
// } else {
|
|
// useTexHeight2 = suimonoModuleLibrary.texHeightT;
|
|
// }
|
|
if (customTexNormal3 != null){
|
|
useTexNormal3 = customTexNormal3;
|
|
} else {
|
|
useTexNormal3 = suimonoModuleLibrary.texNormalR;
|
|
}
|
|
//if (customTexHeight3 != null){
|
|
// useTexHeight3 = customTexHeight3;
|
|
// } else {
|
|
// useTexHeight3 = suimonoModuleLibrary.texHeightR;
|
|
// }
|
|
|
|
} else {
|
|
if (suimonoModuleLibrary != null){
|
|
useTexNormal1 = suimonoModuleLibrary.texNormalC;
|
|
//useTexHeight1 = suimonoModuleLibrary.texHeightC;
|
|
useTexNormal2 = suimonoModuleLibrary.texNormalT;
|
|
//useTexHeight2 = suimonoModuleLibrary.texHeightT;
|
|
useTexNormal3 = suimonoModuleLibrary.texNormalR;
|
|
//useTexHeight3 = suimonoModuleLibrary.texHeightR;
|
|
}
|
|
}
|
|
if (suimonoModuleLibrary != null){
|
|
if (surfaceRenderer != null) surfaceRenderer.sharedMaterial.SetTexture("_MaskTex",suimonoModuleLibrary.texMask);
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### SET REFLECTION OBJECT PROPERTIES ###
|
|
//-------------------------------------------------------
|
|
if (surfaceReflections != null && moduleObject != null){
|
|
|
|
useEnableReflections = enableReflections;
|
|
useEnableDynamicReflections = enableDynamicReflections;
|
|
|
|
if (!moduleObject.enableReflections) useEnableReflections = false;
|
|
if (!moduleObject.enableDynamicReflections) useEnableDynamicReflections = false;
|
|
|
|
if (!useEnableReflections || !moduleObject.enableReflections){
|
|
useReflections = false;
|
|
surfaceReflections.gameObject.SetActive(false);
|
|
} else {
|
|
|
|
if (!useEnableDynamicReflections || !moduleObject.enableDynamicReflections){
|
|
surfaceReflections.gameObject.SetActive(false);
|
|
} else {
|
|
surfaceReflections.gameObject.SetActive(true);
|
|
useReflections = true;
|
|
reflectLayer = (reflectLayer & ~(1 << moduleObject.layerWaterNum));
|
|
reflectLayer = (reflectLayer & ~(1 << moduleObject.layerDepthNum));
|
|
reflectLayer = (reflectLayer & ~(1 << moduleObject.layerScreenFXNum));
|
|
|
|
surfaceReflections.setLayers = reflectLayer;
|
|
surfaceReflections.resolution = System.Convert.ToInt32(resolutions[reflectResolution]);
|
|
if (moduleObject.setCameraComponent != null){
|
|
reflectionDistance = moduleObject.setCameraComponent.farClipPlane+200.0f;
|
|
}
|
|
surfaceReflections.reflectionDistance = reflectionDistance;
|
|
|
|
//blur settings
|
|
surfaceReflBlur.blurAmt = reflectBlur;
|
|
|
|
if (useShader == shader_Under){
|
|
surfaceReflections.isUnderwater = true;
|
|
} else {
|
|
surfaceReflections.isUnderwater = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### SEND SETTINGS TO SHADER ###
|
|
//-------------------------------------------------------
|
|
if (surfaceRenderer != null){
|
|
|
|
//set shader
|
|
if (Application.isPlaying && useShader != null){
|
|
if (currUseShader != useShader){
|
|
currUseShader = useShader;
|
|
surfaceRenderer.sharedMaterial.shader = currUseShader;
|
|
}
|
|
}
|
|
|
|
//set playmode
|
|
if (!Application.isPlaying){
|
|
surfaceRenderer.sharedMaterial.SetFloat("_isPlaying",0.0f);
|
|
} else {
|
|
surfaceRenderer.sharedMaterial.SetFloat("_isPlaying",1.0f);
|
|
}
|
|
|
|
//set texture
|
|
surfaceRenderer.sharedMaterial.SetTexture("_NormalTexS",useTexNormal1);
|
|
surfaceRenderer.sharedMaterial.SetTexture("_NormalTexD",useTexNormal2);
|
|
surfaceRenderer.sharedMaterial.SetTexture("_NormalTexR",useTexNormal3);
|
|
|
|
//set beaufort and waves
|
|
surfaceRenderer.sharedMaterial.SetFloat("_beaufortFlag",useBeaufortScale ? 1.0f : 0.0f);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_beaufortScale",beaufortVal);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_turbulenceFactor",turbulenceFactor);
|
|
|
|
//custom UV scaling
|
|
float useXScale = enableCustomMesh ? cmScaleX : 1f;
|
|
float useYScale = enableCustomMesh ? cmScaleY : 1f;
|
|
|
|
//set texture speed and scale
|
|
surfaceRenderer.sharedMaterial.SetTextureScale("_NormalTexS",new Vector2(((suimonoObject.transform.localScale.x/waveScale)*transform.localScale.x) * useXScale,((suimonoObject.transform.localScale.z/waveScale)*transform.localScale.z)*useYScale));
|
|
surfaceRenderer.sharedMaterial.SetVector("_scaleUVs",new Vector4((suimonoObject.transform.localScale.x/waveScale) * useXScale,(suimonoObject.transform.localScale.z/waveScale) * useYScale,0f,0f));
|
|
surfaceRenderer.sharedMaterial.SetFloat("_lgWaveScale",lgWaveScale);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_lgWaveHeight",lgWaveHeight);
|
|
|
|
//set tessellation settings
|
|
if (typeIndex == 0){
|
|
surfaceRenderer.sharedMaterial.SetFloat("_tessScale",suimonoObject.transform.localScale.x);
|
|
} else {
|
|
surfaceRenderer.sharedMaterial.SetFloat("_tessScale",transform.localScale.x);
|
|
}
|
|
surfaceRenderer.sharedMaterial.SetFloat("_Tess",Mathf.Lerp(0.001f,waveTessAmt,useEnableTess ? 1.0f : 0.0f));
|
|
surfaceRenderer.sharedMaterial.SetFloat("_minDist", Mathf.Lerp(-180.0f,0.0f,waveTessMin));
|
|
surfaceRenderer.sharedMaterial.SetFloat("_maxDist", Mathf.Lerp(20.0f,500.0f,waveTessSpread));
|
|
|
|
//set system fog coordinates
|
|
surfaceRenderer.sharedMaterial.SetFloat("_unity_fogstart",RenderSettings.fogStartDistance);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_unity_fogend",RenderSettings.fogEndDistance);
|
|
|
|
//set caustics
|
|
surfaceRenderer.sharedMaterial.SetFloat("_causticsFlag",enableCausticFX ? 1.0f : 0.0f);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_CausticsFade",Mathf.Lerp(1f,500f,causticsFade));
|
|
surfaceRenderer.sharedMaterial.SetColor("_CausticsColor",causticsColor);
|
|
|
|
//set aberration scale
|
|
surfaceRenderer.sharedMaterial.SetFloat("_aberrationScale",aberrationScale);
|
|
|
|
//set foam speed and scale
|
|
surfaceRenderer.sharedMaterial.SetFloat("_enableFoam", enableFoam ? 1.0f : 0.0f );
|
|
surfaceRenderer.sharedMaterial.SetFloat("_EdgeFoamFade",Mathf.Lerp(1500.0f,5.0f,edgeFoamAmt));
|
|
surfaceRenderer.sharedMaterial.SetFloat("_HeightFoamAmt",heightFoamAmt);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_HeightFoamHeight",hFoamHeight);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_HeightFoamSpread",hFoamSpread);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_foamSpeed",foamSpeed);
|
|
surfaceRenderer.sharedMaterial.SetTextureScale("_FoamTex",foamScale* new Vector2(((suimonoObject.transform.localScale.x/foamScale)*transform.localScale.x)*useXScale,((suimonoObject.transform.localScale.z/foamScale)*transform.localScale.z)*useYScale));
|
|
surfaceRenderer.sharedMaterial.SetFloat("_foamScale",Mathf.Lerp(160.0f,1.0f,foamScale));
|
|
surfaceRenderer.sharedMaterial.SetColor("_FoamColor",foamColor);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_ShallowFoamAmt",shallowFoamAmt);
|
|
|
|
//set height and normal scales
|
|
surfaceRenderer.sharedMaterial.SetFloat("_heightScaleFac",(1.0f/transform.localScale.y));
|
|
surfaceRenderer.sharedMaterial.SetFloat("_heightProjection",useHeightProjection);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_heightScale",waveHeight);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_RefractStrength",refractStrength);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_ReflectStrength",reflectProjection);
|
|
|
|
//set shoreline properties
|
|
surfaceRenderer.sharedMaterial.SetFloat("_shorelineHeight",shorelineHeight);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_shorelineFrequency",shorelineFreq);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_shorelineScale",0.1f);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_shorelineSpeed",shorelineSpeed);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_shorelineNorm",shorelineNorm);
|
|
|
|
//set physical properties
|
|
surfaceRenderer.sharedMaterial.SetFloat("_specularPower",specularPower);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_roughness",roughness);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_roughness2",roughness2);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_reflecTerm",reflectTerm);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_reflecSharp",Mathf.Lerp(0.0f,-1.5f,reflectSharpen));
|
|
|
|
|
|
//set surface settings
|
|
surfaceRenderer.sharedMaterial.SetFloat("_overallBrightness", overallBright);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_overallTransparency", overallTransparency);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_DepthFade",Mathf.Lerp(0.1f,200.0f,depthAmt));
|
|
surfaceRenderer.sharedMaterial.SetFloat("_ShallowFade",Mathf.Lerp(0.1f,800.0f,shallowAmt));
|
|
surfaceRenderer.sharedMaterial.SetColor("_depthColor",depthColor);
|
|
surfaceRenderer.sharedMaterial.SetColor("_shallowColor",shallowColor);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_EdgeFade", Mathf.Lerp(10.0f,1000.0f,edgeAmt));
|
|
surfaceRenderer.sharedMaterial.SetColor("_SpecularColor",specularColor);
|
|
surfaceRenderer.sharedMaterial.SetColor("_SSSColor",sssColor);
|
|
surfaceRenderer.sharedMaterial.SetColor("_BlendColor",blendColor);
|
|
surfaceRenderer.sharedMaterial.SetColor("_OverlayColor",overlayColor);
|
|
surfaceRenderer.sharedMaterial.SetColor("_UnderwaterColor",underwaterColor);
|
|
|
|
//set reflection properties
|
|
surfaceRenderer.sharedMaterial.SetFloat("_reflectFlag",useEnableReflections ? 1.0f : 0.0f);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_reflectDynamicFlag",useEnableDynamicReflections ? 1.0f : 0.0f);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_reflectFallback", reflectFallback);
|
|
surfaceRenderer.sharedMaterial.SetColor("_reflectFallbackColor", customRefColor);
|
|
surfaceRenderer.sharedMaterial.SetColor("_ReflectionColor", reflectionColor);
|
|
|
|
//set skybox texture
|
|
skybox = RenderSettings.skybox;
|
|
if(skybox != null && skybox.HasProperty("_Tex") && skybox.HasProperty("_Tint") && skybox.HasProperty("_Exposure") && skybox.HasProperty("_Rotation")){
|
|
surfaceRenderer.sharedMaterial.SetTexture("_SkyCubemap",skybox.GetTexture("_Tex"));
|
|
surfaceRenderer.sharedMaterial.SetColor("_SkyTint", skybox.GetColor("_Tint"));
|
|
surfaceRenderer.sharedMaterial.SetFloat("_SkyExposure", skybox.GetFloat("_Exposure"));
|
|
surfaceRenderer.sharedMaterial.SetFloat("_SkyRotation", skybox.GetFloat("_Rotation"));
|
|
}
|
|
|
|
//set custom cubemap
|
|
if (customRefCubemap != null)
|
|
surfaceRenderer.sharedMaterial.SetTexture("_CubeTex", customRefCubemap);
|
|
|
|
//set camera properties
|
|
surfaceRenderer.sharedMaterial.SetFloat("_cameraDistance",cameraDistance);
|
|
|
|
|
|
//Force shoreline foam scale
|
|
Vector2 setWaveTiling = new Vector2(1f, 10f);
|
|
surfaceRenderer.sharedMaterial.SetTextureScale("_WaveTex", setWaveTiling);
|
|
scaleRenderer.sharedMaterial.SetTextureScale("_WaveTex", setWaveTiling);
|
|
|
|
|
|
/*
|
|
//-------------------------------------------------------
|
|
//### SET SHADER DEFINE KEYWORDS ###
|
|
//-------------------------------------------------------
|
|
if (surfaceRenderer != null){
|
|
surfaceRenderer.sharedMaterial.DisableKeyword("SUIMONO_TESS_ON");
|
|
surfaceRenderer.sharedMaterial.DisableKeyword("SUIMONO_TRANS_ON");
|
|
surfaceRenderer.sharedMaterial.DisableKeyword("SUIMONO_CAUST_ON");
|
|
surfaceRenderer.sharedMaterial.DisableKeyword("SUIMONO_DYNREFL_ON");
|
|
if (enableTess) surfaceRenderer.sharedMaterial.EnableKeyword("SUIMONO_TESS_ON");
|
|
if (moduleObject.enableTransparency) surfaceRenderer.sharedMaterial.EnableKeyword("SUIMONO_TRANS_ON");
|
|
if (moduleObject.enableCaustics) surfaceRenderer.sharedMaterial.EnableKeyword("SUIMONO_CAUST_ON");
|
|
if (useDynReflections) surfaceRenderer.sharedMaterial.EnableKeyword("SUIMONO_DYNREFL_ON");
|
|
|
|
surfaceRenderer.sharedMaterial.DisableKeyword("SUIMONO_REFL_OFF");
|
|
surfaceRenderer.sharedMaterial.DisableKeyword("SUIMONO_REFL_SKY");
|
|
surfaceRenderer.sharedMaterial.DisableKeyword("SUIMONO_REFL_CUBE");
|
|
surfaceRenderer.sharedMaterial.DisableKeyword("SUIMONO_REFL_COLOR");
|
|
if (reflectFallback == 0) surfaceRenderer.sharedMaterial.EnableKeyword("SUIMONO_REFL_OFF");
|
|
if (reflectFallback == 1) surfaceRenderer.sharedMaterial.EnableKeyword("SUIMONO_REFL_SKY");
|
|
if (reflectFallback == 2) surfaceRenderer.sharedMaterial.EnableKeyword("SUIMONO_REFL_CUBE");
|
|
if (reflectFallback == 3) surfaceRenderer.sharedMaterial.EnableKeyword("SUIMONO_REFL_COLOR");
|
|
|
|
//surfaceRenderer.sharedMaterial.DisableKeyword("SUIMONO_FOAM_ON");
|
|
//if (Application.isPlaying && enableFoam) surfaceRenderer.sharedMaterial.EnableKeyword("SUIMONO_FOAM_ON");
|
|
}
|
|
|
|
if (scaleRenderer != null && typeIndex == 0){
|
|
scaleRenderer.sharedMaterial.DisableKeyword("SUIMONO_TESS_ON");
|
|
scaleRenderer.sharedMaterial.DisableKeyword("SUIMONO_TRANS_ON");
|
|
scaleRenderer.sharedMaterial.DisableKeyword("SUIMONO_CAUST_ON");
|
|
scaleRenderer.sharedMaterial.DisableKeyword("SUIMONO_DYNREFL_ON");
|
|
if (enableTess) scaleRenderer.sharedMaterial.EnableKeyword("SUIMONO_TESS_ON");
|
|
if (moduleObject.enableTransparency) scaleRenderer.sharedMaterial.EnableKeyword("SUIMONO_TRANS_ON");
|
|
if (moduleObject.enableCaustics) scaleRenderer.sharedMaterial.EnableKeyword("SUIMONO_CAUST_ON");
|
|
if (useDynReflections) scaleRenderer.sharedMaterial.EnableKeyword("SUIMONO_DYNREFL_ON");
|
|
|
|
scaleRenderer.sharedMaterial.DisableKeyword("SUIMONO_REFL_OFF");
|
|
scaleRenderer.sharedMaterial.DisableKeyword("SUIMONO_REFL_SKY");
|
|
scaleRenderer.sharedMaterial.DisableKeyword("SUIMONO_REFL_CUBE");
|
|
scaleRenderer.sharedMaterial.DisableKeyword("SUIMONO_REFL_COLOR");
|
|
if (reflectFallback == 0) scaleRenderer.sharedMaterial.EnableKeyword("SUIMONO_REFL_OFF");
|
|
if (reflectFallback == 1) scaleRenderer.sharedMaterial.EnableKeyword("SUIMONO_REFL_SKY");
|
|
if (reflectFallback == 2) scaleRenderer.sharedMaterial.EnableKeyword("SUIMONO_REFL_CUBE");
|
|
if (reflectFallback == 3) scaleRenderer.sharedMaterial.EnableKeyword("SUIMONO_REFL_COLOR");
|
|
|
|
//scaleRenderer.sharedMaterial.DisableKeyword("SUIMONO_FOAM_ON");
|
|
//if (Application.isPlaying && enableFoam) scaleRenderer.sharedMaterial.EnableKeyword("SUIMONO_FOAM_ON");
|
|
|
|
}
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### SET SHADER BRANCH KEYS ###
|
|
//-------------------------------------------------------
|
|
|
|
suimono_refl_off = 0.0f;
|
|
suimono_refl_sky = 0.0f;
|
|
suimono_refl_cube = 0.0f;
|
|
suimono_refl_color = 0.0f;
|
|
if (reflectFallback == 0) suimono_refl_off = 1.0f;
|
|
if (reflectFallback == 1) suimono_refl_sky = 1.0f;
|
|
if (reflectFallback == 2) suimono_refl_cube = 1.0f;
|
|
if (reflectFallback == 3) suimono_refl_color = 1.0f;
|
|
|
|
if (surfaceRenderer != null){
|
|
surfaceRenderer.sharedMaterial.SetFloat("suimono_tess_on", enableTess?1.0f:0.0f);
|
|
surfaceRenderer.sharedMaterial.SetFloat("suimono_trans_on", moduleObject.enableTransparency?1.0f:0.0f);
|
|
surfaceRenderer.sharedMaterial.SetFloat("suimono_caust_on", moduleObject.enableCaustics?1.0f:0.0f);
|
|
surfaceRenderer.sharedMaterial.SetFloat("suimono_dynrefl_on", useDynReflections?1.0f:0.0f);
|
|
surfaceRenderer.sharedMaterial.SetFloat("suimono_refl_off", suimono_refl_off);
|
|
surfaceRenderer.sharedMaterial.SetFloat("suimono_refl_sky", suimono_refl_sky);
|
|
surfaceRenderer.sharedMaterial.SetFloat("suimono_refl_cube", suimono_refl_cube);
|
|
surfaceRenderer.sharedMaterial.SetFloat("suimono_refl_color", suimono_refl_color);
|
|
}
|
|
|
|
if (scaleRenderer != null && typeIndex == 0){
|
|
scaleRenderer.sharedMaterial.SetFloat("suimono_tess_on", enableTess?1.0f:0.0f);
|
|
scaleRenderer.sharedMaterial.SetFloat("suimono_trans_on", moduleObject.enableTransparency?1.0f:0.0f);
|
|
scaleRenderer.sharedMaterial.SetFloat("suimono_caust_on", moduleObject.enableCaustics?1.0f:0.0f);
|
|
scaleRenderer.sharedMaterial.SetFloat("suimono_dynrefl_on", useDynReflections?1.0f:0.0f);
|
|
scaleRenderer.sharedMaterial.SetFloat("suimono_refl_off", suimono_refl_off);
|
|
scaleRenderer.sharedMaterial.SetFloat("suimono_refl_sky", suimono_refl_sky);
|
|
scaleRenderer.sharedMaterial.SetFloat("suimono_refl_cube", suimono_refl_cube);
|
|
scaleRenderer.sharedMaterial.SetFloat("suimono_refl_color", suimono_refl_color);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### enable / disable infinite scale surface ###
|
|
//-------------------------------------------------------
|
|
if (typeIndex == 0 && Application.isPlaying){
|
|
if (moduleObject.isUnderwater){
|
|
if (scaleRenderer != null) scaleRenderer.enabled = false;
|
|
if (scaleCollider != null) scaleCollider.enabled = false;
|
|
|
|
} else {
|
|
if (scaleRenderer != null) scaleRenderer.enabled = true;
|
|
if (scaleCollider != null) scaleCollider.enabled = true;
|
|
}
|
|
} else {
|
|
if (scaleRenderer != null) scaleRenderer.enabled = false;
|
|
if (scaleCollider != null) scaleCollider.enabled = false;
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### set position and rotation for infinite ocean ###
|
|
//-------------------------------------------------------
|
|
if (Application.isPlaying){
|
|
if (typeIndex == 0){
|
|
|
|
//force rotation
|
|
transform.eulerAngles = new Vector3(transform.eulerAngles.x, 0.0f, transform.eulerAngles.z);
|
|
|
|
//calculate scales
|
|
if (oceanScale < 1.0f) oceanScale = 1.0f;
|
|
offamt = (0.4027f * oceanScale)/waveScale;
|
|
spacer = (suimonoObject.transform.localScale.x * 4.0f);
|
|
if (moduleObject.setCamera != null) newPos = new Vector3(moduleObject.setCamera.position.x,suimonoObject.transform.position.y,moduleObject.setCamera.position.z);
|
|
if (Mathf.Abs(suimonoObject.transform.position.x - newPos.x) > spacer){
|
|
if (suimonoObject.transform.position.x > newPos.x) setScaleX -= offamt;
|
|
if (suimonoObject.transform.position.x < newPos.x) setScaleX += offamt;
|
|
suimonoObject.transform.position = new Vector3(newPos.x,suimonoObject.transform.position.y, suimonoObject.transform.position.z);
|
|
scaleObject.transform.position = new Vector3(newPos.x, scaleObject.transform.position.y, scaleObject.transform.position.z);
|
|
}
|
|
if (Mathf.Abs(suimonoObject.transform.position.z - newPos.z) > spacer){
|
|
if (suimonoObject.transform.position.z > newPos.z) setScaleZ -= offamt;
|
|
if (suimonoObject.transform.position.z < newPos.z) setScaleZ += offamt;
|
|
suimonoObject.transform.position = new Vector3(suimonoObject.transform.position.x, suimonoObject.transform.position.y, newPos.z);
|
|
scaleObject.transform.position = new Vector3(scaleObject.transform.position.x, scaleObject.transform.position.y, newPos.z);
|
|
}
|
|
|
|
//update position
|
|
if (currentPosition != suimonoObject.transform.position){
|
|
currentPosition = suimonoObject.transform.position;
|
|
savePos = new Vector2(setScaleX,setScaleZ);
|
|
}
|
|
|
|
//set shader offset
|
|
surfaceRenderer.sharedMaterial.SetFloat("_suimono_uvx",0.0f-(savePos.x));
|
|
surfaceRenderer.sharedMaterial.SetFloat("_suimono_uvy",0.0f-(savePos.y));
|
|
|
|
//set scale object offset
|
|
scaleObject.transform.localPosition = new Vector3(scaleObject.transform.localPosition.x, -0.1f, scaleObject.transform.localPosition.z);
|
|
|
|
//set infinite ocean object scaling
|
|
if (scaleRenderer != null && moduleObject.setCameraComponent != null){
|
|
setScale = Mathf.Ceil(moduleObject.setCameraComponent.farClipPlane/20.0f)*suimonoObject.transform.localScale.x;
|
|
scaleObject.transform.localScale = new Vector3(setScale*0.5f,1.0f,setScale*0.5f);
|
|
|
|
oceanUseScale = 4.0f;
|
|
this.transform.localScale = new Vector3(1f,1f,1f);
|
|
suimonoObject.transform.localScale = new Vector3(oceanUseScale*oceanScale,1.0f,oceanUseScale*oceanScale);
|
|
|
|
//copy shader settings to infinite scale surface
|
|
if (scaleRenderer != null){
|
|
scaleRenderer.material.CopyPropertiesFromMaterial(tempMaterial);
|
|
scaleRenderer.sharedMaterial.SetFloat("_suimono_uvx",0.0f-savePos.x);
|
|
scaleRenderer.sharedMaterial.SetFloat("_suimono_uvy",0.0f-savePos.y);
|
|
|
|
setSc = scaleRenderer.sharedMaterial.GetTextureScale("_NormalTexS");
|
|
|
|
useSc = (scaleObject.transform.localScale.x/suimonoObject.transform.localScale.x);
|
|
scaleRenderer.sharedMaterial.SetTextureScale("_NormalTexS", setSc*useSc);
|
|
scaleRenderer.sharedMaterial.SetTextureScale("_FoamTex", setSc*useSc);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
} else {
|
|
savePos = new Vector3(0f,0f,0f);
|
|
suimonoObject.transform.localScale = new Vector3(1f,1f,1f);
|
|
scaleObject.transform.localScale = new Vector3(1f,1f,1f);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_suimono_uvx",0.0f);
|
|
surfaceRenderer.sharedMaterial.SetFloat("_suimono_uvy",0.0f);
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### Set Debug Modes ###
|
|
//-------------------------------------------------------
|
|
if (surfaceRenderer != null){
|
|
if (showDepthMask){
|
|
surfaceRenderer.sharedMaterial.SetFloat("_suimono_DebugDepthMask",1.0f);
|
|
} else {
|
|
surfaceRenderer.sharedMaterial.SetFloat("_suimono_DebugDepthMask",0.0f);
|
|
}
|
|
|
|
if (showWorldMask){
|
|
surfaceRenderer.sharedMaterial.SetFloat("_suimono_DebugWorldNormalMask",1.0f);
|
|
} else {
|
|
surfaceRenderer.sharedMaterial.SetFloat("_suimono_DebugWorldNormalMask",0.0f);
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------
|
|
//### Update Preset Listing ###
|
|
//-------------------------------------------------------
|
|
#if UNITY_EDITOR
|
|
if (presetFileUseIndex != presetFileIndex){
|
|
presetFileUseIndex = presetFileIndex;
|
|
PresetInit();
|
|
}
|
|
#endif
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
public Vector2 SuimonoConvertAngleToVector(float convertAngle){
|
|
flow_dir = new Vector2(0f,0f);
|
|
tempAngle = new Vector3(0f,0f,0f);
|
|
if (convertAngle <= 180.0f){
|
|
tempAngle = Vector3.Slerp(Vector3.forward,-Vector3.forward,(convertAngle)/180.0f);
|
|
flow_dir = new Vector2(tempAngle.x,tempAngle.z);
|
|
}
|
|
if (convertAngle > 180.0f){
|
|
tempAngle = Vector3.Slerp(-Vector3.forward,Vector3.forward,(convertAngle-180.0f)/180.0f);
|
|
flow_dir = new Vector2(-tempAngle.x,tempAngle.z);
|
|
}
|
|
|
|
return flow_dir;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
// ########## PUBLIC FUNCTIONS #######################################################################################################################
|
|
|
|
public void SuimonoSetPreset( string fName, string pName){
|
|
presetTimer = 1f;
|
|
SetTemporaryPresetData();
|
|
PresetLoadBuild(fName,pName);
|
|
}
|
|
|
|
|
|
|
|
public void SuimonoSavePreset( string fName, string pName){
|
|
int setFolder = -1;
|
|
int setPreset = -1;
|
|
|
|
setFolder = PresetGetNum("folder",fName);
|
|
setPreset = PresetGetNum("preset",pName);
|
|
|
|
if (setFolder >= 0 && setPreset >= 0){
|
|
PresetSave(setFolder,setPreset);
|
|
} else {
|
|
Debug.Log("The Preset "+pName+" in folder "+fName+" cannot be found!");
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//########### NEW PRESETS #########################################################################################################################
|
|
void PresetInit(){
|
|
|
|
presetTimer = 1f;
|
|
|
|
#if !UNITY_WEBPLAYER
|
|
|
|
//get preset directories
|
|
presetDirsArr = new List<string>();
|
|
dirInfo = new DirectoryInfo(dir+"/").GetFiles("SUIMONO_PRESETS_*");
|
|
if (new DirectoryInfo(dir+"/") != null){
|
|
for (d = 0; d < dirInfo.Length; d++){
|
|
presetDirsArr.Add(dirInfo[d].ToString());
|
|
}
|
|
}
|
|
presetDirs = new List<string>(new string[presetDirsArr.Count]);
|
|
for (dn = 0; dn < presetDirsArr.Count; dn++){
|
|
presetDirs[dn] = presetDirsArr[dn].ToString();
|
|
presetDirs[dn] = presetDirs[dn].Remove(0,dir.Length);
|
|
presetDirs[dn] = presetDirs[dn].Replace("SUIMONO_PRESETS_","");
|
|
presetDirs[dn] = presetDirs[dn].Replace(".meta","");
|
|
}
|
|
|
|
|
|
//get preset files listing
|
|
presetFilesArr = new List<string>();
|
|
pdir = dir + "/SUIMONO_PRESETS_"+presetDirs[presetFileIndex];
|
|
|
|
fileInfo = new DirectoryInfo(pdir).GetFiles("SUIMONO_PRESET_*");
|
|
if (new DirectoryInfo(pdir) != null){
|
|
for (f = 0; f < fileInfo.Length; f++){
|
|
presetFilesArr.Add(fileInfo[f].ToString());
|
|
}
|
|
}
|
|
px = 0;
|
|
for (nx = 0; nx < presetFilesArr.Count; nx++){
|
|
if (!presetFilesArr[nx].ToString().Contains(".meta")) px++;
|
|
}
|
|
presetFiles = new string[px];
|
|
ax = 0;
|
|
for (n = 0; n < presetFilesArr.Count; n++){
|
|
if (!presetFilesArr[n].ToString().Contains(".meta")){
|
|
presetFiles[ax] = presetFilesArr[n].ToString();
|
|
presetFiles[ax] = presetFiles[ax].Remove(0,pdir.Length);
|
|
presetFiles[ax] = presetFiles[ax].Replace("SUIMONO_PRESET_","");
|
|
presetFiles[ax] = presetFiles[ax].Replace(".txt","");
|
|
ax++;
|
|
}
|
|
}
|
|
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public int PresetGetNum( string mode, string pName){
|
|
|
|
int setMode = -1;
|
|
int setFolder = -1;
|
|
int setPreset = -1;
|
|
|
|
#if !UNITY_WEBPLAYER
|
|
|
|
if (mode == "folder"){
|
|
//get preset directories
|
|
tempPresetDirsArr = new List<string>();
|
|
dirInfo = new DirectoryInfo(dir+"/").GetFiles("SUIMONO_PRESETS_*");
|
|
if (new DirectoryInfo(dir+"/") != null){
|
|
for (d = 0; d < dirInfo.Length; d++){
|
|
tempPresetDirsArr.Add(dirInfo[d].ToString());
|
|
}
|
|
}
|
|
tempPresetDirs = new string[tempPresetDirsArr.Count];
|
|
for (dn = 0; dn < tempPresetDirsArr.Count; dn++){
|
|
tempPresetDirs[dn] = tempPresetDirsArr[dn].ToString();
|
|
tempPresetDirs[dn] = tempPresetDirs[dn].Remove(0,dir.Length);
|
|
tempPresetDirs[dn] = tempPresetDirs[dn].Replace("SUIMONO_PRESETS_","");
|
|
tempPresetDirs[dn] = tempPresetDirs[dn].Replace(".meta","");
|
|
if (tempPresetDirs[dn] == pName) setFolder = dn;
|
|
}
|
|
setMode = setFolder;
|
|
}
|
|
|
|
if (mode == "preset"){
|
|
//get preset files listing
|
|
tempPresetFilesArr = new List<string>();
|
|
pdir = dir + "/SUIMONO_PRESETS_"+presetDirs[presetFileIndex];
|
|
fileInfo = new DirectoryInfo(pdir).GetFiles("SUIMONO_PRESET_*");
|
|
if (new DirectoryInfo(pdir) != null){
|
|
for (f = 0; f < fileInfo.Length; f++){
|
|
tempPresetFilesArr.Add(fileInfo[f].ToString());
|
|
}
|
|
}
|
|
px = 0;
|
|
for (nx = 0; nx < tempPresetFilesArr.Count; nx++){
|
|
if (!tempPresetFilesArr[nx].ToString().Contains(".meta")) px++;
|
|
}
|
|
tempPresetFiles = new string[px];
|
|
ax = 0;
|
|
for (n = 0; n < tempPresetFilesArr.Count; n++){
|
|
if (!tempPresetFilesArr[n].ToString().Contains(".meta")){
|
|
tempPresetFiles[ax] = tempPresetFilesArr[n].ToString();
|
|
tempPresetFiles[ax] = tempPresetFiles[ax].Remove(0,pdir.Length);
|
|
tempPresetFiles[ax] = tempPresetFiles[ax].Replace("SUIMONO_PRESET_","");
|
|
tempPresetFiles[ax] = tempPresetFiles[ax].Replace(".txt","");
|
|
if (tempPresetFiles[ax] == pName) setPreset = ax;
|
|
ax++;
|
|
}
|
|
}
|
|
setMode = setPreset;
|
|
}
|
|
|
|
#endif
|
|
|
|
return setMode;
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public void PresetRename( int ppos, string newName){
|
|
#if UNITY_EDITOR
|
|
#if !UNITY_WEBPLAYER
|
|
pdir = dir + "/SUIMONO_PRESETS_"+presetDirs[presetFileIndex];
|
|
oldName = pdir+"/SUIMONO_PRESET_"+presetFiles[ppos]+".txt";
|
|
moveName = pdir+"/SUIMONO_PRESET_"+newName+".txt";
|
|
File.Move(oldName,moveName);
|
|
AssetDatabase.Refresh();
|
|
PresetInit();
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
|
|
public void PresetAdd(){
|
|
#if UNITY_EDITOR
|
|
#if !UNITY_WEBPLAYER
|
|
setNum = presetFiles.Length;
|
|
pdir = dir + "/SUIMONO_PRESETS_"+presetDirs[presetFileIndex];
|
|
while (File.Exists(pdir+"/SUIMONO_PRESET_New Preset "+setNum+".txt")){
|
|
setNum += 1;
|
|
}
|
|
if (presetFiles.Length >= 1){
|
|
File.Create(pdir+"/SUIMONO_PRESET_New Preset "+setNum+".txt").Close();
|
|
} else {
|
|
File.Create(pdir+"/SUIMONO_PRESET_New Preset 1.txt").Close();
|
|
setNum = 1;
|
|
}
|
|
AssetDatabase.Refresh();
|
|
PresetInit();
|
|
SuimonoSavePreset(presetDirs[presetFileIndex],"New Preset "+setNum);
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
|
|
public void PresetDelete( int fpos, int ppos ){
|
|
#if UNITY_EDITOR
|
|
#if !UNITY_WEBPLAYER
|
|
pdir = dir + "/SUIMONO_PRESETS_"+presetDirs[fpos];
|
|
if (File.Exists(pdir+"/SUIMONO_PRESET_"+presetFiles[ppos]+".txt")){
|
|
File.Delete(pdir+"/SUIMONO_PRESET_"+presetFiles[ppos]+".txt");
|
|
if (presetIndex == ppos) presetIndex = -1;
|
|
}
|
|
AssetDatabase.Refresh();
|
|
PresetInit();
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
|
|
public void PresetSave( int fpos, int ppos ){
|
|
#if UNITY_EDITOR
|
|
#if !UNITY_WEBPLAYER
|
|
pdir = dir + "/SUIMONO_PRESETS_"+presetDirs[fpos];
|
|
if (File.Exists(pdir+"/SUIMONO_PRESET_"+presetFiles[ppos]+".txt")){
|
|
|
|
//Caclulate data
|
|
presetDataString = "";
|
|
presetDataString += (PresetEncode("color_depth")) + "\n";
|
|
presetDataString += (PresetEncode("color_shallow")) + "\n";
|
|
presetDataString += (PresetEncode("color_blend")) + "\n";
|
|
presetDataString += (PresetEncode("color_overlay")) + "\n";
|
|
presetDataString += (PresetEncode("color_caustics")) + "\n";
|
|
presetDataString += (PresetEncode("color_reflection")) + "\n";
|
|
presetDataString += (PresetEncode("color_specular")) + "\n";
|
|
presetDataString += (PresetEncode("color_sss")) + "\n";
|
|
presetDataString += (PresetEncode("color_foam")) + "\n";
|
|
presetDataString += (PresetEncode("color_underwater")) + "\n";
|
|
presetDataString += (PresetEncode("data_beaufort")) + "\n";
|
|
presetDataString += (PresetEncode("data_flowdir")) + "\n";
|
|
presetDataString += (PresetEncode("data_flowspeed")) + "\n";
|
|
presetDataString += (PresetEncode("data_wavescale")) + "\n";
|
|
presetDataString += (PresetEncode("data_customwaves")) + "\n";
|
|
presetDataString += (PresetEncode("data_waveheight")) + "\n";
|
|
presetDataString += (PresetEncode("data_heightprojection")) + "\n";
|
|
presetDataString += (PresetEncode("data_turbulence")) + "\n";
|
|
presetDataString += (PresetEncode("data_lgwaveheight")) + "\n";
|
|
presetDataString += (PresetEncode("data_lgwavescale")) + "\n";
|
|
presetDataString += (PresetEncode("data_shorelineheight")) + "\n";
|
|
presetDataString += (PresetEncode("data_shorelinefreq")) + "\n";
|
|
presetDataString += (PresetEncode("data_shorelinescale")) + "\n";
|
|
presetDataString += (PresetEncode("data_shorelinespeed")) + "\n";
|
|
presetDataString += (PresetEncode("data_shorelinenorm")) + "\n";
|
|
presetDataString += (PresetEncode("data_overallbright")) + "\n";
|
|
presetDataString += (PresetEncode("data_overalltransparency")) + "\n";
|
|
presetDataString += (PresetEncode("data_edgeamt")) + "\n";
|
|
presetDataString += (PresetEncode("data_depthamt")) + "\n";
|
|
presetDataString += (PresetEncode("data_shallowamt")) + "\n";
|
|
presetDataString += (PresetEncode("data_refractstrength")) + "\n";
|
|
presetDataString += (PresetEncode("data_aberrationscale")) + "\n";
|
|
presetDataString += (PresetEncode("data_causticsfade")) + "\n";
|
|
presetDataString += (PresetEncode("data_reflectprojection")) + "\n";
|
|
presetDataString += (PresetEncode("data_reflectblur")) + "\n";
|
|
presetDataString += (PresetEncode("data_reflectterm")) + "\n";
|
|
presetDataString += (PresetEncode("data_reflectsharpen")) + "\n";
|
|
presetDataString += (PresetEncode("data_roughness")) + "\n";
|
|
presetDataString += (PresetEncode("data_roughness2")) + "\n";
|
|
presetDataString += (PresetEncode("data_enablefoam")) + "\n";
|
|
presetDataString += (PresetEncode("data_foamscale")) + "\n";
|
|
presetDataString += (PresetEncode("data_foamspeed")) + "\n";
|
|
presetDataString += (PresetEncode("data_edgefoamamt")) + "\n";
|
|
presetDataString += (PresetEncode("data_shallowfoamamt")) + "\n";
|
|
presetDataString += (PresetEncode("data_heightfoamamt")) + "\n";
|
|
presetDataString += (PresetEncode("data_hfoamheight")) + "\n";
|
|
presetDataString += (PresetEncode("data_hfoamspread")) + "\n";
|
|
presetDataString += (PresetEncode("data_enableunderdebris")) + "\n";
|
|
presetDataString += (PresetEncode("data_underlightfactor")) + "\n";
|
|
presetDataString += (PresetEncode("data_underrefractionamount")) + "\n";
|
|
presetDataString += (PresetEncode("data_underrefractionscale")) + "\n";
|
|
presetDataString += (PresetEncode("data_underrefractionspeed")) + "\n";
|
|
presetDataString += (PresetEncode("data_underbluramount")) + "\n";
|
|
presetDataString += (PresetEncode("data_underwaterfogdist")) + "\n";
|
|
presetDataString += (PresetEncode("data_underwaterfogspread")) + "\n";
|
|
presetDataString += (PresetEncode("data_underDarkRange")) + "\n";
|
|
|
|
//save data
|
|
sw = new StreamWriter(pdir+"/SUIMONO_PRESET_"+presetFiles[ppos]+".txt");
|
|
sw.AutoFlush = true;
|
|
sw.Write(presetDataString);
|
|
sw.Close();
|
|
|
|
Debug.Log("Preset '"+presetFiles[ppos]+"' has been saved!");
|
|
}
|
|
#endif
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
|
|
public void PresetLoad( int ppos ){
|
|
if (presetIndex >= 0){
|
|
pdir = dir + "/SUIMONO_PRESETS_"+presetDirs[presetFileIndex];
|
|
sr = new StreamReader(pdir+"/SUIMONO_PRESET_"+presetFiles[ppos]+".txt");
|
|
presetDataString = sr.ReadToEnd();
|
|
sr.Close();
|
|
|
|
presetDataArray = presetDataString.Split("\n"[0]);
|
|
|
|
//Decode Data
|
|
for (dx = 0; dx < presetDataArray.Length; dx++){
|
|
if (presetDataArray[dx] != "" && presetDataArray[dx] != "\n"){
|
|
pFrom = presetDataArray[dx].IndexOf("<") + "<".Length;
|
|
pTo = presetDataArray[dx].LastIndexOf(">");
|
|
key = presetDataArray[dx].Substring(pFrom, pTo - pFrom);
|
|
|
|
pFrom = presetDataArray[dx].IndexOf("(") + "(".Length;
|
|
pTo = presetDataArray[dx].LastIndexOf(")");
|
|
dat = presetDataArray[dx].Substring(pFrom, pTo - pFrom);
|
|
|
|
SetTemporaryPresetData();
|
|
PresetDecode(key,dat);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
void PresetLoadBuild( string fName, string pName ){
|
|
#if !UNITY_WEBPLAYER
|
|
datFile = Resources.Load("SUIMONO_PRESETS_"+fName+"/SUIMONO_PRESET_"+pName) as TextAsset;
|
|
presetDataString = datFile.text;
|
|
presetDataArray = presetDataString.Split("\n"[0]);
|
|
|
|
//Decode Data
|
|
for (dx = 0; dx < presetDataArray.Length; dx++){
|
|
if (presetDataArray[dx] != "" && presetDataArray[dx] != "\n"){
|
|
pFrom = presetDataArray[dx].IndexOf("<") + "<".Length;
|
|
pTo = presetDataArray[dx].LastIndexOf(">");
|
|
key = presetDataArray[dx].Substring(pFrom, pTo - pFrom);
|
|
|
|
pFrom = presetDataArray[dx].IndexOf("(") + "(".Length;
|
|
pTo = presetDataArray[dx].LastIndexOf(")");
|
|
dat = presetDataArray[dx].Substring(pFrom, pTo - pFrom);
|
|
|
|
PresetDecode(key,dat);
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
|
|
void PresetDecode( string key, string dat ){
|
|
dataS = dat.Split(","[0]);
|
|
|
|
if (presetTimer > 1f) presetTimer = 1f;
|
|
|
|
if (key == "color_depth") depthColor = Color.Lerp(temp_depthColor, DecodeColor(dataS), presetTimer);
|
|
if (key == "color_shallow") shallowColor = Color.Lerp(temp_shallowColor, DecodeColor(dataS), presetTimer);
|
|
if (key == "color_blend") blendColor = Color.Lerp(temp_blendColor, DecodeColor(dataS), presetTimer);
|
|
if (key == "color_overlay") overlayColor = Color.Lerp(temp_overlayColor, DecodeColor(dataS), presetTimer);
|
|
if (key == "color_caustics") causticsColor = Color.Lerp(temp_causticsColor, DecodeColor(dataS), presetTimer);
|
|
if (key == "color_reflection") reflectionColor = Color.Lerp(temp_reflectionColor, DecodeColor(dataS), presetTimer);
|
|
if (key == "color_specular") specularColor = Color.Lerp(temp_specularColor, DecodeColor(dataS), presetTimer);
|
|
if (key == "color_sss") sssColor = Color.Lerp(temp_sssColor, DecodeColor(dataS), presetTimer);
|
|
if (key == "color_foam") foamColor = Color.Lerp(temp_foamColor, DecodeColor(dataS), presetTimer);
|
|
if (key == "color_underwater") underwaterColor = Color.Lerp(temp_underwaterColor, DecodeColor(dataS), presetTimer);
|
|
|
|
if (key == "data_beaufort") beaufortScale = Mathf.Lerp(temp_beaufortScale, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_flowdir") flowDirection = Mathf.Lerp(temp_flowDirection, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_flowspeed") flowSpeed = Mathf.Lerp(temp_flowSpeed, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_wavescale") waveScale = Mathf.Lerp(temp_waveScale, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_waveheight") waveHeight = Mathf.Lerp(temp_waveHeight, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_heightprojection") heightProjection = Mathf.Lerp(temp_heightProjection, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_turbulence") turbulenceFactor = Mathf.Lerp(temp_turbulenceFactor, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_lgwaveheight") lgWaveHeight = Mathf.Lerp(temp_lgWaveHeight, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_lgwavescale") lgWaveScale = Mathf.Lerp(temp_lgWaveScale, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_shorelineheight") shorelineHeight = Mathf.Lerp(temp_shorelineHeight, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_shorelinefreq") shorelineFreq = Mathf.Lerp(temp_shorelineFreq, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_shorelinescale") shorelineScale = Mathf.Lerp(temp_shorelineScale, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_shorelinespeed") shorelineSpeed = Mathf.Lerp(temp_shorelineSpeed, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_shorelinenorm") shorelineNorm = Mathf.Lerp(temp_shorelineNorm, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_overallbright") overallBright = Mathf.Lerp(temp_overallBright, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_overalltransparency") overallTransparency = Mathf.Lerp(temp_overallTransparency, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_edgeamt") edgeAmt = Mathf.Lerp(temp_edgeAmt, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_depthamt") depthAmt = Mathf.Lerp(temp_depthAmt, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_shallowamt") shallowAmt = Mathf.Lerp(temp_shallowAmt, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_refractstrength") refractStrength = Mathf.Lerp(temp_refractStrength, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_aberrationscale") aberrationScale = Mathf.Lerp(temp_aberrationScale, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_causticsfade") causticsFade = Mathf.Lerp(temp_causticsFade, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_reflectprojection") reflectProjection = Mathf.Lerp(temp_reflectProjection, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_reflectblur") reflectBlur = Mathf.Lerp(temp_reflectBlur, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_reflectterm") reflectTerm = Mathf.Lerp(temp_reflectTerm, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_reflectsharpen") reflectSharpen = Mathf.Lerp(temp_reflectSharpen, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_roughness") roughness = Mathf.Lerp(temp_roughness, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_roughness2") roughness2 = Mathf.Lerp(temp_roughness2, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_foamscale") foamScale = Mathf.Lerp(temp_foamScale, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_foamspeed") foamSpeed = Mathf.Lerp(temp_foamSpeed, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_edgefoamamt") edgeFoamAmt = Mathf.Lerp(temp_edgeFoamAmt, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_shallowfoamamt") shallowFoamAmt = Mathf.Lerp(temp_shallowFoamAmt, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_heightfoamamt") heightFoamAmt = Mathf.Lerp(temp_heightFoamAmt, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_hfoamheight") hFoamHeight = Mathf.Lerp(temp_hFoamHeight, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_hfoamspread") hFoamSpread = Mathf.Lerp(temp_hFoamSpread, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_underlightfactor") underLightFactor = Mathf.Lerp(temp_underLightFactor, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_underrefractionamount") underRefractionAmount = Mathf.Lerp(temp_underRefractionAmount, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_underrefractionscale") underRefractionScale = Mathf.Lerp(temp_underRefractionScale, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_underrefractionspeed") underRefractionSpeed = Mathf.Lerp(temp_underRefractionSpeed, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_underbluramount") underBlurAmount = Mathf.Lerp(temp_underBlurAmount, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_underwaterfogdist") underwaterFogDist = Mathf.Lerp(temp_underwaterFogDist, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_underwaterfogspread") underwaterFogSpread = Mathf.Lerp(temp_underwaterFogSpread, DecodeFloat(dataS), presetTimer);
|
|
if (key == "data_underDarkRange") underDarkRange = Mathf.Lerp(temp_underDarkRange, DecodeFloat(dataS), presetTimer);
|
|
|
|
if (key == "data_customwaves") customWaves = DecodeBool(dataS);
|
|
if (key == "data_enablefoam") enableFoam = DecodeBool(dataS);
|
|
if (key == "data_enableunderdebris") enableUnderDebris = DecodeBool(dataS);
|
|
}
|
|
|
|
|
|
public Color DecodeColor(string[] data){
|
|
return new Color(DecodeSingleFloat(data[0]), DecodeSingleFloat( data[1]), DecodeSingleFloat( data[2]), DecodeSingleFloat( data[3]));
|
|
}
|
|
public float DecodeFloat(string[] data){
|
|
return DecodeSingleFloat(data[0]);
|
|
}
|
|
|
|
public int DecodeInt(string[] data){
|
|
return int.Parse(data[0]);
|
|
}
|
|
public bool DecodeBool(string[] data){
|
|
retVal = false;
|
|
if (data[0] == "True") retVal = true;
|
|
return retVal;
|
|
}
|
|
|
|
public float DecodeSingleFloat( string data ) {
|
|
return float.Parse( data,
|
|
System.Globalization.NumberStyles.Float,
|
|
System.Globalization.CultureInfo.InvariantCulture );
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
public string PresetEncode( string key ){
|
|
retData = "";
|
|
|
|
if (key == "color_depth") retData = EncodeColor( depthColor );
|
|
if (key == "color_shallow") retData = EncodeColor( shallowColor );
|
|
if (key == "color_blend") retData = EncodeColor( blendColor );
|
|
if (key == "color_overlay") retData = EncodeColor( overlayColor );
|
|
if (key == "color_caustics") retData = EncodeColor( causticsColor );
|
|
if (key == "color_reflection") retData = EncodeColor( reflectionColor );
|
|
if (key == "color_specular") retData = EncodeColor( specularColor );
|
|
if (key == "color_sss") retData = EncodeColor( sssColor );
|
|
if (key == "color_foam") retData = EncodeColor( foamColor );
|
|
if (key == "color_underwater") retData = EncodeColor( underwaterColor );
|
|
if (key == "data_customwaves") retData = "(" + customWaves.ToString().Replace( " ", "" ) + ")";
|
|
if (key == "data_enableunderdebris") retData = "(" + enableUnderDebris.ToString().Replace( " ", "" ) + ")";
|
|
if (key == "data_enablefoam") retData = "(" + enableFoam.ToString().Replace( " ", "" ) + ")";
|
|
if (key == "data_beaufort") retData = "("+EncodeSingleFloat( beaufortScale )+")";
|
|
if (key == "data_flowdir") retData = "("+EncodeSingleFloat( flowDirection )+")";
|
|
if (key == "data_flowspeed") retData = "("+EncodeSingleFloat( flowSpeed )+")";
|
|
if (key == "data_wavescale") retData = "("+EncodeSingleFloat( waveScale )+")";
|
|
if (key == "data_waveheight") retData = "("+EncodeSingleFloat( waveHeight )+")";
|
|
if (key == "data_heightprojection") retData = "("+EncodeSingleFloat( heightProjection )+")";
|
|
if (key == "data_turbulence") retData = "("+EncodeSingleFloat( turbulenceFactor )+")";
|
|
if (key == "data_lgwaveheight") retData = "("+EncodeSingleFloat( lgWaveHeight )+")";
|
|
if (key == "data_lgwavescale") retData = "("+EncodeSingleFloat( lgWaveScale )+")";
|
|
if (key == "data_shorelineheight") retData = "("+EncodeSingleFloat( shorelineHeight )+")";
|
|
if (key == "data_shorelinefreq") retData = "("+EncodeSingleFloat( shorelineFreq )+")";
|
|
if (key == "data_shorelinescale") retData = "("+EncodeSingleFloat( shorelineScale )+")";
|
|
if (key == "data_shorelinespeed") retData = "("+EncodeSingleFloat( shorelineSpeed )+")";
|
|
if (key == "data_shorelinenorm") retData = "("+EncodeSingleFloat( shorelineNorm )+")";
|
|
if (key == "data_overallbright") retData = "("+EncodeSingleFloat( overallBright )+")";
|
|
if (key == "data_overalltransparency") retData = "("+EncodeSingleFloat( overallTransparency )+")";
|
|
if (key == "data_edgeamt") retData = "("+EncodeSingleFloat( edgeAmt )+")";
|
|
if (key == "data_depthamt") retData = "("+EncodeSingleFloat( depthAmt )+")";
|
|
if (key == "data_shallowamt") retData = "("+EncodeSingleFloat( shallowAmt )+")";
|
|
if (key == "data_refractstrength") retData = "("+EncodeSingleFloat( refractStrength )+")";
|
|
if (key == "data_aberrationscale") retData = "("+EncodeSingleFloat( aberrationScale )+")";
|
|
if (key == "data_causticsfade") retData = "("+EncodeSingleFloat( causticsFade )+")";
|
|
if (key == "data_reflectprojection") retData = "("+EncodeSingleFloat( reflectProjection )+")";
|
|
if (key == "data_reflectblur") retData = "("+EncodeSingleFloat( reflectBlur )+")";
|
|
if (key == "data_reflectterm") retData = "("+EncodeSingleFloat( reflectTerm )+")";
|
|
if (key == "data_reflectsharpen") retData = "("+EncodeSingleFloat( reflectSharpen )+")";
|
|
if (key == "data_roughness") retData = "("+EncodeSingleFloat( roughness )+")";
|
|
if (key == "data_roughness2") retData = "("+EncodeSingleFloat( roughness2 )+")";
|
|
if (key == "data_foamscale") retData = "("+EncodeSingleFloat( foamScale )+")";
|
|
if (key == "data_foamspeed") retData = "("+EncodeSingleFloat( foamSpeed )+")";
|
|
if (key == "data_edgefoamamt") retData = "("+EncodeSingleFloat( edgeFoamAmt )+")";
|
|
if (key == "data_shallowfoamamt") retData = "("+EncodeSingleFloat( shallowFoamAmt )+")";
|
|
if (key == "data_heightfoamamt") retData = "("+EncodeSingleFloat( heightFoamAmt )+")";
|
|
if (key == "data_hfoamheight") retData = "("+EncodeSingleFloat( hFoamHeight )+")";
|
|
if (key == "data_hfoamspread") retData = "("+EncodeSingleFloat( hFoamSpread )+")";
|
|
if (key == "data_underlightfactor") retData = "("+EncodeSingleFloat( underLightFactor )+")";
|
|
if (key == "data_underrefractionamount") retData = "("+EncodeSingleFloat( underRefractionAmount )+")";
|
|
if (key == "data_underrefractionscale") retData = "("+EncodeSingleFloat( underRefractionScale )+")";
|
|
if (key == "data_underrefractionspeed") retData = "("+EncodeSingleFloat( underRefractionSpeed )+")";
|
|
if (key == "data_underbluramount") retData = "("+EncodeSingleFloat( underBlurAmount )+")";
|
|
if (key == "data_underwaterfogdist") retData = "("+EncodeSingleFloat( underwaterFogDist )+")";
|
|
if (key == "data_underwaterfogspread") retData = "("+EncodeSingleFloat( underwaterFogSpread )+")";
|
|
if (key == "data_underDarkRange") retData = "("+EncodeSingleFloat( underDarkRange )+")";
|
|
|
|
retData = "<"+key+">" + retData;
|
|
return retData;
|
|
}
|
|
|
|
|
|
public string EncodeSingleFloat( float data ) {
|
|
return data.ToString( System.Globalization.CultureInfo.InvariantCulture );
|
|
}
|
|
|
|
public string EncodeColor( Color data ) {
|
|
return string.Format( "({0},{1},{2},{3})", EncodeSingleFloat( data.r ), EncodeSingleFloat( data.g ), EncodeSingleFloat( data.b ), EncodeSingleFloat( data.a ) );
|
|
}
|
|
|
|
|
|
|
|
|
|
//PRESET TRANSITION FUNCTION OPTIONS:
|
|
|
|
//Option 1: (string)preset name, (float)transition time in seconds
|
|
//it is assumed that preset is in the "Built-In Presets" folder.
|
|
public void SuimonoTransitionPreset(string pName, float transitionTime){
|
|
presetTimer = 0f;
|
|
presetTransitionTime = transitionTime;
|
|
presetStartTransition = true;
|
|
currentPresetFolder = "Built-In Presets";
|
|
currentPresetName = pName;
|
|
SetTemporaryPresetData();
|
|
}
|
|
//Option 2: (string)preset folder name, (string)preset name, (float)transition time in seconds
|
|
//For accessing presets in a custom folder name.
|
|
public void SuimonoTransitionPreset(string fName, string pName, float transitionTime){
|
|
presetTimer = 0f;
|
|
presetTransitionTime = transitionTime;
|
|
presetStartTransition = true;
|
|
currentPresetFolder = fName;
|
|
currentPresetName = pName;
|
|
SetTemporaryPresetData();
|
|
}
|
|
//Option 3: (string)preset folder name, (string)from preset name, (string)to preset name, (float)transition time in seconds
|
|
//For transitioning directly from one preset to another, when presets are in same folder.
|
|
public void SuimonoTransitionPreset(string fName, string pName0, string pName1, float transitionTime){
|
|
SuimonoSetPreset(fName, pName0);
|
|
presetTimer = 0f;
|
|
presetTransitionTime = transitionTime;
|
|
presetStartTransition = true;
|
|
currentPresetFolder = fName;
|
|
currentPresetName = pName1;
|
|
SetTemporaryPresetData();
|
|
}
|
|
//Option 4: (string)from preset folder name, (string)from preset name, (string)to preset folder name, (string)to preset name, (float)transition time in seconds
|
|
//For transitioning directly from one preset to another, when presets are in different folders.
|
|
public void SuimonoTransitionPreset(string fName0, string pName0, string fName1, string pName1, float transitionTime){
|
|
SuimonoSetPreset(fName0, pName0);
|
|
presetTimer = 0f;
|
|
presetTransitionTime = transitionTime;
|
|
presetStartTransition = true;
|
|
currentPresetFolder = fName1;
|
|
currentPresetName = pName1;
|
|
SetTemporaryPresetData();
|
|
}
|
|
|
|
|
|
|
|
//Caches current data for usage in lerping preset transitions
|
|
void SetTemporaryPresetData(){
|
|
|
|
temp_depthColor = depthColor;
|
|
temp_shallowColor = shallowColor;
|
|
temp_blendColor = blendColor;
|
|
temp_overlayColor = overlayColor;
|
|
temp_causticsColor = causticsColor;
|
|
temp_reflectionColor = reflectionColor;
|
|
temp_specularColor = specularColor;
|
|
temp_sssColor = sssColor;
|
|
temp_foamColor = foamColor;
|
|
temp_underwaterColor = underwaterColor;
|
|
|
|
temp_beaufortScale = beaufortScale;
|
|
temp_flowDirection = flowDirection;
|
|
temp_flowSpeed = flowSpeed;
|
|
temp_waveScale = waveScale;
|
|
temp_waveHeight = waveHeight;
|
|
temp_heightProjection = heightProjection;
|
|
temp_turbulenceFactor = turbulenceFactor;
|
|
temp_lgWaveHeight = lgWaveHeight;
|
|
temp_lgWaveScale = lgWaveScale;
|
|
temp_shorelineHeight = shorelineHeight;
|
|
temp_shorelineFreq = shorelineFreq;
|
|
temp_shorelineScale = shorelineScale;
|
|
temp_shorelineSpeed = shorelineSpeed;
|
|
temp_shorelineNorm = shorelineNorm;
|
|
temp_overallBright = overallBright;
|
|
temp_overallTransparency = overallTransparency;
|
|
temp_edgeAmt = edgeAmt;
|
|
temp_depthAmt = depthAmt;
|
|
temp_shallowAmt = shallowAmt;
|
|
temp_refractStrength = refractStrength;
|
|
temp_aberrationScale = aberrationScale;
|
|
temp_causticsFade = causticsFade;
|
|
temp_reflectProjection = reflectProjection;
|
|
temp_reflectBlur = reflectBlur;
|
|
temp_reflectTerm = reflectTerm;
|
|
temp_reflectSharpen = reflectSharpen;
|
|
temp_roughness = roughness;
|
|
temp_roughness2 = roughness2;
|
|
temp_foamScale = foamScale;
|
|
temp_foamSpeed = foamSpeed;
|
|
temp_edgeFoamAmt = edgeFoamAmt;
|
|
temp_shallowFoamAmt = shallowFoamAmt;
|
|
temp_heightFoamAmt = heightFoamAmt;
|
|
temp_hFoamHeight = hFoamHeight;
|
|
temp_hFoamSpread = hFoamSpread;
|
|
temp_underLightFactor = underLightFactor;
|
|
temp_underRefractionAmount = underRefractionAmount;
|
|
temp_underRefractionScale = underRefractionScale;
|
|
temp_underRefractionSpeed = underRefractionSpeed;
|
|
temp_underBlurAmount = underBlurAmount;
|
|
temp_underwaterFogDist = underwaterFogDist;
|
|
temp_underwaterFogSpread = underwaterFogSpread;
|
|
temp_underDarkRange = underDarkRange;
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
} |