luboslenco
468 lines
14 KiB
Haxe
468 lines
14 KiB
Haxe
package arm;
|
|
|
|
import zui.Nodes;
|
|
import arm.ui.UISidebar;
|
|
import arm.ui.UIView2D;
|
|
import arm.ui.UIFiles;
|
|
import arm.ui.UINodes;
|
|
import arm.ui.UIToolbar;
|
|
import arm.data.LayerSlot;
|
|
import arm.node.MaterialParser;
|
|
|
|
class History {
|
|
|
|
public static var steps: Array<TStep>;
|
|
public static var undoI = 0; // Undo layer
|
|
public static var undos = 0; // Undos available
|
|
public static var redos = 0; // Redos available
|
|
public static var pushUndo = false; // Store undo on next paint
|
|
public static var undoLayers: Array<LayerSlot> = null;
|
|
|
|
public static function undo() {
|
|
if (undos > 0) {
|
|
var active = steps.length - 1 - redos;
|
|
var step = steps[active];
|
|
|
|
if (step.name == tr("New Layer")) {
|
|
Context.layer = Project.layers[step.layer];
|
|
Context.layer.delete();
|
|
}
|
|
else if (step.name == tr("Delete Layer")) {
|
|
var l = Layers.newLayer(false);
|
|
Project.layers.insert(step.layer, Project.layers.pop());
|
|
undoI = undoI - 1 < 0 ? Config.raw.undo_steps - 1 : undoI - 1;
|
|
var lay = undoLayers[undoI];
|
|
l.swap(lay);
|
|
if (step.has_mask) {
|
|
l.createMask(0, false);
|
|
l.swapMask(lay);
|
|
Context.setLayer(l, true);
|
|
Context.layersPreviewDirty = true;
|
|
}
|
|
l.maskOpacity = step.layer_opacity;
|
|
l.blending = step.layer_blending;
|
|
l.objectMask = step.layer_object;
|
|
}
|
|
else if (step.name == tr("Duplicate Layer")) {
|
|
Context.layer = Project.layers[step.layer + 1];
|
|
Context.layer.delete();
|
|
}
|
|
else if (step.name == tr("Order Layers")) {
|
|
var target = Project.layers[step.prev_order];
|
|
Project.layers[step.prev_order] = Project.layers[step.layer];
|
|
Project.layers[step.layer] = target;
|
|
}
|
|
else if (step.name == tr("Merge Layers")) {
|
|
Context.layer = Project.layers[step.layer];
|
|
Context.layer.delete();
|
|
|
|
Context.layer = Layers.newLayer(false);
|
|
Project.layers.insert(step.layer, Project.layers.pop());
|
|
undoI = undoI - 1 < 0 ? Config.raw.undo_steps - 1 : undoI - 1;
|
|
var lay = undoLayers[undoI];
|
|
Context.layer.swap(lay);
|
|
|
|
Context.layer = Layers.newLayer(false);
|
|
Project.layers.insert(step.layer + 1, Project.layers.pop());
|
|
undoI = undoI - 1 < 0 ? Config.raw.undo_steps - 1 : undoI - 1;
|
|
var lay = undoLayers[undoI];
|
|
Context.layer.swap(lay);
|
|
if (step.has_mask) {
|
|
Context.layer.createMask(0, false);
|
|
Context.layer.swapMask(lay);
|
|
Context.setLayer(Context.layer, true);
|
|
}
|
|
Context.layer.maskOpacity = step.layer_opacity;
|
|
Context.layer.blending = step.layer_blending;
|
|
Context.layer.objectMask = step.layer_object;
|
|
Context.layersPreviewDirty = true;
|
|
}
|
|
else if (step.name == tr("New Mask")) {
|
|
undoI = undoI - 1 < 0 ? Config.raw.undo_steps - 1 : undoI - 1;
|
|
var lay = undoLayers[undoI];
|
|
Context.setLayer(Project.layers[step.layer], true);
|
|
Context.layer.swapMask(lay);
|
|
Context.layer.deleteMask();
|
|
Context.setLayer(Project.layers[step.layer], false);
|
|
}
|
|
else if (step.name == tr("Delete Mask")) {
|
|
Context.setLayer(Project.layers[step.layer], false);
|
|
Context.layer.createMask(0, false);
|
|
undoI = undoI - 1 < 0 ? Config.raw.undo_steps - 1 : undoI - 1;
|
|
var lay = undoLayers[undoI];
|
|
Context.layer.swapMask(lay);
|
|
Context.layersPreviewDirty = true;
|
|
Context.setLayer(Context.layer, true);
|
|
}
|
|
else if (step.name == tr("Apply Mask")) {
|
|
Context.layer = Project.layers[step.layer];
|
|
Context.layer.delete();
|
|
|
|
Context.layer = Layers.newLayer(false);
|
|
Project.layers.insert(step.layer, Project.layers.pop());
|
|
undoI = undoI - 1 < 0 ? Config.raw.undo_steps - 1 : undoI - 1;
|
|
var lay = undoLayers[undoI];
|
|
Context.layer.swap(lay);
|
|
Context.layer.createMask(0, false);
|
|
Context.layer.swapMask(lay);
|
|
|
|
Context.layersPreviewDirty = true;
|
|
Context.setLayer(Context.layer, true);
|
|
}
|
|
else if (step.name == tr("To Fill Layer")) {
|
|
Context.layer.toPaintLayer();
|
|
undoI = undoI - 1 < 0 ? Config.raw.undo_steps - 1 : undoI - 1;
|
|
var lay = undoLayers[undoI];
|
|
Context.layer.swap(lay);
|
|
}
|
|
else if (step.name == tr("To Paint Layer")) {
|
|
undoI = undoI - 1 < 0 ? Config.raw.undo_steps - 1 : undoI - 1;
|
|
var lay = undoLayers[undoI];
|
|
Context.layer.swap(lay);
|
|
Context.layer.material_mask = Project.materials[step.material];
|
|
}
|
|
else if (step.name == tr("Layer Opacity")) {
|
|
Context.setLayer(Project.layers[step.layer]);
|
|
var t = Context.layer.maskOpacity;
|
|
Context.layer.maskOpacity = step.layer_opacity;
|
|
step.layer_opacity = t;
|
|
MaterialParser.parseMeshMaterial();
|
|
}
|
|
else if (step.name == tr("Layer Blending")) {
|
|
Context.setLayer(Project.layers[step.layer]);
|
|
var t = Context.layer.blending;
|
|
Context.layer.blending = step.layer_blending;
|
|
step.layer_blending = t;
|
|
MaterialParser.parseMeshMaterial();
|
|
}
|
|
else if (step.name == tr("Edit Nodes")) {
|
|
swapCanvas(step);
|
|
}
|
|
else { // Paint operation
|
|
undoI = undoI - 1 < 0 ? Config.raw.undo_steps - 1 : undoI - 1;
|
|
var lay = undoLayers[undoI];
|
|
Context.selectPaintObject(Project.paintObjects[step.object]);
|
|
Context.setLayer(Project.layers[step.layer], step.is_mask);
|
|
step.is_mask ? Context.layer.swapMask(lay) : Context.layer.swap(lay);
|
|
Context.layerPreviewDirty = true;
|
|
}
|
|
undos--;
|
|
redos++;
|
|
UISidebar.inst.hwnd.redraws = 2;
|
|
Context.ddirty = 2;
|
|
if (UIView2D.inst.show) UIView2D.inst.hwnd.redraws = 2;
|
|
}
|
|
}
|
|
|
|
public static function redo() {
|
|
if (redos > 0) {
|
|
var active = steps.length - redos;
|
|
var step = steps[active];
|
|
|
|
if (step.name == tr("New Layer")) {
|
|
Layers.newLayer();
|
|
Project.layers.insert(step.layer, Project.layers.pop());
|
|
}
|
|
else if (step.name == tr("Delete Layer")) {
|
|
Context.layer = Project.layers[step.layer];
|
|
swapActive();
|
|
Context.layer.delete();
|
|
}
|
|
else if (step.name == tr("Duplicate Layer")) {
|
|
Context.layer = Project.layers[step.layer];
|
|
Context.layer = Context.layer.duplicate();
|
|
}
|
|
else if (step.name == tr("Order Layers")) {
|
|
var target = Project.layers[step.prev_order];
|
|
Project.layers[step.prev_order] = Project.layers[step.layer];
|
|
Project.layers[step.layer] = target;
|
|
}
|
|
else if (step.name == tr("Merge Layers")) {
|
|
Context.layer = Project.layers[step.layer + 1];
|
|
iron.App.notifyOnRender(redoMergeLayers);
|
|
iron.App.notifyOnRender(Layers.mergeSelectedLayer);
|
|
}
|
|
else if (step.name == tr("New Mask")) {
|
|
Context.layer = Project.layers[step.layer];
|
|
Context.layer.createMask(0, false);
|
|
Context.setLayer(Project.layers[step.layer], true);
|
|
var lay = undoLayers[undoI];
|
|
Context.layer.swapMask(lay);
|
|
Context.layerPreviewDirty = true;
|
|
undoI = (undoI + 1) % Config.raw.undo_steps;
|
|
}
|
|
else if (step.name == tr("Delete Mask")) {
|
|
Context.layer = Project.layers[step.layer];
|
|
swapMaskActive();
|
|
Context.layer.deleteMask();
|
|
Context.setLayer(Context.layer, false);
|
|
}
|
|
else if (step.name == tr("Apply Mask")) {
|
|
function makeApply(g: kha.graphics4.Graphics) {
|
|
g.end();
|
|
Context.layer = Project.layers[step.layer];
|
|
copyToUndoWithMask();
|
|
Context.layer.applyMask();
|
|
Context.setLayer(Context.layer, false);
|
|
g.begin();
|
|
iron.App.removeRender(makeApply);
|
|
}
|
|
iron.App.notifyOnRender(makeApply);
|
|
}
|
|
else if (step.name == tr("To Fill Layer")) {
|
|
var lay = undoLayers[undoI];
|
|
Context.layer.swap(lay);
|
|
Context.layer.material_mask = Project.materials[step.material];
|
|
undoI = (undoI + 1) % Config.raw.undo_steps;
|
|
}
|
|
else if (step.name == tr("To Paint Layer")) {
|
|
Context.layer.toPaintLayer();
|
|
var lay = undoLayers[undoI];
|
|
Context.layer.swap(lay);
|
|
undoI = (undoI + 1) % Config.raw.undo_steps;
|
|
}
|
|
else if (step.name == tr("Layer Opacity")) {
|
|
Context.setLayer(Project.layers[step.layer]);
|
|
var t = Context.layer.maskOpacity;
|
|
Context.layer.maskOpacity = step.layer_opacity;
|
|
step.layer_opacity = t;
|
|
MaterialParser.parseMeshMaterial();
|
|
}
|
|
else if (step.name == tr("Layer Blending")) {
|
|
Context.setLayer(Project.layers[step.layer]);
|
|
var t = Context.layer.blending;
|
|
Context.layer.blending = step.layer_blending;
|
|
step.layer_blending = t;
|
|
MaterialParser.parseMeshMaterial();
|
|
}
|
|
else if (step.name == tr("Edit Nodes")) {
|
|
swapCanvas(step);
|
|
}
|
|
else { // Paint operation
|
|
var lay = undoLayers[undoI];
|
|
Context.selectPaintObject(Project.paintObjects[step.object]);
|
|
Context.setLayer(Project.layers[step.layer], step.is_mask);
|
|
step.is_mask ? Context.layer.swapMask(lay) : Context.layer.swap(lay);
|
|
Context.layerPreviewDirty = true;
|
|
undoI = (undoI + 1) % Config.raw.undo_steps;
|
|
}
|
|
undos++;
|
|
redos--;
|
|
UISidebar.inst.hwnd.redraws = 2;
|
|
Context.ddirty = 2;
|
|
if (UIView2D.inst.show) UIView2D.inst.hwnd.redraws = 2;
|
|
}
|
|
}
|
|
|
|
public static function reset() {
|
|
steps = [{name: tr("New"), layer: 0, object: 0, material: 0, brush: 0, is_mask: false, has_mask: false}];
|
|
undos = 0;
|
|
redos = 0;
|
|
undoI = 0;
|
|
}
|
|
|
|
public static function paint() {
|
|
var isMask = Context.layerIsMask;
|
|
copyToUndo(Context.layer.id, undoI, isMask);
|
|
|
|
pushUndo = false;
|
|
push(UIToolbar.inst.toolNames[Context.tool]);
|
|
}
|
|
|
|
public static function newLayer() {
|
|
push(tr("New Layer"));
|
|
}
|
|
|
|
public static function duplicateLayer() {
|
|
push(tr("Duplicate Layer"));
|
|
}
|
|
|
|
public static function deleteLayer() {
|
|
swapActive();
|
|
push(tr("Delete Layer"));
|
|
}
|
|
|
|
public static function orderLayers(prevOrder: Int) {
|
|
var step = push(tr("Order Layers"));
|
|
step.prev_order = prevOrder;
|
|
}
|
|
|
|
public static function mergeLayers(g: kha.graphics4.Graphics) {
|
|
copyMergingLayers();
|
|
|
|
var step = push(tr("Merge Layers"));
|
|
step.layer -= 1; // Merge down
|
|
steps.shift(); // Merge consumes 2 steps
|
|
undos--;
|
|
iron.App.removeRender(mergeLayers);
|
|
// TODO: use undo layer in Layers.mergeSelectedLayer to save memory
|
|
}
|
|
|
|
public static function newMask() {
|
|
push(tr("New Mask"));
|
|
}
|
|
|
|
public static function deleteMask() {
|
|
swapMaskActive();
|
|
push(tr("Delete Mask"));
|
|
}
|
|
|
|
public static function applyMask() {
|
|
copyToUndoWithMask();
|
|
push(tr("Apply Mask"));
|
|
}
|
|
|
|
public static function toFillLayer() {
|
|
copyToUndo(Context.layer.id, undoI, false);
|
|
push(tr("To Fill Layer"));
|
|
}
|
|
|
|
public static function toPaintLayer() {
|
|
copyToUndo(Context.layer.id, undoI, false);
|
|
push(tr("To Paint Layer"));
|
|
}
|
|
|
|
public static function layerOpacity() {
|
|
push(tr("Layer Opacity"));
|
|
}
|
|
|
|
// public static function layerObject() {
|
|
// push("Layer Object");
|
|
// }
|
|
|
|
public static function layerBlending() {
|
|
push(tr("Layer Blending"));
|
|
}
|
|
|
|
// public static function newMaterial() {}
|
|
// public static function deleteMaterial() {}
|
|
|
|
public static function editNodes(canvas: TNodeCanvas, canvas_type: Int) {
|
|
var step = push(tr("Edit Nodes"));
|
|
step.canvas_type = canvas_type;
|
|
step.canvas = haxe.Json.parse(haxe.Json.stringify(canvas));
|
|
}
|
|
|
|
static function push(name: String): TStep {
|
|
kha.Window.get(0).title = UIFiles.filename + "* - ArmorPaint";
|
|
|
|
if (undos < Config.raw.undo_steps) undos++;
|
|
if (redos > 0) {
|
|
for (i in 0...redos) steps.pop();
|
|
redos = 0;
|
|
}
|
|
|
|
var opos = Project.paintObjects.indexOf(cast Context.object);
|
|
var lpos = Project.layers.indexOf(Context.layer);
|
|
var mpos = Project.materials.indexOf(Context.material);
|
|
var bpos = Project.brushes.indexOf(Context.brush);
|
|
|
|
steps.push({
|
|
name: name,
|
|
layer: lpos,
|
|
object: opos,
|
|
material: mpos,
|
|
brush: bpos,
|
|
is_mask: Context.layerIsMask,
|
|
has_mask: Context.layer.texpaint_mask != null,
|
|
layer_opacity: Context.layer.maskOpacity,
|
|
layer_object: Context.layer.objectMask,
|
|
layer_blending: Context.layer.blending
|
|
});
|
|
|
|
while (steps.length > Config.raw.undo_steps + 1) steps.shift();
|
|
return steps[steps.length - 1];
|
|
}
|
|
|
|
static function redoMergeLayers(g: kha.graphics4.Graphics) {
|
|
copyMergingLayers();
|
|
iron.App.removeRender(redoMergeLayers);
|
|
}
|
|
|
|
static function copyMergingLayers() {
|
|
var lay = Context.layer;
|
|
copyToUndo(lay.id, undoI, false);
|
|
if (lay.texpaint_mask != null) {
|
|
undoI = undoI - 1 < 0 ? Config.raw.undo_steps - 1 : undoI - 1;
|
|
copyToUndo(lay.id, undoI, true);
|
|
}
|
|
|
|
var below = Project.layers.indexOf(lay) - 1;
|
|
lay = Project.layers[below];
|
|
copyToUndo(lay.id, undoI, false);
|
|
}
|
|
|
|
static function copyToUndoWithMask() {
|
|
copyToUndo(Context.layer.id, undoI, false);
|
|
undoI = undoI - 1 < 0 ? Config.raw.undo_steps - 1 : undoI - 1;
|
|
copyToUndo(Context.layer.id, undoI, true);
|
|
}
|
|
|
|
static function swapActive() {
|
|
var undoLayer = undoLayers[undoI];
|
|
undoLayer.swap(Context.layer);
|
|
if (Context.layer.texpaint_mask != null) {
|
|
undoLayer.swapMask(Context.layer);
|
|
}
|
|
undoI = (undoI + 1) % Config.raw.undo_steps;
|
|
}
|
|
|
|
static function swapMaskActive() {
|
|
var undoLayer = undoLayers[undoI];
|
|
undoLayer.swapMask(Context.layer);
|
|
undoI = (undoI + 1) % Config.raw.undo_steps;
|
|
}
|
|
|
|
static function copyToUndo(fromId: Int, toId: Int, isMask: Bool) {
|
|
var path = iron.RenderPath.active;
|
|
if (isMask) {
|
|
path.setTarget("texpaint_mask_undo" + toId);
|
|
path.bindTarget("texpaint_mask" + fromId, "tex");
|
|
path.drawShader("shader_datas/copy_pass/copy_pass");
|
|
}
|
|
else {
|
|
path.setTarget("texpaint_undo" + toId, ["texpaint_nor_undo" + toId, "texpaint_pack_undo" + toId]);
|
|
path.bindTarget("texpaint" + fromId, "tex0");
|
|
path.bindTarget("texpaint_nor" + fromId, "tex1");
|
|
path.bindTarget("texpaint_pack" + fromId, "tex2");
|
|
path.drawShader("shader_datas/copy_mrt3_pass/copy_mrt3_pass");
|
|
}
|
|
undoI = (undoI + 1) % Config.raw.undo_steps;
|
|
}
|
|
|
|
static function swapCanvas(step: TStep) {
|
|
if (step.canvas_type == 0) {
|
|
var _canvas = Project.materials[step.material].canvas;
|
|
Project.materials[step.material].canvas = step.canvas;
|
|
step.canvas = _canvas;
|
|
Context.material = Project.materials[step.material];
|
|
}
|
|
else {
|
|
var _canvas = Project.brushes[step.brush].canvas;
|
|
Project.brushes[step.brush].canvas = step.canvas;
|
|
step.canvas = _canvas;
|
|
Context.brush = Project.brushes[step.brush];
|
|
}
|
|
|
|
UINodes.inst.canvasChanged();
|
|
@:privateAccess UINodes.inst.getNodes().handle = new zui.Zui.Handle();
|
|
UINodes.inst.hwnd.redraws = 2;
|
|
}
|
|
}
|
|
|
|
typedef TStep = {
|
|
public var name: String;
|
|
public var layer: Int;
|
|
public var object: Int;
|
|
public var material: Int;
|
|
public var brush: Int;
|
|
public var is_mask: Bool; // Mask operation
|
|
public var has_mask: Bool; // Layer contains mask
|
|
@:optional public var layer_opacity: Float;
|
|
@:optional public var layer_object: Int;
|
|
@:optional public var layer_blending: Int;
|
|
@:optional public var prev_order: Int; // Previous layer position
|
|
@:optional public var canvas: TNodeCanvas; // Node history
|
|
@:optional public var canvas_type: Int;
|
|
}
|