// Update is called once per frame
void Update()
{
material.SetVector("_Dissolve_ObjectWorldPos", transform.position);
//We need to update Unity GI every time we change material properties effecting GI
RendererExtensions.UpdateGIMaterials(mRenderer);
}
void PlayCutout()
{
deltaTime += Time.deltaTime * 0.175f;
float alphaValue = Mathf.Lerp(1f, -1f, Mathf.Clamp01(deltaTime));
for (int i = 0; i < actors.Length; i++)
{
actors[i].material.SetFloat("_V_WIRE_TransparentTex_Alpha_Offset", alphaValue);
//Notify Unity GI about material data changing
RendererExtensions.UpdateGIMaterials(actors[i]);
DynamicGI.UpdateEnvironment();
}
if (deltaTime > 1)
{
playCutoutAnimation = false;
//The End
#if UNITY_EDITOR
UnityEditor.EditorApplication.isPlaying = false;
#endif
}
}
private IEnumerator TransitionLaserOff()
{
GetComponent <Collider>().enabled = false;
float elapsedTime = 0;
float ratio = elapsedTime / duration;
//int property = Shader.PropertyToID("_D7A8CF01");
Vector3 start = new Vector3(1f, 1f, 1f);
Vector3 end = new Vector3(7f, 7f, 7f);
while (ratio < 1f)
{
elapsedTime += Time.deltaTime;
ratio = elapsedTime / duration;
float value = Mathf.Lerp(1f, 0f, ratio);
Vector3 current = Vector3.Lerp(start, end, ratio);
transform.localScale = current;
innerRing.localScale = current;
material.SetFloat("_TransitionState", value);
innerMaterial.SetFloat("_TransitionState", value);
RendererExtensions.UpdateGIMaterials(mRenderer);
RendererExtensions.UpdateGIMaterials(innerRenderer);
yield return(null);
}
mRenderer.enabled = false;
}
// Update is called once per frame
void Update()
{
if (Time.time > startTime + 5f)
{
RendererExtensions.UpdateGIMaterials(rend);
}
}
IEnumerator LoopNodeFindingDelay()
{
while (true)
{
if (currentNodeRen == null)
{
yield return(new WaitForSecondsRealtime(1f));
continue;
}
if (!RendererExtensions.IsVisibleFrom(currentNodeRen, cam))
{
Debug.Log("current node is not on cam");
calculateNodeSide();
}
else //if node is on screen turn off the UI
{
turnLeftUI.transform.DOScale(0, 0.25f);
turnRightUI.transform.DOScale(0, 0.25f);
distanceLeft = 0;
distanceRight = 0;
}
yield return(new WaitForSecondsRealtime(1f));
}
}
private void Update()
{
if (!RendererExtensions.IsVisibleFrom(gameObject.GetComponentInChildren <Renderer>(), main) && transform.position.x < spawnEndLocation.position.x)
{
transform.position = new Vector3(spawnLocation.position.x, Random.Range((float)spawnLocation.position.y - 1.0f, (float)spawnLocation.position.y + 1.0f), spawnLocation.position.z);
}
}
public void UpdateLights()
{
for (int i = 0; i < _rends.Length; i++)
{
RendererExtensions.UpdateGIMaterials(_rends[i]);
}
}
private void Update()
{
if (!(Renderer == null) && UpdateGIMaterialsEveryTick)
{
RendererExtensions.UpdateGIMaterials(Renderer);
}
}
private IEnumerator RingGrow(float wait)
{
yield return(new WaitForSeconds(wait));
float elapsedTime = 0f;
float ratio = elapsedTime / mySpeed;
//int property = Shader.PropertyToID("_D7A8CF01");
Vector3 startpoint;
Vector3 endpoint;
startpoint = new Vector3(startScale, startScale, startScale);
endpoint = new Vector3(endScale, endScale, endScale);
while (ratio < 1f)
{
elapsedTime += Time.deltaTime;
ratio = elapsedTime / mySpeed;
//float value = Mathf.Lerp(startpoint, endpoint, ratio);
Vector3 value = Vector3.Lerp(startpoint, endpoint, ratio);
transform.localScale = value;
float v = Mathf.Lerp(0f, 1f, ratio);
material.SetFloat("_TransitionState", v);
RendererExtensions.UpdateGIMaterials(mRenderer);
yield return(null);
}
UnityEngine.Object.Destroy(this.gameObject);
}
// Update is called once per frame
void Update()
{
// 炸弹爆炸倒计时，1s
if (boomTime > 0)
{
boomTime -= 0.01f;
}
else
{
OnBooming( );
}
// 设置炸弹闪烁，在颜色计时器的两个区间分别渲染不同颜色
if (tempTime < 1)
{
tempTime += 0.05f;
this.gameObject.GetComponent <Renderer> ( ).material.SetColor("_EmissionColor", Color.HSVToRGB(0, 0, 0));
RendererExtensions.UpdateGIMaterials(this.gameObject.GetComponent <Renderer> ( ));
}
else if (tempTime < 2)
{
tempTime += 0.05f;
this.gameObject.GetComponent <Renderer> ( ).material.SetColor("_EmissionColor", Color.HSVToRGB(1, 1, 1));
RendererExtensions.UpdateGIMaterials(this.gameObject.GetComponent <Renderer> ( ));
}
else
{
tempTime = 0;
}
}
// After all actions the object takes, we face the billboard
void LateUpdate()
{
if (renderer && !RendererExtensions.IsVisibleFrom(renderer, referenceCamera))
{
return;
}
if (Flip)
{
targetPos = transform.position + referenceCamera.transform.rotation * Vector3.back;
}
else
{
targetPos = transform.position + referenceCamera.transform.rotation * Vector3.forward;
}
// Ignore camera Y position to stay upright
if (LockY)
{
targetPos.y = transform.position.y;
}
transform.LookAt(targetPos); // Inefficient, slowdowns with massive billboards
if (Rotate90)
{
transform.Rotate(Vector3.left, 90F);
}
}
private void UpdateEmission(float timePercent)
{
for (int count = 0; count < material.Length; count++)
{
if (material != null)
{
//resets the repitions of the current material to 0 so it can repeat next cycle
if (timePercent > 0.35f && timePercent < 0.75f)
{
repitions[count] = 0;
}
if (timePercent > 0f && timePercent < 0.15f)
{
repitions[count] = 0;
}
//Checks if it is turning into night or day
//Dims the light if it is turning into day
else if (timePercent < 0.25f && timePercent > 0.15f)
{
if (repitions[count] < dawnRepeats)
{
material[count].SetColor("_EmissionColor", material[count].GetColor("_EmissionColor") * dimmingValue);
repitions[count]++;
}
}
//Brightens emission at nighttime
else if (timePercent < 0.9f && timePercent > 0.8f)
{
if (repitions[count] < duskRepeats)
{
material[count].SetColor("_EmissionColor", material[count].GetColor("_EmissionColor") * brightenValue);
repitions[count]++;
}
}
//Makes sure emission is properly off at daytime and that engine confirms it
else if (timePercent > 0.25f && timePercent < 0.3f)
{
material[count].DisableKeyword("_EMISSION");
material[count].globalIlluminationFlags = MaterialGlobalIlluminationFlags.EmissiveIsBlack;
RendererExtensions.UpdateGIMaterials(GetComponent <Renderer>());
DynamicGI.SetEmissive(GetComponent <Renderer>(), Color.black);
DynamicGI.UpdateEnvironment();
}
//Makes sure emission is properly on at nighttime and that engine confirms it
else if (timePercent < 0.8f && timePercent > 0.75f && repitions[count] < 1)
{
material[count].EnableKeyword("_EMISSION");
material[count].globalIlluminationFlags = MaterialGlobalIlluminationFlags.RealtimeEmissive;
material[count].SetColor("_EmissionColor", material[count].GetColor("_Color") * 0.2f);
RendererExtensions.UpdateGIMaterials(GetComponent <Renderer>());
DynamicGI.SetEmissive(GetComponent <Renderer>(), material[count].GetColor("_Color") * 0.2f);
DynamicGI.UpdateEnvironment();
repitions[count]++;
}
}
}
}
void Update()
{
Transform t = Camera.main.transform;
t.rotation = Quaternion.Lerp(t.rotation, to.rotation, Time.time * speed * 0.8f);
t.position = Vector3.Lerp(t.position, to.position, Time.time * speed);
RendererExtensions.UpdateGIMaterials(meshRenderer);
}
void Update()
{
bool isInsideCamera = RendererExtensions.IsVisibleFrom(this.GetComponent <SpriteRenderer>(), Camera.main);
if (isInsideCamera && isInvincible)
{
isInvincible = false;
}
}
// Update is called once per frame
void Update()
{
//Dynamic GI uses META pass, which has no info about mesh position in the world.
//We have to provive mesh world position data manually
material.SetVector("_Dissolve_ObjectWorldPos", transform.position);
//We need to update Unity GI every time we change material properties effecting GI
RendererExtensions.UpdateGIMaterials(mRenderer);
}
void Update()
{
bool isInsideCamera = RendererExtensions.IsVisibleFrom(this.GetComponent <SpriteRenderer>(), mainCamera);
if (!isInsideCamera)
{
Destroy(this.gameObject);
}
}
void Update()
{
curFrame++;
if (curFrame >= Frames)
{
RendererExtensions.UpdateGIMaterials(r);
curFrame = 0;
}
}
/// <summary>
/// 检查动态 GI 是否需要更新
/// </summary>
public void ValidateDynamicGI()
{
if (_updateDynamicGI && _materialType != MaterialType.Specified)
{
#if UNITY_5_6_OR_NEWER
RendererExtensions.UpdateGIMaterials(_renderer);
#else
DynamicGI.UpdateMaterials(_renderer);
#endif
}
}
// Update is called once per frame
public void colorUpdate()
{
/*
* if (hueCycle) {
* mat.SetColor (property, Color.HSVToRGB (Mathf.Repeat (Time.time / 10f, 1f), 1f, 1f));
* }*/
/*if (offsetAnim != Vector2.zero)
* mat.mainTextureOffset += offsetAnim * Time.deltaTime;*/
mat.SetColor(property, color);
RendererExtensions.UpdateGIMaterials(mr);
}
public override void Start()
{
base.Start();
//happens on Interactable Object's start, makes sure all objs start on correct world color
if (this.gameObject.layer == 10)
{
SetMaterialFloatProp("_TransitionStateB", 1);
}
else
{
SetMaterialFloatProp("_TransitionStateB", 0);
}
if (_selectionRenderChange)
{
_selectionRenderChange.SetFlippable();
}
SetMaterialFloatProp("_Flippable", 1f);
SetMaterialFloatProp("_Shimmer", 1f);
SetMaterialFloatProp("_onHold", 0f);
SetMaterialFloatProp("_EdgeThickness", Toolbox.Instance.EdgeGlowThickness());
shimmerColor = _material.GetColor("_ShimmerColor");
_core = GetComponentInChildren <Core>();
if (_core)
{
GetComponentInChildren <Core>().SetColor(shimmerColor);
_coreTransition = _core.GetComponent <Transition>();
}
RendererExtensions.UpdateGIMaterials(_renderer);
_transition = GetComponent <Transition>();
realTransform = sceneContainer.Find("Real");
laserTransform = sceneContainer.Find("Laser");
/*
* if (!slowPickup && !(objectType==ObjectType.Wall || objectType == ObjectType.LinkedPair))
* rigidbody.isKinematic = false;
*/
//if(GetComponent<Rigidbody>()){
// var rb = GetComponent<Rigidbody>();
// rb.constraints = RigidbodyConstraints.None;
// rb.isKinematic = false;
// rb.useGravity = true;
//}
}
// Update is called once per frame
void Update()
{
//if(mat != null && mRenderer != null)
// mat.SetVector("_V_WIRE_ObjectWorldPos", transform.position);
//As in current example GI depends on Distamce Fade effect
//we need to update Unity GI on every frame
RendererExtensions.UpdateGIMaterials(mRenderer);
}
protected void Update()
{
_currentIntensity = Mathf.PingPong(Time.time * _speed, _toIntensity);
_material.SetColor(EmissionColor, _fromColor * _currentIntensity);
_material.EnableKeyword(Emission);
DynamicGI.SetEmissive(_renderer, _fromColor * _currentIntensity);
//DynamicGI.SetEmissive(_renderer, _fromColor * Mathf.LinearToGammaSpace (_currentIntensity));
RendererExtensions.UpdateGIMaterials(_renderer);
DynamicGI.UpdateEnvironment();
}
// Update is called once per frame.
void Update()
{
// Check if this object (corpse) is being renderer by Camera.
if (RendererExtensions.IsVisibleFrom(_renderer, Camera.main))
{
if (!_hasSpawn)
{
_spawnController.SpawnRat(SpawnPoints);
_hasSpawn = true;
}
}
}
// Update is called once per frame
void Update()
{
if (hueCycle)
{
mat.SetColor(property, Color.HSVToRGB(Mathf.Repeat(Time.time / 10f, 1f), 1f, 1f));
}
if (offsetAnim != Vector2.zero)
{
mat.mainTextureOffset += offsetAnim * Time.deltaTime;
}
RendererExtensions.UpdateGIMaterials(mr);
}
public void checkVisibility()
{
isVisible = RendererExtensions.IsVisibleFrom(sprite, cam);
if (isVisible && !lastVisible)
{
GameManager.Instance.currentFight.onPlayerInsideCamera(player);
}
if (!isVisible && lastVisible)
{
GameManager.Instance.currentFight.onPlayerOutOfCamera(player);
}
lastVisible = isVisible;
}
// Update is called once per frame
void Update()
{
material.SetFloat("_DissolveCutoff", Mathf.PingPong(offset + Time.time * speed, 1));
if (updateGI)
{
material.SetVector("_Dissolve_ObjectWorldPos", transform.position);
RendererExtensions.UpdateGIMaterials(mRenderer);
}
}
void ActivateActor(Renderer _renderer, float _intensity)
{
//Make flikering effect
_renderer.gameObject.SetActive(_intensity > 0);
//Enable or Disable GI inside material
_renderer.material.SetFloat("_V_WIRE_DynamicGI", _intensity > 0 ? 1 : 0);
//Notify Unity GI about material data changing
RendererExtensions.UpdateGIMaterials(_renderer);
DynamicGI.UpdateEnvironment();
}
// Update is called once per frame
void Update()
{
//Animating cutout
material.SetFloat("_DissolveCutoff", Mathf.PingPong(offset + Time.time * speed, 1));
//Dynamic GI uses META pass, which does not have info about mesh position in the world.
//We have to provive mesh world position data manually
material.SetVector("_Dissolve_ObjectWorldPos", transform.position);
//We need to update Unity GI every time we change material properties effecting GI
RendererExtensions.UpdateGIMaterials(mRenderer);
}
/**
* Checks every fixed update if the spawner is visible from the main camera.
* If it is then an invoke repeating is executed only once on the Spawn enemy
* function.
*
* If it is not then the invoke is cancelled.
*
* Prevents the world from being stuffed with enemies that aren't in the game's view.
*
*/
private void FixedUpdate()
{
if (RendererExtensions.IsVisibleFrom(gameObject.GetComponent <SpriteRenderer>(), Camera.main))
{
if (IsInvoking("SpawnEnemy"))
{
return;
}
InvokeRepeating("SpawnEnemy", 0.5f, 0.25f);
}
else
{
CancelInvoke("SpawnEnemy");
}
}
IEnumerator ShimmerRoutine(float duration)
{
if (!Toolbox.Instance.EqualToHeld(this.gameObject))
{
selected = false;
}
float elapsedTime = 0;
this.recentlySelected = true;
float ratio = elapsedTime / duration;
while (ratio < 1f)
{
if (selected)
{
SetMaterialFloatProp("_onHold", 1f);
SetMaterialFloatProp("_Shimmer", 1f);
RendererExtensions.UpdateGIMaterials(_renderer);
recentlySelected = false;
yield break;
}
elapsedTime += Time.fixedDeltaTime;
ratio = elapsedTime / duration;
//shimmer stuff
float start = 1f;
float end = 0f;
if (!pickUp.heldObject || !this.gameObject.Equals(pickUp.heldObject))
{
float shimmerValue = Mathf.Lerp(start, end, ratio);
SetMaterialFloatProp("_onHold", shimmerValue);
SetMaterialFloatProp("_Shimmer", shimmerValue);
RendererExtensions.UpdateGIMaterials(_renderer);
}
yield return(new WaitForFixedUpdate());
}
this.recentlySelected = false;
if (!pickUp.heldObject || !this.gameObject.Equals(pickUp.heldObject))
{
SetMaterialFloatProp("_onHold", 0f);
SetMaterialFloatProp("_Shimmer", 1f);
}
}
