254 lines
9.3 KiB
C#
254 lines
9.3 KiB
C#
using System.Collections;
|
|
using UnityEngine;
|
|
using UnityEngine.Rendering;
|
|
|
|
public class ScarecrowFire : MonoBehaviour
|
|
{
|
|
[System.Serializable]
|
|
public class FireElement
|
|
{
|
|
public GameObject VFX;
|
|
/// <summary>Original scale captured at initialization, used as lerp target.</summary>
|
|
[HideInInspector] public Vector3 OriginalScale;
|
|
}
|
|
|
|
[Header("Fire VFX Elements")]
|
|
[SerializeField] private FireElement _fireBase;
|
|
[SerializeField] private FireElement _fireTorso;
|
|
[SerializeField] private FireElement _fireArmLeft;
|
|
[SerializeField] private FireElement _fireArmLeftEnd;
|
|
[SerializeField] private FireElement _fireArmRight;
|
|
[SerializeField] private FireElement _fireArmRightEnd;
|
|
[SerializeField] private FireElement _fireHead;
|
|
[SerializeField] private FireElement _fireBig;
|
|
|
|
[Header("Propagation Timings")]
|
|
[Tooltip("Duration of the scale lerp for each fire element (seconds).")]
|
|
[SerializeField] private float _growDuration = 3f;
|
|
|
|
[Tooltip("How early the next stage starts before the current one finishes (0 = no overlap, 1 = instant).")]
|
|
[Range(0f, 1f)]
|
|
[SerializeField] private float _overlapFactor = 0.4f;
|
|
|
|
[Tooltip("Curve driving the scale growth — tweak directly in the Inspector.")]
|
|
[SerializeField] private AnimationCurve _growCurve = new AnimationCurve(
|
|
new Keyframe(0f, 0f, 0f, 0f),
|
|
new Keyframe(0.3f, 0.1f, 0f, 2f),
|
|
new Keyframe(0.7f, 0.8f, 2f, 0.5f),
|
|
new Keyframe(1f, 1f, 0.2f, 0f)
|
|
);
|
|
|
|
[Header("Post Process")]
|
|
[Tooltip("Volume driving the heat haze effect — weight is driven up as fire spreads.")]
|
|
[SerializeField] private Volume _heatVolume;
|
|
|
|
[Tooltip("Curve driving all heat effects over the full sequence duration.")]
|
|
[SerializeField] private AnimationCurve _heatCurve = new AnimationCurve(
|
|
new Keyframe(0f, 0f, 0f, 0.5f),
|
|
new Keyframe(0.5f, 0.4f, 1f, 1f),
|
|
new Keyframe(1f, 1f, 0.5f, 0f)
|
|
);
|
|
|
|
[Header("Heat Shader")]
|
|
[Tooltip("Material using the HeatHaze shader — _Weight property is driven from 0 to 1.")]
|
|
[SerializeField] private Material _heatMaterial;
|
|
|
|
[Header("Light")]
|
|
[Tooltip("LightFlicker component to drive — baseIntensity is ramped up with the fire.")]
|
|
[SerializeField] private MonoLimboStudio.LightFlicker _lightFlicker;
|
|
|
|
[Tooltip("Final light intensity reached when the fire is fully ablaze.")]
|
|
[SerializeField] private float _targetLightIntensity = 3f;
|
|
|
|
// Flag set when the last GrowFire completes — DriveHeatEffects waits on this
|
|
private bool _fireSequenceComplete = false;
|
|
private float _totalSequenceDuration = 0f;
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
void Awake()
|
|
{
|
|
InitElement(_fireBase);
|
|
InitElement(_fireTorso);
|
|
InitElement(_fireArmLeft);
|
|
InitElement(_fireArmLeftEnd);
|
|
InitElement(_fireArmRight);
|
|
InitElement(_fireArmRightEnd);
|
|
InitElement(_fireHead);
|
|
InitElement(_fireBig);
|
|
|
|
// Used as a time reference for _heatCurve mapping — doesn't need to be exact
|
|
// since DriveHeatEffects now syncs to _fireSequenceComplete rather than this value
|
|
float overlapDelay = _growDuration * (1f - _overlapFactor);
|
|
_totalSequenceDuration = _growDuration + (7f * overlapDelay);
|
|
|
|
// Ensure everything starts at zero
|
|
SetHeatShaderWeight(0f);
|
|
|
|
if (_lightFlicker)
|
|
_lightFlicker.SetBaseIntensity(0f);
|
|
}
|
|
|
|
void Start()
|
|
{
|
|
TriggerFire();
|
|
}
|
|
|
|
/// <summary>
|
|
/// Captures the original Inspector scale, then sets the starting scale to
|
|
/// (x * 0.2, y * 0.1, z * 0.2) so each element grows from near-nothing.
|
|
/// </summary>
|
|
private void InitElement(FireElement el)
|
|
{
|
|
if (!el.VFX) return;
|
|
|
|
el.OriginalScale = el.VFX.transform.localScale;
|
|
el.VFX.transform.localScale = new Vector3(
|
|
el.OriginalScale.x * 0.2f,
|
|
el.OriginalScale.y * 0.1f,
|
|
el.OriginalScale.z * 0.2f
|
|
);
|
|
el.VFX.SetActive(false);
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
/// <summary>Starts the full fire propagation sequence.</summary>
|
|
public void TriggerFire()
|
|
{
|
|
_fireSequenceComplete = false;
|
|
StartCoroutine(FireSequence());
|
|
}
|
|
|
|
/// <summary>
|
|
/// Propagates fire bottom-up with overlapping stages for an organic feel.
|
|
/// Sets _fireSequenceComplete when the last element finishes growing.
|
|
/// </summary>
|
|
private IEnumerator FireSequence()
|
|
{
|
|
float overlapDelay = _growDuration * (1f - _overlapFactor);
|
|
|
|
// Drive all heat effects independently — syncs via _fireSequenceComplete
|
|
StartCoroutine(DriveHeatEffects());
|
|
|
|
// Feet
|
|
StartCoroutine(GrowFire(_fireBase));
|
|
yield return new WaitForSeconds(overlapDelay);
|
|
|
|
// Torso overlaps with feet still growing
|
|
StartCoroutine(GrowFire(_fireTorso));
|
|
yield return new WaitForSeconds(overlapDelay);
|
|
|
|
// Both arms ignite simultaneously, each propagating from shoulder to tip
|
|
StartCoroutine(PropagateArm(_fireArmLeft, _fireArmLeftEnd, overlapDelay));
|
|
StartCoroutine(PropagateArm(_fireArmRight, _fireArmRightEnd, overlapDelay));
|
|
yield return new WaitForSeconds(overlapDelay * 2f);
|
|
|
|
// Head
|
|
StartCoroutine(GrowFire(_fireHead));
|
|
yield return new WaitForSeconds(overlapDelay);
|
|
|
|
// Full blaze — wait for it to fully complete before flagging done
|
|
yield return StartCoroutine(GrowFire(_fireBig));
|
|
|
|
_fireSequenceComplete = true;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Propagates fire along one arm: shoulder ignites first,
|
|
/// then tip starts after overlapDelay rather than waiting for shoulder to finish.
|
|
/// </summary>
|
|
private IEnumerator PropagateArm(FireElement shoulder, FireElement tip, float overlapDelay)
|
|
{
|
|
StartCoroutine(GrowFire(shoulder));
|
|
yield return new WaitForSeconds(overlapDelay);
|
|
yield return StartCoroutine(GrowFire(tip));
|
|
}
|
|
|
|
/// <summary>
|
|
/// Activates a fire element and lerps its scale from near-zero to its original
|
|
/// Inspector scale, driven by _growCurve for an organic progression.
|
|
/// </summary>
|
|
private IEnumerator GrowFire(FireElement el)
|
|
{
|
|
if (!el.VFX) yield break;
|
|
|
|
el.VFX.SetActive(true);
|
|
|
|
Vector3 startScale = Vector3.zero;
|
|
Vector3 targetScale = el.OriginalScale;
|
|
float elapsed = 0f;
|
|
|
|
while (elapsed < _growDuration)
|
|
{
|
|
elapsed += Time.deltaTime;
|
|
float t = Mathf.Clamp01(elapsed / _growDuration);
|
|
float curveT = _growCurve.Evaluate(t);
|
|
|
|
el.VFX.transform.localScale = Vector3.Lerp(startScale, targetScale, curveT);
|
|
|
|
yield return null;
|
|
}
|
|
|
|
el.VFX.transform.localScale = targetScale;
|
|
}
|
|
|
|
// ─────────────────────────────────────────────────────────────────────────
|
|
|
|
/// <summary>
|
|
/// Drives all heat effects (post-process volume, heat shader, light intensity)
|
|
/// using _heatCurve until _fireSequenceComplete is set, then snaps cleanly to 1.
|
|
/// Decoupled from individual fire element timing for smoother blending.
|
|
/// </summary>
|
|
private IEnumerator DriveHeatEffects()
|
|
{
|
|
float elapsed = 0f;
|
|
|
|
while (!_fireSequenceComplete)
|
|
{
|
|
elapsed += Time.deltaTime;
|
|
float t = elapsed / _totalSequenceDuration;
|
|
float weight = _heatCurve.Evaluate(Mathf.Min(t, 0.99f));
|
|
|
|
if (_heatVolume)
|
|
_heatVolume.weight = weight;
|
|
|
|
SetHeatShaderWeight(weight);
|
|
|
|
if (_lightFlicker)
|
|
_lightFlicker.SetBaseIntensity(_targetLightIntensity * weight);
|
|
|
|
yield return null;
|
|
}
|
|
|
|
float lerpElapsed = 0f;
|
|
float lerpDuration = 8f;
|
|
float startWeight = _heatCurve.Evaluate(0.99f);
|
|
|
|
while (lerpElapsed < lerpDuration)
|
|
{
|
|
lerpElapsed += Time.deltaTime;
|
|
float weight = Mathf.Lerp(startWeight, 1f, lerpElapsed / lerpDuration);
|
|
|
|
if (_heatVolume) _heatVolume.weight = weight;
|
|
SetHeatShaderWeight(weight);
|
|
if (_lightFlicker) _lightFlicker.SetBaseIntensity(_targetLightIntensity * weight);
|
|
|
|
yield return null;
|
|
}
|
|
|
|
if (_heatVolume) _heatVolume.weight = 1f;
|
|
SetHeatShaderWeight(1f);
|
|
if (_lightFlicker) _lightFlicker.SetBaseIntensity(_targetLightIntensity);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Drives the heat shader via a single normalized weight (0-1).
|
|
/// All visual parameters are tweaked directly on the material in the Inspector.
|
|
/// </summary>
|
|
private void SetHeatShaderWeight(float weight)
|
|
{
|
|
if (!_heatMaterial) return;
|
|
_heatMaterial.SetFloat("_Weight", weight);
|
|
}
|
|
} |