node_3d_editor_gizmos.cpp | Explore in Territory

/**************************************************************************/
/*  node_3d_editor_gizmos.cpp                                             */
/**************************************************************************/
/*                         This file is part of:                          */
/*                             GODOT ENGINE                               */
/*                        https://godotengine.org                         */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                  */
/*                                                                        */
/* 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.                 */
/**************************************************************************/

#include "node_3d_editor_gizmos.h"

#include "core/math/geometry_2d.h"
#include "core/math/geometry_3d.h"
#include "editor/editor_node.h"
#include "editor/editor_settings.h"
#include "editor/editor_string_names.h"
#include "editor/plugins/node_3d_editor_plugin.h"
#include "scene/resources/3d/primitive_meshes.h"

#define HANDLE_HALF_SIZE …

bool EditorNode3DGizmo::is_editable() const { … }

void EditorNode3DGizmo::clear() { … }

void EditorNode3DGizmo::redraw() { … }

String EditorNode3DGizmo::get_handle_name(int p_id, bool p_secondary) const { … }

bool EditorNode3DGizmo::is_handle_highlighted(int p_id, bool p_secondary) const { … }

Variant EditorNode3DGizmo::get_handle_value(int p_id, bool p_secondary) const { … }

void EditorNode3DGizmo::begin_handle_action(int p_id, bool p_secondary) { … }

void EditorNode3DGizmo::set_handle(int p_id, bool p_secondary, Camera3D *p_camera, const Point2 &p_point) { … }

void EditorNode3DGizmo::commit_handle(int p_id, bool p_secondary, const Variant &p_restore, bool p_cancel) { … }

int EditorNode3DGizmo::subgizmos_intersect_ray(Camera3D *p_camera, const Vector2 &p_point) const { … }

Vector<int> EditorNode3DGizmo::subgizmos_intersect_frustum(const Camera3D *p_camera, const Vector<Plane> &p_frustum) const { … }

Transform3D EditorNode3DGizmo::get_subgizmo_transform(int p_id) const { … }

void EditorNode3DGizmo::set_subgizmo_transform(int p_id, Transform3D p_transform) { … }

void EditorNode3DGizmo::commit_subgizmos(const Vector<int> &p_ids, const Vector<Transform3D> &p_restore, bool p_cancel) { … }

void EditorNode3DGizmo::set_node_3d(Node3D *p_node) { … }

void EditorNode3DGizmo::Instance::create_instance(Node3D *p_base, bool p_hidden) { … }

void EditorNode3DGizmo::add_mesh(const Ref<Mesh> &p_mesh, const Ref<Material> &p_material, const Transform3D &p_xform, const Ref<SkinReference> &p_skin_reference) { … }

void EditorNode3DGizmo::_update_bvh() { … }

void EditorNode3DGizmo::add_lines(const Vector<Vector3> &p_lines, const Ref<Material> &p_material, bool p_billboard, const Color &p_modulate) { … }

void EditorNode3DGizmo::add_vertices(const Vector<Vector3> &p_vertices, const Ref<Material> &p_material, Mesh::PrimitiveType p_primitive_type, bool p_billboard, const Color &p_modulate) { … }

void EditorNode3DGizmo::add_unscaled_billboard(const Ref<Material> &p_material, real_t p_scale, const Color &p_modulate) { … }

void EditorNode3DGizmo::add_collision_triangles(const Ref<TriangleMesh> &p_tmesh) { … }

void EditorNode3DGizmo::add_collision_segments(const Vector<Vector3> &p_lines) { … }

void EditorNode3DGizmo::add_handles(const Vector<Vector3> &p_handles, const Ref<Material> &p_material, const Vector<int> &p_ids, bool p_billboard, bool p_secondary) { … }

void EditorNode3DGizmo::add_solid_box(const Ref<Material> &p_material, Vector3 p_size, Vector3 p_position, const Transform3D &p_xform) { … }

bool EditorNode3DGizmo::intersect_frustum(const Camera3D *p_camera, const Vector<Plane> &p_frustum) { … }

void EditorNode3DGizmo::handles_intersect_ray(Camera3D *p_camera, const Vector2 &p_point, bool p_shift_pressed, int &r_id, bool &r_secondary) { … }

bool EditorNode3DGizmo::intersect_ray(Camera3D *p_camera, const Point2 &p_point, Vector3 &r_pos, Vector3 &r_normal) { … }

bool EditorNode3DGizmo::is_subgizmo_selected(int p_id) const { … }

Vector<int> EditorNode3DGizmo::get_subgizmo_selection() const { … }

void EditorNode3DGizmo::create() { … }

void EditorNode3DGizmo::transform() { … }

void EditorNode3DGizmo::free() { … }

void EditorNode3DGizmo::set_hidden(bool p_hidden) { … }

void EditorNode3DGizmo::set_plugin(EditorNode3DGizmoPlugin *p_plugin) { … }

void EditorNode3DGizmo::_bind_methods() { … }

EditorNode3DGizmo::EditorNode3DGizmo() { … }

EditorNode3DGizmo::~EditorNode3DGizmo() { … }

/////

void EditorNode3DGizmoPlugin::create_material(const String &p_name, const Color &p_color, bool p_billboard, bool p_on_top, bool p_use_vertex_color) { … }

void EditorNode3DGizmoPlugin::create_icon_material(const String &p_name, const Ref<Texture2D> &p_texture, bool p_on_top, const Color &p_albedo) { … }

void EditorNode3DGizmoPlugin::create_handle_material(const String &p_name, bool p_billboard, const Ref<Texture2D> &p_icon) { … }

void EditorNode3DGizmoPlugin::add_material(const String &p_name, Ref<StandardMaterial3D> p_material) { … }

Ref<StandardMaterial3D> EditorNode3DGizmoPlugin::get_material(const String &p_name, const Ref<EditorNode3DGizmo> &p_gizmo) { … }

String EditorNode3DGizmoPlugin::get_gizmo_name() const { … }

int EditorNode3DGizmoPlugin::get_priority() const { … }

Ref<EditorNode3DGizmo> EditorNode3DGizmoPlugin::get_gizmo(Node3D *p_spatial) { … }

void EditorNode3DGizmoPlugin::_bind_methods() { … }

bool EditorNode3DGizmoPlugin::has_gizmo(Node3D *p_spatial) { … }

Ref<EditorNode3DGizmo> EditorNode3DGizmoPlugin::create_gizmo(Node3D *p_spatial) { … }

bool EditorNode3DGizmoPlugin::can_be_hidden() const { … }

bool EditorNode3DGizmoPlugin::is_selectable_when_hidden() const { … }

void EditorNode3DGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) { … }

bool EditorNode3DGizmoPlugin::is_handle_highlighted(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary) const { … }

String EditorNode3DGizmoPlugin::get_handle_name(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary) const { … }

Variant EditorNode3DGizmoPlugin::get_handle_value(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary) const { … }

void EditorNode3DGizmoPlugin::begin_handle_action(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary) { … }

void EditorNode3DGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary, Camera3D *p_camera, const Point2 &p_point) { … }

void EditorNode3DGizmoPlugin::commit_handle(const EditorNode3DGizmo *p_gizmo, int p_id, bool p_secondary, const Variant &p_restore, bool p_cancel) { … }

int EditorNode3DGizmoPlugin::subgizmos_intersect_ray(const EditorNode3DGizmo *p_gizmo, Camera3D *p_camera, const Vector2 &p_point) const { … }

Vector<int> EditorNode3DGizmoPlugin::subgizmos_intersect_frustum(const EditorNode3DGizmo *p_gizmo, const Camera3D *p_camera, const Vector<Plane> &p_frustum) const { … }

Transform3D EditorNode3DGizmoPlugin::get_subgizmo_transform(const EditorNode3DGizmo *p_gizmo, int p_id) const { … }

void EditorNode3DGizmoPlugin::set_subgizmo_transform(const EditorNode3DGizmo *p_gizmo, int p_id, Transform3D p_transform) { … }

void EditorNode3DGizmoPlugin::commit_subgizmos(const EditorNode3DGizmo *p_gizmo, const Vector<int> &p_ids, const Vector<Transform3D> &p_restore, bool p_cancel) { … }

void EditorNode3DGizmoPlugin::set_state(int p_state) { … }

int EditorNode3DGizmoPlugin::get_state() const { … }

void EditorNode3DGizmoPlugin::unregister_gizmo(EditorNode3DGizmo *p_gizmo) { … }

EditorNode3DGizmoPlugin::EditorNode3DGizmoPlugin() { … }

EditorNode3DGizmoPlugin::~EditorNode3DGizmoPlugin() { … }

//////
godot/editor/plugins/node_3d_editor_gizmos.cpp
