364 lines
10 KiB
C#
364 lines
10 KiB
C#
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using UnityEngine;
|
|
|
|
public class setTransparentSurfacesSystem : MonoBehaviour
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public bool checkSurfaceEnabled = true;
|
|
|
|
public Shader transparentShader;
|
|
public float alphaBlendSpeed = 5;
|
|
public float alphaTransparency = 0.2f;
|
|
|
|
public bool useAlphaColor = true;
|
|
public string transparentAmountName = "_TransparentAmount";
|
|
|
|
public string colorPropertyName = "_Color";
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public List<surfaceInfo> surfaceInfoList = new List<surfaceInfo> ();
|
|
public List<GameObject> surfaceGameObjectList = new List<GameObject> ();
|
|
|
|
surfaceInfo newSurfaceInfo;
|
|
materialInfo newMaterialInfo;
|
|
|
|
int transparentAmountID = -1;
|
|
|
|
|
|
public const string mainManagerName = "Set Transparent Surfaces Manager";
|
|
|
|
public static string getMainManagerName ()
|
|
{
|
|
return mainManagerName;
|
|
}
|
|
|
|
private static setTransparentSurfacesSystem _setTransparentSurfacesSystemInstance;
|
|
|
|
public static setTransparentSurfacesSystem Instance { get { return _setTransparentSurfacesSystemInstance; } }
|
|
|
|
bool instanceInitialized;
|
|
|
|
|
|
public void getComponentInstance ()
|
|
{
|
|
if (instanceInitialized) {
|
|
return;
|
|
}
|
|
|
|
if (_setTransparentSurfacesSystemInstance != null && _setTransparentSurfacesSystemInstance != this) {
|
|
Destroy (this.gameObject);
|
|
|
|
return;
|
|
}
|
|
|
|
_setTransparentSurfacesSystemInstance = this;
|
|
|
|
instanceInitialized = true;
|
|
}
|
|
|
|
void Awake ()
|
|
{
|
|
getComponentInstance ();
|
|
}
|
|
|
|
public void addNewSurface (GameObject newSurface, Shader customShader)
|
|
{
|
|
if (!checkSurfaceEnabled) {
|
|
return;
|
|
}
|
|
|
|
newSurfaceInfo = new surfaceInfo ();
|
|
newSurfaceInfo.surfaceGameObject = newSurface;
|
|
|
|
Component[] components = newSurfaceInfo.surfaceGameObject.GetComponentsInChildren (typeof(Renderer));
|
|
|
|
int componentsLength = components.Length;
|
|
|
|
int colorID = Shader.PropertyToID (colorPropertyName);
|
|
|
|
for (int i = 0; i < componentsLength; i++) {
|
|
Renderer child = components [i] as Renderer;
|
|
|
|
if (child.material.shader != null) {
|
|
int materialsLength = child.materials.Length;
|
|
|
|
for (int j = 0; j < materialsLength; j++) {
|
|
Material currentMaterial = child.materials [j];
|
|
|
|
newMaterialInfo = new materialInfo ();
|
|
newMaterialInfo.surfaceMaterial = currentMaterial;
|
|
|
|
float colorValue = 1;
|
|
|
|
if (colorID != -1) {
|
|
if (currentMaterial.HasProperty (colorID)) {
|
|
Color alpha = currentMaterial.color;
|
|
|
|
colorValue = alpha.a;
|
|
}
|
|
}
|
|
|
|
newMaterialInfo.originalAlphaColor = colorValue;
|
|
|
|
newSurfaceInfo.materialInfoList.Add (newMaterialInfo);
|
|
newSurfaceInfo.originalShader.Add (currentMaterial.shader);
|
|
|
|
if (customShader != null) {
|
|
currentMaterial.shader = customShader;
|
|
|
|
newSurfaceInfo.customShader = customShader;
|
|
} else {
|
|
currentMaterial.shader = transparentShader;
|
|
|
|
newSurfaceInfo.customShader = transparentShader;
|
|
}
|
|
|
|
newSurfaceInfo.materialsAmount++;
|
|
}
|
|
}
|
|
}
|
|
|
|
setSurfaceTransparent (newSurfaceInfo);
|
|
|
|
surfaceInfoList.Add (newSurfaceInfo);
|
|
|
|
surfaceGameObjectList.Add (newSurfaceInfo.surfaceGameObject);
|
|
}
|
|
|
|
public bool listContainsSurface (GameObject surfaceToCheck)
|
|
{
|
|
if (!checkSurfaceEnabled) {
|
|
return false;
|
|
}
|
|
|
|
if (surfaceGameObjectList.Contains (surfaceToCheck)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void setSurfaceToRegular (int surfaceIndex, bool removeSurfaceAtEnd)
|
|
{
|
|
if (!checkSurfaceEnabled) {
|
|
return;
|
|
}
|
|
|
|
surfaceInfo currentSurfaceToCheck = surfaceInfoList [surfaceIndex];
|
|
|
|
currentSurfaceToCheck.changingToOriginalActive = true;
|
|
currentSurfaceToCheck.currentMaterialsChangedAmount = 0;
|
|
currentSurfaceToCheck.changingToTransparentActive = false;
|
|
|
|
currentSurfaceToCheck.changingToOriginalTemporaly = !removeSurfaceAtEnd;
|
|
|
|
for (int j = 0; j < currentSurfaceToCheck.materialInfoList.Count; j++) {
|
|
setAlphaValue (currentSurfaceToCheck, j, currentSurfaceToCheck.materialInfoList [j].surfaceMaterial,
|
|
false, currentSurfaceToCheck.originalShader [j], currentSurfaceToCheck.materialInfoList [j].originalAlphaColor, removeSurfaceAtEnd);
|
|
}
|
|
}
|
|
|
|
public void checkSurfaceToSetTransparentAgain (GameObject surfaceToCheck)
|
|
{
|
|
if (!checkSurfaceEnabled) {
|
|
return;
|
|
}
|
|
|
|
int surfaceIndex = surfaceGameObjectList.IndexOf (surfaceToCheck);
|
|
|
|
if (surfaceIndex > -1) {
|
|
surfaceInfo currentSurfaceToCheck = surfaceInfoList [surfaceIndex];
|
|
|
|
if (currentSurfaceToCheck.changingToOriginalActive && !currentSurfaceToCheck.changingToOriginalTemporaly) {
|
|
// print ("changing to original, stopping");
|
|
setSurfaceTransparent (currentSurfaceToCheck);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setSurfaceTransparent (surfaceInfo currentSurfaceToCheck)
|
|
{
|
|
currentSurfaceToCheck.changingToOriginalActive = false;
|
|
currentSurfaceToCheck.currentMaterialsChangedAmount = 0;
|
|
currentSurfaceToCheck.changingToTransparentActive = true;
|
|
|
|
for (int j = 0; j < currentSurfaceToCheck.materialInfoList.Count; j++) {
|
|
setAlphaValue (currentSurfaceToCheck, j, currentSurfaceToCheck.materialInfoList [j].surfaceMaterial,
|
|
true, currentSurfaceToCheck.originalShader [j], currentSurfaceToCheck.materialInfoList [j].originalAlphaColor, false);
|
|
}
|
|
}
|
|
|
|
|
|
public void setAlphaValue (surfaceInfo currentSurfaceToCheck, int surfaceIndex, Material currentMaterial,
|
|
bool changingToTransparent, Shader originalShader, float originalAlphaColor, bool removeSurfaceAtEnd)
|
|
{
|
|
if (currentSurfaceToCheck.materialInfoList [surfaceIndex].alphaBlendCoroutine != null) {
|
|
StopCoroutine (currentSurfaceToCheck.materialInfoList [surfaceIndex].alphaBlendCoroutine);
|
|
}
|
|
|
|
currentSurfaceToCheck.materialInfoList [surfaceIndex].alphaBlendCoroutine =
|
|
StartCoroutine (setAlphaValueCoroutine (currentSurfaceToCheck, currentMaterial,
|
|
changingToTransparent, originalShader, originalAlphaColor, removeSurfaceAtEnd));
|
|
}
|
|
|
|
IEnumerator setAlphaValueCoroutine (surfaceInfo currentSurfaceToCheck, Material currentMaterial, bool changingToTransparent,
|
|
Shader originalShader, float originalAlphaColor, bool removeSurfaceAtEnd)
|
|
{
|
|
float targetValue = originalAlphaColor;
|
|
|
|
if (changingToTransparent) {
|
|
targetValue = alphaTransparency;
|
|
|
|
if (currentSurfaceToCheck.changingToOriginalTemporaly) {
|
|
currentMaterial.shader = currentSurfaceToCheck.customShader;
|
|
}
|
|
}
|
|
|
|
if (useAlphaColor) {
|
|
Color alpha = currentMaterial.color;
|
|
|
|
while (alpha.a != targetValue) {
|
|
alpha.a = Mathf.MoveTowards (alpha.a, targetValue, Time.deltaTime * alphaBlendSpeed);
|
|
currentMaterial.color = alpha;
|
|
|
|
yield return null;
|
|
}
|
|
} else {
|
|
if (transparentAmountID == -1) {
|
|
transparentAmountID = Shader.PropertyToID (transparentAmountName);
|
|
}
|
|
|
|
if (currentMaterial.HasProperty (transparentAmountID)) {
|
|
|
|
float currentTransparentAmount = currentMaterial.GetFloat (transparentAmountID);
|
|
|
|
while (currentTransparentAmount != targetValue) {
|
|
currentTransparentAmount = Mathf.MoveTowards (currentTransparentAmount, targetValue, Time.deltaTime * alphaBlendSpeed);
|
|
currentMaterial.SetFloat (transparentAmountID, currentTransparentAmount);
|
|
|
|
yield return null;
|
|
}
|
|
} else {
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
if (!changingToTransparent) {
|
|
currentMaterial.shader = originalShader;
|
|
}
|
|
|
|
if (currentSurfaceToCheck.changingToOriginalActive) {
|
|
currentSurfaceToCheck.currentMaterialsChangedAmount++;
|
|
|
|
if (removeSurfaceAtEnd) {
|
|
if (currentSurfaceToCheck.currentMaterialsChangedAmount == currentSurfaceToCheck.materialsAmount) {
|
|
surfaceInfoList.Remove (currentSurfaceToCheck);
|
|
|
|
surfaceGameObjectList.Remove (currentSurfaceToCheck.surfaceGameObject);
|
|
}
|
|
}
|
|
} else {
|
|
currentSurfaceToCheck.currentMaterialsChangedAmount++;
|
|
|
|
if (currentSurfaceToCheck.currentMaterialsChangedAmount == currentSurfaceToCheck.materialsAmount) {
|
|
currentSurfaceToCheck.changingToTransparentActive = false;
|
|
|
|
currentSurfaceToCheck.changingToOriginalTemporaly = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkSurfacesToRemove ()
|
|
{
|
|
if (!checkSurfaceEnabled) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < surfaceInfoList.Count; i++) {
|
|
surfaceInfo currentSurfaceToCheck = surfaceInfoList [i];
|
|
|
|
if (currentSurfaceToCheck.numberOfPlayersFound == 0) {
|
|
setSurfaceToRegular (i, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void changeSurfacesToTransparentOrRegularTemporaly (int playerID, int surfaceIndex, bool setTransparentSurface)
|
|
{
|
|
if (surfaceInfoList [surfaceIndex].playerIDs.Contains (playerID)) {
|
|
if (setTransparentSurface) {
|
|
// print ("transparent");
|
|
setSurfaceTransparent (surfaceInfoList [surfaceIndex]);
|
|
} else {
|
|
// print ("regular");
|
|
setSurfaceToRegular (surfaceIndex, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void addPlayerIDToSurface (int playerID, GameObject surfaceToCheck)
|
|
{
|
|
if (!checkSurfaceEnabled) {
|
|
return;
|
|
}
|
|
|
|
for (int i = 0; i < surfaceInfoList.Count; i++) {
|
|
if (surfaceInfoList [i].surfaceGameObject == surfaceToCheck) {
|
|
if (!surfaceInfoList [i].playerIDs.Contains (playerID)) {
|
|
surfaceInfoList [i].playerIDs.Add (playerID);
|
|
|
|
surfaceInfoList [i].numberOfPlayersFound++;
|
|
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void removePlayerIDToSurface (int playerID, int surfaceIndex)
|
|
{
|
|
if (!checkSurfaceEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (surfaceInfoList [surfaceIndex].playerIDs.Contains (playerID)) {
|
|
surfaceInfoList [surfaceIndex].playerIDs.Remove (playerID);
|
|
|
|
surfaceInfoList [surfaceIndex].numberOfPlayersFound--;
|
|
}
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class surfaceInfo
|
|
{
|
|
public GameObject surfaceGameObject;
|
|
public List<Shader> originalShader = new List<Shader> ();
|
|
public List<materialInfo> materialInfoList = new List<materialInfo> ();
|
|
public List<int> playerIDs = new List<int> ();
|
|
public int numberOfPlayersFound;
|
|
|
|
public bool changingToTransparentActive;
|
|
public bool changingToOriginalActive;
|
|
public bool changingToOriginalTemporaly;
|
|
|
|
public int materialsAmount;
|
|
public int currentMaterialsChangedAmount;
|
|
|
|
public Shader customShader;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class materialInfo
|
|
{
|
|
public Material surfaceMaterial;
|
|
public Coroutine alphaBlendCoroutine;
|
|
public float originalAlphaColor;
|
|
}
|
|
}
|