public class RecursiveFloodFill : MonoBehaviour, IFloodFill
{
    public string GetName()
    {
        return "Recursive";
    }

    private void FloodFillRecursive(Texture2D texture, int px, int py, Color targetColor, Color color)
    {
        // check if we are in the bounderies
        if (px < 0 || py < 0) return;
        if (px >= texture.width || py >= texture.height) return;
        
        // get the pixel at PX, PY color
        var pixelColor = texture.GetPixel(px, py);
        // if color is different than the original pixel color, abort
        if (pixelColor != targetColor) return;
        // if same color, we can swap the current color to the "color" we changing it to
        texture.SetPixel(px, py, color);

        // recursivally do the same to the neighbors (up, down, right, left)
        FloodFillRecursive(texture, px + 1, py, targetColor, color);
        FloodFillRecursive(texture, px - 1, py, targetColor, color);
        FloodFillRecursive(texture, px, py + 1, targetColor, color);
        FloodFillRecursive(texture, px, py - 1, targetColor, color);
    }

    public void FloodFill(Texture2D texture, Vector2 pos, Color color)
    {
        // get the initial pixel texture position (`pos` is between [0,1])
        var px = (int)(pos.x * texture.width);
        var py = (int)(pos.y * texture.height);
        // the first pixel color
        var targetColor = texture.GetPixel(px, py);
        FloodFillRecursive(texture, px, py, targetColor, color);
        // after changing all pixels, we should "apply" the texture. This is a requirement for Unity's texture changes
        texture.Apply();
    }
}

public class IterativeFloodFill : MonoBehaviour, IFloodFill
{
    private struct TexturePixelPoint
    {
        public int X;
        public int Y;
    }
    
    public string GetName()
    {
        return "Iterative";
    }

    private void FloodFillIterative(Texture2D texture, int px, int py, Color targetColor, Color color)
    {
        Stack<TexturePixelPoint> floodPixels = new Stack<TexturePixelPoint>();
        // put the first pixel in the stack
        floodPixels.Push(new TexturePixelPoint{ X = px, Y = py });
        // while we have pixels to process. Note that this doesn't change the call stack and therefore should work for medium or big textures.
        while (floodPixels.Count > 0)
        {
            // remove the pixel we are going to process now
            var node = floodPixels.Pop();
            // check for the bounderies
            if (node.X < 0 || node.Y < 0) continue;
            if (node.X >= texture.width || node.Y >= texture.height) continue;
            var pixelColor = texture.GetPixel(node.X, node.Y);
            // if this pixel is different than the original pixel color, skip it
            if (pixelColor != targetColor) continue;
            // change this pixel color
            texture.SetPixel(node.X, node.Y, color);
            // put the neighbors in the stack so they can be processed later
            floodPixels.Push(new TexturePixelPoint{ X = node.X + 1, Y = node.Y });
            floodPixels.Push(new TexturePixelPoint{ X = node.X - 1, Y = node.Y });
            floodPixels.Push(new TexturePixelPoint{ X = node.X, Y = node.Y + 1 });
            floodPixels.Push(new TexturePixelPoint{ X = node.X, Y = node.Y - 1 });
        }
        floodPixels.Clear();
        floodPixels = null;
    }

    public void FloodFill(Texture2D texture, Vector2 pos, Color color)
    {
        // get the initial pixel texture position (`pos` is between [0,1])
        var px = (int)(pos.x * texture.width);
        var py = (int)(pos.y * texture.height);
        // the first pixel color
        var targetColor = texture.GetPixel(px, py);
        // start the flood iterative process
        FloodFillIterative(texture, px, py, targetColor, color);
        // after changing all pixels, we should "apply" the texture. This is a requirement for Unity's texture changes
        texture.Apply();
    }
}

public class IterativeFloodFillEnhanced : MonoBehaviour, IFloodFill
{
    // we can use an array of integers instead of a stack to keep track of next pixel to inspect
    private int[] _floodNodes;
    private int _floodIndex;
    
    public string GetName()
    {
        return "Iterative++";
    }
    
    // this method does essentially the same calculation as the original Unity's Color Comparision one. 
    // However we are avoiding the alpha calculation and the float/double casting. We don't need to be too precise and we know it won't overflow
    [MethodImpl(MethodImplOptions.AggressiveInlining)]
    private static bool ColorEqual(Color32 lhs, Color32 rhs)
    {
        float num1 = lhs.r - rhs.r;
        float num2 = lhs.g - rhs.g;
        float num3 = lhs.b - rhs.b;
        // float num4 = lhs.a - rhs.a;
        return num1 * num1 + num2 * num2 + num3 * num3 /* + (double) num4 * (double) num4*/ < 9.99999943962493E-11;
    }

    private void StartFloodFill(Texture2D texture, int px, int py, Color32 targetColor, Color32 color)
    {
        // Accessing the native pixels from the texture
        var pixels = texture.GetRawTextureData<Color32>();
        // initialize the _floodNodes array
        if (_floodNodes == null || _floodNodes.Length < pixels.Length)
        {
            var floodNodeSize = pixels.Length; 
            _floodNodes = new int[floodNodeSize];
        }
        // reset the _floodIndex. This is where our "stack head" is.
        _floodIndex = 0;
        
        // cache the texture width
        var textureWidth = texture.width;
        // cache the pixels array length
        var pixelsLength = pixels.Length;
        // calculate the pixel position (px, py) on the unidimensional array
        var k = px + py * texture.width;
        if (k < 0 || k >= pixels.Length) return;
        // initialize the "stack" with the first position to inspect
        _floodNodes[_floodIndex++] = k;
        if (ColorEqual(pixels[k], color)) return;
        
        // while we have pixels to inspect
        while (_floodIndex > 0)
        {
            // "pop" the pixel. `k` here is the Texture pixel (px,py) in an unidimensional array index
            k = _floodNodes[--_floodIndex];
            // set the Texture pixel to the desired color. We know we must update this one
            pixels[k] = color;
            // Let's check and add to the "stack" the neighbors. 
            // Different from before, now we are checking the bounds and color before adding to the "stack". Doing this we can save some comparison calls
            var nextNeighborPixel = k + 1;
            if (nextNeighborPixel < pixelsLength && ColorEqual(pixels[nextNeighborPixel], targetColor)) _floodNodes[_floodIndex++] = nextNeighborPixel;
            nextNeighborPixel = k - 1;
            if (nextNeighborPixel >= 0 && ColorEqual(pixels[nextNeighborPixel], targetColor)) _floodNodes[_floodIndex++] = nextNeighborPixel;
            nextNeighborPixel = k + textureWidth;
            if (nextNeighborPixel < pixelsLength && ColorEqual(pixels[nextNeighborPixel], targetColor)) _floodNodes[_floodIndex++] = nextNeighborPixel;
            nextNeighborPixel = k - textureWidth;
            if (nextNeighborPixel >= 0 && ColorEqual(pixels[nextNeighborPixel], targetColor)) _floodNodes[_floodIndex++] = nextNeighborPixel;
        }

        _floodNodes = null;
    }

    public void FloodFill(Texture2D texture, Vector2 pos, Color color)
    {
        // get the initial pixel texture position (`pos` is between [0,1])
        int x = (int)(texture.width * pos.x);
        int y = (int)(texture.height * pos.y);
        // the first pixel color
        Color targetColor = texture.GetPixel(x, y);
        // we can avoid the process if the first pixel is already the desired color
        if (targetColor == color) return;
        // start the flood iterative process
        StartFloodFill(texture, x, y, targetColor, color);
        // after changing all pixels, we should "apply" the texture. This is a requirement for Unity's texture changes
        texture.Apply();
    }
}