Dirty Flag

using UnityEngine;

namespace Patterns.Optimization.DirtyFlag
{
    /// <summary>
    /// Builds a Ship → Turret → Barrel hierarchy, wiggles it and reports how
    /// many world positions were actually recomputed.
    /// </summary>
    public class DirtyFlagTester : MonoBehaviour
    {
        [SerializeField] private float wiggleSpeed = 2f;

        private SceneGraph graph;
        private SceneNode ship, turret, barrel;

        private void Awake()
        {
            graph = new SceneGraph();
            ship = graph.Create("Ship", null, Vector3.zero);
            turret = graph.Create("Turret", ship, new Vector3(0f, 1f, 0f));
            barrel = graph.Create("Barrel", turret, new Vector3(0f, 0f, 1.5f));
        }

        private void Update()
        {
            // Only the turret moves this frame; the ship stays clean.
            turret.LocalPosition = new Vector3(Mathf.Sin(Time.time * wiggleSpeed), 1f, 0f);

            // Reading the barrel recomputes Turret + Barrel, not Ship.
            Vector3 muzzle = barrel.WorldPosition;
            Debug.DrawRay(muzzle, Vector3.forward, Color.yellow);
        }

        private void LateUpdate()
        {
            if (Time.frameCount % 120 == 0)
                Debug.Log($"Recomputes so far: {SceneNode.RecomputeCount}");
        }
    }
}

using System.Collections.Generic;
using UnityEngine;

namespace Patterns.Optimization.DirtyFlag
{
    /// <summary>
    /// A node with a cached world position. Writes mark the node (and its
    /// subtree) dirty; reads recompute lazily only when needed.
    /// </summary>
    public class SceneNode
    {
        public static int RecomputeCount { get; private set; }

        private readonly List<SceneNode> children = new();
        private Vector3 localPosition;
        private Vector3 cachedWorld;
        private bool isDirty = true;

        public string Name { get; }
        public SceneNode Parent { get; }

        public SceneNode(string name, SceneNode parent, Vector3 local)
        {
            Name = name;
            Parent = parent;
            localPosition = local;
            parent?.children.Add(this);
        }

        public Vector3 LocalPosition
        {
            get => localPosition;
            set
            {
                if (localPosition == value) return;
                localPosition = value;
                SetDirty();
            }
        }

        public Vector3 WorldPosition
        {
            get
            {
                if (isDirty)
                {
                    cachedWorld = Parent == null ? localPosition : Parent.WorldPosition + localPosition;
                    isDirty = false;
                    RecomputeCount++;
                }
                return cachedWorld;
            }
        }

        private void SetDirty()
        {
            if (isDirty) return; // subtree is already marked
            isDirty = true;
            foreach (var child in children)
                child.SetDirty();
        }
    }
}

using System.Collections.Generic;
using UnityEngine;

namespace Patterns.Optimization.DirtyFlag
{
    /// <summary>
    /// Owns all nodes and offers a "render" pass that reads every world
    /// position. Clean nodes return their cache instantly.
    /// </summary>
    public class SceneGraph
    {
        private readonly List<SceneNode> nodes = new();

        public IReadOnlyList<SceneNode> Nodes => nodes;

        public SceneNode Create(string name, SceneNode parent, Vector3 local)
        {
            var node = new SceneNode(name, parent, local);
            nodes.Add(node);
            return node;
        }

        /// <summary>Simulates a renderer pulling every world position.</summary>
        public void Render(System.Action<SceneNode, Vector3> draw)
        {
            foreach (var node in nodes)
                draw(node, node.WorldPosition);
        }
    }
}