PixelEngine.hx

package;

import kha.Canvas;
import kha.Color;
import kha.Image;
import kha.graphics2.Graphics;
import kha.graphics2.ImageScaleQuality;
import kha.arrays.Uint32Array;

/**
 * [コア] ピクセルデータの最小管理単位
 * 高速アクセスとGPU同期を両立
 */
class PixelBuffer {
    public var image(default, null):Image;
    public var data(default, null):Uint32Array;
    public var width:Int;
    public var height:Int;
    private var isDirty:Bool = true;

    public function new(w:Int, h:Int) {
        width = w; height = h;
        image = Image.createRenderTarget(w, h);
        data = new Uint32Array(w * h);
        clear(0x00000000);
    }

    public inline function get(x:Int, y:Int):UInt {
        return data[y * width + x];
    }

    public inline function set(x:Int, y:Int, c:UInt):Void {
        var idx = y * width + x;
        if (data[idx] != c) {
            data[idx] = c;
            isDirty = true;
        }
    }

    public function clear(c:UInt):Void {
        for (i in 0...data.length) data[i] = c;
        isDirty = true;
    }

    public function sync():Void {
        if (!isDirty) return;
        var bytes = image.lock();
        for (i in 0...data.length) bytes.setInt32(i * 4, data[i]);
        image.unlock();
        isDirty = false;
    }

    public function destroy() { image.unload(); }
}

/**
 * [履歴] 差分保存によるUndoシステム
 */
class PixelHistory {
    public var layerIdx:Int;
    public var frameIdx:Int;
    public var diff:Map<Int, {oldC:UInt, newC:UInt}> = [];
    public function new(l:Int, f:Int) { layerIdx = l; frameIdx = f; }
}

/**
 * [構造] レイヤーとフレームの管理
 */
class Layer {
    public var name:String;
    public var buffer:PixelBuffer;
    public var visible:Bool = true;
    public var opacity:Float = 1.0;
    public function new(w, h, n) { name = n; buffer = new PixelBuffer(w, h); }
}

class Frame {
    public var layers:Array<Layer> = [];
    public function new(w, h) { layers.push(new Layer(w, h, "Layer 0")); }
}

/**
 * [メイン] PixelMasterEngine
 * 全機能を統合した司令塔
 */
class PixelEngine {
    // キャンバス設定
    public var width(default, null):Int;
    public var height(default, null):Int;
    public var frames:Array<Frame> = [];
    
    // 状態
    public var currentFrame:Int = 0;
    public var currentLayer:Int = 0;
    public var zoom:Float = 12.0;
    public var panX:Float = 0;
    public var panY:Float = 0;
    
    // 描画設定
    public var primaryColor:Color = Color.White;
    public var onionSkin:Bool = true;
    
    // 履歴
    private var undoStack:Array<PixelHistory> = [];
    private var activeHistory:PixelHistory = null;
    
    // 入力補間用
    private var lastX:Int = -1;
    private var lastY:Int = -1;

    public function new(w:Int, h:Int) {
        width = w; height = h;
        frames.push(new Frame(w, h));
    }

    // --- 描画メイン ---

    public function render(canvas:Canvas):Void {
        var g = canvas.g2;
        
        // GPU同期
        for (f in frames) for (l in f.layers) l.buffer.sync();

        g.begin(true, Color.fromBytes(30, 30, 30));
        g.imageScaleQuality = ImageScaleQuality.Low;

        // キャンバス中央配置の計算
        var drawX = (canvas.width - width * zoom) / 2 + panX;
        var drawY = (canvas.height - height * zoom) / 2 + panY;

        // 背景（チェッカーボード）
        drawGrid(g, drawX, drawY);

        // オニオンスキン（前のフレームを薄く表示）
        if (onionSkin && currentFrame > 0) {
            g.opacity = 0.2;
            for (l in frames[currentFrame - 1].layers) {
                g.drawScaledImage(l.buffer.image, drawX, drawY, width * zoom, height * zoom);
            }
        }

        // メインレイヤー描画
        var f = frames[currentFrame];
        for (l in f.layers) {
            if (!l.visible) continue;
            g.opacity = l.opacity;
            g.drawScaledImage(l.buffer.image, drawX, drawY, width * zoom, height * zoom);
        }

        g.end();
    }

    private function drawGrid(g:Graphics, x:Float, y:Float):Void {
        g.color = Color.fromBytes(50, 50, 50);
        g.fillRect(x, y, width * zoom, height * zoom);
        g.color = Color.fromBytes(70, 70, 70);
        var s = zoom;
        for (yy in 0...height) {
            for (xx in 0...width) {
                if ((xx + yy) % 2 == 0) g.fillRect(x + xx * s, y + yy * s, s, s);
            }
        }
        g.color = Color.White;
    }

    // --- ツール・アルゴリズム ---

    public function startStroke():Void {
        activeHistory = new PixelHistory(currentLayer, currentFrame);
    }

    public function endStroke():Void {
        if (activeHistory != null && Lambda.count(activeHistory.diff) > 0) {
            undoStack.push(activeHistory);
            if (undoStack.length > 50) undoStack.shift();
        }
        activeHistory = null;
        lastX = -1; lastY = -1;
    }

    /**
     * ブレゼンハム・アルゴリズムによる補間描画
     * 素早いドラッグでも線が途切れない
     */
    public function paint(tx:Int, ty:Int):Void {
        if (lastX == -1) {
            setPixel(tx, ty);
        } else {
            var dx = Math.abs(tx - lastX);
            var dy = Math.abs(ty - lastY);
            var sx = (lastX < tx) ? 1 : -1;
            var sy = (lastY < ty) ? 1 : -1;
            var err = dx - dy;

            var x = lastX;
            var y = lastY;
            while (true) {
                setPixel(x, y);
                if (x == tx && y == ty) break;
                var e2 = 2 * err;
                if (e2 > -dy) { err -= dy; x += sx; }
                if (e2 < dx) { err += dx; y += sy; }
            }
        }
        lastX = tx; lastY = ty;
    }

    private function setPixel(x:Int, y:Int):Void {
        if (x < 0 || x >= width || y < 0 || y >= height) return;
        var l = frames[currentFrame].layers[currentLayer];
        var oldC = l.buffer.get(x, y);
        var newC:UInt = cast primaryColor;
        
        if (oldC != newC) {
            l.buffer.set(x, y, newC);
            if (activeHistory != null) {
                var idx = y * width + x;
                if (!activeHistory.diff.exists(idx)) {
                    activeHistory.diff.set(idx, {oldC: oldC, newC: newC});
                }
            }
        }
    }

    /**
     * 高速バケツ塗り
     */
    public function floodFill(x:Int, y:Int):Void {
        var l = frames[currentFrame].layers[currentLayer];
        var target = l.buffer.get(x, y);
        var fill:UInt = cast primaryColor;
        if (target == fill) return;

        startStroke();
        var queue = [{x: x, y: y}];
        while (queue.length > 0) {
            var p = queue.shift();
            if (p.x < 0 || p.x >= width || p.y < 0 || p.y >= height) continue;
            if (l.buffer.get(p.x, p.y) == target) {
                setPixel(p.x, p.y);
                queue.push({x: p.x + 1, y: p.y});
                queue.push({x: p.x - 1, y: p.y});
                queue.push({x: p.x, y: p.y + 1});
                queue.push({x: p.x, y: p.y - 1});
            }
        }
        endStroke();
    }

    public function undo():Void {
        if (undoStack.length == 0) return;
        var h = undoStack.pop();
        var buf = frames[h.frameIdx].layers[h.layerIdx].buffer;
        for (idx in h.diff.keys()) {
            buf.data[idx] = h.diff.get(idx).oldC;
        }
        @:privateAccess buf.isDirty = true;
    }

    // --- ユーティリティ ---

    public function addFrame():Void {
        frames.push(new Frame(width, height));
        currentFrame = frames.length - 1;
    }

    public function screenToLocal(mx:Float, my:Float, canvasW:Int, canvasH:Int):{x:Int, y:Int} {
        var drawX = (canvasW - width * zoom) / 2 + panX;
        var drawY = (canvasH - height * zoom) / 2 + panY;
        return {
            x: Math.floor((mx - drawX) / zoom),
            y: Math.floor((my - drawY) / zoom)
        };
    }
}