2014-07-07 22:44:21 +02:00
/*************************************************************************/
2016-06-18 14:46:12 +02:00
/* polygon_2d_editor_plugin.cpp */
2014-07-07 22:44:21 +02:00
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2017-08-27 14:16:55 +02:00
/* https://godotengine.org */
2014-07-07 22:44:21 +02:00
/*************************************************************************/
2021-01-01 20:13:46 +01:00
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
2014-07-07 22:44:21 +02:00
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/*************************************************************************/
2018-01-05 00:50:27 +01:00
2014-07-07 22:44:21 +02:00
# include "polygon_2d_editor_plugin.h"
2017-01-16 08:04:19 +01:00
2014-07-07 22:44:21 +02:00
# include "canvas_item_editor_plugin.h"
2018-09-11 18:13:45 +02:00
# include "core/os/file_access.h"
# include "core/os/input.h"
# include "core/os/keyboard.h"
2019-12-24 08:17:23 +01:00
# include "editor/editor_scale.h"
2017-03-05 14:21:25 +01:00
# include "editor/editor_settings.h"
2018-05-02 16:00:35 +02:00
# include "scene/2d/skeleton_2d.h"
2018-08-24 09:35:07 +02:00
2017-09-06 18:41:14 +02:00
Node2D * Polygon2DEditor : : _get_node ( ) const {
return node ;
}
void Polygon2DEditor : : _set_node ( Node * p_polygon ) {
node = Object : : cast_to < Polygon2D > ( p_polygon ) ;
2019-02-16 19:46:09 +01:00
_update_polygon_editing_state ( ) ;
2017-09-06 18:41:14 +02:00
}
Vector2 Polygon2DEditor : : _get_offset ( int p_idx ) const {
return node - > get_offset ( ) ;
}
2019-01-08 23:10:24 +01:00
int Polygon2DEditor : : _get_polygon_count ( ) const {
if ( node - > get_internal_vertex_count ( ) > 0 ) {
return 0 ; //do not edit if internal vertices exist
} else {
return 1 ;
}
}
2014-07-07 22:44:21 +02:00
void Polygon2DEditor : : _notification ( int p_what ) {
2017-03-05 16:44:50 +01:00
switch ( p_what ) {
2018-11-24 05:38:26 +01:00
case NOTIFICATION_ENTER_TREE :
case NOTIFICATION_THEME_CHANGED : {
uv_edit_draw - > add_style_override ( " panel " , get_stylebox ( " bg " , " Tree " ) ) ;
bone_scroll - > add_style_override ( " bg " , get_stylebox ( " bg " , " Tree " ) ) ;
} break ;
2014-07-07 22:44:21 +02:00
case NOTIFICATION_READY : {
2017-03-05 16:44:50 +01:00
button_uv - > set_icon ( get_icon ( " Uv " , " EditorIcons " ) ) ;
2014-07-07 22:44:21 +02:00
2019-01-08 23:10:24 +01:00
uv_button [ UV_MODE_CREATE ] - > set_icon ( get_icon ( " Edit " , " EditorIcons " ) ) ;
uv_button [ UV_MODE_CREATE_INTERNAL ] - > set_icon ( get_icon ( " EditInternal " , " EditorIcons " ) ) ;
uv_button [ UV_MODE_REMOVE_INTERNAL ] - > set_icon ( get_icon ( " RemoveInternal " , " EditorIcons " ) ) ;
2017-03-05 16:44:50 +01:00
uv_button [ UV_MODE_EDIT_POINT ] - > set_icon ( get_icon ( " ToolSelect " , " EditorIcons " ) ) ;
uv_button [ UV_MODE_MOVE ] - > set_icon ( get_icon ( " ToolMove " , " EditorIcons " ) ) ;
uv_button [ UV_MODE_ROTATE ] - > set_icon ( get_icon ( " ToolRotate " , " EditorIcons " ) ) ;
uv_button [ UV_MODE_SCALE ] - > set_icon ( get_icon ( " ToolScale " , " EditorIcons " ) ) ;
2019-01-08 23:10:24 +01:00
uv_button [ UV_MODE_ADD_POLYGON ] - > set_icon ( get_icon ( " Edit " , " EditorIcons " ) ) ;
uv_button [ UV_MODE_REMOVE_POLYGON ] - > set_icon ( get_icon ( " Close " , " EditorIcons " ) ) ;
2020-01-31 04:15:52 +01:00
uv_button [ UV_MODE_PAINT_WEIGHT ] - > set_icon ( get_icon ( " Bucket " , " EditorIcons " ) ) ;
uv_button [ UV_MODE_CLEAR_WEIGHT ] - > set_icon ( get_icon ( " Clear " , " EditorIcons " ) ) ;
2014-07-07 22:44:21 +02:00
2017-03-05 16:44:50 +01:00
b_snap_grid - > set_icon ( get_icon ( " Grid " , " EditorIcons " ) ) ;
2017-09-17 22:52:41 +02:00
b_snap_enable - > set_icon ( get_icon ( " SnapGrid " , " EditorIcons " ) ) ;
2017-03-05 16:44:50 +01:00
uv_icon_zoom - > set_texture ( get_icon ( " Zoom " , " EditorIcons " ) ) ;
2020-01-23 01:55:52 +01:00
uv_vscroll - > set_anchors_and_margins_preset ( PRESET_RIGHT_WIDE ) ;
uv_hscroll - > set_anchors_and_margins_preset ( PRESET_BOTTOM_WIDE ) ;
2014-07-07 22:44:21 +02:00
} break ;
2018-11-24 05:38:26 +01:00
case NOTIFICATION_VISIBILITY_CHANGED : {
if ( ! is_visible ( ) ) {
uv_edit - > hide ( ) ;
}
2014-07-07 22:44:21 +02:00
} break ;
}
}
2018-05-02 16:00:35 +02:00
void Polygon2DEditor : : _sync_bones ( ) {
2018-12-17 12:28:09 +01:00
Skeleton2D * skeleton = NULL ;
2018-05-02 16:00:35 +02:00
if ( ! node - > has_node ( node - > get_skeleton ( ) ) ) {
error - > set_text ( TTR ( " The skeleton property of the Polygon2D does not point to a Skeleton2D node " ) ) ;
error - > popup_centered_minsize ( ) ;
2018-11-24 05:38:26 +01:00
} else {
Node * sn = node - > get_node ( node - > get_skeleton ( ) ) ;
skeleton = Object : : cast_to < Skeleton2D > ( sn ) ;
2018-05-02 16:00:35 +02:00
}
2018-11-24 05:38:26 +01:00
Array prev_bones = node - > call ( " _get_bones " ) ;
node - > clear_bones ( ) ;
2018-05-02 16:00:35 +02:00
if ( ! skeleton ) {
error - > set_text ( TTR ( " The skeleton property of the Polygon2D does not point to a Skeleton2D node " ) ) ;
error - > popup_centered_minsize ( ) ;
2018-11-24 05:38:26 +01:00
} else {
for ( int i = 0 ; i < skeleton - > get_bone_count ( ) ; i + + ) {
NodePath path = skeleton - > get_path_to ( skeleton - > get_bone ( i ) ) ;
PoolVector < float > weights ;
int wc = node - > get_polygon ( ) . size ( ) ;
for ( int j = 0 ; j < prev_bones . size ( ) ; j + = 2 ) {
NodePath pvp = prev_bones [ j ] ;
PoolVector < float > pv = prev_bones [ j + 1 ] ;
if ( pvp = = path & & pv . size ( ) = = wc ) {
weights = pv ;
}
2018-05-02 16:00:35 +02:00
}
2018-11-24 05:38:26 +01:00
if ( weights . size ( ) = = 0 ) { //create them
weights . resize ( node - > get_polygon ( ) . size ( ) ) ;
PoolVector < float > : : Write w = weights . write ( ) ;
for ( int j = 0 ; j < wc ; j + + ) {
w [ j ] = 0.0 ;
}
2018-05-02 16:00:35 +02:00
}
2018-11-24 05:38:26 +01:00
node - > add_bone ( path , weights ) ;
}
2018-05-02 16:00:35 +02:00
}
2018-11-24 05:38:26 +01:00
2018-05-02 16:00:35 +02:00
Array new_bones = node - > call ( " _get_bones " ) ;
2018-11-24 05:38:26 +01:00
undo_redo - > create_action ( TTR ( " Sync Bones " ) ) ;
2018-05-02 16:00:35 +02:00
undo_redo - > add_do_method ( node , " _set_bones " , new_bones ) ;
undo_redo - > add_undo_method ( node , " _set_bones " , prev_bones ) ;
undo_redo - > add_do_method ( this , " _update_bone_list " ) ;
undo_redo - > add_undo_method ( this , " _update_bone_list " ) ;
2018-11-24 05:38:26 +01:00
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
2018-05-02 16:00:35 +02:00
undo_redo - > commit_action ( ) ;
}
void Polygon2DEditor : : _update_bone_list ( ) {
NodePath selected ;
while ( bone_scroll_vb - > get_child_count ( ) ) {
CheckBox * cb = Object : : cast_to < CheckBox > ( bone_scroll_vb - > get_child ( 0 ) ) ;
if ( cb & & cb - > is_pressed ( ) ) {
selected = cb - > get_meta ( " bone_path " ) ;
}
memdelete ( bone_scroll_vb - > get_child ( 0 ) ) ;
}
Ref < ButtonGroup > bg ;
bg . instance ( ) ;
for ( int i = 0 ; i < node - > get_bone_count ( ) ; i + + ) {
CheckBox * cb = memnew ( CheckBox ) ;
NodePath np = node - > get_bone_path ( i ) ;
String name ;
if ( np . get_name_count ( ) ) {
name = np . get_name ( np . get_name_count ( ) - 1 ) ;
}
if ( name = = String ( ) ) {
name = " Bone " + itos ( i ) ;
}
cb - > set_text ( name ) ;
cb - > set_button_group ( bg ) ;
cb - > set_meta ( " bone_path " , np ) ;
2018-11-24 05:38:26 +01:00
cb - > set_focus_mode ( FOCUS_NONE ) ;
2018-05-02 16:00:35 +02:00
bone_scroll_vb - > add_child ( cb ) ;
2018-11-24 05:38:26 +01:00
if ( np = = selected | | bone_scroll_vb - > get_child_count ( ) < 2 )
2018-05-02 16:00:35 +02:00
cb - > set_pressed ( true ) ;
cb - > connect ( " pressed " , this , " _bone_paint_selected " , varray ( i ) ) ;
}
uv_edit_draw - > update ( ) ;
}
void Polygon2DEditor : : _bone_paint_selected ( int p_index ) {
uv_edit_draw - > update ( ) ;
}
2018-02-22 21:38:33 +01:00
void Polygon2DEditor : : _uv_edit_mode_select ( int p_mode ) {
2018-05-02 16:00:35 +02:00
if ( p_mode = = 0 ) { //uv
2018-11-24 05:38:26 +01:00
2018-02-22 21:38:33 +01:00
uv_button [ UV_MODE_CREATE ] - > hide ( ) ;
2019-01-08 23:10:24 +01:00
uv_button [ UV_MODE_CREATE_INTERNAL ] - > hide ( ) ;
uv_button [ UV_MODE_REMOVE_INTERNAL ] - > hide ( ) ;
2020-10-29 20:45:17 +01:00
for ( int i = UV_MODE_EDIT_POINT ; i < = UV_MODE_SCALE ; i + + ) {
2018-02-25 16:06:30 +01:00
uv_button [ i ] - > show ( ) ;
}
2019-01-08 23:10:24 +01:00
uv_button [ UV_MODE_ADD_POLYGON ] - > hide ( ) ;
uv_button [ UV_MODE_REMOVE_POLYGON ] - > hide ( ) ;
2018-05-02 16:00:35 +02:00
uv_button [ UV_MODE_PAINT_WEIGHT ] - > hide ( ) ;
uv_button [ UV_MODE_CLEAR_WEIGHT ] - > hide ( ) ;
2018-02-25 16:06:30 +01:00
_uv_mode ( UV_MODE_EDIT_POINT ) ;
2018-05-02 16:00:35 +02:00
bone_scroll_main_vb - > hide ( ) ;
bone_paint_strength - > hide ( ) ;
bone_paint_radius - > hide ( ) ;
bone_paint_radius_label - > hide ( ) ;
} else if ( p_mode = = 1 ) { //poly
2018-11-24 05:38:26 +01:00
2018-02-25 16:06:30 +01:00
for ( int i = 0 ; i < = UV_MODE_SCALE ; i + + ) {
uv_button [ i ] - > show ( ) ;
}
2019-01-08 23:10:24 +01:00
uv_button [ UV_MODE_ADD_POLYGON ] - > hide ( ) ;
uv_button [ UV_MODE_REMOVE_POLYGON ] - > hide ( ) ;
2018-05-02 16:00:35 +02:00
uv_button [ UV_MODE_PAINT_WEIGHT ] - > hide ( ) ;
uv_button [ UV_MODE_CLEAR_WEIGHT ] - > hide ( ) ;
2018-02-25 16:06:30 +01:00
_uv_mode ( UV_MODE_EDIT_POINT ) ;
2018-05-02 16:00:35 +02:00
bone_scroll_main_vb - > hide ( ) ;
bone_paint_strength - > hide ( ) ;
bone_paint_radius - > hide ( ) ;
bone_paint_radius_label - > hide ( ) ;
} else if ( p_mode = = 2 ) { //splits
2018-11-24 05:38:26 +01:00
2018-02-25 16:06:30 +01:00
for ( int i = 0 ; i < = UV_MODE_SCALE ; i + + ) {
uv_button [ i ] - > hide ( ) ;
}
2019-01-08 23:10:24 +01:00
uv_button [ UV_MODE_ADD_POLYGON ] - > show ( ) ;
uv_button [ UV_MODE_REMOVE_POLYGON ] - > show ( ) ;
2018-05-02 16:00:35 +02:00
uv_button [ UV_MODE_PAINT_WEIGHT ] - > hide ( ) ;
uv_button [ UV_MODE_CLEAR_WEIGHT ] - > hide ( ) ;
2019-01-08 23:10:24 +01:00
_uv_mode ( UV_MODE_ADD_POLYGON ) ;
2018-05-02 16:00:35 +02:00
bone_scroll_main_vb - > hide ( ) ;
bone_paint_strength - > hide ( ) ;
bone_paint_radius - > hide ( ) ;
bone_paint_radius_label - > hide ( ) ;
} else if ( p_mode = = 3 ) { //bones´
2018-11-24 05:38:26 +01:00
2019-01-08 23:10:24 +01:00
for ( int i = 0 ; i < = UV_MODE_REMOVE_POLYGON ; i + + ) {
2018-05-02 16:00:35 +02:00
uv_button [ i ] - > hide ( ) ;
}
uv_button [ UV_MODE_PAINT_WEIGHT ] - > show ( ) ;
uv_button [ UV_MODE_CLEAR_WEIGHT ] - > show ( ) ;
_uv_mode ( UV_MODE_PAINT_WEIGHT ) ;
bone_scroll_main_vb - > show ( ) ;
bone_paint_strength - > show ( ) ;
bone_paint_radius - > show ( ) ;
bone_paint_radius_label - > show ( ) ;
_update_bone_list ( ) ;
bone_paint_pos = Vector2 ( - 100000 , - 100000 ) ; //send brush away when switching
2018-02-22 21:38:33 +01:00
}
2018-11-24 05:38:26 +01:00
uv_edit - > set_size ( uv_edit - > get_size ( ) ) ; // Necessary readjustment of the popup window.
2018-02-22 21:38:33 +01:00
uv_edit_draw - > update ( ) ;
}
2018-11-24 05:38:26 +01:00
void Polygon2DEditor : : _uv_edit_popup_hide ( ) {
EditorSettings : : get_singleton ( ) - > set ( " interface/dialogs/uv_editor_bounds " , uv_edit - > get_rect ( ) ) ;
_cancel_editing ( ) ;
}
2014-07-07 22:44:21 +02:00
void Polygon2DEditor : : _menu_option ( int p_option ) {
2017-03-05 16:44:50 +01:00
switch ( p_option ) {
2014-07-07 22:44:21 +02:00
case MODE_EDIT_UV : {
if ( node - > get_texture ( ) . is_null ( ) ) {
2018-11-24 05:38:26 +01:00
error - > set_text ( TTR ( " No texture in this polygon. \n Set a texture to be able to edit UV. " ) ) ;
2015-04-08 19:02:13 +02:00
error - > popup_centered_minsize ( ) ;
2014-07-07 22:44:21 +02:00
return ;
}
2017-01-07 22:25:37 +01:00
PoolVector < Vector2 > points = node - > get_polygon ( ) ;
PoolVector < Vector2 > uvs = node - > get_uv ( ) ;
2017-03-05 16:44:50 +01:00
if ( uvs . size ( ) ! = points . size ( ) ) {
2016-05-04 03:25:37 +02:00
undo_redo - > create_action ( TTR ( " Create UV Map " ) ) ;
2017-03-05 16:44:50 +01:00
undo_redo - > add_do_method ( node , " set_uv " , points ) ;
undo_redo - > add_undo_method ( node , " set_uv " , uvs ) ;
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
2014-07-07 22:44:21 +02:00
undo_redo - > commit_action ( ) ;
}
2018-11-24 05:38:26 +01:00
if ( EditorSettings : : get_singleton ( ) - > has_setting ( " interface/dialogs/uv_editor_bounds " ) )
uv_edit - > popup ( EditorSettings : : get_singleton ( ) - > get ( " interface/dialogs/uv_editor_bounds " ) ) ;
else
uv_edit - > popup_centered_ratio ( 0.85 ) ;
2019-01-08 23:10:24 +01:00
_update_bone_list ( ) ;
2014-07-07 22:44:21 +02:00
} break ;
case UVEDIT_POLYGON_TO_UV : {
2017-01-07 22:25:37 +01:00
PoolVector < Vector2 > points = node - > get_polygon ( ) ;
2017-03-05 16:44:50 +01:00
if ( points . size ( ) = = 0 )
2014-07-07 22:44:21 +02:00
break ;
2017-01-07 22:25:37 +01:00
PoolVector < Vector2 > uvs = node - > get_uv ( ) ;
2016-05-04 03:25:37 +02:00
undo_redo - > create_action ( TTR ( " Create UV Map " ) ) ;
2017-03-05 16:44:50 +01:00
undo_redo - > add_do_method ( node , " set_uv " , points ) ;
undo_redo - > add_undo_method ( node , " set_uv " , uvs ) ;
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
2014-07-07 22:44:21 +02:00
undo_redo - > commit_action ( ) ;
} break ;
case UVEDIT_UV_TO_POLYGON : {
2017-01-07 22:25:37 +01:00
PoolVector < Vector2 > points = node - > get_polygon ( ) ;
PoolVector < Vector2 > uvs = node - > get_uv ( ) ;
2017-03-05 16:44:50 +01:00
if ( uvs . size ( ) = = 0 )
2014-07-07 22:44:21 +02:00
break ;
2018-11-24 05:38:26 +01:00
undo_redo - > create_action ( TTR ( " Create Polygon " ) ) ;
2017-03-05 16:44:50 +01:00
undo_redo - > add_do_method ( node , " set_polygon " , uvs ) ;
undo_redo - > add_undo_method ( node , " set_polygon " , points ) ;
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
2014-07-07 22:44:21 +02:00
undo_redo - > commit_action ( ) ;
} break ;
case UVEDIT_UV_CLEAR : {
2017-01-07 22:25:37 +01:00
PoolVector < Vector2 > uvs = node - > get_uv ( ) ;
2017-03-05 16:44:50 +01:00
if ( uvs . size ( ) = = 0 )
2014-07-07 22:44:21 +02:00
break ;
2016-05-04 03:25:37 +02:00
undo_redo - > create_action ( TTR ( " Create UV Map " ) ) ;
2017-03-05 16:44:50 +01:00
undo_redo - > add_do_method ( node , " set_uv " , PoolVector < Vector2 > ( ) ) ;
undo_redo - > add_undo_method ( node , " set_uv " , uvs ) ;
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
2014-07-07 22:44:21 +02:00
undo_redo - > commit_action ( ) ;
} break ;
2018-05-03 22:29:15 +02:00
case UVEDIT_GRID_SETTINGS : {
grid_settings - > popup_centered_minsize ( ) ;
} break ;
2017-09-06 18:41:14 +02:00
default : {
AbstractPolygon2DEditor : : _menu_option ( p_option ) ;
} break ;
2014-07-07 22:44:21 +02:00
}
}
2018-11-24 05:38:26 +01:00
void Polygon2DEditor : : _cancel_editing ( ) {
if ( uv_create ) {
uv_drag = false ;
uv_create = false ;
node - > set_uv ( uv_create_uv_prev ) ;
node - > set_polygon ( uv_create_poly_prev ) ;
2019-01-08 23:10:24 +01:00
node - > set_internal_vertex_count ( uv_create_prev_internal_vertices ) ;
node - > set_vertex_colors ( uv_create_colors_prev ) ;
2018-11-24 05:38:26 +01:00
node - > call ( " _set_bones " , uv_create_bones_prev ) ;
2019-01-08 23:10:24 +01:00
node - > set_polygons ( polygons_prev ) ;
2019-02-16 19:46:09 +01:00
_update_polygon_editing_state ( ) ;
2018-11-24 05:38:26 +01:00
} else if ( uv_drag ) {
uv_drag = false ;
if ( uv_edit_mode [ 0 ] - > is_pressed ( ) ) { // Edit UV.
node - > set_uv ( points_prev ) ;
} else if ( uv_edit_mode [ 1 ] - > is_pressed ( ) ) { // Edit polygon.
node - > set_polygon ( points_prev ) ;
}
}
2019-01-08 23:10:24 +01:00
polygon_create . clear ( ) ;
2018-11-24 05:38:26 +01:00
}
2019-02-16 19:46:09 +01:00
void Polygon2DEditor : : _update_polygon_editing_state ( ) {
if ( ! _get_node ( ) )
return ;
if ( node - > get_internal_vertex_count ( ) > 0 )
disable_polygon_editing ( true , TTR ( " Polygon 2D has internal vertices, so it can no longer be edited in the viewport. " ) ) ;
else
disable_polygon_editing ( false , String ( ) ) ;
}
2018-11-24 05:38:26 +01:00
void Polygon2DEditor : : _commit_action ( ) {
2019-02-16 19:46:09 +01:00
// Makes that undo/redoing actions made outside of the UV editor still affect its polygon.
2018-11-24 05:38:26 +01:00
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_do_method ( CanvasItemEditor : : get_singleton ( ) , " update_viewport " ) ;
undo_redo - > add_undo_method ( CanvasItemEditor : : get_singleton ( ) , " update_viewport " ) ;
undo_redo - > commit_action ( ) ;
}
2017-03-05 16:44:50 +01:00
void Polygon2DEditor : : _set_use_snap ( bool p_use ) {
use_snap = p_use ;
2018-11-24 05:38:26 +01:00
EditorSettings : : get_singleton ( ) - > set_project_metadata ( " polygon_2d_uv_editor " , " snap_enabled " , p_use ) ;
2015-09-28 05:06:06 +02:00
}
2017-03-05 16:44:50 +01:00
void Polygon2DEditor : : _set_show_grid ( bool p_show ) {
snap_show_grid = p_show ;
2018-11-24 05:38:26 +01:00
EditorSettings : : get_singleton ( ) - > set_project_metadata ( " polygon_2d_uv_editor " , " show_grid " , p_show ) ;
2015-09-28 05:06:06 +02:00
uv_edit_draw - > update ( ) ;
}
2017-03-05 16:44:50 +01:00
void Polygon2DEditor : : _set_snap_off_x ( float p_val ) {
snap_offset . x = p_val ;
2018-11-24 05:38:26 +01:00
EditorSettings : : get_singleton ( ) - > set_project_metadata ( " polygon_2d_uv_editor " , " snap_offset " , snap_offset ) ;
2015-09-28 05:06:06 +02:00
uv_edit_draw - > update ( ) ;
}
2017-03-05 16:44:50 +01:00
void Polygon2DEditor : : _set_snap_off_y ( float p_val ) {
snap_offset . y = p_val ;
2018-11-24 05:38:26 +01:00
EditorSettings : : get_singleton ( ) - > set_project_metadata ( " polygon_2d_uv_editor " , " snap_offset " , snap_offset ) ;
2015-09-28 05:06:06 +02:00
uv_edit_draw - > update ( ) ;
}
2017-03-05 16:44:50 +01:00
void Polygon2DEditor : : _set_snap_step_x ( float p_val ) {
snap_step . x = p_val ;
2018-11-24 05:38:26 +01:00
EditorSettings : : get_singleton ( ) - > set_project_metadata ( " polygon_2d_uv_editor " , " snap_step " , snap_step ) ;
2015-09-28 05:06:06 +02:00
uv_edit_draw - > update ( ) ;
}
2017-03-05 16:44:50 +01:00
void Polygon2DEditor : : _set_snap_step_y ( float p_val ) {
snap_step . y = p_val ;
2018-11-24 05:38:26 +01:00
EditorSettings : : get_singleton ( ) - > set_project_metadata ( " polygon_2d_uv_editor " , " snap_step " , snap_step ) ;
2015-09-28 05:06:06 +02:00
uv_edit_draw - > update ( ) ;
}
2014-07-07 22:44:21 +02:00
void Polygon2DEditor : : _uv_mode ( int p_mode ) {
2019-01-08 23:10:24 +01:00
polygon_create . clear ( ) ;
2018-02-25 16:06:30 +01:00
uv_drag = false ;
uv_create = false ;
2017-03-05 16:44:50 +01:00
uv_mode = UVMode ( p_mode ) ;
for ( int i = 0 ; i < UV_MODE_MAX ; i + + ) {
uv_button [ i ] - > set_pressed ( p_mode = = i ) ;
2014-07-07 22:44:21 +02:00
}
}
2017-05-20 17:38:03 +02:00
void Polygon2DEditor : : _uv_input ( const Ref < InputEvent > & p_input ) {
2018-11-24 05:38:26 +01:00
if ( ! _get_node ( ) )
return ;
2017-01-11 04:52:51 +01:00
Transform2D mtx ;
2017-03-05 16:44:50 +01:00
mtx . elements [ 2 ] = - uv_draw_ofs ;
mtx . scale_basis ( Vector2 ( uv_draw_zoom , uv_draw_zoom ) ) ;
2014-07-07 22:44:21 +02:00
2017-05-20 17:38:03 +02:00
Ref < InputEventMouseButton > mb = p_input ;
2014-07-07 22:44:21 +02:00
2017-05-20 17:38:03 +02:00
if ( mb . is_valid ( ) ) {
if ( mb - > get_button_index ( ) = = BUTTON_LEFT ) {
if ( mb - > is_pressed ( ) ) {
2018-11-24 05:38:26 +01:00
uv_drag_from = snap_point ( Vector2 ( mb - > get_position ( ) . x , mb - > get_position ( ) . y ) ) ;
2017-03-05 16:44:50 +01:00
uv_drag = true ;
2018-05-04 14:32:40 +02:00
points_prev = node - > get_uv ( ) ;
2018-02-22 21:38:33 +01:00
2018-02-25 16:06:30 +01:00
if ( uv_edit_mode [ 0 ] - > is_pressed ( ) ) { //edit uv
2018-05-04 14:32:40 +02:00
points_prev = node - > get_uv ( ) ;
2018-02-25 16:06:30 +01:00
} else { //edit polygon
2018-05-04 14:32:40 +02:00
points_prev = node - > get_polygon ( ) ;
2018-02-25 16:06:30 +01:00
}
2018-02-22 21:38:33 +01:00
2017-03-05 16:44:50 +01:00
uv_move_current = uv_mode ;
2018-02-22 21:38:33 +01:00
if ( uv_move_current = = UV_MODE_CREATE ) {
if ( ! uv_create ) {
2018-05-04 14:32:40 +02:00
points_prev . resize ( 0 ) ;
2018-11-24 05:38:26 +01:00
Vector2 tuv = mtx . affine_inverse ( ) . xform ( snap_point ( Vector2 ( mb - > get_position ( ) . x , mb - > get_position ( ) . y ) ) ) ;
2018-05-04 14:32:40 +02:00
points_prev . push_back ( tuv ) ;
2018-02-22 21:38:33 +01:00
uv_create_to = tuv ;
2018-05-04 14:32:40 +02:00
point_drag_index = 0 ;
2018-02-22 21:38:33 +01:00
uv_drag_from = tuv ;
uv_drag = true ;
uv_create = true ;
uv_create_uv_prev = node - > get_uv ( ) ;
uv_create_poly_prev = node - > get_polygon ( ) ;
2019-01-08 23:10:24 +01:00
uv_create_prev_internal_vertices = node - > get_internal_vertex_count ( ) ;
uv_create_colors_prev = node - > get_vertex_colors ( ) ;
2018-05-02 16:00:35 +02:00
uv_create_bones_prev = node - > call ( " _get_bones " ) ;
2019-01-08 23:10:24 +01:00
polygons_prev = node - > get_polygons ( ) ;
2019-02-16 19:46:09 +01:00
disable_polygon_editing ( false , String ( ) ) ;
2018-05-04 14:32:40 +02:00
node - > set_polygon ( points_prev ) ;
node - > set_uv ( points_prev ) ;
2019-01-15 19:43:55 +01:00
node - > set_internal_vertex_count ( 0 ) ;
2018-02-22 21:38:33 +01:00
2018-11-24 05:38:26 +01:00
uv_edit_draw - > update ( ) ;
2018-02-22 21:38:33 +01:00
} else {
2018-11-24 05:38:26 +01:00
Vector2 tuv = mtx . affine_inverse ( ) . xform ( snap_point ( Vector2 ( mb - > get_position ( ) . x , mb - > get_position ( ) . y ) ) ) ;
2020-06-23 09:22:08 +02:00
// Close the polygon if selected point is near start. Threshold for closing scaled by zoom level
if ( points_prev . size ( ) > 2 & & tuv . distance_to ( points_prev [ 0 ] ) < ( 8 / uv_draw_zoom ) ) {
2018-02-22 21:38:33 +01:00
undo_redo - > create_action ( TTR ( " Create Polygon & UV " ) ) ;
undo_redo - > add_do_method ( node , " set_uv " , node - > get_uv ( ) ) ;
2018-11-24 05:38:26 +01:00
undo_redo - > add_undo_method ( node , " set_uv " , uv_create_uv_prev ) ;
2018-02-22 21:38:33 +01:00
undo_redo - > add_do_method ( node , " set_polygon " , node - > get_polygon ( ) ) ;
2018-11-24 05:38:26 +01:00
undo_redo - > add_undo_method ( node , " set_polygon " , uv_create_poly_prev ) ;
2019-01-08 23:10:24 +01:00
undo_redo - > add_do_method ( node , " set_internal_vertex_count " , 0 ) ;
undo_redo - > add_undo_method ( node , " set_internal_vertex_count " , uv_create_prev_internal_vertices ) ;
undo_redo - > add_do_method ( node , " set_vertex_colors " , Vector < Color > ( ) ) ;
undo_redo - > add_undo_method ( node , " set_vertex_colors " , uv_create_colors_prev ) ;
2018-05-02 16:00:35 +02:00
undo_redo - > add_do_method ( node , " clear_bones " ) ;
2018-11-24 05:38:26 +01:00
undo_redo - > add_undo_method ( node , " _set_bones " , uv_create_bones_prev ) ;
2019-02-16 19:46:09 +01:00
undo_redo - > add_do_method ( this , " _update_polygon_editing_state " ) ;
undo_redo - > add_undo_method ( this , " _update_polygon_editing_state " ) ;
2018-02-22 21:38:33 +01:00
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
undo_redo - > commit_action ( ) ;
uv_drag = false ;
uv_create = false ;
2018-11-24 05:38:26 +01:00
2018-02-22 21:38:33 +01:00
_uv_mode ( UV_MODE_EDIT_POINT ) ;
2018-11-24 05:38:26 +01:00
_menu_option ( MODE_EDIT ) ;
2018-02-22 21:38:33 +01:00
} else {
2018-05-04 14:32:40 +02:00
points_prev . push_back ( tuv ) ;
point_drag_index = points_prev . size ( ) - 1 ;
2018-02-22 21:38:33 +01:00
uv_drag_from = tuv ;
}
2018-05-04 14:32:40 +02:00
node - > set_polygon ( points_prev ) ;
node - > set_uv ( points_prev ) ;
2018-02-22 21:38:33 +01:00
}
2018-11-24 05:38:26 +01:00
CanvasItemEditor : : get_singleton ( ) - > update_viewport ( ) ;
2018-02-22 21:38:33 +01:00
}
2019-01-08 23:10:24 +01:00
if ( uv_move_current = = UV_MODE_CREATE_INTERNAL ) {
uv_create_uv_prev = node - > get_uv ( ) ;
uv_create_poly_prev = node - > get_polygon ( ) ;
uv_create_colors_prev = node - > get_vertex_colors ( ) ;
uv_create_bones_prev = node - > call ( " _get_bones " ) ;
int internal_vertices = node - > get_internal_vertex_count ( ) ;
Vector2 pos = mtx . affine_inverse ( ) . xform ( snap_point ( Vector2 ( mb - > get_position ( ) . x , mb - > get_position ( ) . y ) ) ) ;
uv_create_poly_prev . push_back ( pos ) ;
uv_create_uv_prev . push_back ( pos ) ;
if ( uv_create_colors_prev . size ( ) ) {
uv_create_colors_prev . push_back ( Color ( 1 , 1 , 1 ) ) ;
}
undo_redo - > create_action ( TTR ( " Create Internal Vertex " ) ) ;
undo_redo - > add_do_method ( node , " set_uv " , uv_create_uv_prev ) ;
undo_redo - > add_undo_method ( node , " set_uv " , node - > get_uv ( ) ) ;
undo_redo - > add_do_method ( node , " set_polygon " , uv_create_poly_prev ) ;
undo_redo - > add_undo_method ( node , " set_polygon " , node - > get_polygon ( ) ) ;
undo_redo - > add_do_method ( node , " set_vertex_colors " , uv_create_colors_prev ) ;
undo_redo - > add_undo_method ( node , " set_vertex_colors " , node - > get_vertex_colors ( ) ) ;
for ( int i = 0 ; i < node - > get_bone_count ( ) ; i + + ) {
PoolVector < float > bonew = node - > get_bone_weights ( i ) ;
bonew . push_back ( 0 ) ;
undo_redo - > add_do_method ( node , " set_bone_weights " , i , bonew ) ;
undo_redo - > add_undo_method ( node , " set_bone_weights " , i , node - > get_bone_weights ( i ) ) ;
}
undo_redo - > add_do_method ( node , " set_internal_vertex_count " , internal_vertices + 1 ) ;
undo_redo - > add_undo_method ( node , " set_internal_vertex_count " , internal_vertices ) ;
2019-02-16 19:46:09 +01:00
undo_redo - > add_do_method ( this , " _update_polygon_editing_state " ) ;
undo_redo - > add_undo_method ( this , " _update_polygon_editing_state " ) ;
2019-01-08 23:10:24 +01:00
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
undo_redo - > commit_action ( ) ;
}
if ( uv_move_current = = UV_MODE_REMOVE_INTERNAL ) {
uv_create_uv_prev = node - > get_uv ( ) ;
uv_create_poly_prev = node - > get_polygon ( ) ;
uv_create_colors_prev = node - > get_vertex_colors ( ) ;
uv_create_bones_prev = node - > call ( " _get_bones " ) ;
int internal_vertices = node - > get_internal_vertex_count ( ) ;
if ( internal_vertices < = 0 )
return ;
int closest = - 1 ;
float closest_dist = 1e20 ;
for ( int i = points_prev . size ( ) - internal_vertices ; i < points_prev . size ( ) ; i + + ) {
Vector2 tuv = mtx . xform ( uv_create_poly_prev [ i ] ) ;
float dist = tuv . distance_to ( Vector2 ( mb - > get_position ( ) . x , mb - > get_position ( ) . y ) ) ;
if ( dist < 8 & & dist < closest_dist ) {
closest = i ;
closest_dist = dist ;
}
}
if ( closest = = - 1 )
return ;
uv_create_poly_prev . remove ( closest ) ;
uv_create_uv_prev . remove ( closest ) ;
if ( uv_create_colors_prev . size ( ) ) {
uv_create_colors_prev . remove ( closest ) ;
}
undo_redo - > create_action ( TTR ( " Remove Internal Vertex " ) ) ;
undo_redo - > add_do_method ( node , " set_uv " , uv_create_uv_prev ) ;
undo_redo - > add_undo_method ( node , " set_uv " , node - > get_uv ( ) ) ;
undo_redo - > add_do_method ( node , " set_polygon " , uv_create_poly_prev ) ;
undo_redo - > add_undo_method ( node , " set_polygon " , node - > get_polygon ( ) ) ;
undo_redo - > add_do_method ( node , " set_vertex_colors " , uv_create_colors_prev ) ;
undo_redo - > add_undo_method ( node , " set_vertex_colors " , node - > get_vertex_colors ( ) ) ;
for ( int i = 0 ; i < node - > get_bone_count ( ) ; i + + ) {
PoolVector < float > bonew = node - > get_bone_weights ( i ) ;
bonew . remove ( closest ) ;
undo_redo - > add_do_method ( node , " set_bone_weights " , i , bonew ) ;
undo_redo - > add_undo_method ( node , " set_bone_weights " , i , node - > get_bone_weights ( i ) ) ;
}
undo_redo - > add_do_method ( node , " set_internal_vertex_count " , internal_vertices - 1 ) ;
undo_redo - > add_undo_method ( node , " set_internal_vertex_count " , internal_vertices ) ;
2019-02-16 19:46:09 +01:00
undo_redo - > add_do_method ( this , " _update_polygon_editing_state " ) ;
undo_redo - > add_undo_method ( this , " _update_polygon_editing_state " ) ;
2019-01-08 23:10:24 +01:00
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
undo_redo - > commit_action ( ) ;
}
2017-03-05 16:44:50 +01:00
if ( uv_move_current = = UV_MODE_EDIT_POINT ) {
2017-05-20 17:38:03 +02:00
if ( mb - > get_shift ( ) & & mb - > get_command ( ) )
2017-03-05 16:44:50 +01:00
uv_move_current = UV_MODE_SCALE ;
2017-05-20 17:38:03 +02:00
else if ( mb - > get_shift ( ) )
2017-03-05 16:44:50 +01:00
uv_move_current = UV_MODE_MOVE ;
2017-05-20 17:38:03 +02:00
else if ( mb - > get_command ( ) )
2017-03-05 16:44:50 +01:00
uv_move_current = UV_MODE_ROTATE ;
2014-07-07 22:44:21 +02:00
}
2017-03-05 16:44:50 +01:00
if ( uv_move_current = = UV_MODE_EDIT_POINT ) {
2018-05-04 14:32:40 +02:00
point_drag_index = - 1 ;
for ( int i = 0 ; i < points_prev . size ( ) ; i + + ) {
Vector2 tuv = mtx . xform ( points_prev [ i ] ) ;
2017-06-03 10:54:24 +02:00
if ( tuv . distance_to ( Vector2 ( mb - > get_position ( ) . x , mb - > get_position ( ) . y ) ) < 8 ) {
2017-03-05 16:44:50 +01:00
uv_drag_from = tuv ;
2018-05-04 14:32:40 +02:00
point_drag_index = i ;
2014-07-07 22:44:21 +02:00
}
}
2018-05-04 14:32:40 +02:00
if ( point_drag_index = = - 1 ) {
2017-03-05 16:44:50 +01:00
uv_drag = false ;
2014-07-07 22:44:21 +02:00
}
}
2018-02-25 16:06:30 +01:00
2019-01-08 23:10:24 +01:00
if ( uv_move_current = = UV_MODE_ADD_POLYGON ) {
int closest = - 1 ;
float closest_dist = 1e20 ;
2018-02-25 16:06:30 +01:00
2018-05-04 14:32:40 +02:00
for ( int i = 0 ; i < points_prev . size ( ) ; i + + ) {
Vector2 tuv = mtx . xform ( points_prev [ i ] ) ;
2019-01-08 23:10:24 +01:00
float dist = tuv . distance_to ( Vector2 ( mb - > get_position ( ) . x , mb - > get_position ( ) . y ) ) ;
if ( dist < 8 & & dist < closest_dist ) {
closest = i ;
closest_dist = dist ;
2018-02-25 16:06:30 +01:00
}
}
2019-01-08 23:10:24 +01:00
if ( closest ! = - 1 ) {
if ( polygon_create . size ( ) & & closest = = polygon_create [ 0 ] ) {
//close
if ( polygon_create . size ( ) < 3 ) {
error - > set_text ( TTR ( " Invalid Polygon (need 3 different vertices) " ) ) ;
error - > popup_centered_minsize ( ) ;
2018-05-04 14:32:40 +02:00
} else {
2019-01-08 23:10:24 +01:00
Array polygons = node - > get_polygons ( ) ;
polygons = polygons . duplicate ( ) ; //copy because its a reference
//todo, could check whether it already exists?
polygons . push_back ( polygon_create ) ;
2019-01-11 01:19:01 +01:00
undo_redo - > create_action ( TTR ( " Add Custom Polygon " ) ) ;
2019-01-08 23:10:24 +01:00
undo_redo - > add_do_method ( node , " set_polygons " , polygons ) ;
2019-01-11 01:19:01 +01:00
undo_redo - > add_undo_method ( node , " set_polygons " , node - > get_polygons ( ) ) ;
2019-01-08 23:10:24 +01:00
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
undo_redo - > commit_action ( ) ;
2018-05-04 14:32:40 +02:00
}
2019-01-08 23:10:24 +01:00
polygon_create . clear ( ) ;
} else if ( polygon_create . find ( closest ) = = - 1 ) {
//add temporarily if not exists
polygon_create . push_back ( closest ) ;
2018-02-25 16:06:30 +01:00
}
}
}
2019-01-08 23:10:24 +01:00
if ( uv_move_current = = UV_MODE_REMOVE_POLYGON ) {
Array polygons = node - > get_polygons ( ) ;
polygons = polygons . duplicate ( ) ; //copy because its a reference
int erase_index = - 1 ;
for ( int i = polygons . size ( ) - 1 ; i > = 0 ; i - - ) {
PoolVector < int > points = polygons [ i ] ;
Vector < Vector2 > polys ;
polys . resize ( points . size ( ) ) ;
for ( int j = 0 ; j < polys . size ( ) ; j + + ) {
int idx = points [ j ] ;
if ( idx < 0 | | idx > = points_prev . size ( ) )
continue ;
polys . write [ j ] = mtx . xform ( points_prev [ idx ] ) ;
}
2018-02-25 16:06:30 +01:00
2019-01-08 23:10:24 +01:00
if ( Geometry : : is_point_in_polygon ( Vector2 ( mb - > get_position ( ) . x , mb - > get_position ( ) . y ) , polys ) ) {
erase_index = i ;
2018-02-25 16:06:30 +01:00
break ;
}
}
2019-01-08 23:10:24 +01:00
if ( erase_index ! = - 1 ) {
polygons . remove ( erase_index ) ;
2019-01-11 01:19:01 +01:00
undo_redo - > create_action ( TTR ( " Remove Custom Polygon " ) ) ;
2019-01-08 23:10:24 +01:00
undo_redo - > add_do_method ( node , " set_polygons " , polygons ) ;
2019-01-11 01:19:01 +01:00
undo_redo - > add_undo_method ( node , " set_polygons " , node - > get_polygons ( ) ) ;
2019-01-08 23:10:24 +01:00
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
undo_redo - > commit_action ( ) ;
}
2018-02-25 16:06:30 +01:00
}
2018-05-02 16:00:35 +02:00
if ( uv_move_current = = UV_MODE_PAINT_WEIGHT | | uv_move_current = = UV_MODE_CLEAR_WEIGHT ) {
int bone_selected = - 1 ;
for ( int i = 0 ; i < bone_scroll_vb - > get_child_count ( ) ; i + + ) {
CheckBox * c = Object : : cast_to < CheckBox > ( bone_scroll_vb - > get_child ( i ) ) ;
if ( c & & c - > is_pressed ( ) ) {
bone_selected = i ;
break ;
}
}
2018-05-04 14:32:40 +02:00
if ( bone_selected ! = - 1 & & node - > get_bone_weights ( bone_selected ) . size ( ) = = points_prev . size ( ) ) {
2018-05-02 16:00:35 +02:00
prev_weights = node - > get_bone_weights ( bone_selected ) ;
bone_painting = true ;
bone_painting_bone = bone_selected ;
}
}
2020-06-25 08:16:41 +02:00
} else {
if ( uv_drag & & ! uv_create ) {
if ( uv_edit_mode [ 0 ] - > is_pressed ( ) ) { // Edit UV.
undo_redo - > create_action ( TTR ( " Transform UV Map " ) ) ;
undo_redo - > add_do_method ( node , " set_uv " , node - > get_uv ( ) ) ;
undo_redo - > add_undo_method ( node , " set_uv " , points_prev ) ;
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
undo_redo - > commit_action ( ) ;
} else if ( uv_edit_mode [ 1 ] - > is_pressed ( ) & & uv_move_current = = UV_MODE_EDIT_POINT ) { // Edit polygon.
undo_redo - > create_action ( TTR ( " Transform Polygon " ) ) ;
undo_redo - > add_do_method ( node , " set_polygon " , node - > get_polygon ( ) ) ;
undo_redo - > add_undo_method ( node , " set_polygon " , points_prev ) ;
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
undo_redo - > commit_action ( ) ;
}
2018-05-02 16:00:35 +02:00
2020-06-25 08:16:41 +02:00
uv_drag = false ;
}
2014-07-07 22:44:21 +02:00
2020-06-25 08:16:41 +02:00
if ( bone_painting ) {
undo_redo - > create_action ( TTR ( " Paint Bone Weights " ) ) ;
undo_redo - > add_do_method ( node , " set_bone_weights " , bone_painting_bone , node - > get_bone_weights ( bone_painting_bone ) ) ;
undo_redo - > add_undo_method ( node , " set_bone_weights " , bone_painting_bone , prev_weights ) ;
2019-01-11 01:19:01 +01:00
undo_redo - > add_do_method ( uv_edit_draw , " update " ) ;
undo_redo - > add_undo_method ( uv_edit_draw , " update " ) ;
undo_redo - > commit_action ( ) ;
2020-06-25 08:16:41 +02:00
bone_painting = false ;
2018-02-22 21:38:33 +01:00
}
2014-07-07 22:44:21 +02:00
}
2017-05-20 17:38:03 +02:00
} else if ( mb - > get_button_index ( ) = = BUTTON_RIGHT & & mb - > is_pressed ( ) ) {
2018-11-24 05:38:26 +01:00
_cancel_editing ( ) ;
2018-02-22 21:38:33 +01:00
2018-11-24 05:38:26 +01:00
if ( bone_painting )
2018-05-02 16:00:35 +02:00
node - > set_bone_weights ( bone_painting_bone , prev_weights ) ;
2018-11-24 05:38:26 +01:00
uv_edit_draw - > update ( ) ;
2014-07-07 22:44:21 +02:00
2017-05-20 17:38:03 +02:00
} else if ( mb - > get_button_index ( ) = = BUTTON_WHEEL_UP & & mb - > is_pressed ( ) ) {
uv_zoom - > set_value ( uv_zoom - > get_value ( ) / ( 1 - ( 0.1 * mb - > get_factor ( ) ) ) ) ;
} else if ( mb - > get_button_index ( ) = = BUTTON_WHEEL_DOWN & & mb - > is_pressed ( ) ) {
uv_zoom - > set_value ( uv_zoom - > get_value ( ) * ( 1 - ( 0.1 * mb - > get_factor ( ) ) ) ) ;
2014-07-07 22:44:21 +02:00
}
2017-05-20 17:38:03 +02:00
}
2014-07-07 22:44:21 +02:00
2017-05-20 17:38:03 +02:00
Ref < InputEventMouseMotion > mm = p_input ;
2014-07-07 22:44:21 +02:00
2017-05-20 17:38:03 +02:00
if ( mm . is_valid ( ) ) {
2017-09-07 21:48:50 +02:00
if ( ( mm - > get_button_mask ( ) & BUTTON_MASK_MIDDLE ) | | Input : : get_singleton ( ) - > is_key_pressed ( KEY_SPACE ) ) {
2017-05-20 17:38:03 +02:00
Vector2 drag ( mm - > get_relative ( ) . x , mm - > get_relative ( ) . y ) ;
2017-03-05 16:44:50 +01:00
uv_hscroll - > set_value ( uv_hscroll - > get_value ( ) - drag . x ) ;
uv_vscroll - > set_value ( uv_vscroll - > get_value ( ) - drag . y ) ;
2014-07-07 22:44:21 +02:00
} else if ( uv_drag ) {
2017-06-03 10:54:24 +02:00
Vector2 uv_drag_to = mm - > get_position ( ) ;
2018-11-24 05:38:26 +01:00
uv_drag_to = snap_point ( uv_drag_to ) ; // FIXME: Only works correctly with 'UV_MODE_EDIT_POINT', it's imprecise with the rest.
2014-07-07 22:44:21 +02:00
Vector2 drag = mtx . affine_inverse ( ) . xform ( uv_drag_to ) - mtx . affine_inverse ( ) . xform ( uv_drag_from ) ;
2017-03-05 16:44:50 +01:00
switch ( uv_move_current ) {
2018-02-22 21:38:33 +01:00
case UV_MODE_CREATE : {
if ( uv_create ) {
2018-11-24 05:38:26 +01:00
uv_create_to = mtx . affine_inverse ( ) . xform ( snap_point ( Vector2 ( mm - > get_position ( ) . x , mm - > get_position ( ) . y ) ) ) ;
2018-02-22 21:38:33 +01:00
}
} break ;
2014-07-07 22:44:21 +02:00
case UV_MODE_EDIT_POINT : {
2018-05-04 14:32:40 +02:00
PoolVector < Vector2 > uv_new = points_prev ;
uv_new . set ( point_drag_index , uv_new [ point_drag_index ] + drag ) ;
2018-02-22 21:38:33 +01:00
if ( uv_edit_mode [ 0 ] - > is_pressed ( ) ) { //edit uv
node - > set_uv ( uv_new ) ;
2018-02-25 16:06:30 +01:00
} else if ( uv_edit_mode [ 1 ] - > is_pressed ( ) ) { //edit polygon
2018-02-22 21:38:33 +01:00
node - > set_polygon ( uv_new ) ;
}
2014-07-07 22:44:21 +02:00
} break ;
case UV_MODE_MOVE : {
2018-05-04 14:32:40 +02:00
PoolVector < Vector2 > uv_new = points_prev ;
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < uv_new . size ( ) ; i + + )
uv_new . set ( i , uv_new [ i ] + drag ) ;
2014-07-07 22:44:21 +02:00
2018-02-22 21:38:33 +01:00
if ( uv_edit_mode [ 0 ] - > is_pressed ( ) ) { //edit uv
node - > set_uv ( uv_new ) ;
2018-02-25 16:06:30 +01:00
} else if ( uv_edit_mode [ 1 ] - > is_pressed ( ) ) { //edit polygon
2018-02-22 21:38:33 +01:00
node - > set_polygon ( uv_new ) ;
}
2014-07-07 22:44:21 +02:00
} break ;
case UV_MODE_ROTATE : {
Vector2 center ;
2018-05-04 14:32:40 +02:00
PoolVector < Vector2 > uv_new = points_prev ;
2014-07-07 22:44:21 +02:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < uv_new . size ( ) ; i + + )
2018-05-04 14:32:40 +02:00
center + = points_prev [ i ] ;
2017-03-05 16:44:50 +01:00
center / = uv_new . size ( ) ;
2014-07-07 22:44:21 +02:00
2017-03-05 16:44:50 +01:00
float angle = ( uv_drag_from - mtx . xform ( center ) ) . normalized ( ) . angle_to ( ( uv_drag_to - mtx . xform ( center ) ) . normalized ( ) ) ;
2014-07-07 22:44:21 +02:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < uv_new . size ( ) ; i + + ) {
2018-05-04 14:32:40 +02:00
Vector2 rel = points_prev [ i ] - center ;
2017-03-05 16:44:50 +01:00
rel = rel . rotated ( angle ) ;
uv_new . set ( i , center + rel ) ;
2014-07-07 22:44:21 +02:00
}
2018-02-22 21:38:33 +01:00
if ( uv_edit_mode [ 0 ] - > is_pressed ( ) ) { //edit uv
node - > set_uv ( uv_new ) ;
2018-02-25 16:06:30 +01:00
} else if ( uv_edit_mode [ 1 ] - > is_pressed ( ) ) { //edit polygon
2018-02-22 21:38:33 +01:00
node - > set_polygon ( uv_new ) ;
}
2014-07-07 22:44:21 +02:00
} break ;
case UV_MODE_SCALE : {
Vector2 center ;
2018-05-04 14:32:40 +02:00
PoolVector < Vector2 > uv_new = points_prev ;
2014-07-07 22:44:21 +02:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < uv_new . size ( ) ; i + + )
2018-05-04 14:32:40 +02:00
center + = points_prev [ i ] ;
2017-03-05 16:44:50 +01:00
center / = uv_new . size ( ) ;
2014-07-07 22:44:21 +02:00
float from_dist = uv_drag_from . distance_to ( mtx . xform ( center ) ) ;
float to_dist = uv_drag_to . distance_to ( mtx . xform ( center ) ) ;
2017-03-05 16:44:50 +01:00
if ( from_dist < 2 )
2014-07-07 22:44:21 +02:00
break ;
2017-03-05 16:44:50 +01:00
float scale = to_dist / from_dist ;
2014-07-07 22:44:21 +02:00
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < uv_new . size ( ) ; i + + ) {
2018-05-04 14:32:40 +02:00
Vector2 rel = points_prev [ i ] - center ;
2017-03-05 16:44:50 +01:00
rel = rel * scale ;
uv_new . set ( i , center + rel ) ;
2014-07-07 22:44:21 +02:00
}
2018-02-22 21:38:33 +01:00
if ( uv_edit_mode [ 0 ] - > is_pressed ( ) ) { //edit uv
node - > set_uv ( uv_new ) ;
2018-02-25 16:06:30 +01:00
} else if ( uv_edit_mode [ 1 ] - > is_pressed ( ) ) { //edit polygon
2018-02-22 21:38:33 +01:00
node - > set_polygon ( uv_new ) ;
}
2014-07-07 22:44:21 +02:00
} break ;
2018-11-24 05:38:26 +01:00
case UV_MODE_PAINT_WEIGHT :
case UV_MODE_CLEAR_WEIGHT : {
bone_paint_pos = Vector2 ( mm - > get_position ( ) . x , mm - > get_position ( ) . y ) ;
} break ;
2019-04-09 17:08:36 +02:00
default : {
}
2014-07-07 22:44:21 +02:00
}
2018-05-02 16:00:35 +02:00
if ( bone_painting ) {
PoolVector < float > painted_weights = node - > get_bone_weights ( bone_painting_bone ) ;
{
int pc = painted_weights . size ( ) ;
float amount = bone_paint_strength - > get_value ( ) ;
float radius = bone_paint_radius - > get_value ( ) * EDSCALE ;
if ( uv_mode = = UV_MODE_CLEAR_WEIGHT ) {
amount = - amount ;
}
PoolVector < float > : : Write w = painted_weights . write ( ) ;
PoolVector < float > : : Read r = prev_weights . read ( ) ;
2018-05-04 14:32:40 +02:00
PoolVector < Vector2 > : : Read rv = points_prev . read ( ) ;
2018-05-02 16:00:35 +02:00
for ( int i = 0 ; i < pc ; i + + ) {
if ( mtx . xform ( rv [ i ] ) . distance_to ( bone_paint_pos ) < radius ) {
w [ i ] = CLAMP ( r [ i ] + amount , 0 , 1 ) ;
}
}
}
node - > set_bone_weights ( bone_painting_bone , painted_weights ) ;
}
2018-11-24 05:38:26 +01:00
2014-07-07 22:44:21 +02:00
uv_edit_draw - > update ( ) ;
2018-11-24 05:38:26 +01:00
CanvasItemEditor : : get_singleton ( ) - > update_viewport ( ) ;
2019-01-08 23:10:24 +01:00
} else if ( polygon_create . size ( ) ) {
2018-02-25 16:06:30 +01:00
uv_create_to = mtx . affine_inverse ( ) . xform ( Vector2 ( mm - > get_position ( ) . x , mm - > get_position ( ) . y ) ) ;
uv_edit_draw - > update ( ) ;
2018-05-02 16:00:35 +02:00
} else if ( uv_mode = = UV_MODE_PAINT_WEIGHT | | uv_mode = = UV_MODE_CLEAR_WEIGHT ) {
bone_paint_pos = Vector2 ( mm - > get_position ( ) . x , mm - > get_position ( ) . y ) ;
uv_edit_draw - > update ( ) ;
2014-07-07 22:44:21 +02:00
}
}
2017-11-01 21:49:39 +01:00
Ref < InputEventMagnifyGesture > magnify_gesture = p_input ;
if ( magnify_gesture . is_valid ( ) ) {
uv_zoom - > set_value ( uv_zoom - > get_value ( ) * magnify_gesture - > get_factor ( ) ) ;
}
Ref < InputEventPanGesture > pan_gesture = p_input ;
if ( pan_gesture . is_valid ( ) ) {
uv_hscroll - > set_value ( uv_hscroll - > get_value ( ) + uv_hscroll - > get_page ( ) * pan_gesture - > get_delta ( ) . x / 8 ) ;
uv_vscroll - > set_value ( uv_vscroll - > get_value ( ) + uv_vscroll - > get_page ( ) * pan_gesture - > get_delta ( ) . y / 8 ) ;
}
2014-07-07 22:44:21 +02:00
}
void Polygon2DEditor : : _uv_scroll_changed ( float ) {
if ( updating_uv_scroll )
return ;
2017-03-05 16:44:50 +01:00
uv_draw_ofs . x = uv_hscroll - > get_value ( ) ;
uv_draw_ofs . y = uv_vscroll - > get_value ( ) ;
uv_draw_zoom = uv_zoom - > get_value ( ) ;
2014-07-07 22:44:21 +02:00
uv_edit_draw - > update ( ) ;
}
void Polygon2DEditor : : _uv_draw ( ) {
2018-11-24 05:38:26 +01:00
if ( ! uv_edit - > is_visible ( ) | | ! _get_node ( ) )
return ;
2014-07-07 22:44:21 +02:00
Ref < Texture > base_tex = node - > get_texture ( ) ;
if ( base_tex . is_null ( ) )
return ;
2018-05-03 22:29:15 +02:00
String warning ;
2017-01-11 04:52:51 +01:00
Transform2D mtx ;
2017-03-05 16:44:50 +01:00
mtx . elements [ 2 ] = - uv_draw_ofs ;
mtx . scale_basis ( Vector2 ( uv_draw_zoom , uv_draw_zoom ) ) ;
2014-07-07 22:44:21 +02:00
2017-03-05 16:44:50 +01:00
VS : : get_singleton ( ) - > canvas_item_add_set_transform ( uv_edit_draw - > get_canvas_item ( ) , mtx ) ;
uv_edit_draw - > draw_texture ( base_tex , Point2 ( ) ) ;
VS : : get_singleton ( ) - > canvas_item_add_set_transform ( uv_edit_draw - > get_canvas_item ( ) , Transform2D ( ) ) ;
2014-07-07 22:44:21 +02:00
2015-09-28 05:06:06 +02:00
if ( snap_show_grid ) {
2018-11-24 05:38:26 +01:00
Color grid_color = Color ( 1.0 , 1.0 , 1.0 , 0.15 ) ;
2015-09-28 05:06:06 +02:00
Size2 s = uv_edit_draw - > get_size ( ) ;
2017-09-01 22:33:39 +02:00
int last_cell = 0 ;
2015-09-28 05:06:06 +02:00
2017-03-05 16:44:50 +01:00
if ( snap_step . x ! = 0 ) {
for ( int i = 0 ; i < s . width ; i + + ) {
int cell = Math : : fast_ftoi ( Math : : floor ( ( mtx . affine_inverse ( ) . xform ( Vector2 ( i , 0 ) ) . x - snap_offset . x ) / snap_step . x ) ) ;
if ( i = = 0 )
last_cell = cell ;
if ( last_cell ! = cell )
2019-07-09 01:49:43 +02:00
uv_edit_draw - > draw_line ( Point2 ( i , 0 ) , Point2 ( i , s . height ) , grid_color , Math : : round ( EDSCALE ) ) ;
2017-03-05 16:44:50 +01:00
last_cell = cell ;
2015-09-28 05:06:06 +02:00
}
}
2017-03-05 16:44:50 +01:00
if ( snap_step . y ! = 0 ) {
for ( int i = 0 ; i < s . height ; i + + ) {
int cell = Math : : fast_ftoi ( Math : : floor ( ( mtx . affine_inverse ( ) . xform ( Vector2 ( 0 , i ) ) . y - snap_offset . y ) / snap_step . y ) ) ;
if ( i = = 0 )
last_cell = cell ;
if ( last_cell ! = cell )
2019-07-09 01:49:43 +02:00
uv_edit_draw - > draw_line ( Point2 ( 0 , i ) , Point2 ( s . width , i ) , grid_color , Math : : round ( EDSCALE ) ) ;
2017-03-05 16:44:50 +01:00
last_cell = cell ;
2015-09-28 05:06:06 +02:00
}
}
}
2019-01-08 23:10:24 +01:00
Array polygons = node - > get_polygons ( ) ;
2018-02-22 21:38:33 +01:00
PoolVector < Vector2 > uvs ;
2018-02-25 16:06:30 +01:00
if ( uv_edit_mode [ 0 ] - > is_pressed ( ) ) { //edit uv
2018-02-22 21:38:33 +01:00
uvs = node - > get_uv ( ) ;
2018-02-25 16:06:30 +01:00
} else { //edit polygon
2018-02-22 21:38:33 +01:00
uvs = node - > get_polygon ( ) ;
2018-02-25 16:06:30 +01:00
}
2018-02-22 21:38:33 +01:00
2018-05-02 16:00:35 +02:00
PoolVector < float > : : Read weight_r ;
if ( uv_edit_mode [ 3 ] - > is_pressed ( ) ) {
int bone_selected = - 1 ;
for ( int i = 0 ; i < bone_scroll_vb - > get_child_count ( ) ; i + + ) {
CheckBox * c = Object : : cast_to < CheckBox > ( bone_scroll_vb - > get_child ( i ) ) ;
if ( c & & c - > is_pressed ( ) ) {
bone_selected = i ;
break ;
}
}
if ( bone_selected ! = - 1 & & node - > get_bone_weights ( bone_selected ) . size ( ) = = uvs . size ( ) ) {
weight_r = node - > get_bone_weights ( bone_selected ) . read ( ) ;
}
}
2019-08-18 22:18:57 +02:00
// All UV points are sharp, so use the sharp handle icon
Ref < Texture > handle = get_icon ( " EditorPathSharpHandle " , " EditorIcons " ) ;
2014-07-07 22:44:21 +02:00
2018-11-24 05:38:26 +01:00
Color poly_line_color = Color ( 0.9 , 0.5 , 0.5 ) ;
2019-02-13 15:37:35 +01:00
if ( polygons . size ( ) | | polygon_create . size ( ) ) {
poly_line_color . a * = 0.25 ;
}
2019-01-08 23:10:24 +01:00
Color polygon_line_color = Color ( 0.5 , 0.5 , 0.9 ) ;
Vector < Color > polygon_fill_color ;
{
Color pf = polygon_line_color ;
pf . a * = 0.5 ;
polygon_fill_color . push_back ( pf ) ;
}
2018-11-24 05:38:26 +01:00
Color prev_color = Color ( 0.5 , 0.5 , 0.5 ) ;
2019-04-25 15:51:27 +02:00
Rect2 rect ;
2014-07-07 22:44:21 +02:00
2019-01-08 23:10:24 +01:00
int uv_draw_max = uvs . size ( ) ;
2019-02-13 15:37:35 +01:00
uv_draw_max - = node - > get_internal_vertex_count ( ) ;
if ( uv_draw_max < 0 ) {
uv_draw_max = 0 ;
}
for ( int i = 0 ; i < uvs . size ( ) ; i + + ) {
int next = uv_draw_max > 0 ? ( i + 1 ) % uv_draw_max : 0 ;
if ( i < uv_draw_max & & uv_drag & & uv_move_current = = UV_MODE_EDIT_POINT & & EDITOR_DEF ( " editors/poly_editor/show_previous_outline " , true ) ) {
2019-07-09 01:49:43 +02:00
uv_edit_draw - > draw_line ( mtx . xform ( points_prev [ i ] ) , mtx . xform ( points_prev [ next ] ) , prev_color , Math : : round ( EDSCALE ) , true ) ;
2019-02-13 15:37:35 +01:00
}
Vector2 next_point = uvs [ next ] ;
if ( uv_create & & i = = uvs . size ( ) - 1 ) {
next_point = uv_create_to ;
}
if ( i < uv_draw_max /*&& polygons.size() == 0 && polygon_create.size() == 0*/ ) { //if using or creating polygons, do not show outline (will show polygons instead)
2019-07-09 01:49:43 +02:00
uv_edit_draw - > draw_line ( mtx . xform ( uvs [ i ] ) , mtx . xform ( next_point ) , poly_line_color , Math : : round ( EDSCALE ) , true ) ;
2019-02-13 15:37:35 +01:00
}
rect . expand_to ( mtx . basis_xform ( uvs [ i ] ) ) ;
}
2019-01-08 23:10:24 +01:00
for ( int i = 0 ; i < polygons . size ( ) ; i + + ) {
PoolVector < int > points = polygons [ i ] ;
Vector < Vector2 > polypoints ;
2019-02-12 21:10:08 +01:00
for ( int j = 0 ; j < points . size ( ) ; j + + ) {
int next = ( j + 1 ) % points . size ( ) ;
2019-01-08 23:10:24 +01:00
2019-02-12 21:10:08 +01:00
int idx = points [ j ] ;
2019-01-08 23:10:24 +01:00
int idx_next = points [ next ] ;
if ( idx < 0 | | idx > = uvs . size ( ) )
continue ;
polypoints . push_back ( mtx . xform ( uvs [ idx ] ) ) ;
if ( idx_next < 0 | | idx_next > = uvs . size ( ) )
continue ;
2019-07-09 01:49:43 +02:00
uv_edit_draw - > draw_line ( mtx . xform ( uvs [ idx ] ) , mtx . xform ( uvs [ idx_next ] ) , polygon_line_color , Math : : round ( EDSCALE ) , true ) ;
2019-01-08 23:10:24 +01:00
}
if ( points . size ( ) > = 3 ) {
uv_edit_draw - > draw_polygon ( polypoints , polygon_fill_color ) ;
}
}
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < uvs . size ( ) ; i + + ) {
2018-11-24 05:38:26 +01:00
if ( weight_r . ptr ( ) ) {
2018-05-02 16:00:35 +02:00
Vector2 draw_pos = mtx . xform ( uvs [ i ] ) ;
float weight = weight_r [ i ] ;
2019-07-09 01:49:43 +02:00
uv_edit_draw - > draw_rect ( Rect2 ( draw_pos - Vector2 ( 2 , 2 ) * EDSCALE , Vector2 ( 5 , 5 ) * EDSCALE ) , Color ( weight , weight , weight , 1.0 ) , Math : : round ( EDSCALE ) ) ;
2018-05-02 16:00:35 +02:00
} else {
2019-01-08 23:10:24 +01:00
if ( i < uv_draw_max ) {
uv_edit_draw - > draw_texture ( handle , mtx . xform ( uvs [ i ] ) - handle - > get_size ( ) * 0.5 ) ;
} else {
2019-08-18 22:18:57 +02:00
// Internal vertex
uv_edit_draw - > draw_texture ( handle , mtx . xform ( uvs [ i ] ) - handle - > get_size ( ) * 0.5 , Color ( 0.6 , 0.8 , 1 ) ) ;
2019-01-08 23:10:24 +01:00
}
2018-05-02 16:00:35 +02:00
}
2014-07-07 22:44:21 +02:00
}
2019-01-08 23:10:24 +01:00
if ( polygon_create . size ( ) ) {
for ( int i = 0 ; i < polygon_create . size ( ) ; i + + ) {
Vector2 from = uvs [ polygon_create [ i ] ] ;
Vector2 to = ( i + 1 ) < polygon_create . size ( ) ? uvs [ polygon_create [ i + 1 ] ] : uv_create_to ;
2019-07-09 01:49:43 +02:00
uv_edit_draw - > draw_line ( mtx . xform ( from ) , mtx . xform ( to ) , polygon_line_color , Math : : round ( EDSCALE ) , true ) ;
2019-01-08 23:10:24 +01:00
}
2018-02-25 16:06:30 +01:00
}
2018-05-02 16:00:35 +02:00
if ( uv_mode = = UV_MODE_PAINT_WEIGHT | | uv_mode = = UV_MODE_CLEAR_WEIGHT ) {
2018-05-03 22:29:15 +02:00
NodePath bone_path ;
for ( int i = 0 ; i < bone_scroll_vb - > get_child_count ( ) ; i + + ) {
CheckBox * c = Object : : cast_to < CheckBox > ( bone_scroll_vb - > get_child ( i ) ) ;
if ( c & & c - > is_pressed ( ) ) {
bone_path = node - > get_bone_path ( i ) ;
break ;
}
}
//draw skeleton
NodePath skeleton_path = node - > get_skeleton ( ) ;
if ( node - > has_node ( skeleton_path ) ) {
Skeleton2D * skeleton = Object : : cast_to < Skeleton2D > ( node - > get_node ( skeleton_path ) ) ;
if ( skeleton ) {
for ( int i = 0 ; i < skeleton - > get_bone_count ( ) ; i + + ) {
Bone2D * bone = skeleton - > get_bone ( i ) ;
if ( bone - > get_rest ( ) = = Transform2D ( 0 , 0 , 0 , 0 , 0 , 0 ) )
continue ; //not set
bool current = bone_path = = skeleton - > get_path_to ( bone ) ;
2018-11-23 02:22:16 +01:00
bool found_child = false ;
2018-05-03 22:29:15 +02:00
for ( int j = 0 ; j < bone - > get_child_count ( ) ; j + + ) {
2018-11-23 02:22:16 +01:00
Bone2D * n = Object : : cast_to < Bone2D > ( bone - > get_child ( j ) ) ;
2018-05-03 22:29:15 +02:00
if ( ! n )
continue ;
2018-11-23 02:22:16 +01:00
found_child = true ;
2018-05-03 22:29:15 +02:00
2018-11-23 02:22:16 +01:00
Transform2D bone_xform = node - > get_global_transform ( ) . affine_inverse ( ) * ( skeleton - > get_global_transform ( ) * bone - > get_skeleton_rest ( ) ) ;
Transform2D endpoint_xform = bone_xform * n - > get_transform ( ) ;
2018-05-03 22:29:15 +02:00
2018-11-23 02:22:16 +01:00
Color color = current ? Color ( 1 , 1 , 1 ) : Color ( 0.5 , 0.5 , 0.5 ) ;
2019-07-09 01:49:43 +02:00
uv_edit_draw - > draw_line ( mtx . xform ( bone_xform . get_origin ( ) ) , mtx . xform ( endpoint_xform . get_origin ( ) ) , Color ( 0 , 0 , 0 ) , Math : : round ( ( current ? 5 : 4 ) * EDSCALE ) ) ;
uv_edit_draw - > draw_line ( mtx . xform ( bone_xform . get_origin ( ) ) , mtx . xform ( endpoint_xform . get_origin ( ) ) , color , Math : : round ( ( current ? 3 : 2 ) * EDSCALE ) ) ;
2018-11-23 02:22:16 +01:00
}
if ( ! found_child ) {
//draw normally
Transform2D bone_xform = node - > get_global_transform ( ) . affine_inverse ( ) * ( skeleton - > get_global_transform ( ) * bone - > get_skeleton_rest ( ) ) ;
Transform2D endpoint_xform = bone_xform * Transform2D ( 0 , Vector2 ( bone - > get_default_length ( ) , 0 ) ) ;
Color color = current ? Color ( 1 , 1 , 1 ) : Color ( 0.5 , 0.5 , 0.5 ) ;
2019-07-09 01:49:43 +02:00
uv_edit_draw - > draw_line ( mtx . xform ( bone_xform . get_origin ( ) ) , mtx . xform ( endpoint_xform . get_origin ( ) ) , Color ( 0 , 0 , 0 ) , Math : : round ( ( current ? 5 : 4 ) * EDSCALE ) ) ;
uv_edit_draw - > draw_line ( mtx . xform ( bone_xform . get_origin ( ) ) , mtx . xform ( endpoint_xform . get_origin ( ) ) , color , Math : : round ( ( current ? 3 : 2 ) * EDSCALE ) ) ;
2018-05-03 22:29:15 +02:00
}
}
}
}
//draw paint circle
2018-05-02 16:00:35 +02:00
uv_edit_draw - > draw_circle ( bone_paint_pos , bone_paint_radius - > get_value ( ) * EDSCALE , Color ( 1 , 1 , 1 , 0.1 ) ) ;
}
2019-04-25 15:51:27 +02:00
rect . position - = uv_edit_draw - > get_size ( ) ;
rect . size + = uv_edit_draw - > get_size ( ) * 2.0 ;
2020-01-14 12:25:55 +01:00
2017-03-05 16:44:50 +01:00
updating_uv_scroll = true ;
2020-01-14 12:25:55 +01:00
2017-06-04 00:25:13 +02:00
uv_hscroll - > set_min ( rect . position . x ) ;
uv_hscroll - > set_max ( rect . position . x + rect . size . x ) ;
2018-11-24 05:38:26 +01:00
if ( ABS ( rect . position . x - ( rect . position . x + rect . size . x ) ) < = uv_edit_draw - > get_size ( ) . x ) {
uv_hscroll - > hide ( ) ;
} else {
uv_hscroll - > show ( ) ;
uv_hscroll - > set_page ( uv_edit_draw - > get_size ( ) . x ) ;
uv_hscroll - > set_value ( uv_draw_ofs . x ) ;
}
2014-07-07 22:44:21 +02:00
2017-06-04 00:25:13 +02:00
uv_vscroll - > set_min ( rect . position . y ) ;
uv_vscroll - > set_max ( rect . position . y + rect . size . y ) ;
2018-11-24 05:38:26 +01:00
if ( ABS ( rect . position . y - ( rect . position . y + rect . size . y ) ) < = uv_edit_draw - > get_size ( ) . y ) {
uv_vscroll - > hide ( ) ;
} else {
uv_vscroll - > show ( ) ;
uv_vscroll - > set_page ( uv_edit_draw - > get_size ( ) . y ) ;
uv_vscroll - > set_value ( uv_draw_ofs . y ) ;
}
2020-01-14 12:25:55 +01:00
Size2 hmin = uv_hscroll - > get_combined_minimum_size ( ) ;
Size2 vmin = uv_vscroll - > get_combined_minimum_size ( ) ;
// Avoid scrollbar overlapping.
uv_hscroll - > set_anchor_and_margin ( MARGIN_RIGHT , ANCHOR_END , uv_vscroll - > is_visible ( ) ? - vmin . width : 0 ) ;
uv_vscroll - > set_anchor_and_margin ( MARGIN_BOTTOM , ANCHOR_END , uv_hscroll - > is_visible ( ) ? - hmin . height : 0 ) ;
2017-03-05 16:44:50 +01:00
updating_uv_scroll = false ;
2014-07-07 22:44:21 +02:00
}
void Polygon2DEditor : : _bind_methods ( ) {
2017-03-05 16:44:50 +01:00
ClassDB : : bind_method ( D_METHOD ( " _uv_mode " ) , & Polygon2DEditor : : _uv_mode ) ;
ClassDB : : bind_method ( D_METHOD ( " _uv_draw " ) , & Polygon2DEditor : : _uv_draw ) ;
ClassDB : : bind_method ( D_METHOD ( " _uv_input " ) , & Polygon2DEditor : : _uv_input ) ;
ClassDB : : bind_method ( D_METHOD ( " _uv_scroll_changed " ) , & Polygon2DEditor : : _uv_scroll_changed ) ;
ClassDB : : bind_method ( D_METHOD ( " _set_use_snap " ) , & Polygon2DEditor : : _set_use_snap ) ;
ClassDB : : bind_method ( D_METHOD ( " _set_show_grid " ) , & Polygon2DEditor : : _set_show_grid ) ;
ClassDB : : bind_method ( D_METHOD ( " _set_snap_off_x " ) , & Polygon2DEditor : : _set_snap_off_x ) ;
ClassDB : : bind_method ( D_METHOD ( " _set_snap_off_y " ) , & Polygon2DEditor : : _set_snap_off_y ) ;
ClassDB : : bind_method ( D_METHOD ( " _set_snap_step_x " ) , & Polygon2DEditor : : _set_snap_step_x ) ;
ClassDB : : bind_method ( D_METHOD ( " _set_snap_step_y " ) , & Polygon2DEditor : : _set_snap_step_y ) ;
2018-02-22 21:38:33 +01:00
ClassDB : : bind_method ( D_METHOD ( " _uv_edit_mode_select " ) , & Polygon2DEditor : : _uv_edit_mode_select ) ;
2018-11-24 05:38:26 +01:00
ClassDB : : bind_method ( D_METHOD ( " _uv_edit_popup_hide " ) , & Polygon2DEditor : : _uv_edit_popup_hide ) ;
2018-05-02 16:00:35 +02:00
ClassDB : : bind_method ( D_METHOD ( " _sync_bones " ) , & Polygon2DEditor : : _sync_bones ) ;
ClassDB : : bind_method ( D_METHOD ( " _update_bone_list " ) , & Polygon2DEditor : : _update_bone_list ) ;
2019-02-16 19:46:09 +01:00
ClassDB : : bind_method ( D_METHOD ( " _update_polygon_editing_state " ) , & Polygon2DEditor : : _update_polygon_editing_state ) ;
2018-05-02 16:00:35 +02:00
ClassDB : : bind_method ( D_METHOD ( " _bone_paint_selected " ) , & Polygon2DEditor : : _bone_paint_selected ) ;
2015-09-28 05:06:06 +02:00
}
Vector2 Polygon2DEditor : : snap_point ( Vector2 p_target ) const {
if ( use_snap ) {
2017-09-18 23:44:04 +02:00
p_target . x = Math : : snap_scalar ( snap_offset . x * uv_draw_zoom - uv_draw_ofs . x , snap_step . x * uv_draw_zoom , p_target . x ) ;
p_target . y = Math : : snap_scalar ( snap_offset . y * uv_draw_zoom - uv_draw_ofs . y , snap_step . y * uv_draw_zoom , p_target . y ) ;
2015-09-28 05:06:06 +02:00
}
2014-07-07 22:44:21 +02:00
2015-09-28 05:06:06 +02:00
return p_target ;
2014-07-07 22:44:21 +02:00
}
2017-12-06 21:36:34 +01:00
Polygon2DEditor : : Polygon2DEditor ( EditorNode * p_editor ) :
AbstractPolygon2DEditor ( p_editor ) {
2018-05-17 23:02:16 +02:00
node = NULL ;
2018-11-24 05:38:26 +01:00
snap_offset = EditorSettings : : get_singleton ( ) - > get_project_metadata ( " polygon_2d_uv_editor " , " snap_offset " , Vector2 ( ) ) ;
snap_step = EditorSettings : : get_singleton ( ) - > get_project_metadata ( " polygon_2d_uv_editor " , " snap_step " , Vector2 ( 10 , 10 ) ) ;
use_snap = EditorSettings : : get_singleton ( ) - > get_project_metadata ( " polygon_2d_uv_editor " , " snap_enabled " , false ) ;
snap_show_grid = EditorSettings : : get_singleton ( ) - > get_project_metadata ( " polygon_2d_uv_editor " , " show_grid " , false ) ;
2015-09-28 05:06:06 +02:00
2017-03-05 16:44:50 +01:00
button_uv = memnew ( ToolButton ) ;
2014-07-07 22:44:21 +02:00
add_child ( button_uv ) ;
2018-11-24 05:38:26 +01:00
button_uv - > set_tooltip ( TTR ( " Open Polygon 2D UV editor. " ) ) ;
2017-03-05 16:44:50 +01:00
button_uv - > connect ( " pressed " , this , " _menu_option " , varray ( MODE_EDIT_UV ) ) ;
2014-07-07 22:44:21 +02:00
2017-03-05 16:44:50 +01:00
uv_mode = UV_MODE_EDIT_POINT ;
uv_edit = memnew ( AcceptDialog ) ;
2014-07-07 22:44:21 +02:00
add_child ( uv_edit ) ;
2016-05-04 03:25:37 +02:00
uv_edit - > set_title ( TTR ( " Polygon 2D UV Editor " ) ) ;
2018-11-24 05:38:26 +01:00
uv_edit - > set_resizable ( true ) ;
uv_edit - > connect ( " popup_hide " , this , " _uv_edit_popup_hide " ) ;
2014-07-07 22:44:21 +02:00
2017-03-05 16:44:50 +01:00
VBoxContainer * uv_main_vb = memnew ( VBoxContainer ) ;
2014-07-07 22:44:21 +02:00
uv_edit - > add_child ( uv_main_vb ) ;
2017-03-05 16:44:50 +01:00
HBoxContainer * uv_mode_hb = memnew ( HBoxContainer ) ;
2018-02-22 21:38:33 +01:00
uv_edit_group . instance ( ) ;
uv_edit_mode [ 0 ] = memnew ( ToolButton ) ;
uv_mode_hb - > add_child ( uv_edit_mode [ 0 ] ) ;
uv_edit_mode [ 0 ] - > set_toggle_mode ( true ) ;
uv_edit_mode [ 1 ] = memnew ( ToolButton ) ;
uv_mode_hb - > add_child ( uv_edit_mode [ 1 ] ) ;
uv_edit_mode [ 1 ] - > set_toggle_mode ( true ) ;
2018-02-25 16:06:30 +01:00
uv_edit_mode [ 2 ] = memnew ( ToolButton ) ;
uv_mode_hb - > add_child ( uv_edit_mode [ 2 ] ) ;
uv_edit_mode [ 2 ] - > set_toggle_mode ( true ) ;
2018-05-02 16:00:35 +02:00
uv_edit_mode [ 3 ] = memnew ( ToolButton ) ;
uv_mode_hb - > add_child ( uv_edit_mode [ 3 ] ) ;
uv_edit_mode [ 3 ] - > set_toggle_mode ( true ) ;
2018-02-22 21:38:33 +01:00
uv_edit_mode [ 0 ] - > set_text ( TTR ( " UV " ) ) ;
uv_edit_mode [ 0 ] - > set_pressed ( true ) ;
2019-01-08 23:10:24 +01:00
uv_edit_mode [ 1 ] - > set_text ( TTR ( " Points " ) ) ;
uv_edit_mode [ 2 ] - > set_text ( TTR ( " Polygons " ) ) ;
2018-05-02 16:00:35 +02:00
uv_edit_mode [ 3 ] - > set_text ( TTR ( " Bones " ) ) ;
2018-02-22 21:38:33 +01:00
uv_edit_mode [ 0 ] - > set_button_group ( uv_edit_group ) ;
uv_edit_mode [ 1 ] - > set_button_group ( uv_edit_group ) ;
2018-02-25 16:06:30 +01:00
uv_edit_mode [ 2 ] - > set_button_group ( uv_edit_group ) ;
2018-05-02 16:00:35 +02:00
uv_edit_mode [ 3 ] - > set_button_group ( uv_edit_group ) ;
2018-02-22 21:38:33 +01:00
uv_edit_mode [ 0 ] - > connect ( " pressed " , this , " _uv_edit_mode_select " , varray ( 0 ) ) ;
uv_edit_mode [ 1 ] - > connect ( " pressed " , this , " _uv_edit_mode_select " , varray ( 1 ) ) ;
2018-02-25 16:06:30 +01:00
uv_edit_mode [ 2 ] - > connect ( " pressed " , this , " _uv_edit_mode_select " , varray ( 2 ) ) ;
2018-05-02 16:00:35 +02:00
uv_edit_mode [ 3 ] - > connect ( " pressed " , this , " _uv_edit_mode_select " , varray ( 3 ) ) ;
2018-02-22 21:38:33 +01:00
uv_mode_hb - > add_child ( memnew ( VSeparator ) ) ;
2014-07-07 22:44:21 +02:00
uv_main_vb - > add_child ( uv_mode_hb ) ;
2017-03-05 16:44:50 +01:00
for ( int i = 0 ; i < UV_MODE_MAX ; i + + ) {
uv_button [ i ] = memnew ( ToolButton ) ;
2014-07-07 22:44:21 +02:00
uv_button [ i ] - > set_toggle_mode ( true ) ;
uv_mode_hb - > add_child ( uv_button [ i ] ) ;
2017-03-05 16:44:50 +01:00
uv_button [ i ] - > connect ( " pressed " , this , " _uv_mode " , varray ( i ) ) ;
2014-07-07 22:44:21 +02:00
uv_button [ i ] - > set_focus_mode ( FOCUS_NONE ) ;
}
2019-01-08 23:10:24 +01:00
uv_button [ UV_MODE_CREATE ] - > set_tooltip ( TTR ( " Create Polygon " ) ) ;
uv_button [ UV_MODE_CREATE_INTERNAL ] - > set_tooltip ( TTR ( " Create Internal Vertex " ) ) ;
2019-01-14 16:40:21 +01:00
uv_button [ UV_MODE_REMOVE_INTERNAL ] - > set_tooltip ( TTR ( " Remove Internal Vertex " ) ) ;
2020-10-10 21:55:38 +02:00
# ifdef OSX_ENABLED
uv_button [ UV_MODE_EDIT_POINT ] - > set_tooltip ( TTR ( " Move Points " ) + " \n " + TTR ( " Command: Rotate " ) + " \n " + TTR ( " Shift: Move All " ) + " \n " + TTR ( " Shift+Command: Scale " ) ) ;
# else
2019-01-08 23:10:24 +01:00
uv_button [ UV_MODE_EDIT_POINT ] - > set_tooltip ( TTR ( " Move Points " ) + " \n " + TTR ( " Ctrl: Rotate " ) + " \n " + TTR ( " Shift: Move All " ) + " \n " + TTR ( " Shift+Ctrl: Scale " ) ) ;
2020-10-10 21:55:38 +02:00
# endif
2019-01-08 23:10:24 +01:00
uv_button [ UV_MODE_MOVE ] - > set_tooltip ( TTR ( " Move Polygon " ) ) ;
uv_button [ UV_MODE_ROTATE ] - > set_tooltip ( TTR ( " Rotate Polygon " ) ) ;
uv_button [ UV_MODE_SCALE ] - > set_tooltip ( TTR ( " Scale Polygon " ) ) ;
uv_button [ UV_MODE_ADD_POLYGON ] - > set_tooltip ( TTR ( " Create a custom polygon. Enables custom polygon rendering. " ) ) ;
uv_button [ UV_MODE_REMOVE_POLYGON ] - > set_tooltip ( TTR ( " Remove a custom polygon. If none remain, custom polygon rendering is disabled. " ) ) ;
uv_button [ UV_MODE_PAINT_WEIGHT ] - > set_tooltip ( TTR ( " Paint weights with specified intensity. " ) ) ;
uv_button [ UV_MODE_CLEAR_WEIGHT ] - > set_tooltip ( TTR ( " Unpaint weights with specified intensity. " ) ) ;
uv_button [ UV_MODE_CREATE ] - > hide ( ) ;
uv_button [ UV_MODE_CREATE_INTERNAL ] - > hide ( ) ;
uv_button [ UV_MODE_REMOVE_INTERNAL ] - > hide ( ) ;
uv_button [ UV_MODE_ADD_POLYGON ] - > hide ( ) ;
uv_button [ UV_MODE_REMOVE_POLYGON ] - > hide ( ) ;
uv_button [ UV_MODE_PAINT_WEIGHT ] - > hide ( ) ;
uv_button [ UV_MODE_CLEAR_WEIGHT ] - > hide ( ) ;
uv_button [ UV_MODE_EDIT_POINT ] - > set_pressed ( true ) ;
2018-05-02 16:00:35 +02:00
bone_paint_strength = memnew ( HSlider ) ;
uv_mode_hb - > add_child ( bone_paint_strength ) ;
bone_paint_strength - > set_custom_minimum_size ( Size2 ( 75 * EDSCALE , 0 ) ) ;
bone_paint_strength - > set_v_size_flags ( SIZE_SHRINK_CENTER ) ;
bone_paint_strength - > set_min ( 0 ) ;
bone_paint_strength - > set_max ( 1 ) ;
bone_paint_strength - > set_step ( 0.01 ) ;
bone_paint_strength - > set_value ( 0.5 ) ;
2018-11-24 05:38:26 +01:00
bone_paint_radius_label = memnew ( Label ( TTR ( " Radius: " ) ) ) ;
2018-05-02 16:00:35 +02:00
uv_mode_hb - > add_child ( bone_paint_radius_label ) ;
bone_paint_radius = memnew ( SpinBox ) ;
uv_mode_hb - > add_child ( bone_paint_radius ) ;
bone_paint_strength - > hide ( ) ;
bone_paint_radius - > hide ( ) ;
bone_paint_radius_label - > hide ( ) ;
bone_paint_radius - > set_min ( 1 ) ;
bone_paint_radius - > set_max ( 100 ) ;
bone_paint_radius - > set_step ( 1 ) ;
bone_paint_radius - > set_value ( 32 ) ;
2018-11-24 05:38:26 +01:00
HSplitContainer * uv_main_hsc = memnew ( HSplitContainer ) ;
uv_main_vb - > add_child ( uv_main_hsc ) ;
uv_main_hsc - > set_v_size_flags ( SIZE_EXPAND_FILL ) ;
uv_edit_draw = memnew ( Panel ) ;
uv_main_hsc - > add_child ( uv_edit_draw ) ;
2014-07-07 22:44:21 +02:00
uv_edit_draw - > set_h_size_flags ( SIZE_EXPAND_FILL ) ;
2018-11-24 05:38:26 +01:00
uv_edit_draw - > set_custom_minimum_size ( Size2 ( 200 , 200 ) * EDSCALE ) ;
2020-01-31 04:15:52 +01:00
Control * space = memnew ( Control ) ;
uv_mode_hb - > add_child ( space ) ;
space - > set_h_size_flags ( SIZE_EXPAND_FILL ) ;
2017-03-05 16:44:50 +01:00
uv_menu = memnew ( MenuButton ) ;
2014-07-07 22:44:21 +02:00
uv_mode_hb - > add_child ( uv_menu ) ;
2016-05-04 03:25:37 +02:00
uv_menu - > set_text ( TTR ( " Edit " ) ) ;
2020-01-31 04:15:52 +01:00
uv_menu - > get_popup ( ) - > add_item ( TTR ( " Copy Polygon to UV " ) , UVEDIT_POLYGON_TO_UV ) ;
uv_menu - > get_popup ( ) - > add_item ( TTR ( " Copy UV to Polygon " ) , UVEDIT_UV_TO_POLYGON ) ;
2014-07-07 22:44:21 +02:00
uv_menu - > get_popup ( ) - > add_separator ( ) ;
2017-03-05 16:44:50 +01:00
uv_menu - > get_popup ( ) - > add_item ( TTR ( " Clear UV " ) , UVEDIT_UV_CLEAR ) ;
2018-05-03 22:29:15 +02:00
uv_menu - > get_popup ( ) - > add_separator ( ) ;
uv_menu - > get_popup ( ) - > add_item ( TTR ( " Grid Settings " ) , UVEDIT_GRID_SETTINGS ) ;
2017-03-05 16:44:50 +01:00
uv_menu - > get_popup ( ) - > connect ( " id_pressed " , this , " _menu_option " ) ;
2015-09-28 05:06:06 +02:00
2017-03-05 16:44:50 +01:00
uv_mode_hb - > add_child ( memnew ( VSeparator ) ) ;
2015-09-28 05:06:06 +02:00
2017-03-05 16:44:50 +01:00
b_snap_enable = memnew ( ToolButton ) ;
2015-09-28 05:06:06 +02:00
uv_mode_hb - > add_child ( b_snap_enable ) ;
2016-05-04 03:25:37 +02:00
b_snap_enable - > set_text ( TTR ( " Snap " ) ) ;
2015-09-28 05:06:06 +02:00
b_snap_enable - > set_focus_mode ( FOCUS_NONE ) ;
b_snap_enable - > set_toggle_mode ( true ) ;
b_snap_enable - > set_pressed ( use_snap ) ;
2016-05-04 03:25:37 +02:00
b_snap_enable - > set_tooltip ( TTR ( " Enable Snap " ) ) ;
2017-03-05 16:44:50 +01:00
b_snap_enable - > connect ( " toggled " , this , " _set_use_snap " ) ;
2015-09-28 05:06:06 +02:00
2017-03-05 16:44:50 +01:00
b_snap_grid = memnew ( ToolButton ) ;
2015-09-28 05:06:06 +02:00
uv_mode_hb - > add_child ( b_snap_grid ) ;
2016-05-04 03:25:37 +02:00
b_snap_grid - > set_text ( TTR ( " Grid " ) ) ;
2015-09-28 05:06:06 +02:00
b_snap_grid - > set_focus_mode ( FOCUS_NONE ) ;
b_snap_grid - > set_toggle_mode ( true ) ;
b_snap_grid - > set_pressed ( snap_show_grid ) ;
2016-05-04 03:25:37 +02:00
b_snap_grid - > set_tooltip ( TTR ( " Show Grid " ) ) ;
2017-03-05 16:44:50 +01:00
b_snap_grid - > connect ( " toggled " , this , " _set_show_grid " ) ;
2015-09-28 05:06:06 +02:00
2018-05-03 22:29:15 +02:00
grid_settings = memnew ( AcceptDialog ) ;
grid_settings - > set_title ( TTR ( " Configure Grid: " ) ) ;
add_child ( grid_settings ) ;
VBoxContainer * grid_settings_vb = memnew ( VBoxContainer ) ;
grid_settings - > add_child ( grid_settings_vb ) ;
2015-09-28 05:06:06 +02:00
2017-03-05 16:44:50 +01:00
SpinBox * sb_off_x = memnew ( SpinBox ) ;
2015-09-28 05:06:06 +02:00
sb_off_x - > set_min ( - 256 ) ;
sb_off_x - > set_max ( 256 ) ;
sb_off_x - > set_step ( 1 ) ;
2017-01-04 05:16:14 +01:00
sb_off_x - > set_value ( snap_offset . x ) ;
2015-09-28 05:06:06 +02:00
sb_off_x - > set_suffix ( " px " ) ;
sb_off_x - > connect ( " value_changed " , this , " _set_snap_off_x " ) ;
2018-05-03 22:29:15 +02:00
grid_settings_vb - > add_margin_child ( TTR ( " Grid Offset X: " ) , sb_off_x ) ;
2015-09-28 05:06:06 +02:00
2017-03-05 16:44:50 +01:00
SpinBox * sb_off_y = memnew ( SpinBox ) ;
2015-09-28 05:06:06 +02:00
sb_off_y - > set_min ( - 256 ) ;
sb_off_y - > set_max ( 256 ) ;
sb_off_y - > set_step ( 1 ) ;
2017-01-04 05:16:14 +01:00
sb_off_y - > set_value ( snap_offset . y ) ;
2015-09-28 05:06:06 +02:00
sb_off_y - > set_suffix ( " px " ) ;
sb_off_y - > connect ( " value_changed " , this , " _set_snap_off_y " ) ;
2018-05-03 22:29:15 +02:00
grid_settings_vb - > add_margin_child ( TTR ( " Grid Offset Y: " ) , sb_off_y ) ;
2015-09-28 05:06:06 +02:00
2017-03-05 16:44:50 +01:00
SpinBox * sb_step_x = memnew ( SpinBox ) ;
2015-09-28 05:06:06 +02:00
sb_step_x - > set_min ( - 256 ) ;
sb_step_x - > set_max ( 256 ) ;
sb_step_x - > set_step ( 1 ) ;
2017-01-04 05:16:14 +01:00
sb_step_x - > set_value ( snap_step . x ) ;
2015-09-28 05:06:06 +02:00
sb_step_x - > set_suffix ( " px " ) ;
sb_step_x - > connect ( " value_changed " , this , " _set_snap_step_x " ) ;
2018-05-03 22:29:15 +02:00
grid_settings_vb - > add_margin_child ( TTR ( " Grid Step X: " ) , sb_step_x ) ;
2015-09-28 05:06:06 +02:00
2017-03-05 16:44:50 +01:00
SpinBox * sb_step_y = memnew ( SpinBox ) ;
2015-09-28 05:06:06 +02:00
sb_step_y - > set_min ( - 256 ) ;
sb_step_y - > set_max ( 256 ) ;
sb_step_y - > set_step ( 1 ) ;
2017-01-04 05:16:14 +01:00
sb_step_y - > set_value ( snap_step . y ) ;
2015-09-28 05:06:06 +02:00
sb_step_y - > set_suffix ( " px " ) ;
sb_step_y - > connect ( " value_changed " , this , " _set_snap_step_y " ) ;
2018-05-03 22:29:15 +02:00
grid_settings_vb - > add_margin_child ( TTR ( " Grid Step Y: " ) , sb_step_y ) ;
2015-09-28 05:06:06 +02:00
2017-03-05 16:44:50 +01:00
uv_mode_hb - > add_child ( memnew ( VSeparator ) ) ;
uv_icon_zoom = memnew ( TextureRect ) ;
2018-11-24 05:38:26 +01:00
uv_icon_zoom - > set_stretch_mode ( TextureRect : : STRETCH_KEEP_CENTERED ) ;
2017-03-05 16:44:50 +01:00
uv_mode_hb - > add_child ( uv_icon_zoom ) ;
uv_zoom = memnew ( HSlider ) ;
2014-07-07 22:44:21 +02:00
uv_zoom - > set_min ( 0.01 ) ;
2019-12-14 20:48:47 +01:00
uv_zoom - > set_max ( 16 ) ;
2017-01-04 05:16:14 +01:00
uv_zoom - > set_value ( 1 ) ;
2014-07-07 22:44:21 +02:00
uv_zoom - > set_step ( 0.01 ) ;
2018-05-02 16:00:35 +02:00
uv_zoom - > set_v_size_flags ( SIZE_SHRINK_CENTER ) ;
2014-07-07 22:44:21 +02:00
uv_mode_hb - > add_child ( uv_zoom ) ;
2018-05-03 22:29:15 +02:00
uv_zoom - > set_custom_minimum_size ( Size2 ( 80 * EDSCALE , 0 ) ) ;
2017-03-05 16:44:50 +01:00
uv_zoom_value = memnew ( SpinBox ) ;
2014-07-07 22:44:21 +02:00
uv_zoom - > share ( uv_zoom_value ) ;
2017-03-05 16:44:50 +01:00
uv_zoom_value - > set_custom_minimum_size ( Size2 ( 50 , 0 ) ) ;
2014-07-07 22:44:21 +02:00
uv_mode_hb - > add_child ( uv_zoom_value ) ;
2017-03-05 16:44:50 +01:00
uv_zoom - > connect ( " value_changed " , this , " _uv_scroll_changed " ) ;
2014-07-07 22:44:21 +02:00
2017-03-05 16:44:50 +01:00
uv_vscroll = memnew ( VScrollBar ) ;
2018-11-24 05:38:26 +01:00
uv_vscroll - > set_step ( 0.001 ) ;
uv_edit_draw - > add_child ( uv_vscroll ) ;
2017-03-05 16:44:50 +01:00
uv_vscroll - > connect ( " value_changed " , this , " _uv_scroll_changed " ) ;
uv_hscroll = memnew ( HScrollBar ) ;
2018-11-24 05:38:26 +01:00
uv_hscroll - > set_step ( 0.001 ) ;
uv_edit_draw - > add_child ( uv_hscroll ) ;
2017-03-05 16:44:50 +01:00
uv_hscroll - > connect ( " value_changed " , this , " _uv_scroll_changed " ) ;
2014-07-07 22:44:21 +02:00
2018-05-02 16:00:35 +02:00
bone_scroll_main_vb = memnew ( VBoxContainer ) ;
bone_scroll_main_vb - > hide ( ) ;
2018-11-24 05:38:26 +01:00
bone_scroll_main_vb - > set_custom_minimum_size ( Size2 ( 150 * EDSCALE , 0 ) ) ;
2018-05-03 22:29:15 +02:00
sync_bones = memnew ( Button ( TTR ( " Sync Bones to Polygon " ) ) ) ;
2018-05-02 16:00:35 +02:00
bone_scroll_main_vb - > add_child ( sync_bones ) ;
2018-11-24 05:38:26 +01:00
sync_bones - > set_h_size_flags ( 0 ) ;
sync_bones - > connect ( " pressed " , this , " _sync_bones " ) ;
uv_main_hsc - > add_child ( bone_scroll_main_vb ) ;
2018-05-02 16:00:35 +02:00
bone_scroll = memnew ( ScrollContainer ) ;
bone_scroll - > set_v_scroll ( true ) ;
bone_scroll - > set_h_scroll ( false ) ;
bone_scroll_main_vb - > add_child ( bone_scroll ) ;
bone_scroll - > set_v_size_flags ( SIZE_EXPAND_FILL ) ;
bone_scroll_vb = memnew ( VBoxContainer ) ;
bone_scroll - > add_child ( bone_scroll_vb ) ;
2017-03-05 16:44:50 +01:00
uv_edit_draw - > connect ( " draw " , this , " _uv_draw " ) ;
uv_edit_draw - > connect ( " gui_input " , this , " _uv_input " ) ;
uv_draw_zoom = 1.0 ;
2018-05-04 14:32:40 +02:00
point_drag_index = - 1 ;
2017-03-05 16:44:50 +01:00
uv_drag = false ;
2018-02-25 16:06:30 +01:00
uv_create = false ;
2017-03-05 16:44:50 +01:00
updating_uv_scroll = false ;
2018-05-02 16:00:35 +02:00
bone_painting = false ;
2014-07-07 22:44:21 +02:00
2017-03-05 16:44:50 +01:00
error = memnew ( AcceptDialog ) ;
2014-07-07 22:44:21 +02:00
add_child ( error ) ;
2017-01-09 19:50:08 +01:00
uv_edit_draw - > set_clip_contents ( true ) ;
2014-07-07 22:44:21 +02:00
}
2017-12-06 21:36:34 +01:00
Polygon2DEditorPlugin : : Polygon2DEditorPlugin ( EditorNode * p_node ) :
AbstractPolygon2DEditorPlugin ( p_node , memnew ( Polygon2DEditor ( p_node ) ) , " Polygon2D " ) {
2014-07-07 22:44:21 +02:00
}