add ckg

plantilla base para movimiento básico

Assets/Game Kit Controller/Scripts/Camera/Others/playerCullingSystem.cs

@@ -0,0 +1,268 @@
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public class playerCullingSystem : MonoBehaviour
+{
+	[Header ("Main Settings")]
+	[Space]
+
+	public bool cullingSystemEnabled = true;
+
+	public float minDistanceToApplyShader = 1;
+	public float minCullingShaderValue = 0.2f;
+	public float slerpCullingSpeed = 1;
+
+	public float stippleSize;
+
+	public string transparentAmountName = "_TransparentAmount";
+
+	public bool setStippleSize;
+	public string stippleSizeName = "_StippleSize";
+
+	[Space]
+	[Header ("Player GameObject List")]
+	[Space]
+
+	public List<GameObject> playerGameObjectList = new List<GameObject> ();
+	public List<GameObject> playerGameObjectWithChildList = new List<GameObject> ();
+
+	[Space]
+	[Header ("Debug")]
+	[Space]
+
+	public bool pauseCullingState;
+	public float cullingAmountToApply;
+	public bool cullingActive;
+	public float currentDistance;
+	public float currentCullingValue;
+	public bool materialsChangedChecked;
+
+	[Space]
+	[Header ("Components")]
+	[Space]
+
+	public Shader cullingShader;
+	public Transform playerTransform;
+	public Transform cameraTransform;
+	public playerCamera mainPlayerCamera;
+
+	public List<Renderer> rendererParts = new List<Renderer> ();
+	public List<Shader> originalShader = new List<Shader> ();
+	public List<Material> materialList = new List<Material> ();
+
+	float previousCullingValue;
+
+	bool materialsStored;
+
+	int transparentAmountID;
+
+	int stippleSizeID;
+
+	float previousStippleSize = -1;
+
+	int materialsCount;
+
+	Material temporalMaterial;
+
+	void Start ()
+	{
+		if (rendererParts.Count == 0) {
+			storePlayerRenderer ();
+		}
+
+		transparentAmountID = Shader.PropertyToID (transparentAmountName);
+
+		stippleSizeID = Shader.PropertyToID (stippleSizeName);
+	}
+
+	void FixedUpdate ()
+	{
+		if (!cullingSystemEnabled) {
+			return;
+		}
+
+		currentDistance = GKC_Utils.distance (playerTransform.position, cameraTransform.position);
+
+		if (!pauseCullingState && currentDistance < minDistanceToApplyShader) {
+			cullingAmountToApply = currentDistance / minDistanceToApplyShader;
+
+			cullingActive = true;
+		} else {
+			cullingActive = false;
+
+			cullingAmountToApply = 1;
+		}
+
+		if (cullingActive) {
+			if (mainPlayerCamera.isFirstPersonActive ()) {
+				cullingActive = false;
+			} else {
+				if (mainPlayerCamera.isFullBodyAwarenessActive ()) {
+					cullingActive = false;
+				} else {
+					bool isCameraTypeFree = mainPlayerCamera.isCameraTypeFree ();
+
+					if (!isCameraTypeFree) {
+						cullingActive = false;
+					} else {
+						if (mainPlayerCamera.isPlayerAiming ()) {
+							cullingAmountToApply = 1;
+						}
+					}
+				}
+			}
+		}
+			
+		if (materialsChangedChecked != cullingActive) {
+			materialsChangedChecked = cullingActive;
+
+			if (!materialsStored) {
+				getMaterialList ();
+
+				materialsStored = true;
+			}
+
+			materialsCount = materialList.Count;
+
+			for (int j = 0; j < materialsCount; j++) {
+				temporalMaterial = materialList [j];
+
+				if (cullingActive) {
+					temporalMaterial.shader = cullingShader;
+
+					if (setStippleSize) {
+						if (stippleSize != previousStippleSize) {
+							previousStippleSize = stippleSize;
+
+							temporalMaterial.SetFloat (stippleSizeID, stippleSize);
+						}
+					}
+				} else {
+					temporalMaterial.shader = originalShader [j];
+				}
+			}
+		}
+			
+		currentCullingValue = Mathf.Lerp (currentCullingValue, cullingAmountToApply, Time.deltaTime * slerpCullingSpeed);
+
+		if (currentCullingValue <= 1) {
+			if (Mathf.Abs (currentCullingValue - previousCullingValue) > 0.01f) {
+
+				materialsCount = materialList.Count;
+
+				for (int j = 0; j < materialsCount; j++) {
+					materialList [j].SetFloat (transparentAmountID, currentCullingValue);
+				}
+
+				previousCullingValue = currentCullingValue;
+			}
+		}
+	}
+
+	public void setPauseCullingState (bool state)
+	{
+		pauseCullingState = state;
+	}
+
+	public void getMaterialList ()
+	{
+		if (materialList.Count == 0) {
+			int rendererPartsCount = rendererParts.Count;
+
+			for (int i = 0; i < rendererPartsCount; i++) {
+				Renderer currentRenderer = rendererParts [i];
+
+				if (currentRenderer != null) {
+					
+					if (currentRenderer.material.shader != null) {
+						int materialsLength = currentRenderer.materials.Length;
+
+						for (int j = 0; j < materialsLength; j++) {
+
+							Material currentMaterial = currentRenderer.materials [j];
+							
+							if (currentMaterial != null) {
+								
+								materialList.Add (currentMaterial);
+
+								originalShader.Add (currentMaterial.shader);
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	public void clearRendererList ()
+	{
+		rendererParts.Clear ();
+
+		originalShader.Clear ();
+	}
+
+	public void storePlayerRenderer ()
+	{
+		clearRendererList ();
+
+		for (int i = 0; i < playerGameObjectList.Count; i++) {
+			GameObject currentObject = playerGameObjectList [i];
+
+			if (currentObject != null) {
+				Renderer currentRenderer = currentObject.GetComponent<Renderer> ();
+
+				rendererParts.Add (currentRenderer);
+			}
+		}
+
+		for (int i = 0; i < playerGameObjectWithChildList.Count; i++) {
+			GameObject currentObject = playerGameObjectWithChildList [i];
+
+			if (currentObject != null) {
+				Component[] components = currentObject.GetComponentsInChildren (typeof(Renderer));
+
+				int componentsLength = components.Length;
+
+				for (int j = 0; j < componentsLength; j++) {
+					rendererParts.Add (components [j] as Renderer);
+				}
+			}
+		}
+
+		print ("Total amount of " + rendererParts.Count + " render found");
+	}
+
+	public void storePlayerRendererFromEditor ()
+	{
+		storePlayerRenderer ();
+
+		updateComponent ();
+	}
+
+	public void clearRendererListFromEditor ()
+	{
+		clearRendererList ();
+
+		updateComponent ();
+	}
+
+	public void setCullingSystemEnabledState (bool state)
+	{
+		cullingSystemEnabled = state;
+	}
+
+	public void setCullingSystemEnabledStateFromEditor (bool state)
+	{
+		setCullingSystemEnabledState (state);
+
+		updateComponent ();
+	}
+
+	public void updateComponent ()
+	{
+		GKC_Utils.updateComponent (this);
+
+		GKC_Utils.updateDirtyScene ("Update Player Culling System", gameObject);
+	}
+}