summaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--doc/classes/Timer.xml10
-rw-r--r--editor/plugins/spatial_editor_plugin.cpp2
-rw-r--r--editor/plugins/tile_set_editor_plugin.cpp283
-rw-r--r--editor/plugins/tile_set_editor_plugin.h26
-rw-r--r--main/main.cpp6
-rw-r--r--modules/bullet/bullet_physics_server.cpp2
-rw-r--r--platform/uwp/export/export.cpp70
-rw-r--r--platform/windows/detect.py6
-rw-r--r--scene/3d/skeleton.cpp23
-rw-r--r--scene/3d/skeleton.h2
-rw-r--r--scene/animation/animation_tree_player.cpp2
-rw-r--r--servers/visual/shader_language.cpp1
12 files changed, 357 insertions, 76 deletions
diff --git a/doc/classes/Timer.xml b/doc/classes/Timer.xml
index 7ea83b0b22..09071b2ad1 100644
--- a/doc/classes/Timer.xml
+++ b/doc/classes/Timer.xml
@@ -15,20 +15,21 @@
<return type="float">
</return>
<description>
- Return the time left for timeout in seconds if the timer is active, 0 otherwise.
+ Returns the timer's remaining time in seconds. Returns 0 if the timer is inactive.
</description>
</method>
<method name="is_paused" qualifiers="const">
<return type="bool">
</return>
<description>
- Return if the timer is paused or not.
+ Returns [code]true[/code] if the timer is paused.
</description>
</method>
<method name="is_stopped" qualifiers="const">
<return type="bool">
</return>
<description>
+ Returns [code]true[/code] if the timer is stopped.
</description>
</method>
<method name="set_paused">
@@ -37,14 +38,15 @@
<argument index="0" name="paused" type="bool">
</argument>
<description>
- Set whether the timer is paused or not. A paused timer will be inactive until it is unpaused again.
+ Pauses the timer. If [code]paused[/code] is [code]true[/code], the timer will not process until it is started or unpaused again, even if [method start] is called.
</description>
</method>
<method name="start">
<return type="void">
</return>
<description>
- Start the Timer.
+ Starts the timer. This also resets the remaining time to [code]wait_time[/code].
+ Note: this method will not resume a paused timer. See [method set_paused].
</description>
</method>
<method name="stop">
diff --git a/editor/plugins/spatial_editor_plugin.cpp b/editor/plugins/spatial_editor_plugin.cpp
index b26038fe09..e0a697ec26 100644
--- a/editor/plugins/spatial_editor_plugin.cpp
+++ b/editor/plugins/spatial_editor_plugin.cpp
@@ -3213,7 +3213,7 @@ bool SpatialEditorViewport::can_drop_data_fw(const Point2 &p_point, const Varian
continue;
}
memdelete(instanced_scene);
- } else if (type == "Mesh" || "ArrayMesh" || "PrimitiveMesh") {
+ } else if (type == "Mesh" || type == "ArrayMesh" || type == "PrimitiveMesh") {
Ref<Mesh> mesh = ResourceLoader::load(files[i]);
if (!mesh.is_valid()) {
continue;
diff --git a/editor/plugins/tile_set_editor_plugin.cpp b/editor/plugins/tile_set_editor_plugin.cpp
index b56585f62c..a8e4d73cd2 100644
--- a/editor/plugins/tile_set_editor_plugin.cpp
+++ b/editor/plugins/tile_set_editor_plugin.cpp
@@ -343,12 +343,13 @@ AutotileEditor::AutotileEditor(EditorNode *p_editor) {
split->add_child(property_editor);
helper = memnew(AutotileEditorHelper(this));
- property_editor->call_deferred("edit", helper);
+ property_editor->edit(helper);
// Editor
dragging_point = -1;
creating_shape = false;
+ snap_step = Vector2(32, 32);
set_custom_minimum_size(Size2(0, 150));
@@ -426,10 +427,78 @@ AutotileEditor::AutotileEditor(EditorNode *p_editor) {
tools[SHAPE_KEEP_INSIDE_TILE]->set_toggle_mode(true);
tools[SHAPE_KEEP_INSIDE_TILE]->set_pressed(true);
tool_containers[TOOLBAR_SHAPE]->add_child(tools[SHAPE_KEEP_INSIDE_TILE]);
- tools[SHAPE_SNAP_TO_BITMASK_GRID] = memnew(ToolButton);
- tools[SHAPE_SNAP_TO_BITMASK_GRID]->set_toggle_mode(true);
- tools[SHAPE_SNAP_TO_BITMASK_GRID]->set_pressed(true);
- tool_containers[TOOLBAR_SHAPE]->add_child(tools[SHAPE_SNAP_TO_BITMASK_GRID]);
+ tools[SHAPE_GRID_SNAP] = memnew(ToolButton);
+ tools[SHAPE_GRID_SNAP]->set_toggle_mode(true);
+ tools[SHAPE_GRID_SNAP]->connect("toggled", this, "_on_grid_snap_toggled");
+ tool_containers[TOOLBAR_SHAPE]->add_child(tools[SHAPE_GRID_SNAP]);
+
+ hb_grid = memnew(HBoxContainer);
+ tool_containers[TOOLBAR_SHAPE]->add_child(hb_grid);
+
+ hb_grid->add_child(memnew(VSeparator));
+ hb_grid->add_child(memnew(Label(TTR("Offset:"))));
+
+ sb_off_x = memnew(SpinBox);
+ sb_off_x->set_min(-256);
+ sb_off_x->set_max(256);
+ sb_off_x->set_step(1);
+ sb_off_x->set_value(snap_offset.x);
+ sb_off_x->set_suffix("px");
+ sb_off_x->connect("value_changed", this, "_set_snap_off_x");
+ hb_grid->add_child(sb_off_x);
+
+ sb_off_y = memnew(SpinBox);
+ sb_off_y->set_min(-256);
+ sb_off_y->set_max(256);
+ sb_off_y->set_step(1);
+ sb_off_y->set_value(snap_offset.y);
+ sb_off_y->set_suffix("px");
+ sb_off_y->connect("value_changed", this, "_set_snap_off_y");
+ hb_grid->add_child(sb_off_y);
+
+ hb_grid->add_child(memnew(VSeparator));
+ hb_grid->add_child(memnew(Label(TTR("Step:"))));
+
+ sb_step_x = memnew(SpinBox);
+ sb_step_x->set_min(-256);
+ sb_step_x->set_max(256);
+ sb_step_x->set_step(1);
+ sb_step_x->set_value(snap_step.x);
+ sb_step_x->set_suffix("px");
+ sb_step_x->connect("value_changed", this, "_set_snap_step_x");
+ hb_grid->add_child(sb_step_x);
+
+ sb_step_y = memnew(SpinBox);
+ sb_step_y->set_min(-256);
+ sb_step_y->set_max(256);
+ sb_step_y->set_step(1);
+ sb_step_y->set_value(snap_step.y);
+ sb_step_y->set_suffix("px");
+ sb_step_y->connect("value_changed", this, "_set_snap_step_y");
+ hb_grid->add_child(sb_step_y);
+
+ hb_grid->add_child(memnew(VSeparator));
+ hb_grid->add_child(memnew(Label(TTR("Separation:"))));
+
+ sb_sep_x = memnew(SpinBox);
+ sb_sep_x->set_min(0);
+ sb_sep_x->set_max(256);
+ sb_sep_x->set_step(1);
+ sb_sep_x->set_value(snap_separation.x);
+ sb_sep_x->set_suffix("px");
+ sb_sep_x->connect("value_changed", this, "_set_snap_sep_x");
+ hb_grid->add_child(sb_sep_x);
+
+ sb_sep_y = memnew(SpinBox);
+ sb_sep_y->set_min(0);
+ sb_sep_y->set_max(256);
+ sb_sep_y->set_step(1);
+ sb_sep_y->set_value(snap_separation.y);
+ sb_sep_y->set_suffix("px");
+ sb_sep_y->connect("value_changed", this, "_set_snap_sep_y");
+ hb_grid->add_child(sb_sep_y);
+
+ hb_grid->hide();
spin_priority = memnew(SpinBox);
spin_priority->set_min(1);
@@ -489,6 +558,13 @@ void AutotileEditor::_bind_methods() {
ClassDB::bind_method("_on_workspace_input", &AutotileEditor::_on_workspace_input);
ClassDB::bind_method("_on_tool_clicked", &AutotileEditor::_on_tool_clicked);
ClassDB::bind_method("_on_priority_changed", &AutotileEditor::_on_priority_changed);
+ ClassDB::bind_method("_on_grid_snap_toggled", &AutotileEditor::_on_grid_snap_toggled);
+ ClassDB::bind_method("_set_snap_step_x", &AutotileEditor::_set_snap_step_x);
+ ClassDB::bind_method("_set_snap_step_y", &AutotileEditor::_set_snap_step_y);
+ ClassDB::bind_method("_set_snap_off_x", &AutotileEditor::_set_snap_off_x);
+ ClassDB::bind_method("_set_snap_off_y", &AutotileEditor::_set_snap_off_y);
+ ClassDB::bind_method("_set_snap_sep_x", &AutotileEditor::_set_snap_sep_x);
+ ClassDB::bind_method("_set_snap_sep_y", &AutotileEditor::_set_snap_sep_y);
}
void AutotileEditor::_notification(int p_what) {
@@ -501,7 +577,7 @@ void AutotileEditor::_notification(int p_what) {
tools[SHAPE_NEW_POLYGON]->set_icon(get_icon("CollisionPolygon2D", "EditorIcons"));
tools[SHAPE_DELETE]->set_icon(get_icon("Remove", "EditorIcons"));
tools[SHAPE_KEEP_INSIDE_TILE]->set_icon(get_icon("Snap", "EditorIcons"));
- tools[SHAPE_SNAP_TO_BITMASK_GRID]->set_icon(get_icon("SnapGrid", "EditorIcons"));
+ tools[SHAPE_GRID_SNAP]->set_icon(get_icon("SnapGrid", "EditorIcons"));
tools[ZOOM_OUT]->set_icon(get_icon("ZoomLess", "EditorIcons"));
tools[ZOOM_1]->set_icon(get_icon("ZoomReset", "EditorIcons"));
tools[ZOOM_IN]->set_icon(get_icon("ZoomMore", "EditorIcons"));
@@ -632,6 +708,7 @@ void AutotileEditor::_on_workspace_draw() {
Vector2 coord = edited_shape_coord;
draw_highlight_tile(coord);
draw_polygon_shapes();
+ draw_grid_snap();
} break;
case EDITMODE_PRIORITY: {
spin_priority->set_value(tile_set->autotile_get_subtile_priority(get_current_tile(), edited_shape_coord));
@@ -880,15 +957,15 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
Vector<TileSet::ShapeData> sd = tile_set->tile_get_shapes(get_current_tile());
for (int i = 0; i < sd.size(); i++) {
if (sd[i].autotile_coord == coord) {
- Ref<ConcavePolygonShape2D> shape = sd[i].shape;
+ Ref<ConvexPolygonShape2D> shape = sd[i].shape;
if (shape.is_valid()) {
- //FIXME: i need a way to know if the point is countained on the polygon instead of the rect
+
Rect2 bounding_rect;
PoolVector2Array polygon;
- bounding_rect.position = shape->get_segments()[0];
- for (int j = 0; j < shape->get_segments().size(); j += 2) {
- polygon.push_back(shape->get_segments()[j] + shape_anchor);
- bounding_rect.expand_to(shape->get_segments()[j] + shape_anchor);
+ bounding_rect.position = shape->get_points()[0];
+ for (int j = 0; j < shape->get_points().size(); j++) {
+ polygon.push_back(shape->get_points()[j] + shape_anchor);
+ bounding_rect.expand_to(shape->get_points()[j] + shape_anchor);
}
if (bounding_rect.has_point(mb->get_position())) {
current_shape = polygon;
@@ -905,17 +982,17 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
if (dragging_point >= 0) {
dragging_point = -1;
- PoolVector<Vector2> segments;
- segments.resize(current_shape.size() * 2);
- PoolVector<Vector2>::Write w = segments.write();
+ Vector<Vector2> points;
for (int i = 0; i < current_shape.size(); i++) {
- w[(i << 1) + 0] = current_shape[i] - shape_anchor;
- w[(i << 1) + 1] = current_shape[(i + 1) % current_shape.size()] - shape_anchor;
+ Vector2 p = current_shape[i];
+ if (tools[SHAPE_GRID_SNAP]->is_pressed() || tools[SHAPE_KEEP_INSIDE_TILE]->is_pressed()) {
+ p = snap_point(p);
+ }
+ points.push_back(p - shape_anchor);
}
- w = PoolVector<Vector2>::Write();
- edited_collision_shape->set_segments(segments);
+ edited_collision_shape->set_points(points);
workspace->update();
}
@@ -982,11 +1059,30 @@ void AutotileEditor::_on_workspace_input(const Ref<InputEvent> &p_ie) {
current_shape.push_back(pos);
workspace->update();
} else {
+ int t_id = get_current_tile();
+ if (t_id >= 0) {
+ Vector<TileSet::ShapeData> sd = tile_set->tile_get_shapes(t_id);
+ for (int i = 0; i < sd.size(); i++) {
+ if (sd[i].autotile_coord == edited_shape_coord) {
+ Ref<ConvexPolygonShape2D> shape = sd[i].shape;
+
+ if (!shape.is_null()) {
+ sd.remove(i);
+ tile_set->tile_set_shapes(get_current_tile(), sd);
+ edited_collision_shape = Ref<Shape2D>();
+ current_shape.resize(0);
+ workspace->update();
+ }
+ break;
+ }
+ }
+ }
+
creating_shape = true;
current_shape.resize(0);
current_shape.push_back(snap_point(pos));
}
- } else if (mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT) {
+ } else if (mb->is_pressed() && mb->get_button_index() == BUTTON_RIGHT && current_shape.size() > 2) {
if (creating_shape) {
close_shape(shape_anchor);
}
@@ -1034,7 +1130,7 @@ void AutotileEditor::_on_tool_clicked(int p_tool) {
if (index >= 0) {
sd.remove(index);
tile_set->tile_set_shapes(get_current_tile(), sd);
- edited_collision_shape = Ref<ConcavePolygonShape2D>();
+ edited_collision_shape = Ref<Shape2D>();
current_shape.resize(0);
workspace->update();
}
@@ -1081,6 +1177,43 @@ void AutotileEditor::_on_priority_changed(float val) {
workspace->update();
}
+void AutotileEditor::_on_grid_snap_toggled(bool p_val) {
+ if (p_val)
+ hb_grid->show();
+ else
+ hb_grid->hide();
+ workspace->update();
+}
+
+void AutotileEditor::_set_snap_step_x(float p_val) {
+ snap_step.x = p_val;
+ workspace->update();
+}
+
+void AutotileEditor::_set_snap_step_y(float p_val) {
+ snap_step.y = p_val;
+ workspace->update();
+}
+
+void AutotileEditor::_set_snap_off_x(float p_val) {
+ snap_offset.x = p_val;
+ workspace->update();
+}
+
+void AutotileEditor::_set_snap_off_y(float p_val) {
+ snap_offset.y = p_val;
+ workspace->update();
+}
+void AutotileEditor::_set_snap_sep_x(float p_val) {
+ snap_separation.x = p_val;
+ workspace->update();
+}
+
+void AutotileEditor::_set_snap_sep_y(float p_val) {
+ snap_separation.y = p_val;
+ workspace->update();
+}
+
void AutotileEditor::draw_highlight_tile(Vector2 coord, const Vector<Vector2> &other_highlighted) {
Vector2 size = tile_set->autotile_get_size(get_current_tile());
@@ -1103,6 +1236,49 @@ void AutotileEditor::draw_highlight_tile(Vector2 coord, const Vector<Vector2> &o
}
}
+void AutotileEditor::draw_grid_snap() {
+ if (tools[SHAPE_GRID_SNAP]->is_pressed()) {
+ Color grid_color = Color(0.39, 0, 1, 0.2f);
+ Size2 s = workspace->get_size();
+
+ Vector2 size = tile_set->autotile_get_size(get_current_tile());
+
+ int width_count = (int)(s.width / (snap_step.x + snap_separation.x));
+ int height_count = (int)(s.height / (snap_step.y + snap_separation.y));
+
+ if (snap_step.x != 0) {
+ int last_p = 0;
+ for (int i = 0; i <= width_count; i++) {
+ if (i == 0 && snap_offset.x != 0) {
+ last_p = snap_offset.x;
+ }
+ if (snap_separation.x != 0 && i != 0) {
+ workspace->draw_rect(Rect2(last_p, 0, snap_separation.x, s.height), grid_color);
+ last_p += snap_separation.x;
+ } else
+ workspace->draw_line(Point2(last_p, 0), Point2(last_p, s.height), grid_color);
+
+ last_p += snap_step.x;
+ }
+ }
+
+ if (snap_step.y != 0) {
+ int last_p = 0;
+ for (int i = 0; i <= height_count; i++) {
+ if (i == 0 && snap_offset.y != 0) {
+ last_p = snap_offset.y;
+ }
+ if (snap_separation.x != 0 && i != 0) {
+ workspace->draw_rect(Rect2(0, last_p, s.width, snap_separation.y), grid_color);
+ last_p += snap_separation.y;
+ } else
+ workspace->draw_line(Point2(0, last_p), Point2(s.width, last_p), grid_color);
+ last_p += snap_step.y;
+ }
+ }
+ }
+}
+
void AutotileEditor::draw_polygon_shapes() {
int t_id = get_current_tile();
@@ -1119,7 +1295,7 @@ void AutotileEditor::draw_polygon_shapes() {
anchor.y += tile_set->autotile_get_spacing(t_id);
anchor.x *= coord.x;
anchor.y *= coord.y;
- Ref<ConcavePolygonShape2D> shape = sd[i].shape;
+ Ref<ConvexPolygonShape2D> shape = sd[i].shape;
if (shape.is_valid()) {
Color c_bg;
Color c_border;
@@ -1138,19 +1314,22 @@ void AutotileEditor::draw_polygon_shapes() {
colors.push_back(c_bg);
}
} else {
- for (int j = 0; j < shape->get_segments().size(); j += 2) {
- polygon.push_back(shape->get_segments()[j] + anchor);
+ for (int j = 0; j < shape->get_points().size(); j++) {
+ polygon.push_back(shape->get_points()[j] + anchor);
colors.push_back(c_bg);
}
}
- workspace->draw_polygon(polygon, colors);
+ if (polygon.size() > 2) {
+ workspace->draw_polygon(polygon, colors);
+ }
if (coord == edited_shape_coord) {
- for (int j = 0; j < shape->get_segments().size(); j += 2) {
- workspace->draw_line(shape->get_segments()[j] + anchor, shape->get_segments()[j + 1] + anchor, c_border, 1, true);
+ for (int j = 0; j < shape->get_points().size() - 1; j++) {
+ workspace->draw_line(shape->get_points()[j] + anchor, shape->get_points()[j + 1] + anchor, c_border, 1, true);
}
+
if (shape == edited_collision_shape) {
for (int j = 0; j < current_shape.size(); j++) {
- workspace->draw_circle(current_shape[j], 5, Color(1, 0, 0));
+ workspace->draw_circle(current_shape[j], 8 / workspace->get_scale().x, Color(1, 0, 0, 0.7f));
}
}
}
@@ -1198,7 +1377,7 @@ void AutotileEditor::draw_polygon_shapes() {
workspace->draw_line(shape->get_polygon()[shape->get_polygon().size() - 1] + anchor, shape->get_polygon()[0] + anchor, c_border, 1, true);
if (shape == edited_occlusion_shape) {
for (int j = 0; j < current_shape.size(); j++) {
- workspace->draw_circle(current_shape[j], 5, Color(1, 0, 0));
+ workspace->draw_circle(current_shape[j], 8 / workspace->get_scale().x, Color(1, 0, 0));
}
}
}
@@ -1248,7 +1427,7 @@ void AutotileEditor::draw_polygon_shapes() {
}
if (shape == edited_navigation_shape) {
for (int j = 0; j < current_shape.size(); j++) {
- workspace->draw_circle(current_shape[j], 5, Color(1, 0, 0));
+ workspace->draw_circle(current_shape[j], 8 / workspace->get_scale().x, Color(1, 0, 0));
}
}
}
@@ -1270,22 +1449,21 @@ void AutotileEditor::close_shape(const Vector2 &shape_anchor) {
creating_shape = false;
if (edit_mode == EDITMODE_COLLISION) {
- Ref<ConcavePolygonShape2D> shape = memnew(ConcavePolygonShape2D);
+ if (current_shape.size() >= 3) {
+ Ref<ConvexPolygonShape2D> shape = memnew(ConvexPolygonShape2D);
- PoolVector<Vector2> segments;
- segments.resize(current_shape.size() * 2);
- PoolVector<Vector2>::Write w = segments.write();
+ Vector<Vector2> segments;
- for (int i = 0; i < current_shape.size(); i++) {
- w[(i << 1) + 0] = current_shape[i] - shape_anchor;
- w[(i << 1) + 1] = current_shape[(i + 1) % current_shape.size()] - shape_anchor;
- }
+ for (int i = 0; i < current_shape.size(); i++) {
+ segments.push_back(current_shape[i] - shape_anchor);
+ }
- w = PoolVector<Vector2>::Write();
- shape->set_segments(segments);
+ shape->set_points(segments);
+
+ tile_set->tile_add_shape(get_current_tile(), shape, Transform2D(), false, edited_shape_coord);
+ edited_collision_shape = shape;
+ }
- tile_set->tile_add_shape(get_current_tile(), shape, Transform2D(), false, edited_shape_coord);
- edited_collision_shape = shape;
tools[TOOL_SELECT]->set_pressed(true);
workspace->update();
} else if (edit_mode == EDITMODE_OCCLUSION) {
@@ -1338,6 +1516,10 @@ Vector2 AutotileEditor::snap_point(const Vector2 &point) {
anchor.x *= (tile_size.x + spacing);
anchor.y *= (tile_size.y + spacing);
Rect2 region(anchor, tile_size);
+ if (tools[SHAPE_GRID_SNAP]->is_pressed()) {
+ p.x = Math::snap_scalar_seperation(snap_offset.x, snap_step.x, p.x, snap_separation.x);
+ p.y = Math::snap_scalar_seperation(snap_offset.y, snap_step.y, p.y, snap_separation.y);
+ }
if (tools[SHAPE_KEEP_INSIDE_TILE]->is_pressed()) {
if (p.x < region.position.x)
p.x = region.position.x;
@@ -1348,23 +1530,6 @@ Vector2 AutotileEditor::snap_point(const Vector2 &point) {
if (p.y > region.position.y + region.size.y)
p.y = region.position.y + region.size.y;
}
- if (tools[SHAPE_SNAP_TO_BITMASK_GRID]->is_pressed()) {
- Vector2 p2 = p;
- if (tile_set->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_2X2) {
- p2.x = Math::stepify(p2.x, tile_size.x / 2);
- p2.y = Math::stepify(p2.y, tile_size.y / 2);
- if ((p2 - p).length_squared() <= MAX(tile_size.y / 4, MIN_DISTANCE_SQUARED)) {
- p = p2;
- }
- } else if (tile_set->autotile_get_bitmask_mode(get_current_tile()) == TileSet::BITMASK_3X3) {
- p2.x = Math::stepify(p2.x, tile_size.x / 3);
- p2.y = Math::stepify(p2.y, tile_size.y / 3);
- if ((p2 - p).length_squared() <= MAX(tile_size.y / 6, MIN_DISTANCE_SQUARED)) {
- p = p2;
- }
- }
- }
- p.floor();
return p;
}
diff --git a/editor/plugins/tile_set_editor_plugin.h b/editor/plugins/tile_set_editor_plugin.h
index d60d0d5c3c..34284cb90f 100644
--- a/editor/plugins/tile_set_editor_plugin.h
+++ b/editor/plugins/tile_set_editor_plugin.h
@@ -33,7 +33,7 @@
#include "editor/editor_name_dialog.h"
#include "editor/editor_node.h"
#include "scene/2d/sprite.h"
-#include "scene/resources/concave_polygon_shape_2d.h"
+#include "scene/resources/convex_polygon_shape_2d.h"
#include "scene/resources/tile_set.h"
class AutotileEditorHelper;
@@ -70,7 +70,7 @@ class AutotileEditor : public Control {
SHAPE_CREATE_FROM_BITMASK,
SHAPE_CREATE_FROM_NOT_BITMASK,
SHAPE_KEEP_INSIDE_TILE,
- SHAPE_SNAP_TO_BITMASK_GRID,
+ SHAPE_GRID_SNAP,
ZOOM_OUT,
ZOOM_1,
ZOOM_IN,
@@ -78,7 +78,7 @@ class AutotileEditor : public Control {
};
Ref<TileSet> tile_set;
- Ref<ConcavePolygonShape2D> edited_collision_shape;
+ Ref<ConvexPolygonShape2D> edited_collision_shape;
Ref<OccluderPolygon2D> edited_occlusion_shape;
Ref<NavigationPolygon> edited_navigation_shape;
@@ -91,10 +91,21 @@ class AutotileEditor : public Control {
Button *tool_editmode[EDITMODE_MAX];
HBoxContainer *tool_containers[TOOLBAR_MAX];
HBoxContainer *toolbar;
+ HBoxContainer *hb_grid;
ToolButton *tools[TOOL_MAX];
SpinBox *spin_priority;
+ SpinBox *sb_step_y;
+ SpinBox *sb_step_x;
+ SpinBox *sb_off_y;
+ SpinBox *sb_off_x;
+ SpinBox *sb_sep_y;
+ SpinBox *sb_sep_x;
EditMode edit_mode;
+ Vector2 snap_step;
+ Vector2 snap_offset;
+ Vector2 snap_separation;
+
bool creating_shape;
int dragging_point;
Vector2 edited_shape_coord;
@@ -119,9 +130,16 @@ private:
void _on_workspace_input(const Ref<InputEvent> &p_ie);
void _on_tool_clicked(int p_tool);
void _on_priority_changed(float val);
+ void _on_grid_snap_toggled(bool p_val);
+ void _set_snap_step_x(float p_val);
+ void _set_snap_step_y(float p_val);
+ void _set_snap_off_x(float p_val);
+ void _set_snap_off_y(float p_val);
+ void _set_snap_sep_x(float p_val);
+ void _set_snap_sep_y(float p_val);
void draw_highlight_tile(Vector2 coord, const Vector<Vector2> &other_highlighted = Vector<Vector2>());
- void draw_grid(const Vector2 &size, int spacing);
+ void draw_grid_snap();
void draw_polygon_shapes();
void close_shape(const Vector2 &shape_anchor);
Vector2 snap_point(const Vector2 &point);
diff --git a/main/main.cpp b/main/main.cpp
index 5648676c4c..b72ffb9850 100644
--- a/main/main.cpp
+++ b/main/main.cpp
@@ -755,8 +755,10 @@ Error Main::setup(const char *execpath, int argc, char *argv[], bool p_second_ph
if (editor) {
Engine::get_singleton()->set_editor_hint(true);
main_args.push_back("--editor");
- init_maximized = true;
- video_mode.maximized = true;
+ if (!init_windowed) {
+ init_maximized = true;
+ video_mode.maximized = true;
+ }
use_custom_res = false;
}
diff --git a/modules/bullet/bullet_physics_server.cpp b/modules/bullet/bullet_physics_server.cpp
index b233edc0d4..ae062904b4 100644
--- a/modules/bullet/bullet_physics_server.cpp
+++ b/modules/bullet/bullet_physics_server.cpp
@@ -121,7 +121,7 @@ RID BulletPhysicsServer::shape_create(ShapeType p_shape) {
shape = bulletnew(RayShapeBullet);
} break;
case SHAPE_CUSTOM:
- defaul:
+ default:
ERR_FAIL_V(RID());
break;
}
diff --git a/platform/uwp/export/export.cpp b/platform/uwp/export/export.cpp
index 45ca097de5..9fbbca0716 100644
--- a/platform/uwp/export/export.cpp
+++ b/platform/uwp/export/export.cpp
@@ -1041,6 +1041,10 @@ public:
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "identity/product_guid"), "00000000-0000-0000-0000-000000000000"));
r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "identity/publisher_guid"), "00000000-0000-0000-0000-000000000000"));
+ r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "signing/certificate", PROPERTY_HINT_GLOBAL_FILE, "*.pfx"), ""));
+ r_options->push_back(ExportOption(PropertyInfo(Variant::STRING, "signing/password"), ""));
+ r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "signing/algorithm", PROPERTY_HINT_ENUM, "MD5,SHA1,SHA256"), 2));
+
r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "version/major"), 1));
r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "version/minor"), 0));
r_options->push_back(ExportOption(PropertyInfo(Variant::INT, "version/build"), 0));
@@ -1370,6 +1374,58 @@ public:
packager.finish();
+#ifdef WINDOWS_ENABLED
+ // Sign with signtool
+ String signtool_path = EditorSettings::get_singleton()->get("export/uwp/signtool");
+ if (signtool_path == String()) {
+ return OK;
+ }
+
+ if (!FileAccess::exists(signtool_path)) {
+ ERR_PRINTS("Could not find signtool executable at " + signtool_path + ", aborting.");
+ return ERR_FILE_NOT_FOUND;
+ }
+
+ static String algs[] = { "MD5", "SHA1", "SHA256" };
+
+ String cert_path = EditorSettings::get_singleton()->get("export/uwp/debug_certificate");
+ String cert_pass = EditorSettings::get_singleton()->get("export/uwp/debug_password");
+ int cert_alg = EditorSettings::get_singleton()->get("export/uwp/debug_algorithm");
+
+ if (!p_debug) {
+ cert_path = p_preset->get("signing/certificate");
+ cert_pass = p_preset->get("signing/password");
+ cert_alg = p_preset->get("signing/algorithm");
+ }
+
+ if (cert_path == String()) {
+ return OK; // Certificate missing, don't try to sign
+ }
+
+ if (!FileAccess::exists(cert_path)) {
+ ERR_PRINTS("Could not find certificate file at " + cert_path + ", aborting.");
+ return ERR_FILE_NOT_FOUND;
+ }
+
+ if (cert_alg < 0 || cert_alg > 2) {
+ ERR_PRINTS("Invalid certificate algorithm " + itos(cert_alg) + ", aborting.");
+ return ERR_INVALID_DATA;
+ }
+
+ List<String> args;
+ args.push_back("sign");
+ args.push_back("/fd");
+ args.push_back(algs[cert_alg]);
+ args.push_back("/a");
+ args.push_back("/f");
+ args.push_back(cert_path);
+ args.push_back("/p");
+ args.push_back(cert_pass);
+ args.push_back(p_path);
+
+ OS::get_singleton()->execute(signtool_path, args, true);
+#endif // WINDOWS_ENABLED
+
return OK;
}
@@ -1387,6 +1443,18 @@ public:
};
void register_uwp_exporter() {
- Ref<EditorExportUWP> exporter = Ref<EditorExportUWP>(memnew(EditorExportUWP));
+
+#ifdef WINDOWS_ENABLED
+ EDITOR_DEF("export/uwp/signtool", "");
+ EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING, "export/uwp/signtool", PROPERTY_HINT_GLOBAL_FILE, "*.exe"));
+ EDITOR_DEF("export/uwp/debug_certificate", "");
+ EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::STRING, "export/uwp/debug_certificate", PROPERTY_HINT_GLOBAL_FILE, "*.pfx"));
+ EDITOR_DEF("export/uwp/debug_password", "");
+ EDITOR_DEF("export/uwp/debug_algorithm", 2); // SHA256 is the default
+ EditorSettings::get_singleton()->add_property_hint(PropertyInfo(Variant::INT, "export/uwp/debug_algorithm", PROPERTY_HINT_ENUM, "MD5,SHA1,SHA256"));
+#endif // WINDOWS_ENABLED
+
+ Ref<EditorExportUWP> exporter;
+ exporter.instance();
EditorExport::get_singleton()->add_export_platform(exporter);
}
diff --git a/platform/windows/detect.py b/platform/windows/detect.py
index 3b8de2caf4..489bac50f5 100644
--- a/platform/windows/detect.py
+++ b/platform/windows/detect.py
@@ -190,7 +190,11 @@ def configure(env):
if (env["use_lto"]):
env.Append(CCFLAGS=['/GL'])
- env.Append(LINKFLAGS=['/LTCG'])
+ env.Append(ARFLAGS=['/LTCG'])
+ if env["progress"]:
+ env.Append(LINKFLAGS=['/LTCG:STATUS'])
+ else:
+ env.Append(LINKFLAGS=['/LTCG'])
env.Append(CCFLAGS=["/I" + p for p in os.getenv("INCLUDE").split(";")])
env.Append(LIBPATH=[p for p in os.getenv("LIB").split(";")])
diff --git a/scene/3d/skeleton.cpp b/scene/3d/skeleton.cpp
index a4a43c1a88..417fe90d7c 100644
--- a/scene/3d/skeleton.cpp
+++ b/scene/3d/skeleton.cpp
@@ -153,6 +153,24 @@ void Skeleton::_notification(int p_what) {
case NOTIFICATION_EXIT_WORLD: {
} break;
+ case NOTIFICATION_TRANSFORM_CHANGED: {
+
+ if (dirty)
+ break; //will be eventually updated
+
+ //if moved, just update transforms
+ VisualServer *vs = VisualServer::get_singleton();
+ Bone *bonesptr = &bones[0];
+ int len = bones.size();
+ Transform global_transform = get_global_transform();
+ Transform global_transform_inverse = global_transform.affine_inverse();
+
+ for (int i = 0; i < len; i++) {
+
+ Bone &b = bonesptr[i];
+ vs->skeleton_bone_set_transform(skeleton, i, global_transform * (b.transform_final * global_transform_inverse));
+ }
+ } break;
case NOTIFICATION_UPDATE_SKELETON: {
VisualServer *vs = VisualServer::get_singleton();
@@ -242,8 +260,8 @@ void Skeleton::_notification(int p_what) {
}
}
- Transform transform = b.pose_global * b.rest_global_inverse;
- vs->skeleton_bone_set_transform(skeleton, i, global_transform * (transform * global_transform_inverse));
+ b.transform_final = b.pose_global * b.rest_global_inverse;
+ vs->skeleton_bone_set_transform(skeleton, i, global_transform * (b.transform_final * global_transform_inverse));
for (List<uint32_t>::Element *E = b.nodes_bound.front(); E; E = E->next()) {
@@ -547,6 +565,7 @@ Skeleton::Skeleton() {
rest_global_inverse_dirty = true;
dirty = false;
skeleton = VisualServer::get_singleton()->skeleton_create();
+ set_notify_transform(true);
}
Skeleton::~Skeleton() {
diff --git a/scene/3d/skeleton.h b/scene/3d/skeleton.h
index fdc1100472..11ff728474 100644
--- a/scene/3d/skeleton.h
+++ b/scene/3d/skeleton.h
@@ -57,6 +57,8 @@ class Skeleton : public Spatial {
bool custom_pose_enable;
Transform custom_pose;
+ Transform transform_final;
+
List<uint32_t> nodes_bound;
Bone() {
diff --git a/scene/animation/animation_tree_player.cpp b/scene/animation/animation_tree_player.cpp
index a50047e426..d110984bbc 100644
--- a/scene/animation/animation_tree_player.cpp
+++ b/scene/animation/animation_tree_player.cpp
@@ -556,7 +556,7 @@ float AnimationTreePlayer::_process_node(const StringName &p_node, AnimationNode
return _process_node(osn->inputs[0].node, r_prev_anim, p_time, p_seek, p_fallback_weight, p_weights);
}
- float os_seek = p_seek;
+ bool os_seek = p_seek;
if (p_seek)
osn->time = p_time;
diff --git a/servers/visual/shader_language.cpp b/servers/visual/shader_language.cpp
index 834505df9a..076f337635 100644
--- a/servers/visual/shader_language.cpp
+++ b/servers/visual/shader_language.cpp
@@ -334,6 +334,7 @@ ShaderLanguage::Token ShaderLanguage::_get_token() {
while (true) {
if (GETCHAR(0) == '\n') {
+ tk_line++;
char_idx++;
break;
}
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-04 12:47:59 +0000