mirrors/Pixel-Composer
1
0
Fork 0
mirror of https://github.com/Ttanasart-pt/Pixel-Composer.git synced 2025-01-12 23:37:10 +01:00
Code Issues Projects Releases Packages Wiki Activity
Pixel-Composer/scripts/node_tiler/node_tiler.gml
Tanasart 058cea8906 autotile 1
2024-10-19 17:35:47 +07:00

568 lines
No EOL
21 KiB
Text
Raw Blame History

enum AUTOTILE_TYPE {
box3_3,
}
function Node_Tile_Drawer(_x, _y, _group = noone) : Node_Processor(_x, _y, _group) constructor {
name = "Tile Drawer";
bypass_grid = true;
newInput( 0, nodeValue_Surface("Tileset", self, noone));
newInput( 1, nodeValue_IVec2("Map size", self, [ 16, 16 ]));
newInput( 2, nodeValue_Vec2("Tile size", self, [ 16, 16 ]));
#region tile selector
tile_selector_surface = 0;
tile_selector_mask = 0;
tile_selector_h = ui(320);
tile_selector_x = 0;
tile_selector_y = 0;
tile_selector_s = 1;
tile_selector_s_to = 1;
tile_dragging = false;
tile_drag_sx = 0;
tile_drag_sy = 0;
tile_drag_mx = 0;
tile_drag_my = 0;
tile_selecting = false;
tile_select_ss = [ 0, 0 ];
autotile_selector_mask = 0;
grid_draw = true;
tile_selector = new Inspector_Custom_Renderer(function(_x, _y, _w, _m, _hover, _focus, _panel = noone) {
var _h = tile_selector_h;
var _pd = ui(4);
var _tileSet = current_data[0];
var _tileSiz = current_data[2];
var _sx = _x + _pd;
var _sy = _y + _pd;
var _sw = _w - _pd * 2;
var _sh = _h - _pd * 2;
draw_sprite_stretched_ext(THEME.ui_panel_bg, 1, _x, _y, _w, _h, c_white, 1);
tile_selector_surface = surface_verify(tile_selector_surface, _sw, _sh);
tile_selector_mask = surface_verify(tile_selector_mask, _sw, _sh);
autotile_selector_mask = surface_verify(autotile_selector_mask, _sw, _sh);
if(!is_surface(_tileSet)) return _h;
var _tdim = surface_get_dimension(_tileSet);
var _tileAmo = [ floor(_tdim[0] / _tileSiz[0]), floor(_tdim[1] / _tileSiz[1]) ];
var _tileSel_w = _tileSiz[0] * tile_selector_s;
var _tileSel_h = _tileSiz[1] * tile_selector_s;
var _msx = _m[0] - _sx - tile_selector_x;
var _msy = _m[1] - _sy - tile_selector_y;
var _mtx = floor(_msx / tile_selector_s / _tileSiz[0]);
var _mty = floor(_msy / tile_selector_s / _tileSiz[1]);
var _mid = _mtx >= 0 && _mtx < _tileAmo[0] && _mty >= 0 && _mtx < _tileAmo[1]? _mty * _tileAmo[0] + _mtx : noone;
var _tileHov_x = tile_selector_x + _mtx * _tileSiz[0] * tile_selector_s;
var _tileHov_y = tile_selector_y + _mty * _tileSiz[1] * tile_selector_s;
var _hov = _hover && point_in_rectangle(_m[0], _m[1], _x, _y, _x + _w, _y + _h);
surface_set_target(tile_selector_surface);
draw_clear(COLORS.panel_bg_clear);
draw_sprite_tiled_ext(s_transparent, 0, tile_selector_x, tile_selector_y, tile_selector_s, tile_selector_s, COLORS.panel_preview_transparent, 1);
draw_surface_ext(_tileSet, tile_selector_x, tile_selector_y, tile_selector_s, tile_selector_s, 0, c_white, 1);
if(grid_draw) {
var _gw = _tileSiz[0] * tile_selector_s;
var _gh = _tileSiz[1] * tile_selector_s;
var gw = _tdim[0] / _tileSiz[0];
var gh = _tdim[1] / _tileSiz[1];
var cx = tile_selector_x;
var cy = tile_selector_y;
draw_set_color(PROJECT.previewGrid.color);
draw_set_alpha(PROJECT.previewGrid.opacity);
for( var i = 1; i < gw; i++ ) {
var _xx = cx + i * _gw;
draw_line(_xx, cy, _xx, cy + _tdim[1] * tile_selector_s);
}
for( var i = 1; i < gh; i++ ) {
var _yy = cy + i * _gh;
draw_line(cx, _yy, cx + _tdim[0] * tile_selector_s, _yy);
}
draw_set_alpha(1);
}
draw_set_color(COLORS.panel_preview_surface_outline);
draw_rectangle(tile_selector_x, tile_selector_y, tile_selector_x + _tdim[0] * tile_selector_s - 1, tile_selector_y + _tdim[1] * tile_selector_s - 1, true);
draw_set_color(c_white);
draw_rectangle_width(_tileHov_x - 1, _tileHov_y - 1, _tileHov_x + _tileSel_w, _tileHov_y + _tileSel_h, 1);
draw_set_color(c_black);
draw_rectangle_width(_tileHov_x, _tileHov_y, _tileHov_x + _tileSel_w - 1, _tileHov_y + _tileSel_h - 1, 1);
if(_hov && _mid > noone && mouse_press(mb_left, _focus)) {
tile_selecting = true;
tile_select_ss = [ _mtx, _mty ];
}
surface_reset_target();
surface_set_target(tile_selector_mask);
DRAW_CLEAR
draw_set_color(c_white);
for( var i = 0, n = array_length(brush.brush_indices); i < n; i++ )
for( var j = 0, m = array_length(brush.brush_indices[i]); j < m; j++ ) {
var _bindex = brush.brush_indices[i][j];
var _tileSel_row = floor(_bindex / _tileAmo[0]);
var _tileSel_col = safe_mod(_bindex, _tileAmo[0]);
var _tileSel_x = tile_selector_x + _tileSel_col * _tileSiz[0] * tile_selector_s;
var _tileSel_y = tile_selector_y + _tileSel_row * _tileSiz[1] * tile_selector_s;
draw_rectangle(_tileSel_x, _tileSel_y, _tileSel_x + _tileSel_w, _tileSel_y + _tileSel_h, false);
}
surface_reset_target();
#region tile selection
if(tile_selecting) {
var _ts_sx = clamp(min(tile_select_ss[0], _mtx), 0, _tileAmo[0] - 1);
var _ts_sy = clamp(min(tile_select_ss[1], _mty), 0, _tileAmo[1] - 1);
var _ts_ex = clamp(max(tile_select_ss[0], _mtx), 0, _tileAmo[0] - 1);
var _ts_ey = clamp(max(tile_select_ss[1], _mty), 0, _tileAmo[1] - 1);
brush.brush_indices = [];
brush.brush_width = _ts_ex - _ts_sx + 1;
brush.brush_height = _ts_ey - _ts_sy + 1;
var _ind = 0;
for( var i = _ts_sy; i <= _ts_ey; i++ )
for( var j = _ts_sx; j <= _ts_ex; j++ )
brush.brush_indices[i - _ts_sy][j - _ts_sx] = i * _tileAmo[0] + j;
if(mouse_release(mb_left))
tile_selecting = false;
}
#endregion
#region pan zoom
if(tile_dragging) {
var _tdx = _m[0] - tile_drag_mx;
var _tdy = _m[1] - tile_drag_my;
tile_selector_x = tile_drag_sx + _tdx;
tile_selector_y = tile_drag_sy + _tdy;
if(mouse_release(mb_middle))
tile_dragging = false;
}
if(_hov) {
if(mouse_press(mb_middle, _focus)) {
tile_dragging = true;
tile_drag_sx = tile_selector_x;
tile_drag_sy = tile_selector_y;
tile_drag_mx = _m[0];
tile_drag_my = _m[1];
}
var _s = tile_selector_s;
if(mouse_wheel_up()) { tile_selector_s_to = clamp(tile_selector_s_to * 1.2, 0.5, 4); }
if(mouse_wheel_down()) { tile_selector_s_to = clamp(tile_selector_s_to / 1.2, 0.5, 4); }
tile_selector_s = lerp_float(tile_selector_s, tile_selector_s_to, 2);
if(_s != tile_selector_s) {
var _ds = tile_selector_s - _s;
tile_selector_x -= _msx * _ds / _s;
tile_selector_y -= _msy * _ds / _s;
}
}
var _tdim_ws = _tdim[0] * tile_selector_s;
var _tdim_hs = _tdim[1] * tile_selector_s;
var _minx = -(_tdim_ws - _w) - 32;
var _miny = -(_tdim_hs - _h) - 32;
var _maxx = 32;
var _maxy = 32;
if(_minx > _maxx) { _minx = (_minx + _maxx) / 2; _maxx = _minx; }
if(_miny > _maxy) { _miny = (_miny + _maxy) / 2; _maxy = _miny; }
tile_selector_x = clamp(tile_selector_x, _minx, _maxx);
tile_selector_y = clamp(tile_selector_y, _miny, _maxy);
#endregion
draw_surface(tile_selector_surface, _sx, _sy);
shader_set(sh_brush_outline);
shader_set_f("dimension", _sw, _sh);
draw_surface(tile_selector_mask, _sx, _sy);
shader_reset();
#region autotile
for( var i = 0, n = array_length(autotiles); i < n; i++ ) {
var _att = autotiles[i];
surface_set_target(autotile_selector_mask);
DRAW_CLEAR
draw_set_color(c_white);
for( var j = 0, m = array_length(_att.index); j < m; j++ ) {
var _bindex = _att.index[j];
var _tileSel_row = floor(_bindex / _tileAmo[0]);
var _tileSel_col = safe_mod(_bindex, _tileAmo[0]);
var _tileSel_x = tile_selector_x + _tileSel_col * _tileSiz[0] * tile_selector_s;
var _tileSel_y = tile_selector_y + _tileSel_row * _tileSiz[1] * tile_selector_s;
draw_rectangle(_tileSel_x, _tileSel_y, _tileSel_x + _tileSel_w, _tileSel_y + _tileSel_h, false);
}
surface_reset_target();
shader_set(sh_brush_outline);
shader_set_f("dimension", _sw, _sh);
draw_surface_ext(autotile_selector_mask, _sx, _sy, 1, 1, 0, COLORS._main_accent, 1);
shader_reset();
}
#endregion
return _h;
});
#endregion
#region ++++ auto tile ++++
autotiles = [
new tiler_brush_autotile(AUTOTILE_TYPE.box3_3, [
0, 1, 2,
11, 12, 13,
22, 23, 24,
]),
];
autotile_selecting = 0;
autotile_selector = new Inspector_Custom_Renderer(function(_x, _y, _w, _m, _hover, _focus, _panel = noone) {
var _hh = 0;
return _hh;
});
#endregion
input_display_list = [
["Tileset", false], 0, 2,
["Map", false], 1,
["Tiles", false], tile_selector,
["Autotiles",false], autotile_selector,
]
newOutput(0, nodeValue_Output("Tile output", self, VALUE_TYPE.surface, noone));
newOutput(1, nodeValue_Output("Tile map", self, VALUE_TYPE.surface, noone));
newOutput(2, nodeValue_Output("Index array", self, VALUE_TYPE.integer, []))
.setArrayDepth(1);
#region ++++ data ++++
canvas_surface = surface_create_empty(1, 1, surface_r16float);
canvas_buffer = buffer_create(1 * 1 * 2, buffer_grow, 2);
drawing_surface = surface_create_empty(1, 1, surface_r16float);
draw_stack = ds_list_create();
preview_drawing_tile = surface_create_empty(1, 1);
preview_draw_overlay = surface_create_empty(1, 1);
preview_draw_overlay_tile = surface_create_empty(1, 1);
_preview_draw_mask = surface_create_empty(1, 1);
preview_draw_mask = surface_create_empty(1, 1);
attributes.dimension = [ 1, 1 ];
temp_surface = [ 0 ];
selection_mask = noone;
#endregion
#region ++++ selection ++++
selecting = false;
selection_x = 0;
selection_y = 0;
selection_mask = noone;
#endregion
#region ++++ tool object ++++
brush = new tiler_brush(self);
tool_brush = new tiler_tool_brush(self, brush, false);
tool_eraser = new tiler_tool_brush(self, brush, true);
tool_fill = new tiler_tool_fill( self, brush, tool_attribute);
tool_rectangle = new tiler_tool_shape(self, brush, CANVAS_TOOL_SHAPE.rectangle);
tool_ellipse = new tiler_tool_shape(self, brush, CANVAS_TOOL_SHAPE.ellipse);
#endregion
#region ++++ tools ++++
tool_attribute.size = 1;
tool_size_edit = new textBox(TEXTBOX_INPUT.number, function(val) { tool_attribute.size = max(1, round(val)); }).setSlideType(true)
.setFont(f_p3)
.setSideButton(button(function() { dialogPanelCall(new Panel_Node_Canvas_Pressure(self), mouse_mx, mouse_my, { anchor: ANCHOR.top | ANCHOR.left }) })
.setIcon(THEME.pen_pressure, 0, COLORS._main_icon));
tool_size = [ "Size", tool_size_edit, "size", tool_attribute ];
tool_attribute.fillType = 0;
tool_fil8_edit = new buttonGroup( [ THEME.canvas_fill_type, THEME.canvas_fill_type, THEME.canvas_fill_type ], function(val) { tool_attribute.fillType = val; })
.setTooltips( [ "Edge", "Edge + Corner" ] )
.setCollape(false);
tool_fil8 = [ "Fill", tool_fil8_edit, "fillType", tool_attribute ];
tools = [
new NodeTool( "Pencil", THEME.canvas_tools_pencil)
.setSetting(tool_size)
.setToolObject(tool_brush),
new NodeTool( "Eraser", THEME.canvas_tools_eraser)
.setSetting(tool_size)
.setToolObject(tool_eraser),
new NodeTool( "Rectangle", [ THEME.canvas_tools_rect, THEME.canvas_tools_rect_fill ])
.setSetting(tool_size)
.setToolObject(tool_rectangle),
new NodeTool( "Ellipse", [ THEME.canvas_tools_ellip, THEME.canvas_tools_ellip_fill ])
.setSetting(tool_size)
.setToolObject(tool_ellipse),
new NodeTool( "Fill", THEME.canvas_tools_bucket)
.setSetting(tool_fil8)
.setToolObject(tool_fill),
];
#endregion
function apply_draw_surface() {
if(!is_surface(canvas_surface)) return;
if(!is_surface(drawing_surface)) return;
if(selecting) {
surface_set_shader(canvas_surface, sh_draw_tile_apply_selection, true, BLEND.over);
shader_set_surface("selectionMask", selection_mask);
draw_surface(drawing_surface, 0, 0);
surface_reset_shader();
} else {
surface_set_shader(canvas_surface, sh_draw_tile_apply, true, BLEND.over);
draw_surface(drawing_surface, 0, 0);
surface_reset_shader();
}
triggerRender();
}
static drawOverlay = function(hover, active, _x, _y, _s, _mx, _my, _snx, _sny, params) {
var _tileSet = current_data[0];
var _mapSize = current_data[1];
var _tileSize = current_data[2];
if(!is_surface(drawing_surface)) {
drawing_surface = surface_verify(drawing_surface, _mapSize[0], _mapSize[1], surface_r16float);
surface_set_shader(drawing_surface, noone, true, BLEND.over);
draw_surface(canvas_surface, 0, 0);
surface_reset_shader();
}
#region surfaces
var _dim = attributes.dimension;
var _outDim = [ _tileSize[0] * _dim[0], _tileSize[1] * _dim[1] ];
preview_draw_overlay = surface_verify(preview_draw_overlay, _dim[0], _dim[1], surface_r16float);
preview_drawing_tile = surface_verify(preview_drawing_tile, _dim[0] * _tileSize[0], _dim[1] * _tileSize[1]);
preview_draw_overlay_tile = surface_verify(preview_draw_overlay_tile, _dim[0] * _tileSize[0], _dim[1] * _tileSize[1]);
var __s = surface_get_target();
var _sw = surface_get_width(__s);
var _sh = surface_get_height(__s);
_preview_draw_mask = surface_verify(_preview_draw_mask, _dim[0], _dim[1]);
preview_draw_mask = surface_verify( preview_draw_mask, _sw, _sh);
#endregion
#region tools
var _currTool = PANEL_PREVIEW.tool_current;
var _tool = _currTool == noone? noone : _currTool.getToolObject();
brush.brush_size = tool_attribute.size;
brush.autotiler = autotile_selecting == noone? noone : autotiles[autotile_selecting];
if(_tool) {
_tool.subtool = _currTool.selecting;
_tool.apply_draw_surface = apply_draw_surface;
_tool.drawing_surface = drawing_surface;
_tool.tile_size = _tileSize;
_tool.step(hover, active, _x, _y, _s, _mx, _my, _snx, _sny);
surface_set_target(preview_draw_overlay);
DRAW_CLEAR
_tool.drawPreview(hover, active, _x, _y, _s, _mx, _my, _snx, _sny);
surface_reset_target();
surface_set_target(_preview_draw_mask);
DRAW_CLEAR
_tool.drawMask(hover, active, _x, _y, _s, _mx, _my, _snx, _sny);
surface_reset_target();
surface_set_target(preview_draw_mask);
DRAW_CLEAR
draw_surface_ext(_preview_draw_mask, _x, _y, _s * _tileSize[0], _s * _tileSize[1], 0, c_white, 1);
surface_reset_target();
if(_tool.brush_resizable) {
if(hover && key_mod_press(CTRL)) {
if(mouse_wheel_down()) tool_attribute.size = max( 1, tool_attribute.size - 1);
if(mouse_wheel_up()) tool_attribute.size = min(64, tool_attribute.size + 1);
}
brush.sizing(hover, active, _x, _y, _s, _mx, _my, _snx, _sny);
}
}
#endregion
#region draw preview surfaces
var _tileSetDim = surface_get_dimension(_tileSet);
surface_set_shader(preview_drawing_tile, sh_draw_tile_map, true, BLEND.over);
shader_set_2("dimension", _outDim);
shader_set_2("tileSize", _tileSize);
shader_set_2("tileAmo", [ floor(_tileSetDim[0] / _tileSize[0]), floor(_tileSetDim[1] / _tileSize[1]) ]);
shader_set_surface("tileTexture", _tileSet);
shader_set_2("tileTextureDim", _tileSetDim);
shader_set_surface("indexTexture", drawing_surface);
shader_set_2("indexTextureDim", surface_get_dimension(drawing_surface));
draw_empty();
surface_reset_shader();
draw_surface_ext(preview_drawing_tile, _x, _y, _s, _s, 0, c_white, 1);
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
surface_set_shader(preview_draw_overlay_tile, sh_draw_tile_map, true, BLEND.over);
shader_set_2("dimension", _outDim);
shader_set_2("tileSize", _tileSize);
shader_set_2("tileAmo", [ floor(_tileSetDim[0] / _tileSize[0]), floor(_tileSetDim[1] / _tileSize[1]) ]);
shader_set_surface("tileTexture", _tileSet);
shader_set_2("tileTextureDim", _tileSetDim);
shader_set_surface("indexTexture", preview_draw_overlay);
shader_set_2("indexTextureDim", surface_get_dimension(preview_draw_overlay));
draw_empty();
surface_reset_shader();
draw_surface_ext(preview_draw_overlay_tile, _x, _y, _s, _s, 0, c_white, 1);
params.panel.drawNodeGrid();
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
shader_set(sh_brush_outline);
shader_set_f("dimension", _sw, _sh);
draw_surface(preview_draw_mask, 0, 0);
shader_reset();
#endregion
if(autotiles[0].mask_surface) draw_surface_ext(autotiles[0].mask_surface, 32, 32, 8, 8, 0, c_white, 1);
}
static processData = function(_outData, _data, _output_index, _array_index) {
var _tileSet = _data[0];
var _mapSize = _data[1];
var _tileSize = _data[2];
attributes.dimension[0] = _mapSize[0];
attributes.dimension[1] = _mapSize[1];
if(!is_surface(canvas_surface) && buffer_exists(canvas_buffer)) {
canvas_surface = surface_create(_mapSize[0], _mapSize[1], surface_r16float);
buffer_set_surface(canvas_buffer, canvas_surface, 0);
} else
canvas_surface = surface_verify(canvas_surface, _mapSize[0], _mapSize[1], surface_r16float);
drawing_surface = surface_verify(drawing_surface, _mapSize[0], _mapSize[1], surface_r16float);
surface_set_shader(drawing_surface, noone, true, BLEND.over);
draw_surface(canvas_surface, 0, 0);
surface_reset_shader();
if(!is_surface(_tileSet)) return _outData;
var _tileOut = _outData[0];
var _tileMap = _outData[1];
var _arrIndx = _outData[2];
var _outDim = [ _tileSize[0] * _mapSize[0], _tileSize[1] * _mapSize[1] ];
_tileOut = surface_verify(_tileOut, _outDim[0], _outDim[1]);
_tileMap = surface_verify(_tileMap, _mapSize[0], _mapSize[1], surface_r16float);
_arrIndx = array_verify(_arrIndx, _mapSize[0] * _mapSize[1]);
buffer_resize(canvas_buffer, _mapSize[0] * _mapSize[1] * 2);
buffer_get_surface(canvas_buffer, canvas_surface, 0);
surface_set_shader(_tileMap, sh_sample, true, BLEND.over);
draw_surface(canvas_surface, 0, 0);
surface_reset_shader();
var _tileSetDim = surface_get_dimension(_tileSet);
surface_set_shader(_tileOut, sh_draw_tile_map, true, BLEND.over);
shader_set_2("dimension", _outDim);
shader_set_2("tileSize", _tileSize);
shader_set_2("tileAmo", [ floor(_tileSetDim[0] / _tileSize[0]), floor(_tileSetDim[1] / _tileSize[1]) ]);
shader_set_surface("tileTexture", _tileSet);
shader_set_2("tileTextureDim", _tileSetDim);
shader_set_surface("indexTexture", _tileMap);
shader_set_2("indexTextureDim", surface_get_dimension(_tileMap));
draw_empty();
surface_reset_shader();
return [ _tileOut, _tileMap, _arrIndx ];
}
static getPreviewValues = function() { return preview_drawing_tile; }
static getGraphPreviewSurface = function() { return getSingleValue(0, preview_index, true); }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
static doSerialize = function(_map) {
_map.surface = buffer_serialize(canvas_buffer);
}
static doApplyDeserialize = function() {
canvas_buffer = buffer_deserialize(load_map.surface);
canvas_surface = surface_verify(canvas_surface, attributes.dimension[0], attributes.dimension[1], surface_r16float);
drawing_surface = surface_verify(drawing_surface, attributes.dimension[0], attributes.dimension[1], surface_r16float);
buffer_set_surface(canvas_buffer, canvas_surface, 0);
buffer_set_surface(canvas_buffer, drawing_surface, 0);
}
}
Reference in a new issue View git blame Copy permalink