ssadmin
/
siege-song
1
0
Fork 0
Code Issues Pull Requests 1 Projects Releases Wiki Activity
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.
master
fix
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from 'd55df21e82'
${ noResults }
siege-song/Data/Assets/SUIMONO - WATER SYSTEM 2/SCRIPTS/SuimonoModule.cs

1744 lines
57 KiB
C#
Raw Normal View History Unescape Escape

Initial files
4 years ago
using UnityEngine;
using System.Collections;
using System.Collections.Generic;
#if UNITY_EDITOR
using UnityEditor;
#endif
namespace Suimono.Core
{
[ExecuteInEditMode]
public class SuimonoModule : MonoBehaviour {
//Underwater Effects variables
public string suimonoVersionNumber = "";
public float systemTime = 0f;
//layers
public bool autoSetLayers = true;
public string layerWater;
public int layerWaterNum = -1;
public string layerDepth;
public int layerDepthNum = -1;
public string layerScreenFX;
public int layerScreenFXNum = -1;
//public string layerUnderwater;
public bool layersAreSet = false;
#if UNITY_EDITOR
public SerializedObject tagManager;
public SerializedProperty projectlayers;
#endif
public bool autoSetCameraFX = true;
public Transform manualCamera;
public Transform mainCamera;
public int cameraTypeIndex = 0;
[System.NonSerialized] public List<string> cameraTypeOptions = new List<string>(){"Auto Select Camera","Manual Select Camera"};
public Transform setCamera;
public Transform setTrack;
public Light setLight;
public bool enableUnderwaterFX = true;
public bool enableInteraction = true;
public float objectEnableUnderwaterFX = 1f;
public bool disableMSAA = false;
public bool enableRefraction = true;
public bool enableReflections = true;
public bool enableDynamicReflections = true;
public bool enableCaustics = true;
public bool enableCausticsBlending = false;
public bool enableAdvancedEdge = true;
public bool enableAdvancedDistort = true;
public bool enableTenkoku = false;
public bool enableAutoAdvance = true;
public bool showPerformance = false;
public bool showGeneral = false;
public Color underwaterColor = new Color(0.58f,0.61f,0.61f,0.0f);
public bool enableTransition = true;
public float transition_offset = 0.1f;
public GameObject fxRippleObject;
//private ParticleSystem underwaterDebris;
private float underLightAmt = 0f;
private GameObject targetSurface;
private float doTransitionTimer = 0f;
public bool isUnderwater = false;
static bool doWaterTransition = false;
//transparency
public bool enableTransparency = true;
private bool useEnableTransparency = true;
public int transResolution = 3;
public int transLayer = 0;
public LayerMask transLayerMask;
public int causticLayer = 0;
public LayerMask causticLayerMask;
[System.NonSerialized] public List<string> suiLayerMasks;
[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 float transRenderDistance = 100f;
//private Suimono.Core.cameraTools transToolsObject;
//private Camera transCamObject;
//private Suimono.Core.cameraTools causticToolsObject;
//private Suimono.Core.cameraCausticsHandler causticHandlerObjectTrans;
//private Suimono.Core.cameraCausticsHandler causticHandlerObject;
//private Camera causticCamObject;
//private GameObject wakeObject;
//private Camera wakeCamObject;
//private GameObject normalsObject;
//private Camera normalsCamObject;
public bool playSounds = true;
public bool playSoundBelow = true;
public bool playSoundAbove = true;
public float maxVolume = 1f;
public int maxSounds = 10;
public AudioClip[] defaultSplashSound;
//public Suimono.Core.SuimonoModuleFX fxObject;
private float setvolume = 0.65f;
//private Suimono.Core.fx_soundModule sndparentobj;
private GameObject underSoundObject;
private AudioSource underSoundComponent;
private AudioSource[] sndComponents;
private int currentSound = 0;
public float transitionStrength = 1f;
public float currentObjectIsOver = 0f;
public float currentObjectDepth = 0f;
public float currentTransitionDepth = 0f;
public float currentSurfaceLevel = 0f;
public float underwaterThreshold = 0.1f;
public Suimono.Core.SuimonoObject suimonoObject;
private ParticleSystem.Particle[] effectBubbles;
public Suimono.Core.SuimonoModuleLib suimonoModuleLibrary;
//private Renderer underwaterDebrisRendererComponent;
//private Transform underwaterDebrisTransform;
public Camera setCameraComponent;
private float underTrans = 0f;
//tenkoku specific variables
public float useTenkoku = 0f;
public float tenkokuWindDir = 0f;
public float tenkokuWindAmt = 0f;
public bool tenkokuUseWind = true;
private GameObject tenObject;
public bool showTenkoku = true;
public bool tenkokuUseReflect = true;
private WindZone tenkokuWindModule;
//collect for GC
private int lx;
private int fx;
private int px;
private ParticleSystem.Particle[] setParticles;
private AudioClip setstep;
private float setpitch;
//private float waitTime;
private AudioSource useSoundAudioComponent;
private float useRefract;
private float useLight = 1f;
private Color useLightCol;
private Vector2 flow_dir;
private Vector3 tempAngle;
//private Color getmap;
private float getheight;
private float getheightC;
private float getheightT;
private float getheightR;
private bool isOverWater;
private float surfaceLevel;
//private float groundLevel;
private int layer;
private int layermask;
private Vector3 testpos;
private int i;
private RaycastHit hit;
private Vector2 pixelUV;
private float returnValue;
private float[] returnValueAll;
private float h1;
private float setDegrees = 0f;
private float enabledUFX = 1f;
private float enabledCaustics = 1f;
private float setUnderBright;
//public Suimono.Core.fx_causticModule causticObject;
private float enCaustic = 0f;
private float setEdge = 1f;
private Suimono.Core.Suimono_UnderwaterFog underwaterObject;
private GameObject currentSurfaceObject = null;
public float[] heightValues;
//public Light causticObjectLight;
public float isForward = 0f;
public float isAdvDist = 0f;
//Height Variables
public float waveScale = 1f;
public float flowSpeed = 0.02f;
public float offset = 0f;
public Texture2D heightTex;
public Texture2D heightTexT;
public Texture2D heightTexR;
public Transform heightObject;
public Vector2 relativePos = new Vector2(0f,0f);
public Vector3 texCoord = new Vector3(0f,0f,0f);
public Vector3 texCoord1 = new Vector3(0f,0f,0f);
public Vector3 texCoordT = new Vector3(0f,0f,0f);
public Vector3 texCoordT1 = new Vector3(0f,0f,0f);
public Vector3 texCoordR = new Vector3(0f,0f,0f);
public Vector3 texCoordR1 = new Vector3(0f,0f,0f);
public Color heightVal0;
public Color heightVal1;
public Color heightValT0;
public Color heightValT1;
public Color heightValR0;
public Color heightValR1;
public float localTime = 0f;
private float baseHeight = 0f;
private float baseAngle = 0f;
private Color[] pixelArray;
private Color[] pixelArrayT;
private Color[] pixelArrayR;
private Texture2D useDecodeTex;
private Color[] useDecodeArray;
public int row;
public int pixIndex;
public Color pixCol;
public int t;
public int y;
#if UNITY_EDITOR
public SerializedProperty layerTP;
public SerializedProperty layerWP;
public SerializedProperty layerSP;
public SerializedProperty layerXP;
public SerializedProperty layerN;
#endif
public Vector3 dir;
public Vector3 pivotPoint;
public float useLocalTime;
public Vector2 flow_dirC;
public Vector2 flowSpeed0;
public Vector2 flowSpeed1;
public Vector2 flowSpeed2;
public Vector2 flowSpeed3;
public float tScale;
public Vector2 oPos;
private int renderCount = 0;
private int randSeed;
private Suimono.Core.Random modRand;
//private float surfaceTimer = 0f;
//private Suimono.Core.SuimonoObject[] sObjects;
private List<SuimonoObject> sObjects;
private List<Renderer> sRends;
private List<Renderer> sRendSCs;
//Variables for Unity 5.4+ only
#if UNITY_5_4_OR_NEWER
private ParticleSystem.EmissionModule debrisEmission;
#endif
private ColorSpace _colorspace;
private float _deltaTime;
void Awake () {
//### SET CURRENT SUIMONO NUMBER ###
suimonoVersionNumber = "2.1.14";
//Force name
gameObject.name = "SUIMONO_Module";
//Initialize Lists
sObjects = new List<SuimonoObject>();
sRends = new List<Renderer>();
sRendSCs = new List<Renderer>();
}
void Start () {
//### DISCONNECT FROM PREFAB ###;
#if UNITY_EDITOR
#if !UNITY_2018_3_OR_NEWER
PrefabUtility.DisconnectPrefabInstance(this.gameObject);
#endif
#endif
//set random
randSeed = System.Environment.TickCount;
modRand = new Suimono.Core.Random(randSeed);
//### SET LAYERS ###;
InitLayers();
//Set Camera and Track Objects
Suimono_CheckCamera();
//SET PHYSICS LAYER INTERACTIONS
//This is introduced because Unity 5 no longer handles mesh colliders and triggers without throwing an error.
//thanks a whole lot guys O_o (for nuthin'). The below physics setup should workaround this problem for everyone.
if (autoSetLayers){
for (lx = 0; lx < 32; lx++){
//loop through and decouple layer collisions for all layers(up to 20).
//layer 4 is the built-in water layer.
Physics.IgnoreLayerCollision(lx,layerWaterNum);
}
}
//INITIATE OBJECTS
suimonoModuleLibrary = this.gameObject.GetComponent<Suimono.Core.SuimonoModuleLib>() as Suimono.Core.SuimonoModuleLib;
/*
if (GameObject.Find("_caustic_effects") != null) causticObject = GameObject.Find("_caustic_effects").GetComponent<Suimono.Core.fx_causticModule>();
if (causticObject != null) causticObjectLight = GameObject.Find("mainCausticObject").GetComponent<Light>();
//transparency objects
transToolsObject = this.transform.Find("cam_SuimonoTrans").gameObject.GetComponent<Suimono.Core.cameraTools>();
transCamObject = this.transform.Find("cam_SuimonoTrans").gameObject.GetComponent<Camera>() as Camera;
causticHandlerObjectTrans = this.transform.Find("cam_SuimonoTrans").gameObject.GetComponent<cameraCausticsHandler>();
causticToolsObject = this.transform.Find("cam_SuimonoCaustic").gameObject.GetComponent<Suimono.Core.cameraTools>();
causticCamObject = this.transform.Find("cam_SuimonoCaustic").gameObject.GetComponent<Camera>() as Camera;
causticHandlerObject = this.transform.Find("cam_SuimonoCaustic").gameObject.GetComponent<Suimono.Core.cameraCausticsHandler>();
//wake advanced effect objects
wakeObject = this.transform.Find("cam_SuimonoWake").gameObject;
wakeCamObject = this.transform.Find("cam_SuimonoWake").gameObject.GetComponent<Camera>() as Camera;
normalsObject = this.transform.Find("cam_SuimonoNormals").gameObject;
normalsCamObject = this.transform.Find("cam_SuimonoNormals").gameObject.GetComponent<Camera>() as Camera;
//Effects Initialization
fxObject = this.gameObject.GetComponent<Suimono.Core.SuimonoModuleFX>() as Suimono.Core.SuimonoModuleFX;
if (GameObject.Find("_sound_effects") != null) sndparentobj = GameObject.Find("_sound_effects").gameObject.GetComponent<Suimono.Core.fx_soundModule>();
if (GameObject.Find("effect_underwater_debris") != null) underwaterDebris = GameObject.Find("effect_underwater_debris").gameObject.GetComponent<ParticleSystem>();
//if (GameObject.Find("effect_fx_bubbles") != null) effectBubbleSystem = GameObject.Find("effect_fx_bubbles").gameObject.GetComponent<ParticleSystem>();
*/
//get Surface objects
//InitSurfaceRenderers();
#if UNITY_EDITOR
if (EditorApplication.isPlaying){
#endif
if (suimonoModuleLibrary.sndparentobj != null){
//init sound object pool
maxSounds = suimonoModuleLibrary.sndparentobj.maxSounds;
sndComponents = new AudioSource[maxSounds];
GameObject[] soundObjectPrefab = new GameObject[maxSounds];
for (int sx = 0; sx < (maxSounds); sx++){
soundObjectPrefab[sx] = new GameObject("SuimonoAudioObject");
soundObjectPrefab[sx].transform.parent = suimonoModuleLibrary.sndparentobj.transform;
soundObjectPrefab[sx].AddComponent<AudioSource>();
sndComponents[sx] = soundObjectPrefab[sx].GetComponent<AudioSource>();
}
//init underwater sound
if(suimonoModuleLibrary.sndparentobj.underwaterSound != null){
underSoundObject = new GameObject("Underwater Sound");
underSoundObject.AddComponent<AudioSource>();
underSoundObject.transform.parent = suimonoModuleLibrary.sndparentobj.transform;
underSoundComponent = underSoundObject.GetComponent<AudioSource>();
}
}
#if UNITY_EDITOR
}
#endif
//tun off antialiasing (causes unexpected rendering issues. Recommend post fx aliasing instead)
if (disableMSAA){
QualitySettings.antiAliasing = 0;
}
//cache quality settings
_colorspace = QualitySettings.activeColorSpace;
//set linear space flag
if (_colorspace == ColorSpace.Linear){
Shader.SetGlobalFloat("_Suimono_isLinear",1.0f);
} else {
Shader.SetGlobalFloat("_Suimono_isLinear",0.0f);
}
//store pixel arrays for Height Calculation
if (suimonoModuleLibrary != null){
if (suimonoModuleLibrary.texNormalC != null){
heightTex = suimonoModuleLibrary.texNormalC;
pixelArray = suimonoModuleLibrary.texNormalC.GetPixels(0);
}
if (suimonoModuleLibrary.texNormalT != null){
heightTexT = suimonoModuleLibrary.texNormalT;
pixelArrayT = suimonoModuleLibrary.texNormalT.GetPixels(0);
}
if (suimonoModuleLibrary.texNormalR != null){
heightTexR = suimonoModuleLibrary.texNormalR;
pixelArrayR = suimonoModuleLibrary.texNormalR.GetPixels(0);
}
}
//set tenkoku flag
tenObject = GameObject.Find("Tenkoku DynamicSky");
Shader.SetGlobalFloat("_useTenkoku",0.0f);
}
void InitLayers () {
//check whether layers are set
#if UNITY_EDITOR
tagManager = new SerializedObject(AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/TagManager.asset")[0]);
projectlayers = tagManager.FindProperty("layers");
layersAreSet = false;
for (t = 8; t <= 31; t++){
layerTP = projectlayers.GetArrayElementAtIndex(t);
if (layerTP.stringValue != ""){
if (layerTP.stringValue == "Suimono_Water" || layerTP.stringValue == "Suimono_Depth" || layerTP.stringValue == "Suimono_Screen" || layerTP.stringValue == "Suimono_Underwater"){
layersAreSet = true;
}
}
}
if (!autoSetLayers){
//if (layerTP.stringValue == "Suimono_Water") layerWaterNum = t;
//if (layerTP.stringValue == "Suimono_Depth") layerDepthNum = t;
//if (layerTP.stringValue == "Suimono_Screen") layerScreenFXNum = t;
layerWaterNum = LayerMask.NameToLayer("Suimono_Water");
layerDepthNum = LayerMask.NameToLayer("Suimono_Depth");
layerScreenFXNum = LayerMask.NameToLayer("Suimono_Screen");
}
#endif
if (autoSetLayers){
//Set Layers if Applicable
if (!layersAreSet){
#if UNITY_EDITOR
if (projectlayers == null || !projectlayers.isArray){
Debug.LogWarning("Can't set up Suimono layers. It's possible the format of the layers and tags data has changed in this version of Unity.");
Debug.LogWarning("Layers is null: " + (projectlayers == null));
return;
}
layerWater = "Suimono_Water";
layerDepth = "Suimono_Depth";
layerScreenFX = "Suimono_Screen";
//ASSIGN LAYERS
layerWaterNum = -1;
layerDepthNum = -1;
layerScreenFXNum = -1;
for (y = 8; y <= 31; y++){
layerWP = projectlayers.GetArrayElementAtIndex(y);
if (layerWP.stringValue != layerWater && layerWP.stringValue == "" && layerWaterNum == -1){
layerWaterNum = y;
if (!layersAreSet) Debug.Log("Setting up Suimono layers. Layer " + layerWaterNum + " is now called " + layerWater);
layerWP.stringValue = layerWater;
}
layerSP = projectlayers.GetArrayElementAtIndex(y);
if (layerSP.stringValue != layerDepth && layerWP.stringValue == "" && layerDepthNum == -1){
layerDepthNum = y;
if (!layersAreSet) Debug.Log("Setting up Suimono layers. Layer " + layerDepthNum + " is now called " + layerDepth);
layerSP.stringValue = layerDepth;
}
layerXP = projectlayers.GetArrayElementAtIndex(y);
if (layerXP.stringValue != layerScreenFX && layerWP.stringValue == "" && layerScreenFXNum == -1){
layerScreenFXNum = y;
if (!layersAreSet) Debug.Log("Setting up Suimono layers. Layer " + layerScreenFXNum + " is now called " + layerScreenFX);
layerXP.stringValue = layerScreenFX;
}
}
if (!layersAreSet) tagManager.ApplyModifiedProperties();
#endif
layersAreSet = true;
}
}
}
/*
void InitLayers_orig () {
//check whether layers are set
#if UNITY_EDITOR
tagManager = new SerializedObject(AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/TagManager.asset")[0]);
projectlayers = tagManager.FindProperty("layers");
layersAreSet = false;
for (t = 8; t <= 31; t++){
layerTP = projectlayers.GetArrayElementAtIndex(t);
if (layerTP.stringValue != ""){
if (layerTP.stringValue == "Suimono_Water" || layerTP.stringValue == "Suimono_Depth" || layerTP.stringValue == "Suimono_Screen" || layerTP.stringValue == "Suimono_Underwater"){
layersAreSet = true;
}
}
if (!autoSetLayers){
if (layerTP.stringValue == "Suimono_Water") layerWaterNum = t;
if (layerTP.stringValue == "Suimono_Depth") layerDepthNum = t;
if (layerTP.stringValue == "Suimono_Screen") layerScreenFXNum = t;
}
}
#endif
if (autoSetLayers){
//Set Layers if Applicable
if (!layersAreSet){
#if UNITY_EDITOR
if (projectlayers == null || !projectlayers.isArray){
Debug.LogWarning("Can't set up Suimono layers. It's possible the format of the layers and tags data has changed in this version of Unity.");
Debug.LogWarning("Layers is null: " + (projectlayers == null));
return;
}
layerWater = "Suimono_Water";
layerDepth = "Suimono_Depth";
layerScreenFX = "Suimono_Screen";
layerUnderwater = "Suimono_Underwater";
//ASSIGN LAYERS
layerWaterNum = -1;
layerDepthNum = -1;
layerScreenFXNum = -1;
for (y = 8; y <= 31; y++){
layerWP = projectlayers.GetArrayElementAtIndex(y);
if (layerWP.stringValue != layerWater && layerWP.stringValue == "" && layerWaterNum == -1){
layerWaterNum = y;
if (!layersAreSet) Debug.Log("Setting up Suimono layers. Layer " + layerWaterNum + " is now called " + layerWater);
layerWP.stringValue = layerWater;
}
layerSP = projectlayers.GetArrayElementAtIndex(y);
if (layerSP.stringValue != layerDepth && layerWP.stringValue == "" && layerDepthNum == -1){
layerDepthNum = y;
if (!layersAreSet) Debug.Log("Setting up Suimono layers. Layer " + layerDepthNum + " is now called " + layerDepth);
layerSP.stringValue = layerDepth;
}
layerXP = projectlayers.GetArrayElementAtIndex(y);
if (layerXP.stringValue != layerScreenFX && layerWP.stringValue == "" && layerScreenFXNum == -1){
layerScreenFXNum = y;
if (!layersAreSet) Debug.Log("Setting up Suimono layers. Layer " + layerScreenFXNum + " is now called " + layerScreenFX);
layerXP.stringValue = layerScreenFX;
}
}
if (!layersAreSet) tagManager.ApplyModifiedProperties();
#endif
layersAreSet = true;
}
}
}
*/
void LateUpdate (){
//Cache Time for performance
_deltaTime = Time.deltaTime;
//Update Random
if (modRand == null) modRand = new Suimono.Core.Random(randSeed);
//Set Water System Time
if (systemTime < 0.0f) systemTime = 0.0f;
if (enableAutoAdvance) systemTime += _deltaTime;
//set project layer masks
#if UNITY_EDITOR
suiLayerMasks = new List<string>();
tagManager = new SerializedObject(AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/TagManager.asset")[0]);
projectlayers = tagManager.FindProperty("layers");
for (i = 0; i < projectlayers.arraySize; i++){
layerN = projectlayers.GetArrayElementAtIndex(i);
suiLayerMasks.Add(layerN.stringValue);
}
#endif
//CHECK FOR SURFACE OBJECT CULLING
SetCullFunction();
//GET TENKOKU SPECIFIC VARIABLES
useTenkoku = 0.0f;
if (tenObject != null){
if (tenObject.activeInHierarchy){
useTenkoku = 1.0f;
}
if (useTenkoku == 1.0f){
if (setLight == null) setLight = GameObject.Find("LIGHT_World").GetComponent<Light>();
if (tenkokuWindModule == null){
tenkokuWindModule = GameObject.Find("Tenkoku_WindZone").GetComponent<WindZone>();
} else {
tenkokuWindDir = tenkokuWindModule.transform.eulerAngles.y;
tenkokuWindAmt = tenkokuWindModule.windMain;
}
}
}
Shader.SetGlobalFloat("_useTenkoku",useTenkoku);
//GET RIPPLE OBJECT REFERENCE AND LAYER
if (Application.isPlaying && fxRippleObject == null){
fxRippleObject = GameObject.Find("fx_rippleNormals(Clone)");
}
if (fxRippleObject != null){
fxRippleObject.layer = layerScreenFXNum;
}
//SET COMPONENT LAYERS
if (suimonoModuleLibrary.normalsCamObject != null) suimonoModuleLibrary.normalsCamObject.cullingMask = 1<<layerScreenFXNum;
if (suimonoModuleLibrary.wakeCamObject != null) suimonoModuleLibrary.wakeCamObject.cullingMask = 1<<layerScreenFXNum;
//HANDLE COMPONENTS
//Tranparency function
if (suimonoModuleLibrary.transCamObject != null){
transLayer = (transLayer & ~(1 << layerWaterNum)); //remove water layer from transparent mask
transLayer = (transLayer & ~(1 << layerDepthNum)); //remove Depth layer from transparent mask
transLayer = (transLayer & ~(1 << layerScreenFXNum)); //remove Screen layer from transparent mask
suimonoModuleLibrary.transCamObject.cullingMask = transLayer;
suimonoModuleLibrary.transCamObject.farClipPlane = transRenderDistance*1.2f;
Shader.SetGlobalFloat("_suimonoTransDist", transRenderDistance);
} else {
suimonoModuleLibrary.transCamObject = this.transform.Find("cam_SuimonoTrans").gameObject.GetComponent<Camera>() as Camera;
}
if (suimonoModuleLibrary.transToolsObject != null){
suimonoModuleLibrary.transToolsObject.resolution = System.Convert.ToInt32(resolutions[transResolution]);
//if (useEnableTransparency == false){
// suimonoModuleLibrary.transToolsObject.gameObject.SetActive(false);
//} else {
// suimonoModuleLibrary.transToolsObject.gameObject.SetActive(true);
//}
suimonoModuleLibrary.transToolsObject.gameObject.SetActive(enableTransparency);
} else {
suimonoModuleLibrary.transToolsObject = this.transform.Find("cam_SuimonoTrans").gameObject.GetComponent<cameraTools>();
}
//Caustic function
if (suimonoModuleLibrary.causticCamObject != null){
if (enableCaustics){
suimonoModuleLibrary.causticCamObject.gameObject.SetActive(enableCausticsBlending);
transLayer = (transLayer & ~(1 << layerDepthNum)); //remove Depth layer from transparent mask
transLayer = (transLayer & ~(1 << layerScreenFXNum)); //remove Screen layer from transparent mask
suimonoModuleLibrary.causticCamObject.cullingMask = transLayer;
suimonoModuleLibrary.causticCamObject.farClipPlane = transRenderDistance*1.2f;
}
//remove caustics from transparency function
if (suimonoModuleLibrary.causticHandlerObjectTrans != null){
suimonoModuleLibrary.causticHandlerObjectTrans.enabled = !enableCausticsBlending;
//if (!enableCaustics){
// suimonoModuleLibrary.causticHandlerObjectTrans.enabled = false;
//}
}
} else {
suimonoModuleLibrary.causticCamObject = this.transform.Find("cam_SuimonoCaustic").gameObject.GetComponent<Camera>() as Camera;
}
if (suimonoModuleLibrary.causticToolsObject != null){
suimonoModuleLibrary.causticToolsObject.resolution = System.Convert.ToInt32(resolutions[transResolution]);
} else {
suimonoModuleLibrary.causticToolsObject = this.transform.Find("cam_SuimonoCaustic").gameObject.GetComponent<Suimono.Core.cameraTools>();
}
Shader.SetGlobalFloat("_enableTransparency",useEnableTransparency?1.0f:0.0f);
//caustics function
enCaustic = 0.0f;
if (enableCaustics) enCaustic = 1.0f;
Shader.SetGlobalFloat("_suimono_enableCaustic",enCaustic);
// Remove Suimono layers from caustics rendering.
// Note: This can cause "layer exclusion" console notice in deferred rendering
// when too many layers are excluded from lighting.
//causticLayer = (causticLayer &= ~(1 << layerWaterNum));
//causticLayer = (causticLayer &= ~(1 << layerDepthNum));
//causticLayer = (causticLayer &= ~(1 << layerScreenFXNum));
causticLayer = (causticLayer &= ~(1 << layerWaterNum << layerDepthNum << layerScreenFXNum));
//advanced edge function
setEdge = 1.0f;
if (!enableAdvancedEdge) setEdge = 0.0f;
Shader.SetGlobalFloat("_suimono_advancedEdge",setEdge);
}
void FixedUpdate (){
//SET PHYSICS LAYER INTERACTIONS
//This is introduced because Unity 5 no longer handles mesh colliders and triggers without throwing an error.
//thanks a whole lot guys O_o (for nuthin'). The below physics setup should workaround this problem for everyone.
if (autoSetLayers){
for (lx = 0; lx < 20; lx++){
//loop through and decouple layer collisions for all layers(up to 20).
//layer 4 is the built-in water layer.
Physics.IgnoreLayerCollision(lx,layerWaterNum);
}
}
//Set Camera and Track Objects
Suimono_CheckCamera();
//set caustics
if (suimonoModuleLibrary.causticObject != null){
if (Application.isPlaying){
suimonoModuleLibrary.causticObject.enableCaustics = enableCaustics;
} else {
suimonoModuleLibrary.causticObject.enableCaustics = false;
}
if (setLight != null){
suimonoModuleLibrary.causticObject.sceneLightObject = setLight;
}
}
//play underwater sounds
PlayUnderwaterSound();
//######## HANDLE FORWARD RENDERING SWITCH #######
if (setCamera != null){
isForward = 0.0f;
if (setCameraComponent.actualRenderingPath == RenderingPath.Forward){
isForward = 1.0f;
}
Shader.SetGlobalFloat("_isForward",isForward);
}
//######## HANDLE ADVANCED DISTORTION SWITCH #######
if (enableAdvancedDistort){
isAdvDist = 1.0f;
suimonoModuleLibrary.wakeObject.SetActive(true);
suimonoModuleLibrary.normalsObject.SetActive(true);
} else {
isAdvDist = 0.0f;
suimonoModuleLibrary.wakeObject.SetActive(false);
suimonoModuleLibrary.normalsObject.SetActive(false);
}
Shader.SetGlobalFloat("_suimono_advancedDistort",isAdvDist);
//######## Set Camera Background Color on Shader #######
if (setCameraComponent != null){
if (suimonoObject != null){
setCameraComponent.backgroundColor = suimonoObject.underwaterColor;
}
Shader.SetGlobalColor("_cameraBGColor",setCameraComponent.backgroundColor);
}
//######## Set Camera Specific Settings #######
if (setCameraComponent != null){
//set camera depth mode to 'Depth'. The alternative mode
//'DepthNormals' causes rendering errors in Deferred Rendering
if (setCameraComponent.actualRenderingPath == RenderingPath.DeferredShading){
setCameraComponent.depthTextureMode = DepthTextureMode.Depth;
} else if (setCameraComponent.actualRenderingPath == RenderingPath.DeferredLighting){
setCameraComponent.depthTextureMode = DepthTextureMode.Depth;
} else {
setCameraComponent.depthTextureMode = DepthTextureMode.DepthNormals;
}
//Set Water specific visibility layers on camera
setCameraComponent.cullingMask = setCameraComponent.cullingMask | (1 <<layerWaterNum);
setCameraComponent.cullingMask = (setCameraComponent.cullingMask & ~(1 << layerDepthNum) & ~(1 << layerScreenFXNum));
}
}
void OnDisable(){
CancelInvoke("StoreSurfaceHeight");
}
void OnEnable(){
InvokeRepeating("StoreSurfaceHeight",0.01f,0.1f);
}
void StoreSurfaceHeight(){
if (this.enabled){
if (setCamera != null){
heightValues = SuimonoGetHeightAll(setCamera.transform.position);
currentSurfaceLevel = heightValues[1];
currentObjectDepth = heightValues[3];
currentObjectIsOver = heightValues[4];
currentTransitionDepth = heightValues[9];
objectEnableUnderwaterFX = heightValues[10];
checkUnderwaterEffects();
checkWaterTransition();
}
}
}
void PlayUnderwaterSound(){
if (Application.isPlaying){
if (underSoundObject != null && setTrack != null && underSoundComponent != null){
underSoundObject.transform.position = setTrack.position;
if (currentTransitionDepth > 0.0f){
if (playSoundBelow && playSounds){
underSoundComponent.clip = suimonoModuleLibrary.sndparentobj.underwaterSound;
underSoundComponent.volume = maxVolume;
underSoundComponent.loop = true;
if (!underSoundComponent.isPlaying){
underSoundComponent.Play();
}
} else {
underSoundComponent.Stop();
}
} else {
if (suimonoModuleLibrary.sndparentobj.underwaterSound != null){
if (playSoundAbove && playSounds){
underSoundComponent.clip = suimonoModuleLibrary.sndparentobj.abovewaterSound;
underSoundComponent.volume = 0.45f*maxVolume;
underSoundComponent.loop = true;
if (!underSoundComponent.isPlaying){
underSoundComponent.Play();
}
} else {
underSoundComponent.Stop();
}
}
}
}
}
}
public void AddFX(int fxSystem, Vector3 effectPos, int addRate, float addSize, float addRot, float addARot, Vector3 addVeloc, Color addCol){
if (suimonoModuleLibrary.fxObject != null){
fx = fxSystem;
if (suimonoModuleLibrary.fxObject.fxParticles[fx] != null){
suimonoModuleLibrary.fxObject.fxParticles[fx].Emit(addRate);
//get particles
if (setParticles != null) setParticles = null;
setParticles = new ParticleSystem.Particle[suimonoModuleLibrary.fxObject.fxParticles[fx].particleCount];
suimonoModuleLibrary.fxObject.fxParticles[fx].GetParticles(setParticles);
//set particles
if (suimonoModuleLibrary.fxObject.fxParticles[fx].particleCount > 0.0f){
for (px = (suimonoModuleLibrary.fxObject.fxParticles[fx].particleCount-addRate); px < suimonoModuleLibrary.fxObject.fxParticles[fx].particleCount; px++){
//set position
setParticles[px].position = new Vector3(effectPos.x, effectPos.y, effectPos.z);
//set variables
#if UNITY_5_4_OR_NEWER
setParticles[px].startSize = addSize;
#else
setParticles[px].size = addSize;
#endif
setParticles[px].rotation = addRot;
setParticles[px].angularVelocity = addARot;
setParticles[px].velocity = new Vector3(addVeloc.x, addVeloc.y, addVeloc.z);
#if UNITY_5_4_OR_NEWER
setParticles[px].startColor *= addCol;
#else
setParticles[px].color *= addCol;
#endif
}
suimonoModuleLibrary.fxObject.fxParticles[fx].SetParticles(setParticles,setParticles.Length);
suimonoModuleLibrary.fxObject.fxParticles[fx].Play();
}
}
}
}
public void AddSoundFX(AudioClip sndClip, Vector3 soundPos, Vector3 sndVelocity){
if (enableInteraction){
setpitch = 1.0f;
setvolume = 1.0f;
if (playSounds && suimonoModuleLibrary.sndparentobj.defaultSplashSound.Length >= 1 ){
setstep = suimonoModuleLibrary.sndparentobj.defaultSplashSound[modRand.Next(0,defaultSplashSound.Length-1)];
setpitch = sndVelocity.y;
setvolume = sndVelocity.z;
setvolume = Mathf.Lerp(0.0f,1.0f,setvolume) * maxVolume;
//check depth and morph sounds if underwater
if (currentObjectDepth > 0.0f){
setpitch *= 0.25f;
setvolume *= 0.5f;
}
useSoundAudioComponent = sndComponents[currentSound];
useSoundAudioComponent.clip = sndClip;
if (!useSoundAudioComponent.isPlaying){
useSoundAudioComponent.transform.localPosition = soundPos;
useSoundAudioComponent.volume = setvolume;
useSoundAudioComponent.pitch = setpitch;
useSoundAudioComponent.minDistance = 4.0f;
useSoundAudioComponent.maxDistance = 20.0f;
useSoundAudioComponent.clip = setstep;
useSoundAudioComponent.loop = false;
useSoundAudioComponent.Play();
}
currentSound += 1;
if (currentSound >= (maxSounds-1)) currentSound = 0;
}
}
}
public void AddSound(string sndMode, Vector3 soundPos, Vector3 sndVelocity){
if (enableInteraction){
setpitch = 1.0f;
setvolume = 1.0f;
if (playSounds && suimonoModuleLibrary.sndparentobj.defaultSplashSound.Length >= 1 ){
setstep = suimonoModuleLibrary.sndparentobj.defaultSplashSound[modRand.Next(0,suimonoModuleLibrary.sndparentobj.defaultSplashSound.Length-1)];
setpitch = sndVelocity.y;
setvolume = sndVelocity.z;
setvolume = Mathf.Lerp(0.0f,10.0f,setvolume);
//check depth and morph sounds if underwater
if (currentObjectDepth > 0.0f){
setpitch *= 0.25f;
setvolume *= 0.5f;
}
useSoundAudioComponent = sndComponents[currentSound];
if (!useSoundAudioComponent.isPlaying){
useSoundAudioComponent.transform.localPosition = soundPos;
useSoundAudioComponent.volume = setvolume;
useSoundAudioComponent.pitch = setpitch;
useSoundAudioComponent.minDistance = 4.0f;
useSoundAudioComponent.maxDistance = 20.0f;
useSoundAudioComponent.clip = setstep;
useSoundAudioComponent.loop = false;
useSoundAudioComponent.Play();
}
currentSound += 1;
if (currentSound >= (maxSounds-1)) currentSound = 0;
}
}
}
void checkUnderwaterEffects(){
if (Application.isPlaying){
if (currentTransitionDepth > underwaterThreshold){
if (suimonoObject != null){
if (enableUnderwaterFX && suimonoObject.enableUnderwater && currentObjectIsOver==1.0f){
isUnderwater = true;
Shader.SetGlobalFloat("_Suimono_IsUnderwater",1.0f);
if (suimonoObject != null){
suimonoObject.useShader = suimonoObject.shader_Under;
}
if (suimonoModuleLibrary.causticHandlerObject != null){
suimonoModuleLibrary.causticHandlerObjectTrans.isUnderwater = true;
suimonoModuleLibrary.causticHandlerObject.isUnderwater = true;
}
}
}
} else {
//swap camera rendering to back to default
isUnderwater = false;
Shader.SetGlobalFloat("_Suimono_IsUnderwater",0.0f);
if (suimonoObject != null){
suimonoObject.useShader = suimonoObject.shader_Surface;
}
if (suimonoModuleLibrary.causticHandlerObject != null){
suimonoModuleLibrary.causticHandlerObjectTrans.isUnderwater = false;
suimonoModuleLibrary.causticHandlerObject.isUnderwater = false;
}
}
}
}
void checkWaterTransition () {
if (Application.isPlaying){
doTransitionTimer += _deltaTime;
//SET COLORS
if (currentTransitionDepth > underwaterThreshold && currentObjectIsOver==1.0f){
doWaterTransition = true;
//set underwater debris
if (suimonoObject != null && setCamera != null){
if (enableUnderwaterFX && suimonoObject.enableUnderwater && objectEnableUnderwaterFX==1.0f){
if (suimonoObject.enableUnderDebris){
suimonoModuleLibrary.underwaterDebrisTransform.position = setCamera.transform.position;
suimonoModuleLibrary.underwaterDebrisTransform.rotation = setCamera.transform.rotation;
suimonoModuleLibrary.underwaterDebrisTransform.Translate(Vector3.forward * 5.0f);
suimonoModuleLibrary.underwaterDebrisRendererComponent.enabled=true;
#if UNITY_5_4_OR_NEWER
debrisEmission = suimonoModuleLibrary.underwaterDebris.emission;
debrisEmission.enabled = isUnderwater;
#else
suimonoModuleLibrary.underwaterDebris.enableEmission = isUnderwater;
#endif
} else {
if (suimonoModuleLibrary.underwaterDebris != null) suimonoModuleLibrary.underwaterDebrisRendererComponent.enabled = false;
}
setUnderBright = underLightAmt;
setUnderBright *= 0.5f;
//set attributes to shader
useLight = 1.0f;
useLightCol = new Color(1f,1f,1f,1f);
useRefract = 1.0f;
if (setLight != null){
useLight = setLight.intensity;
useLightCol = setLight.color;
}
if (!enableRefraction) useRefract = 0.0f;
if (underwaterObject == null){
if (setCamera.gameObject.GetComponent<Suimono.Core.Suimono_UnderwaterFog>() != null){
underwaterObject = setCamera.gameObject.GetComponent<Suimono.Core.Suimono_UnderwaterFog>();
}
}
if (underwaterObject != null){
underwaterObject.lightFactor = suimonoObject.underLightFactor * useLight;
underwaterObject.refractAmt = suimonoObject.underRefractionAmount * useRefract;
underwaterObject.refractScale = suimonoObject.underRefractionScale;
underwaterObject.refractSpd = suimonoObject.underRefractionSpeed * useRefract;
underwaterObject.fogEnd = suimonoObject.underwaterFogDist;
underwaterObject.fogStart = suimonoObject.underwaterFogSpread;
underwaterObject.blurSpread = suimonoObject.underBlurAmount;
underwaterObject.underwaterColor = suimonoObject.underwaterColor;
underwaterObject.darkRange = suimonoObject.underDarkRange;
underwaterObject.transitionStrength = transitionStrength;
Shader.SetGlobalColor("_suimono_lightColor",useLightCol);
underwaterObject.doTransition = false;
//set caustic and underwater light brightness
if (suimonoModuleLibrary.causticObject != null){
if (Application.isPlaying){
if (suimonoModuleLibrary.causticObject != null){
suimonoModuleLibrary.causticObject.heightFac = underwaterObject.hFac * 2.0f;
}
}
}
}
} else {
if (suimonoModuleLibrary.underwaterDebris != null) suimonoModuleLibrary.underwaterDebrisRendererComponent.enabled = false;
}
}
if (underwaterObject != null){
underwaterObject.cancelTransition = true;
}
} else {
//reset underwater debris
if (suimonoModuleLibrary.underwaterDebris != null){
suimonoModuleLibrary.underwaterDebrisRendererComponent.enabled=false;
}
//show water transition
if (enableTransition){
if (doWaterTransition && setCamera != null){
doTransitionTimer = 0.0f;
if (underwaterObject != null){
underwaterObject.doTransition = true;
}
doWaterTransition = false;
} else {
underTrans = 1.0f;
}
}
}
if (!enableUnderwaterFX){
if (suimonoModuleLibrary.underwaterDebrisRendererComponent != null){
suimonoModuleLibrary.underwaterDebrisRendererComponent.enabled=false;
}
}
}
}
void Suimono_CheckCamera(){
//get main camera object
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;
}
}
}
//set camera
if (setCamera != mainCamera){
setCamera = mainCamera;
setCameraComponent = setCamera.gameObject.GetComponent<Camera>();
underwaterObject = setCamera.gameObject.GetComponent<Suimono.Core.Suimono_UnderwaterFog>();
}
//set camera component
if (setCameraComponent == null && setCamera != null){
setCameraComponent = setCamera.gameObject.GetComponent<Camera>();
}
//reset camera component
if (setCamera != null && setCameraComponent != null){
if (setCameraComponent.transform != setCamera){
setCameraComponent = setCamera.gameObject.GetComponent<Camera>();
underwaterObject = setCamera.gameObject.GetComponent<Suimono.Core.Suimono_UnderwaterFog>();
}
}
//set track object
if (setTrack == null && setCamera != null){
setTrack = setCamera.transform;
}
//install camera effects
InstallCameraEffect();
}
public Vector2 SuimonoConvertAngleToDegrees(float convertAngle){
flow_dir = new Vector3(0f,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 Vector2 SuimonoConvertAngleToVector(float convertAngle){
flow_dir = new Vector3(0f,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 float SuimonoGetHeight(Vector3 testObject, string returnMode) {
// Get Heights
CalculateHeights(testObject);
// Return values
returnValue = 0.0f;
if (returnMode == "height") returnValue = getheight;
if (returnMode == "surfaceLevel") returnValue = surfaceLevel+getheight;
if (returnMode == "baseLevel") returnValue = surfaceLevel;
if (returnMode == "object depth") returnValue = getheight-testObject.y;
if (returnMode == "isOverWater" && isOverWater) returnValue = 1.0f;
if (returnMode == "isOverWater" && !isOverWater) returnValue = 0.0f;
if (returnMode == "isAtSurface"){
if (((surfaceLevel+getheight)-testObject.y) < 0.25f && ((surfaceLevel+getheight)-testObject.y) > -0.25f)
returnValue = 1.0f;
}
if (suimonoObject != null){
if (returnMode == "direction") returnValue = suimonoObject.flowDirection;
if (returnMode == "speed") returnValue = suimonoObject.flowSpeed;
if (returnMode == "wave height"){
h1 = 0.0f;
returnValue = getheight/h1;
}
}
if (returnMode == "transitionDepth") returnValue = ((surfaceLevel+getheight)-(testObject.y-(transition_offset*underTrans)));
if (returnMode == "underwaterEnabled"){
enabledUFX = 1f;
if (!suimonoObject.enableUnderwater) enabledUFX = 0f;
returnValue = enabledUFX;
}
if (returnMode == "causticsEnabled"){
enabledCaustics = 1f;
if (!suimonoObject.enableCausticFX) enabledCaustics = 0f;
returnValue = enabledCaustics;
}
return returnValue;
}
public float[] SuimonoGetHeightAll(Vector3 testObject){
// Get Heights
CalculateHeights(testObject);
// Return values
returnValueAll = new float[12];
// 0 height
returnValueAll[0]=(getheight);
// 1 surface level
returnValueAll[1]=(getheight);
// 2 base level
returnValueAll[2]=(surfaceLevel);
// 3 object depth
returnValueAll[3]=((getheight)-testObject.y);
// 4 is Over Water
returnValue = 1.0f;
if (!isOverWater) returnValue = 0.0f;
returnValueAll[4]= returnValue;
// 5 is at surface
returnValue = 0.0f;
if (((getheight)-testObject.y) < 0.25f && ((getheight)-testObject.y) > -0.25f) returnValue = 1.0f;
returnValueAll[5]=(returnValue);
// 6 direction
if (suimonoObject != null){
setDegrees = suimonoObject.flowDirection + suimonoObject.transform.eulerAngles.y;
if (setDegrees < 0.0f) setDegrees = 365.0f + setDegrees;
if (setDegrees > 365.0f) setDegrees = setDegrees-365.0f;
if (suimonoObject != null) returnValueAll[6] = setDegrees;
if (suimonoObject == null) returnValueAll[6] = 0.0f;
// 7 speed
if (suimonoObject != null) returnValueAll[7] = (suimonoObject.flowSpeed);
if (suimonoObject == null) returnValueAll[7] = 0.0f;
// 8 wave height
if (suimonoObject != null) h1 = (suimonoObject.lgWaveHeight);
if (suimonoObject == null) h1 = 0.0f;
returnValueAll[8]=(getheight/h1);
}
// 9 transition depth
returnValueAll[9] = ((getheight)-(testObject.y-(transition_offset*underTrans)));
// 10 enabled Underwater FX
enabledUFX = 1f;
if (suimonoObject != null){
if (!suimonoObject.enableUnderwater) enabledUFX = 0f;
returnValueAll[10] = enabledUFX;
}
// 11 enabled Underwater FX
enabledCaustics = 1f;
if (suimonoObject != null){
if (!suimonoObject.enableCausticFX) enabledCaustics = 0f;
returnValueAll[11] = enabledCaustics;
}
return returnValueAll;
}
public Vector3 RotatePointAroundPivot(Vector3 point, Vector3 pivot, Vector3 angles){
dir = point - pivot;
dir = Quaternion.Euler(angles * -1f) * dir;
point = dir + pivot;
return point;
}
public Color DecodeHeightPixels(float texPosx, float texPosy, int texNum){
if (texNum == 0){
useDecodeTex = heightTex;
useDecodeArray = pixelArray;
}
if (texNum == 1){
useDecodeTex = heightTexT;
useDecodeArray = pixelArrayT;
}
if (texNum == 2){
useDecodeTex = heightTexR;
useDecodeArray = pixelArrayR;
}
texPosx = (texPosx % useDecodeTex.width);
texPosy = (texPosy % useDecodeTex.height);
if (texPosx < 0f) texPosx = useDecodeTex.width - Mathf.Abs(texPosx);
if (texPosy < 0f) texPosy = useDecodeTex.height - Mathf.Abs(texPosy);
if (texPosx > useDecodeTex.width) texPosx = texPosx - useDecodeTex.width;
if (texPosy > useDecodeTex.height) texPosy = texPosy - useDecodeTex.height;
row = (useDecodeArray.Length/useDecodeTex.height) - Mathf.FloorToInt(texPosy);
pixIndex = ((Mathf.FloorToInt(texPosx) + 1) + (useDecodeArray.Length - (useDecodeTex.width * row))) - 1;
if (pixIndex > useDecodeArray.Length) pixIndex = pixIndex - (useDecodeArray.Length);
if (pixIndex < 0) pixIndex = useDecodeArray.Length - pixIndex;
pixCol = useDecodeArray[pixIndex];
if (_colorspace == ColorSpace.Linear){
pixCol.a = Mathf.Clamp(Mathf.Lerp(-0.035f, 0.5f, pixCol.a ), 0f, 1f);
}
if (_colorspace == ColorSpace.Gamma){
pixCol.a = Mathf.Clamp(Mathf.Lerp(-0.035f, 0.5f, pixCol.a ), 0f, 1f);
}
return pixCol;
}
void CalculateHeights(Vector3 testObject){
getheight = -1.0f;
getheightC = -1.0f;
getheightT = -1.0f;
getheightR = 0.0f;
isOverWater = false;
surfaceLevel = -1.0f;
layermask = 1 <<layerWaterNum;
testpos = new Vector3(testObject.x,testObject.y+30000f,testObject.z);
if(Physics.Raycast(testpos, -Vector3.up, out hit, 60000f, layermask)){
targetSurface = hit.transform.gameObject;
if (currentSurfaceObject != targetSurface || suimonoObject == null){
currentSurfaceObject = targetSurface;
if (hit.transform.parent != null && hit.transform.parent.gameObject.GetComponent<Suimono.Core.SuimonoObject>() != null){
suimonoObject = hit.transform.parent.gameObject.GetComponent<Suimono.Core.SuimonoObject>();
}
}
if (suimonoObject != null){
if (enableInteraction && suimonoObject.enableInteraction){
if (suimonoObject.typeIndex == 0){
heightObject = hit.transform;
} else {
heightObject = hit.transform.parent;
}
if (suimonoObject != null && hit.collider != null){
isOverWater = true;
surfaceLevel = heightObject.position.y;
//calculate relative position
if (heightObject != null){
baseHeight = heightObject.position.y;
baseAngle = heightObject.rotation.y;
relativePos.x = ((heightObject.position.x - testObject.x)/(20.0f*heightObject.localScale.x) + 1f) * 0.5f * heightObject.localScale.x;
relativePos.y = ((heightObject.position.z - testObject.z)/(20.0f*heightObject.localScale.z) + 1f) * 0.5f * heightObject.localScale.z;
}
//Custom UV Scaling
float useXScale = suimonoObject.enableCustomMesh ? suimonoObject.cmScaleX : 1f;
float useYScale = suimonoObject.enableCustomMesh ? suimonoObject.cmScaleY : 1f;
relativePos.x = relativePos.x * useXScale;
relativePos.y = relativePos.y * useYScale;
//calculate offset
useLocalTime = suimonoObject.localTime;
flow_dirC = SuimonoConvertAngleToVector(suimonoObject.flowDirection);
flowSpeed0 = new Vector2(flow_dirC.x*useLocalTime,flow_dirC.y*useLocalTime);
flowSpeed1 = new Vector2(flow_dirC.x*useLocalTime*0.25f,flow_dirC.y*useLocalTime*0.25f);
flowSpeed2 = new Vector2(flow_dirC.x*useLocalTime*0.0625f,flow_dirC.y*useLocalTime*0.0625f);
flowSpeed3 = new Vector2(flow_dirC.x*useLocalTime*0.125f,flow_dirC.y*useLocalTime*0.125f);
tScale = (1.0f/(suimonoObject.waveScale));
oPos = new Vector2(0.0f-suimonoObject.savePos.x,0.0f-suimonoObject.savePos.y);
//calculate texture coordinates
if (heightTex != null){
texCoord.x = (relativePos.x * tScale + flowSpeed0.x + (oPos.x)) * heightTex.width;
texCoord.z = (relativePos.y * tScale + flowSpeed0.y + (oPos.y)) * heightTex.height;
texCoord1.x = ((relativePos.x * tScale * 0.75f) - flowSpeed1.x + (oPos.x*0.75f)) * heightTex.width;
texCoord1.z = ((relativePos.y * tScale * 0.75f) - flowSpeed1.y + (oPos.y*0.75f)) * heightTex.height;
texCoordT.x = (relativePos.x * tScale + flowSpeed0.x + (oPos.x)) * heightTexT.width;
texCoordT.z = (relativePos.y * tScale + flowSpeed0.y + (oPos.y)) * heightTexT.height;
texCoordT1.x = ((relativePos.x * tScale * 0.5f) - flowSpeed1.x + (oPos.x*0.5f)) * heightTexT.width;
texCoordT1.z = ((relativePos.y * tScale * 0.5f) - flowSpeed1.y + (oPos.y*0.5f)) * heightTexT.height;
texCoordR.x = (relativePos.x * suimonoObject.lgWaveScale * tScale + flowSpeed2.x + (oPos.x*suimonoObject.lgWaveScale)) * heightTexR.width;
texCoordR.z = (relativePos.y * suimonoObject.lgWaveScale * tScale + flowSpeed2.y + (oPos.y*suimonoObject.lgWaveScale)) * heightTexR.height;
texCoordR1.x = ((relativePos.x * suimonoObject.lgWaveScale * tScale) + flowSpeed3.x + (oPos.x*suimonoObject.lgWaveScale)) * heightTexR.width;
texCoordR1.z = ((relativePos.y * suimonoObject.lgWaveScale * tScale ) + flowSpeed3.y + (oPos.y*suimonoObject.lgWaveScale)) * heightTexR.height;
//rotate coordinates
if (baseAngle != 0.0f){
pivotPoint = new Vector3(heightTex.width*heightObject.localScale.x*tScale*0.5f+(flowSpeed0.x*heightTex.width),0f,heightTex.height*heightObject.localScale.z*tScale*0.5f+(flowSpeed0.y*heightTex.height));
texCoord = RotatePointAroundPivot(texCoord,pivotPoint,heightObject.eulerAngles);
pivotPoint = new Vector3(heightTex.width*heightObject.localScale.x*tScale*0.5f*0.75f-(flowSpeed1.x*heightTex.width),0f,heightTex.height*heightObject.localScale.z*tScale*0.5f*0.75f-(flowSpeed1.y*heightTex.height));
texCoord1 = RotatePointAroundPivot(texCoord1,pivotPoint,heightObject.eulerAngles);
pivotPoint = new Vector3(heightTexT.width*heightObject.localScale.x*tScale*0.5f+(flowSpeed0.x*heightTexT.width),0f,heightTexT.height*heightObject.localScale.z*tScale*0.5f+(flowSpeed0.y*heightTexT.height));
texCoordT = RotatePointAroundPivot(texCoordT,pivotPoint,heightObject.eulerAngles);
pivotPoint = new Vector3(heightTexT.width*heightObject.localScale.x*tScale*0.5f*0.5f-(flowSpeed1.x*heightTexT.width),0f,heightTexT.height*heightObject.localScale.z*tScale*0.5f*0.5f-(flowSpeed1.y*heightTexT.height));
texCoordT1 = RotatePointAroundPivot(texCoordT1,pivotPoint,heightObject.eulerAngles);
pivotPoint = new Vector3(heightTexR.width*heightObject.localScale.x*suimonoObject.lgWaveScale*tScale*0.5f+(flowSpeed2.x*heightTexR.width),0f,heightTexR.height*heightObject.localScale.z*suimonoObject.lgWaveScale*tScale*0.5f+(flowSpeed2.y*heightTexR.height));
texCoordR = RotatePointAroundPivot(texCoordR,pivotPoint,heightObject.eulerAngles);
pivotPoint = new Vector3(heightTexR.width*heightObject.localScale.x*suimonoObject.lgWaveScale*tScale*0.5f+(flowSpeed3.x*heightTexR.width),0f,heightTexR.height*heightObject.localScale.z*suimonoObject.lgWaveScale*tScale*0.5f+(flowSpeed3.y*heightTexR.height));
texCoordR1 = RotatePointAroundPivot(texCoordR1,pivotPoint,heightObject.eulerAngles);
}
//decode height value
heightVal0 = DecodeHeightPixels(texCoord.x,texCoord.z,0);
heightVal1 = DecodeHeightPixels(texCoord1.x,texCoord1.z,0);
heightValT0 = DecodeHeightPixels(texCoordT.x,texCoordT.z,1);
heightValT1 = DecodeHeightPixels(texCoordT1.x,texCoordT1.z,1);
heightValR0 = DecodeHeightPixels(texCoordR.x,texCoordR.z,2);
heightValR1 = DecodeHeightPixels(texCoordR1.x,texCoordR1.z,2);
//set heightvalue
getheightC = (heightVal0.a + heightVal1.a) * 0.8f;
getheightT = ((heightValT0.a*0.2f) + (heightValT0.a * heightValT1.a * 0.8f)) * suimonoObject.turbulenceFactor * 0.5f;
getheightR = ((heightValR0.a * 4.0f) + (heightValR1.a * 3.0f));
getheight = baseHeight + (getheightC * suimonoObject.waveHeight);
getheight += (getheightT * suimonoObject.waveHeight);
getheight += (getheightR * suimonoObject.lgWaveHeight);
getheight = Mathf.Lerp(baseHeight,getheight,suimonoObject.useHeightProjection);
}
}
}
}
}
}
public void RegisterSurface(SuimonoObject surface)
{
if (Application.isPlaying){
if (surface != null && sObjects != null){
// If IndexOf() returns a valid index, the surface was already registered before and we can break
if (sObjects.IndexOf(surface) > -1) return;
sObjects.Add(surface);
sRends.Add(surface.transform.Find("Suimono_Object").gameObject.GetComponent<Renderer>());
sRendSCs.Add( surface.transform.Find("Suimono_ObjectScale").gameObject.GetComponent<Renderer>() );
}
}
}
public void DeregisterSurface(SuimonoObject surface)
{
if (Application.isPlaying){
if (surface != null && sObjects != null){
int surfaceIndex = sObjects.IndexOf(surface);
// If IndexOf() returns -1, the surface wasn't registered before and we can break
if (surfaceIndex < 0) return;
sObjects.RemoveAt(surfaceIndex);
sRends.RemoveAt(surfaceIndex);
sRendSCs.RemoveAt(surfaceIndex);
}
}
}
/*
//Check for visibility of all Suimono Surfaces in Scene
void InitSurfaceRenderers(){
sObjects = FindObjectsOfType(typeof(Suimono.Core.SuimonoObject)) as Suimono.Core.SuimonoObject[];
sRends = new List<Renderer>();
sRendSCs = new List<Renderer>();
for (int s = 0; s < sObjects.Length; s++){
sRends.Add( sObjects[s].transform.Find("Suimono_Object").gameObject.GetComponent<Renderer>() );
sRendSCs.Add( sObjects[s].transform.Find("Suimono_ObjectScale").gameObject.GetComponent<Renderer>() );
}
}
*/
/*
//Checks if surface objects are visible and disables module functions accordingly.
void SetCullFunction(){
renderCount = 0;
//Update surface count every 5 seconds
surfaceTimer += _deltaTime;
if (surfaceTimer > 5f){
surfaceTimer = 0f;
InitSurfaceRenderers();
}
//check for visibility
for (int sX = 0; sX < sRends.Count; sX++){
if (sRends[sX] != null){
if (sRends[sX].isVisible){
if (sObjects[sX].typeIndex == 0){
if (sRendSCs[sX].isVisible){
renderCount++;
}
} else {
renderCount++;
}
}
}
}
//Enable Functions
if (renderCount > 0 || isUnderwater){
useEnableTransparency = enableTransparency;
}
//Disable Functions
if (renderCount <= 0 && !isUnderwater){
useEnableTransparency = false;
}
}
*/
//Checks if surface objects are visible and disables module functions accordingly.
void SetCullFunction()
{
renderCount = 0;
//Update surface count every 5 seconds
//surfaceTimer += _deltaTime;
//if (surfaceTimer > 5f){
// surfaceTimer = 0f;
// InitSurfaceRenderers();
//}
//check for visibility
for (int sX = 0; sX < sObjects.Count; sX++)
{
if (sRends[sX] == null || !sRends[sX].isVisible) continue;
if (sObjects[sX].typeIndex == 0)
{
if (sRendSCs[sX] != null && sRendSCs[sX].isVisible) { renderCount++; }
}
else { renderCount++; }
}
//Enable Functions
if (renderCount > 0 || isUnderwater){
useEnableTransparency = enableTransparency;
}
//Disable Functions
if (renderCount <= 0 && !isUnderwater){
useEnableTransparency = false;
}
}
void InstallCameraEffect(){
//Installs Camera effect if it doesn't already exist.
if (setCameraComponent != null && autoSetCameraFX){
if (setCameraComponent.gameObject.GetComponent<Suimono.Core.Suimono_UnderwaterFog>() != null){
//do nothing
} else {
if (enableUnderwaterFX){
setCameraComponent.gameObject.AddComponent<Suimono.Core.Suimono_UnderwaterFog>();
}
}
}
}
}
}