virtualx-engine/editor/plugins/node_3d_editor_plugin.h

894 lines
26 KiB
C++
Raw Normal View History

2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* node_3d_editor_plugin.h */
2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
2014-02-10 02:10:30 +01:00
/*************************************************************************/
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
2014-02-10 02:10:30 +01: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. */
/*************************************************************************/
#ifndef NODE_3D_EDITOR_PLUGIN_H
#define NODE_3D_EDITOR_PLUGIN_H
2014-02-10 02:10:30 +01:00
#include "editor/editor_plugin.h"
2019-10-23 11:46:26 +02:00
#include "editor/editor_scale.h"
#include "editor/editor_spin_slider.h"
#include "editor/plugins/node_3d_editor_gizmos.h"
#include "scene/3d/camera_3d.h"
#include "scene/3d/light_3d.h"
#include "scene/3d/visual_instance_3d.h"
#include "scene/3d/world_environment.h"
#include "scene/gui/color_picker.h"
2014-02-10 02:10:30 +01:00
#include "scene/gui/panel_container.h"
#include "scene/gui/spin_box.h"
#include "scene/gui/split_container.h"
#include "scene/resources/environment.h"
#include "scene/resources/fog_material.h"
#include "scene/resources/sky_material.h"
2014-02-10 02:10:30 +01:00
class EditorData;
class Node3DEditor;
class Node3DEditorViewport;
class SubViewportContainer;
class DirectionalLight3D;
class WorldEnvironment;
2014-02-10 02:10:30 +01:00
2019-10-23 11:46:26 +02:00
class ViewportRotationControl : public Control {
GDCLASS(ViewportRotationControl, Control);
struct Axis2D {
Vector2i screen_point;
float z_axis = -99.0;
int axis = -1;
};
struct Axis2DCompare {
_FORCE_INLINE_ bool operator()(const Axis2D &l, const Axis2D &r) const {
return l.z_axis < r.z_axis;
}
};
Node3DEditorViewport *viewport = nullptr;
2019-10-23 11:46:26 +02:00
Vector<Color> axis_colors;
Vector<int> axis_menu_options;
Vector2i orbiting_mouse_start;
2019-10-23 11:46:26 +02:00
bool orbiting = false;
int focused_axis = -2;
const float AXIS_CIRCLE_RADIUS = 8.0f * EDSCALE;
protected:
void _notification(int p_what);
virtual void gui_input(const Ref<InputEvent> &p_event) override;
2019-10-23 11:46:26 +02:00
void _draw();
void _draw_axis(const Axis2D &p_axis);
void _get_sorted_axis(Vector<Axis2D> &r_axis);
void _update_focus();
void _on_mouse_exited();
public:
void set_viewport(Node3DEditorViewport *p_viewport);
2019-10-23 11:46:26 +02:00
};
class Node3DEditorViewport : public Control {
GDCLASS(Node3DEditorViewport, Control);
friend class Node3DEditor;
2019-10-23 11:46:26 +02:00
friend class ViewportRotationControl;
2014-02-10 02:10:30 +01:00
enum {
VIEW_TOP,
VIEW_BOTTOM,
VIEW_LEFT,
VIEW_RIGHT,
VIEW_FRONT,
VIEW_REAR,
VIEW_CENTER_TO_ORIGIN,
2014-02-10 02:10:30 +01:00
VIEW_CENTER_TO_SELECTION,
VIEW_ALIGN_TRANSFORM_WITH_VIEW,
VIEW_ALIGN_ROTATION_WITH_VIEW,
2014-02-10 02:10:30 +01:00
VIEW_PERSPECTIVE,
VIEW_ENVIRONMENT,
Huge Amount of BugFix -=-=-=-=-=-=-=-=-=-=- -Fixes to Collada Exporter (avoid crash situtions) -Fixed to Collada Importer (Fixed Animation Optimizer Bugs) -Fixes to RigidBody/RigidBody2D body_enter/body_exit, was buggy -Fixed ability for RigidBody/RigidBody2D to get contacts reported and bodyin/out in Kinematic mode. -Added proper trigger support for 3D Physics shapes -Changed proper value for Z-Offset in OmniLight -Fixed spot attenuation bug in SpotLight -Fixed some 3D and 2D spatial soudn bugs related to distance attenuation. -Fixed bugs in EventPlayer (channels were muted by default) -Fix in ButtonGroup (get nodes in group are now returned in order) -Fixed Linear->SRGB Conversion, previous algo sucked, new algo works OK -Changed SRGB->Linear conversion to use hardware if supported, improves texture quality a lot -Fixed options for Y-Fov and X-Fov in camera, should be more intuitive. -Fixed bugs related to viewports and transparency Huge Amount of New Stuff: -=-=-=-=-=-=-=-==-=-=-=- -Ability to manually advance an AnimationPlayer that is inactive (with advance() function) -More work in WinRT platform -Added XY normalmap support, imports on this format by default. Reduces normlmap size and enables much nice compression using LATC -Added Anisotropic filter support to textures, can be specified on import -Added support for Non-Square, Isometric and Hexagonal tilemaps in TileMap. -Added Isometric Dungeon demo. -Added simple hexagonal map demo. -Added Truck-Town demo. Shows how most types of joints and vehicles are used. Please somebody make a nicer town, this one is too hardcore. -Added an Object-Picking API to both RigidBody and Area! (and relevant demo)
2014-10-03 05:10:51 +02:00
VIEW_ORTHOGONAL,
2017-10-31 18:23:25 +01:00
VIEW_HALF_RESOLUTION,
Huge Amount of BugFix -=-=-=-=-=-=-=-=-=-=- -Fixes to Collada Exporter (avoid crash situtions) -Fixed to Collada Importer (Fixed Animation Optimizer Bugs) -Fixes to RigidBody/RigidBody2D body_enter/body_exit, was buggy -Fixed ability for RigidBody/RigidBody2D to get contacts reported and bodyin/out in Kinematic mode. -Added proper trigger support for 3D Physics shapes -Changed proper value for Z-Offset in OmniLight -Fixed spot attenuation bug in SpotLight -Fixed some 3D and 2D spatial soudn bugs related to distance attenuation. -Fixed bugs in EventPlayer (channels were muted by default) -Fix in ButtonGroup (get nodes in group are now returned in order) -Fixed Linear->SRGB Conversion, previous algo sucked, new algo works OK -Changed SRGB->Linear conversion to use hardware if supported, improves texture quality a lot -Fixed options for Y-Fov and X-Fov in camera, should be more intuitive. -Fixed bugs related to viewports and transparency Huge Amount of New Stuff: -=-=-=-=-=-=-=-==-=-=-=- -Ability to manually advance an AnimationPlayer that is inactive (with advance() function) -More work in WinRT platform -Added XY normalmap support, imports on this format by default. Reduces normlmap size and enables much nice compression using LATC -Added Anisotropic filter support to textures, can be specified on import -Added support for Non-Square, Isometric and Hexagonal tilemaps in TileMap. -Added Isometric Dungeon demo. -Added simple hexagonal map demo. -Added Truck-Town demo. Shows how most types of joints and vehicles are used. Please somebody make a nicer town, this one is too hardcore. -Added an Object-Picking API to both RigidBody and Area! (and relevant demo)
2014-10-03 05:10:51 +02:00
VIEW_AUDIO_LISTENER,
VIEW_AUDIO_DOPPLER,
VIEW_GIZMOS,
VIEW_INFORMATION,
VIEW_FRAME_TIME,
VIEW_DISPLAY_NORMAL,
VIEW_DISPLAY_WIREFRAME,
VIEW_DISPLAY_OVERDRAW,
VIEW_DISPLAY_SHADELESS,
2019-10-03 22:39:08 +02:00
VIEW_DISPLAY_LIGHTING,
VIEW_DISPLAY_ADVANCED,
VIEW_DISPLAY_NORMAL_BUFFER,
2019-10-03 22:39:08 +02:00
VIEW_DISPLAY_DEBUG_SHADOW_ATLAS,
VIEW_DISPLAY_DEBUG_DIRECTIONAL_SHADOW_ATLAS,
VIEW_DISPLAY_DEBUG_VOXEL_GI_ALBEDO,
VIEW_DISPLAY_DEBUG_VOXEL_GI_LIGHTING,
VIEW_DISPLAY_DEBUG_VOXEL_GI_EMISSION,
2020-01-12 02:26:52 +01:00
VIEW_DISPLAY_DEBUG_SCENE_LUMINANCE,
VIEW_DISPLAY_DEBUG_SSAO,
2021-08-03 09:07:32 +02:00
VIEW_DISPLAY_DEBUG_SSIL,
VIEW_DISPLAY_DEBUG_PSSM_SPLITS,
VIEW_DISPLAY_DEBUG_DECAL_ATLAS,
VIEW_DISPLAY_DEBUG_SDFGI,
VIEW_DISPLAY_DEBUG_SDFGI_PROBES,
VIEW_DISPLAY_DEBUG_GI_BUFFER,
VIEW_DISPLAY_DEBUG_DISABLE_LOD,
VIEW_DISPLAY_DEBUG_CLUSTER_OMNI_LIGHTS,
VIEW_DISPLAY_DEBUG_CLUSTER_SPOT_LIGHTS,
VIEW_DISPLAY_DEBUG_CLUSTER_DECALS,
VIEW_DISPLAY_DEBUG_CLUSTER_REFLECTION_PROBES,
VIEW_DISPLAY_DEBUG_OCCLUDERS,
VIEW_DISPLAY_MOTION_VECTORS,
VIEW_LOCK_ROTATION,
2019-10-03 22:39:08 +02:00
VIEW_CINEMATIC_PREVIEW,
2019-10-23 11:46:26 +02:00
VIEW_AUTO_ORTHOGONAL,
2019-10-03 22:39:08 +02:00
VIEW_MAX
2014-02-10 02:10:30 +01:00
};
enum ViewType {
VIEW_TYPE_USER,
VIEW_TYPE_TOP,
VIEW_TYPE_BOTTOM,
VIEW_TYPE_LEFT,
VIEW_TYPE_RIGHT,
VIEW_TYPE_FRONT,
VIEW_TYPE_REAR,
};
public:
enum {
GIZMO_BASE_LAYER = 27,
GIZMO_EDIT_LAYER = 26,
GIZMO_GRID_LAYER = 25,
MISC_TOOL_LAYER = 24,
FRAME_TIME_HISTORY = 20,
};
enum NavigationScheme {
NAVIGATION_GODOT,
NAVIGATION_MAYA,
NAVIGATION_MODO,
};
enum FreelookNavigationScheme {
FREELOOK_DEFAULT,
FREELOOK_PARTIALLY_AXIS_LOCKED,
FREELOOK_FULLY_AXIS_LOCKED,
};
private:
double cpu_time_history[FRAME_TIME_HISTORY];
int cpu_time_history_index;
double gpu_time_history[FRAME_TIME_HISTORY];
int gpu_time_history_index;
int index;
ViewType view_type;
2014-02-10 02:10:30 +01:00
void _menu_option(int p_option);
2019-10-23 11:46:26 +02:00
void _set_auto_orthogonal();
Node3D *preview_node = nullptr;
AABB *preview_bounds = nullptr;
Vector<String> selected_files;
AcceptDialog *accept = nullptr;
Node *target_node = nullptr;
Point2 drop_pos;
EditorData *editor_data = nullptr;
EditorSelection *editor_selection = nullptr;
UndoRedo *undo_redo = nullptr;
2014-02-10 02:10:30 +01:00
CheckBox *preview_camera = nullptr;
SubViewportContainer *subviewport_container = nullptr;
2014-02-10 02:10:30 +01:00
MenuButton *view_menu = nullptr;
PopupMenu *display_submenu = nullptr;
2014-02-10 02:10:30 +01:00
Control *surface = nullptr;
SubViewport *viewport = nullptr;
Camera3D *camera = nullptr;
bool transforming = false;
2014-02-10 02:10:30 +01:00
bool orthogonal;
2019-10-23 11:46:26 +02:00
bool auto_orthogonal;
bool lock_rotation;
real_t gizmo_scale;
bool freelook_active;
real_t freelook_speed;
Vector2 previous_mouse_position;
2014-02-10 02:10:30 +01:00
Label *info_label = nullptr;
Label *cinema_label = nullptr;
Label *locked_label = nullptr;
Label *zoom_limit_label = nullptr;
VBoxContainer *top_right_vbox = nullptr;
ViewportRotationControl *rotation_control = nullptr;
Gradient *frame_time_gradient = nullptr;
Label *cpu_time_label = nullptr;
Label *gpu_time_label = nullptr;
Label *fps_label = nullptr;
2019-10-23 11:46:26 +02:00
struct _RayResult {
Node3D *item = nullptr;
real_t depth = 0;
_FORCE_INLINE_ bool operator<(const _RayResult &p_rr) const { return depth < p_rr.depth; }
};
void _update_name();
void _compute_edit(const Point2 &p_point);
2014-02-10 02:10:30 +01:00
void _clear_selected();
void _select_clicked(bool p_allow_locked);
ObjectID _select_ray(const Point2 &p_pos);
void _find_items_at_pos(const Point2 &p_pos, Vector<_RayResult> &r_results, bool p_include_locked);
Vector3 _get_ray_pos(const Vector2 &p_pos) const;
Vector3 _get_ray(const Vector2 &p_pos) const;
Point2 _point_to_screen(const Vector3 &p_point);
Transform3D _get_camera_transform() const;
2014-02-10 02:10:30 +01:00
int get_selected_count() const;
Implement blender-style 3D transform tools. See godotengine/godot-proposals#1215. This adds shortcuts for blender-inspired transforms, where you can press the key and immediately be transforming an object without holding the mouse. Clicking commits the transformation, ESC aborts it. This is inspired by Blender's G(rab)/R(otate)/S(cale) shortcuts, but I decided not to add default bindings as `S` is already bound to the regular scale tool, and it might be confusing to only bind some of them. While actively using a transform tool, you can press X/Y/Z to lock the transform to an axis or (shift)+X/Y/Z to constrain the transform to a plane. These keys are only processed if you have a transform tool (translate/rotate/scale) active _and_ the mouse button is held. Pressing XX/YY/ZZ will lock the transform to a local (rather than global) axis. This is achieved by temporarily toggling the local transform button. I did this (vs handling it in the transform functions) for 3 reasons: - Transform logic for translate/rotate (but not scale) appears to be tightly coupled to the gizmo - This ensures the gizmo changes to indicate we're transforming locally/globally - Toggling the button state in the UI also gives the user feedback about the nature of the transform. The original state of the button is reset when the transform completes. Pressing the `spatial_editor/cancel_transform` shortcut key during a transform operation will cancel the transform and reset the objects back to their original transforms. This functionality was already accessible by pressing RMB during a transform, however: - ESC is more familiar to blender users, and a more common "cancel" key in general. - Given you must hold LMB during a transform, pressing RMB as well is clumsy if not impossible (on a laptop trackpad).
2020-07-18 21:03:08 +02:00
void cancel_transform();
2022-06-03 02:12:41 +02:00
void _update_shrink();
2014-02-10 02:10:30 +01:00
Vector3 _get_camera_position() const;
2014-02-10 02:10:30 +01:00
Vector3 _get_camera_normal() const;
Vector3 _get_screen_to_space(const Vector3 &p_vector3);
2014-02-10 02:10:30 +01:00
void _select_region();
bool _transform_gizmo_select(const Vector2 &p_screenpos, bool p_highlight_only = false);
void _transform_gizmo_apply(Node3D *p_node, const Transform3D &p_transform, bool p_local);
2014-02-10 02:10:30 +01:00
2017-11-01 21:49:39 +01:00
void _nav_pan(Ref<InputEventWithModifiers> p_event, const Vector2 &p_relative);
void _nav_zoom(Ref<InputEventWithModifiers> p_event, const Vector2 &p_relative);
void _nav_orbit(Ref<InputEventWithModifiers> p_event, const Vector2 &p_relative);
void _nav_look(Ref<InputEventWithModifiers> p_event, const Vector2 &p_relative);
2014-02-10 02:10:30 +01:00
float get_znear() const;
float get_zfar() const;
float get_fov() const;
ObjectID clicked;
Vector<_RayResult> selection_results;
bool clicked_wants_append = false;
bool selection_in_progress = false;
2014-02-10 02:10:30 +01:00
PopupMenu *selection_menu = nullptr;
2014-12-28 14:01:08 +01:00
enum NavigationZoomStyle {
NAVIGATION_ZOOM_VERTICAL,
NAVIGATION_ZOOM_HORIZONTAL
};
enum NavigationMode {
NAVIGATION_NONE,
NAVIGATION_PAN,
NAVIGATION_ZOOM,
NAVIGATION_ORBIT,
NAVIGATION_LOOK
};
2014-02-10 02:10:30 +01:00
enum TransformMode {
TRANSFORM_NONE,
TRANSFORM_ROTATE,
TRANSFORM_TRANSLATE,
TRANSFORM_SCALE
};
enum TransformPlane {
TRANSFORM_VIEW,
TRANSFORM_X_AXIS,
TRANSFORM_Y_AXIS,
TRANSFORM_Z_AXIS,
TRANSFORM_YZ,
TRANSFORM_XZ,
TRANSFORM_XY,
2014-02-10 02:10:30 +01:00
};
struct EditData {
TransformMode mode;
TransformPlane plane;
Transform3D original;
2014-02-10 02:10:30 +01:00
Vector3 click_ray;
Vector3 click_ray_pos;
Vector3 center;
Point2 mouse_pos;
Point2 original_mouse_pos;
bool snap = false;
bool show_rotation_line = false;
Ref<EditorNode3DGizmo> gizmo;
int gizmo_handle = 0;
bool gizmo_handle_secondary = false;
2014-02-10 02:10:30 +01:00
Variant gizmo_initial_value;
Implement blender-style 3D transform tools. See godotengine/godot-proposals#1215. This adds shortcuts for blender-inspired transforms, where you can press the key and immediately be transforming an object without holding the mouse. Clicking commits the transformation, ESC aborts it. This is inspired by Blender's G(rab)/R(otate)/S(cale) shortcuts, but I decided not to add default bindings as `S` is already bound to the regular scale tool, and it might be confusing to only bind some of them. While actively using a transform tool, you can press X/Y/Z to lock the transform to an axis or (shift)+X/Y/Z to constrain the transform to a plane. These keys are only processed if you have a transform tool (translate/rotate/scale) active _and_ the mouse button is held. Pressing XX/YY/ZZ will lock the transform to a local (rather than global) axis. This is achieved by temporarily toggling the local transform button. I did this (vs handling it in the transform functions) for 3 reasons: - Transform logic for translate/rotate (but not scale) appears to be tightly coupled to the gizmo - This ensures the gizmo changes to indicate we're transforming locally/globally - Toggling the button state in the UI also gives the user feedback about the nature of the transform. The original state of the button is reset when the transform completes. Pressing the `spatial_editor/cancel_transform` shortcut key during a transform operation will cancel the transform and reset the objects back to their original transforms. This functionality was already accessible by pressing RMB during a transform, however: - ESC is more familiar to blender users, and a more common "cancel" key in general. - Given you must hold LMB during a transform, pressing RMB as well is clumsy if not impossible (on a laptop trackpad).
2020-07-18 21:03:08 +02:00
bool original_local;
bool instant;
2014-02-10 02:10:30 +01:00
} _edit;
struct Cursor {
Vector3 pos;
real_t x_rot, y_rot, distance, fov_scale;
Vector3 eye_pos; // Used in freelook mode
2014-02-10 02:10:30 +01:00
bool region_select;
Point2 region_begin, region_end;
2014-02-10 02:10:30 +01:00
Cursor() {
// These rotations place the camera in +X +Y +Z, aka south east, facing north west.
x_rot = 0.5;
y_rot = -0.5;
distance = 4;
fov_scale = 1.0;
region_select = false;
}
};
// Viewport camera supports movement smoothing,
// so one cursor is the real cursor, while the other can be an interpolated version.
Cursor cursor; // Immediate cursor
Cursor camera_cursor; // That one may be interpolated (don't modify this one except for smoothing purposes)
2014-02-10 02:10:30 +01:00
void scale_fov(real_t p_fov_offset);
void reset_fov();
void scale_cursor_distance(real_t scale);
void set_freelook_active(bool active_now);
void scale_freelook_speed(real_t scale);
real_t zoom_indicator_delay;
int zoom_failed_attempts_count = 0;
Implement blender-style 3D transform tools. See godotengine/godot-proposals#1215. This adds shortcuts for blender-inspired transforms, where you can press the key and immediately be transforming an object without holding the mouse. Clicking commits the transformation, ESC aborts it. This is inspired by Blender's G(rab)/R(otate)/S(cale) shortcuts, but I decided not to add default bindings as `S` is already bound to the regular scale tool, and it might be confusing to only bind some of them. While actively using a transform tool, you can press X/Y/Z to lock the transform to an axis or (shift)+X/Y/Z to constrain the transform to a plane. These keys are only processed if you have a transform tool (translate/rotate/scale) active _and_ the mouse button is held. Pressing XX/YY/ZZ will lock the transform to a local (rather than global) axis. This is achieved by temporarily toggling the local transform button. I did this (vs handling it in the transform functions) for 3 reasons: - Transform logic for translate/rotate (but not scale) appears to be tightly coupled to the gizmo - This ensures the gizmo changes to indicate we're transforming locally/globally - Toggling the button state in the UI also gives the user feedback about the nature of the transform. The original state of the button is reset when the transform completes. Pressing the `spatial_editor/cancel_transform` shortcut key during a transform operation will cancel the transform and reset the objects back to their original transforms. This functionality was already accessible by pressing RMB during a transform, however: - ESC is more familiar to blender users, and a more common "cancel" key in general. - Given you must hold LMB during a transform, pressing RMB as well is clumsy if not impossible (on a laptop trackpad).
2020-07-18 21:03:08 +02:00
RID move_gizmo_instance[3], move_plane_gizmo_instance[3], rotate_gizmo_instance[4], scale_gizmo_instance[3], scale_plane_gizmo_instance[3], axis_gizmo_instance[3];
2014-02-10 02:10:30 +01:00
String last_message;
String message;
double message_time;
2014-02-10 02:10:30 +01:00
void set_message(String p_message, float p_time = 5);
2014-02-10 02:10:30 +01:00
void _view_settings_confirmed(real_t p_interp_delta);
void _update_camera(real_t p_interp_delta);
Transform3D to_camera_transform(const Cursor &p_cursor) const;
2014-02-10 02:10:30 +01:00
void _draw();
void _surface_mouse_enter();
void _surface_mouse_exit();
void _surface_focus_enter();
void _surface_focus_exit();
2017-08-12 18:52:50 +02:00
void _sinput(const Ref<InputEvent> &p_event);
void _update_freelook(real_t delta);
Node3DEditor *spatial_editor = nullptr;
2014-02-10 02:10:30 +01:00
Camera3D *previewing = nullptr;
Camera3D *preview = nullptr;
2014-02-10 02:10:30 +01:00
bool previewing_cinema;
bool _is_node_locked(const Node *p_node);
2014-02-10 02:10:30 +01:00
void _preview_exited_scene();
void _toggle_camera_preview(bool);
void _toggle_cinema_preview(bool);
void _init_gizmo_instance(int p_idx);
void _finish_gizmo_instances();
void _selection_result_pressed(int);
void _selection_menu_hide();
void _list_select(Ref<InputEventMouseButton> b);
Point2i _get_warped_mouse_motion(const Ref<InputEventMouseMotion> &p_ev_mouse_motion) const;
Vector3 _get_instance_position(const Point2 &p_pos) const;
static AABB _calculate_spatial_bounds(const Node3D *p_parent, bool p_exclude_top_level_transform = true);
Node *_sanitize_preview_node(Node *p_node) const;
void _create_preview(const Vector<String> &files) const;
void _remove_preview();
bool _cyclical_dependency_exists(const String &p_target_scene_path, Node *p_desired_node);
bool _create_instance(Node *parent, String &path, const Point2 &p_point);
void _perform_drop_data();
bool can_drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from) const;
void drop_data_fw(const Point2 &p_point, const Variant &p_data, Control *p_from);
void _project_settings_changed();
Transform3D _compute_transform(TransformMode p_mode, const Transform3D &p_original, const Transform3D &p_original_local, Vector3 p_motion, double p_extra, bool p_local, bool p_orthogonal);
Implement blender-style 3D transform tools. See godotengine/godot-proposals#1215. This adds shortcuts for blender-inspired transforms, where you can press the key and immediately be transforming an object without holding the mouse. Clicking commits the transformation, ESC aborts it. This is inspired by Blender's G(rab)/R(otate)/S(cale) shortcuts, but I decided not to add default bindings as `S` is already bound to the regular scale tool, and it might be confusing to only bind some of them. While actively using a transform tool, you can press X/Y/Z to lock the transform to an axis or (shift)+X/Y/Z to constrain the transform to a plane. These keys are only processed if you have a transform tool (translate/rotate/scale) active _and_ the mouse button is held. Pressing XX/YY/ZZ will lock the transform to a local (rather than global) axis. This is achieved by temporarily toggling the local transform button. I did this (vs handling it in the transform functions) for 3 reasons: - Transform logic for translate/rotate (but not scale) appears to be tightly coupled to the gizmo - This ensures the gizmo changes to indicate we're transforming locally/globally - Toggling the button state in the UI also gives the user feedback about the nature of the transform. The original state of the button is reset when the transform completes. Pressing the `spatial_editor/cancel_transform` shortcut key during a transform operation will cancel the transform and reset the objects back to their original transforms. This functionality was already accessible by pressing RMB during a transform, however: - ESC is more familiar to blender users, and a more common "cancel" key in general. - Given you must hold LMB during a transform, pressing RMB as well is clumsy if not impossible (on a laptop trackpad).
2020-07-18 21:03:08 +02:00
void begin_transform(TransformMode p_mode, bool instant);
void commit_transform();
void update_transform(Point2 p_mousepos, bool p_shift);
void finish_transform();
Implement blender-style 3D transform tools. See godotengine/godot-proposals#1215. This adds shortcuts for blender-inspired transforms, where you can press the key and immediately be transforming an object without holding the mouse. Clicking commits the transformation, ESC aborts it. This is inspired by Blender's G(rab)/R(otate)/S(cale) shortcuts, but I decided not to add default bindings as `S` is already bound to the regular scale tool, and it might be confusing to only bind some of them. While actively using a transform tool, you can press X/Y/Z to lock the transform to an axis or (shift)+X/Y/Z to constrain the transform to a plane. These keys are only processed if you have a transform tool (translate/rotate/scale) active _and_ the mouse button is held. Pressing XX/YY/ZZ will lock the transform to a local (rather than global) axis. This is achieved by temporarily toggling the local transform button. I did this (vs handling it in the transform functions) for 3 reasons: - Transform logic for translate/rotate (but not scale) appears to be tightly coupled to the gizmo - This ensures the gizmo changes to indicate we're transforming locally/globally - Toggling the button state in the UI also gives the user feedback about the nature of the transform. The original state of the button is reset when the transform completes. Pressing the `spatial_editor/cancel_transform` shortcut key during a transform operation will cancel the transform and reset the objects back to their original transforms. This functionality was already accessible by pressing RMB during a transform, however: - ESC is more familiar to blender users, and a more common "cancel" key in general. - Given you must hold LMB during a transform, pressing RMB as well is clumsy if not impossible (on a laptop trackpad).
2020-07-18 21:03:08 +02:00
void register_shortcut_action(const String &p_path, const String &p_name, Key p_keycode);
void shortcut_changed_callback(const Ref<Shortcut> p_shortcut, const String &p_shortcut_path);
2014-02-10 02:10:30 +01:00
protected:
void _notification(int p_what);
static void _bind_methods();
public:
void update_surface() { surface->update(); }
void update_transform_gizmo_view();
void set_can_preview(Camera3D *p_preview);
void set_state(const Dictionary &p_state);
2014-02-10 02:10:30 +01:00
Dictionary get_state() const;
void reset();
bool is_freelook_active() const { return freelook_active; }
void focus_selection();
void assign_pending_data_pointers(
Node3D *p_preview_node,
2017-11-17 03:09:00 +01:00
AABB *p_preview_bounds,
AcceptDialog *p_accept);
SubViewport *get_viewport_node() { return viewport; }
Camera3D *get_camera_3d() { return camera; } // return the default camera object.
2014-02-10 02:10:30 +01:00
Node3DEditorViewport(Node3DEditor *p_spatial_editor, int p_index);
~Node3DEditorViewport();
2014-02-10 02:10:30 +01:00
};
class Node3DEditorSelectedItem : public Object {
GDCLASS(Node3DEditorSelectedItem, Object);
2014-02-10 02:10:30 +01:00
public:
2017-11-17 03:09:00 +01:00
AABB aabb;
Transform3D original; // original location when moving
Transform3D original_local;
Transform3D last_xform; // last transform
bool last_xform_dirty;
Node3D *sp = nullptr;
2014-02-10 02:10:30 +01:00
RID sbox_instance;
RID sbox_instance_offset;
RID sbox_instance_xray;
RID sbox_instance_xray_offset;
Ref<EditorNode3DGizmo> gizmo;
HashMap<int, Transform3D> subgizmos; // map ID -> initial transform
2014-02-10 02:10:30 +01:00
Node3DEditorSelectedItem() {
2020-04-02 01:20:12 +02:00
sp = nullptr;
last_xform_dirty = true;
}
~Node3DEditorSelectedItem();
2014-02-10 02:10:30 +01:00
};
class Node3DEditorViewportContainer : public Container {
GDCLASS(Node3DEditorViewportContainer, Container);
public:
enum View {
VIEW_USE_1_VIEWPORT,
VIEW_USE_2_VIEWPORTS,
VIEW_USE_2_VIEWPORTS_ALT,
VIEW_USE_3_VIEWPORTS,
VIEW_USE_3_VIEWPORTS_ALT,
VIEW_USE_4_VIEWPORTS,
};
private:
View view;
bool mouseover;
real_t ratio_h;
real_t ratio_v;
bool hovering_v;
bool hovering_h;
bool dragging_v;
bool dragging_h;
Vector2 drag_begin_pos;
Vector2 drag_begin_ratio;
virtual void gui_input(const Ref<InputEvent> &p_event) override;
protected:
void _notification(int p_what);
public:
void set_view(View p_view);
View get_view();
Node3DEditorViewportContainer();
};
class Node3DEditor : public VBoxContainer {
GDCLASS(Node3DEditor, VBoxContainer);
2014-02-10 02:10:30 +01:00
public:
static const unsigned int VIEWPORTS_COUNT = 4;
2014-02-10 02:10:30 +01:00
enum ToolMode {
TOOL_MODE_SELECT,
TOOL_MODE_MOVE,
TOOL_MODE_ROTATE,
TOOL_MODE_SCALE,
TOOL_MODE_LIST_SELECT,
TOOL_LOCK_SELECTED,
TOOL_UNLOCK_SELECTED,
2019-04-17 18:24:28 +02:00
TOOL_GROUP_SELECTED,
TOOL_UNGROUP_SELECTED,
TOOL_MAX
2014-02-10 02:10:30 +01:00
};
enum ToolOptions {
TOOL_OPT_LOCAL_COORDS,
TOOL_OPT_USE_SNAP,
TOOL_OPT_OVERRIDE_CAMERA,
TOOL_OPT_MAX
};
2014-02-10 02:10:30 +01:00
private:
EditorSelection *editor_selection = nullptr;
2014-02-10 02:10:30 +01:00
Node3DEditorViewportContainer *viewport_base = nullptr;
Node3DEditorViewport *viewports[VIEWPORTS_COUNT];
VSplitContainer *shader_split = nullptr;
HSplitContainer *left_panel_split = nullptr;
HSplitContainer *right_panel_split = nullptr;
2014-02-10 02:10:30 +01:00
/////
ToolMode tool_mode;
RID origin;
RID origin_instance;
bool origin_enabled = false;
2014-02-10 02:10:30 +01:00
RID grid[3];
RID grid_instance[3];
bool grid_visible[3]; //currently visible
bool grid_enable[3]; //should be always visible if true
bool grid_enabled = false;
bool grid_init_draw = false;
Camera3D::Projection grid_camera_last_update_perspective = Camera3D::PROJECTION_PERSPECTIVE;
Vector3 grid_camera_last_update_position = Vector3();
2014-02-10 02:10:30 +01:00
Implement blender-style 3D transform tools. See godotengine/godot-proposals#1215. This adds shortcuts for blender-inspired transforms, where you can press the key and immediately be transforming an object without holding the mouse. Clicking commits the transformation, ESC aborts it. This is inspired by Blender's G(rab)/R(otate)/S(cale) shortcuts, but I decided not to add default bindings as `S` is already bound to the regular scale tool, and it might be confusing to only bind some of them. While actively using a transform tool, you can press X/Y/Z to lock the transform to an axis or (shift)+X/Y/Z to constrain the transform to a plane. These keys are only processed if you have a transform tool (translate/rotate/scale) active _and_ the mouse button is held. Pressing XX/YY/ZZ will lock the transform to a local (rather than global) axis. This is achieved by temporarily toggling the local transform button. I did this (vs handling it in the transform functions) for 3 reasons: - Transform logic for translate/rotate (but not scale) appears to be tightly coupled to the gizmo - This ensures the gizmo changes to indicate we're transforming locally/globally - Toggling the button state in the UI also gives the user feedback about the nature of the transform. The original state of the button is reset when the transform completes. Pressing the `spatial_editor/cancel_transform` shortcut key during a transform operation will cancel the transform and reset the objects back to their original transforms. This functionality was already accessible by pressing RMB during a transform, however: - ESC is more familiar to blender users, and a more common "cancel" key in general. - Given you must hold LMB during a transform, pressing RMB as well is clumsy if not impossible (on a laptop trackpad).
2020-07-18 21:03:08 +02:00
Ref<ArrayMesh> move_gizmo[3], move_plane_gizmo[3], rotate_gizmo[4], scale_gizmo[3], scale_plane_gizmo[3], axis_gizmo[3];
Ref<StandardMaterial3D> gizmo_color[3];
Ref<StandardMaterial3D> plane_gizmo_color[3];
Ref<ShaderMaterial> rotate_gizmo_color[3];
Ref<StandardMaterial3D> gizmo_color_hl[3];
Ref<StandardMaterial3D> plane_gizmo_color_hl[3];
Ref<ShaderMaterial> rotate_gizmo_color_hl[3];
2014-02-10 02:10:30 +01:00
Ref<Node3DGizmo> current_hover_gizmo;
int current_hover_gizmo_handle;
bool current_hover_gizmo_handle_secondary;
real_t snap_translate_value;
real_t snap_rotate_value;
real_t snap_scale_value;
Ref<ArrayMesh> selection_box_xray;
Ref<ArrayMesh> selection_box;
2014-02-10 02:10:30 +01:00
RID indicators;
2016-03-09 00:00:52 +01:00
RID indicators_instance;
2014-02-10 02:10:30 +01:00
RID cursor_mesh;
RID cursor_instance;
Ref<StandardMaterial3D> indicator_mat;
Ref<ShaderMaterial> grid_mat[3];
Ref<StandardMaterial3D> cursor_material;
2014-02-10 02:10:30 +01:00
// Scene drag and drop support
Node3D *preview_node = nullptr;
2017-11-17 03:09:00 +01:00
AABB preview_bounds;
2014-02-10 02:10:30 +01:00
struct Gizmo {
bool visible = false;
real_t scale = 0;
Transform3D transform;
2014-02-10 02:10:30 +01:00
} gizmo;
2016-03-09 00:00:52 +01:00
enum MenuOption {
MENU_TOOL_SELECT,
MENU_TOOL_MOVE,
MENU_TOOL_ROTATE,
MENU_TOOL_SCALE,
MENU_TOOL_LIST_SELECT,
MENU_TOOL_LOCAL_COORDS,
MENU_TOOL_USE_SNAP,
MENU_TOOL_OVERRIDE_CAMERA,
MENU_TRANSFORM_CONFIGURE_SNAP,
MENU_TRANSFORM_DIALOG,
MENU_VIEW_USE_1_VIEWPORT,
MENU_VIEW_USE_2_VIEWPORTS,
MENU_VIEW_USE_2_VIEWPORTS_ALT,
MENU_VIEW_USE_3_VIEWPORTS,
MENU_VIEW_USE_3_VIEWPORTS_ALT,
MENU_VIEW_USE_4_VIEWPORTS,
MENU_VIEW_ORIGIN,
MENU_VIEW_GRID,
MENU_VIEW_GIZMOS_3D_ICONS,
MENU_VIEW_CAMERA_SETTINGS,
MENU_LOCK_SELECTED,
MENU_UNLOCK_SELECTED,
MENU_GROUP_SELECTED,
MENU_UNGROUP_SELECTED,
MENU_SNAP_TO_FLOOR
};
Button *tool_button[TOOL_MAX];
Button *tool_option_button[TOOL_OPT_MAX];
2014-02-10 02:10:30 +01:00
MenuButton *transform_menu = nullptr;
PopupMenu *gizmos_menu = nullptr;
MenuButton *view_menu = nullptr;
2014-02-10 02:10:30 +01:00
AcceptDialog *accept = nullptr;
ConfirmationDialog *snap_dialog = nullptr;
ConfirmationDialog *xform_dialog = nullptr;
ConfirmationDialog *settings_dialog = nullptr;
2014-02-10 02:10:30 +01:00
bool snap_enabled;
bool snap_key_enabled;
LineEdit *snap_translate = nullptr;
LineEdit *snap_rotate = nullptr;
LineEdit *snap_scale = nullptr;
2014-02-10 02:10:30 +01:00
LineEdit *xform_translate[3];
LineEdit *xform_rotate[3];
LineEdit *xform_scale[3];
OptionButton *xform_type = nullptr;
2014-02-10 02:10:30 +01:00
VBoxContainer *settings_vbc = nullptr;
SpinBox *settings_fov = nullptr;
SpinBox *settings_znear = nullptr;
SpinBox *settings_zfar = nullptr;
void _snap_changed();
void _snap_update();
2014-02-10 02:10:30 +01:00
void _xform_dialog_action();
void _menu_item_pressed(int p_option);
void _menu_item_toggled(bool pressed, int p_option);
void _menu_gizmo_toggled(int p_option);
void _update_camera_override_button(bool p_game_running);
void _update_camera_override_viewport(Object *p_viewport);
HBoxContainer *hbc_menu = nullptr;
// Used for secondary menu items which are displayed depending on the currently selected node
// (such as MeshInstance's "Mesh" menu).
PanelContainer *context_menu_container = nullptr;
HBoxContainer *hbc_context_menu = nullptr;
2014-02-10 02:10:30 +01:00
void _generate_selection_boxes();
UndoRedo *undo_redo = nullptr;
2014-02-10 02:10:30 +01:00
int camera_override_viewport_id;
2014-02-10 02:10:30 +01:00
void _init_indicators();
void _update_context_menu_stylebox();
void _update_gizmos_menu();
void _update_gizmos_menu_theme();
void _init_grid();
2014-02-10 02:10:30 +01:00
void _finish_indicators();
void _finish_grid();
2014-02-10 02:10:30 +01:00
void _toggle_maximize_view(Object *p_viewport);
Node *custom_camera = nullptr;
2014-02-10 02:10:30 +01:00
Object *_get_editor_data(Object *p_what);
Ref<Environment> viewport_environment;
Node3D *selected = nullptr;
void _request_gizmo(Object *p_obj);
void _set_subgizmo_selection(Object *p_obj, Ref<Node3DGizmo> p_gizmo, int p_id, Transform3D p_transform = Transform3D());
void _clear_subgizmo_selection(Object *p_obj = nullptr);
2014-02-10 02:10:30 +01:00
static Node3DEditor *singleton;
2014-02-10 02:10:30 +01:00
void _node_added(Node *p_node);
void _node_removed(Node *p_node);
Vector<Ref<EditorNode3DGizmoPlugin>> gizmo_plugins_by_priority;
Vector<Ref<EditorNode3DGizmoPlugin>> gizmo_plugins_by_name;
void _register_all_gizmos();
void _selection_changed();
void _refresh_menu_icons();
// Preview Sun and Environment
uint32_t world_env_count = 0;
uint32_t directional_light_count = 0;
Button *sun_button = nullptr;
Label *sun_state = nullptr;
Label *sun_title = nullptr;
VBoxContainer *sun_vb = nullptr;
Popup *sun_environ_popup = nullptr;
Control *sun_direction = nullptr;
EditorSpinSlider *sun_angle_altitude = nullptr;
EditorSpinSlider *sun_angle_azimuth = nullptr;
ColorPickerButton *sun_color = nullptr;
EditorSpinSlider *sun_energy = nullptr;
EditorSpinSlider *sun_max_distance = nullptr;
Button *sun_add_to_scene = nullptr;
void _sun_direction_draw();
void _sun_direction_input(const Ref<InputEvent> &p_event);
void _sun_direction_angle_set();
Vector2 sun_rotation;
Ref<Shader> sun_direction_shader;
Ref<ShaderMaterial> sun_direction_material;
Button *environ_button = nullptr;
Label *environ_state = nullptr;
Label *environ_title = nullptr;
VBoxContainer *environ_vb = nullptr;
ColorPickerButton *environ_sky_color = nullptr;
ColorPickerButton *environ_ground_color = nullptr;
EditorSpinSlider *environ_energy = nullptr;
Button *environ_ao_button = nullptr;
Button *environ_glow_button = nullptr;
Button *environ_tonemap_button = nullptr;
Button *environ_gi_button = nullptr;
Button *environ_add_to_scene = nullptr;
Button *sun_environ_settings = nullptr;
DirectionalLight3D *preview_sun = nullptr;
WorldEnvironment *preview_environment = nullptr;
Ref<Environment> environment;
Ref<ProceduralSkyMaterial> sky_material;
bool sun_environ_updating = false;
void _load_default_preview_settings();
void _update_preview_environment();
void _preview_settings_changed();
void _sun_environ_settings_pressed();
void _add_sun_to_scene(bool p_already_added_environment = false);
void _add_environment_to_scene(bool p_already_added_sun = false);
void _update_theme();
2016-03-09 00:00:52 +01:00
protected:
2014-02-10 02:10:30 +01:00
void _notification(int p_what);
//void _gui_input(InputEvent p_event);
virtual void shortcut_input(const Ref<InputEvent> &p_event) override;
2014-02-10 02:10:30 +01:00
static void _bind_methods();
public:
static Node3DEditor *get_singleton() { return singleton; }
2014-02-10 02:10:30 +01:00
Vector3 snap_point(Vector3 p_target, Vector3 p_start = Vector3(0, 0, 0)) const;
float get_znear() const { return settings_znear->get_value(); }
float get_zfar() const { return settings_zfar->get_value(); }
float get_fov() const { return settings_fov->get_value(); }
2014-02-10 02:10:30 +01:00
Transform3D get_gizmo_transform() const { return gizmo.transform; }
bool is_gizmo_visible() const;
2014-02-10 02:10:30 +01:00
ToolMode get_tool_mode() const { return tool_mode; }
bool are_local_coords_enabled() const { return tool_option_button[Node3DEditor::TOOL_OPT_LOCAL_COORDS]->is_pressed(); }
Implement blender-style 3D transform tools. See godotengine/godot-proposals#1215. This adds shortcuts for blender-inspired transforms, where you can press the key and immediately be transforming an object without holding the mouse. Clicking commits the transformation, ESC aborts it. This is inspired by Blender's G(rab)/R(otate)/S(cale) shortcuts, but I decided not to add default bindings as `S` is already bound to the regular scale tool, and it might be confusing to only bind some of them. While actively using a transform tool, you can press X/Y/Z to lock the transform to an axis or (shift)+X/Y/Z to constrain the transform to a plane. These keys are only processed if you have a transform tool (translate/rotate/scale) active _and_ the mouse button is held. Pressing XX/YY/ZZ will lock the transform to a local (rather than global) axis. This is achieved by temporarily toggling the local transform button. I did this (vs handling it in the transform functions) for 3 reasons: - Transform logic for translate/rotate (but not scale) appears to be tightly coupled to the gizmo - This ensures the gizmo changes to indicate we're transforming locally/globally - Toggling the button state in the UI also gives the user feedback about the nature of the transform. The original state of the button is reset when the transform completes. Pressing the `spatial_editor/cancel_transform` shortcut key during a transform operation will cancel the transform and reset the objects back to their original transforms. This functionality was already accessible by pressing RMB during a transform, however: - ESC is more familiar to blender users, and a more common "cancel" key in general. - Given you must hold LMB during a transform, pressing RMB as well is clumsy if not impossible (on a laptop trackpad).
2020-07-18 21:03:08 +02:00
void set_local_coords_enabled(bool on) const { tool_option_button[Node3DEditor::TOOL_OPT_LOCAL_COORDS]->set_pressed(on); }
bool is_snap_enabled() const { return snap_enabled ^ snap_key_enabled; }
double get_translate_snap() const;
double get_rotate_snap() const;
double get_scale_snap() const;
2014-02-10 02:10:30 +01:00
Ref<ArrayMesh> get_move_gizmo(int idx) const { return move_gizmo[idx]; }
Implement blender-style 3D transform tools. See godotengine/godot-proposals#1215. This adds shortcuts for blender-inspired transforms, where you can press the key and immediately be transforming an object without holding the mouse. Clicking commits the transformation, ESC aborts it. This is inspired by Blender's G(rab)/R(otate)/S(cale) shortcuts, but I decided not to add default bindings as `S` is already bound to the regular scale tool, and it might be confusing to only bind some of them. While actively using a transform tool, you can press X/Y/Z to lock the transform to an axis or (shift)+X/Y/Z to constrain the transform to a plane. These keys are only processed if you have a transform tool (translate/rotate/scale) active _and_ the mouse button is held. Pressing XX/YY/ZZ will lock the transform to a local (rather than global) axis. This is achieved by temporarily toggling the local transform button. I did this (vs handling it in the transform functions) for 3 reasons: - Transform logic for translate/rotate (but not scale) appears to be tightly coupled to the gizmo - This ensures the gizmo changes to indicate we're transforming locally/globally - Toggling the button state in the UI also gives the user feedback about the nature of the transform. The original state of the button is reset when the transform completes. Pressing the `spatial_editor/cancel_transform` shortcut key during a transform operation will cancel the transform and reset the objects back to their original transforms. This functionality was already accessible by pressing RMB during a transform, however: - ESC is more familiar to blender users, and a more common "cancel" key in general. - Given you must hold LMB during a transform, pressing RMB as well is clumsy if not impossible (on a laptop trackpad).
2020-07-18 21:03:08 +02:00
Ref<ArrayMesh> get_axis_gizmo(int idx) const { return axis_gizmo[idx]; }
Ref<ArrayMesh> get_move_plane_gizmo(int idx) const { return move_plane_gizmo[idx]; }
Ref<ArrayMesh> get_rotate_gizmo(int idx) const { return rotate_gizmo[idx]; }
Ref<ArrayMesh> get_scale_gizmo(int idx) const { return scale_gizmo[idx]; }
Ref<ArrayMesh> get_scale_plane_gizmo(int idx) const { return scale_plane_gizmo[idx]; }
void update_grid();
2014-02-10 02:10:30 +01:00
void update_transform_gizmo();
2020-04-02 01:20:12 +02:00
void update_all_gizmos(Node *p_node = nullptr);
void snap_selected_nodes_to_floor();
2017-04-06 17:35:08 +02:00
void select_gizmo_highlight_axis(int p_axis);
void set_custom_camera(Node *p_camera) { custom_camera = p_camera; }
2014-02-10 02:10:30 +01:00
void set_undo_redo(UndoRedo *p_undo_redo) { undo_redo = p_undo_redo; }
2014-02-10 02:10:30 +01:00
Dictionary get_state() const;
void set_state(const Dictionary &p_state);
2014-02-10 02:10:30 +01:00
Ref<Environment> get_viewport_environment() { return viewport_environment; }
UndoRedo *get_undo_redo() { return undo_redo; }
void add_control_to_menu_panel(Control *p_control);
void remove_control_from_menu_panel(Control *p_control);
2014-02-10 02:10:30 +01:00
void add_control_to_left_panel(Control *p_control);
void remove_control_from_left_panel(Control *p_control);
void add_control_to_right_panel(Control *p_control);
void remove_control_from_right_panel(Control *p_control);
void move_control_to_left_panel(Control *p_control);
void move_control_to_right_panel(Control *p_control);
2014-02-10 02:10:30 +01:00
VSplitContainer *get_shader_split();
Node3D *get_single_selected_node() { return selected; }
bool is_current_selected_gizmo(const EditorNode3DGizmo *p_gizmo);
bool is_subgizmo_selected(int p_id);
Vector<int> get_subgizmo_selection();
Ref<EditorNode3DGizmo> get_current_hover_gizmo() const { return current_hover_gizmo; }
void set_current_hover_gizmo(Ref<EditorNode3DGizmo> p_gizmo) { current_hover_gizmo = p_gizmo; }
void set_current_hover_gizmo_handle(int p_id, bool p_secondary) {
current_hover_gizmo_handle = p_id;
current_hover_gizmo_handle_secondary = p_secondary;
}
int get_current_hover_gizmo_handle(bool &r_secondary) const {
r_secondary = current_hover_gizmo_handle_secondary;
return current_hover_gizmo_handle;
}
void set_can_preview(Camera3D *p_preview);
2014-02-10 02:10:30 +01:00
Node3DEditorViewport *get_editor_viewport(int p_idx) {
2020-04-02 01:20:12 +02:00
ERR_FAIL_INDEX_V(p_idx, static_cast<int>(VIEWPORTS_COUNT), nullptr);
2015-05-31 06:59:42 +02:00
return viewports[p_idx];
}
void add_gizmo_plugin(Ref<EditorNode3DGizmoPlugin> p_plugin);
void remove_gizmo_plugin(Ref<EditorNode3DGizmoPlugin> p_plugin);
void edit(Node3D *p_spatial);
void clear();
Node3DEditor();
~Node3DEditor();
2014-02-10 02:10:30 +01:00
};
class Node3DEditorPlugin : public EditorPlugin {
GDCLASS(Node3DEditorPlugin, EditorPlugin);
2016-03-09 00:00:52 +01:00
Node3DEditor *spatial_editor = nullptr;
public:
Node3DEditor *get_spatial_editor() { return spatial_editor; }
2020-07-10 12:34:39 +02:00
virtual String get_name() const override { return "3D"; }
bool has_main_screen() const override { return true; }
virtual void make_visible(bool p_visible) override;
virtual void edit(Object *p_object) override;
virtual bool handles(Object *p_object) const override;
2014-02-10 02:10:30 +01:00
2020-07-10 12:34:39 +02:00
virtual Dictionary get_state() const override;
virtual void set_state(const Dictionary &p_state) override;
virtual void clear() override { spatial_editor->clear(); }
2014-02-10 02:10:30 +01:00
2020-07-10 12:34:39 +02:00
virtual void edited_scene_changed() override;
Node3DEditorPlugin();
~Node3DEditorPlugin();
2014-02-10 02:10:30 +01:00
};
#endif // NODE_3D_EDITOR_PLUGIN_H