look_at_modifier_3d.cpp | Explore in Territory

/**************************************************************************/
/*  look_at_modifier_3d.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 "look_at_modifier_3d.h"

void LookAtModifier3D::_validate_property(PropertyInfo &p_property) const { … }

PackedStringArray LookAtModifier3D::get_configuration_warnings() const { … }

void LookAtModifier3D::set_bone_name(const String &p_bone_name) { … }

String LookAtModifier3D::get_bone_name() const { … }

void LookAtModifier3D::set_bone(int p_bone) { … }

int LookAtModifier3D::get_bone() const { … }

void LookAtModifier3D::set_forward_axis(BoneAxis p_axis) { … }

LookAtModifier3D::BoneAxis LookAtModifier3D::get_forward_axis() const { … }

void LookAtModifier3D::set_primary_rotation_axis(Vector3::Axis p_axis) { … }

Vector3::Axis LookAtModifier3D::get_primary_rotation_axis() const { … }

void LookAtModifier3D::set_use_secondary_rotation(bool p_enabled) { … }

bool LookAtModifier3D::is_using_secondary_rotation() const { … }

void LookAtModifier3D::set_target_node(const NodePath &p_target_node) { … }

NodePath LookAtModifier3D::get_target_node() const { … }

// For origin settings.

void LookAtModifier3D::set_origin_from(OriginFrom p_origin_from) { … }

LookAtModifier3D::OriginFrom LookAtModifier3D::get_origin_from() const { … }

void LookAtModifier3D::set_origin_bone_name(const String &p_bone_name) { … }

String LookAtModifier3D::get_origin_bone_name() const { … }

void LookAtModifier3D::set_origin_bone(int p_bone) { … }

int LookAtModifier3D::get_origin_bone() const { … }

void LookAtModifier3D::set_origin_external_node(const NodePath &p_external_node) { … }

NodePath LookAtModifier3D::get_origin_external_node() const { … }

void LookAtModifier3D::set_origin_offset(const Vector3 &p_offset) { … }

Vector3 LookAtModifier3D::get_origin_offset() const { … }

void LookAtModifier3D::set_origin_safe_margin(float p_margin) { … }

float LookAtModifier3D::get_origin_safe_margin() const { … }

// For time-based interpolation.

void LookAtModifier3D::set_duration(float p_duration) { … }

float LookAtModifier3D::get_duration() const { … }

void LookAtModifier3D::set_transition_type(Tween::TransitionType p_transition_type) { … }

Tween::TransitionType LookAtModifier3D::get_transition_type() const { … }

void LookAtModifier3D::set_ease_type(Tween::EaseType p_ease_type) { … }

Tween::EaseType LookAtModifier3D::get_ease_type() const { … }

// For angle limitation.

void LookAtModifier3D::set_use_angle_limitation(bool p_enabled) { … }

bool LookAtModifier3D::is_using_angle_limitation() const { … }

void LookAtModifier3D::set_symmetry_limitation(bool p_enabled) { … }

bool LookAtModifier3D::is_limitation_symmetry() const { … }

void LookAtModifier3D::set_primary_limit_angle(float p_angle) { … }

float LookAtModifier3D::get_primary_limit_angle() const { … }

void LookAtModifier3D::set_primary_damp_threshold(float p_power) { … }

float LookAtModifier3D::get_primary_damp_threshold() const { … }

void LookAtModifier3D::set_primary_positive_limit_angle(float p_angle) { … }

float LookAtModifier3D::get_primary_positive_limit_angle() const { … }

void LookAtModifier3D::set_primary_positive_damp_threshold(float p_power) { … }

float LookAtModifier3D::get_primary_positive_damp_threshold() const { … }

void LookAtModifier3D::set_primary_negative_limit_angle(float p_angle) { … }

float LookAtModifier3D::get_primary_negative_limit_angle() const { … }

void LookAtModifier3D::set_primary_negative_damp_threshold(float p_power) { … }

float LookAtModifier3D::get_primary_negative_damp_threshold() const { … }

void LookAtModifier3D::set_secondary_limit_angle(float p_angle) { … }

float LookAtModifier3D::get_secondary_limit_angle() const { … }

void LookAtModifier3D::set_secondary_damp_threshold(float p_power) { … }

float LookAtModifier3D::get_secondary_damp_threshold() const { … }

void LookAtModifier3D::set_secondary_positive_limit_angle(float p_angle) { … }

float LookAtModifier3D::get_secondary_positive_limit_angle() const { … }

void LookAtModifier3D::set_secondary_positive_damp_threshold(float p_power) { … }

float LookAtModifier3D::get_secondary_positive_damp_threshold() const { … }

void LookAtModifier3D::set_secondary_negative_limit_angle(float p_angle) { … }

float LookAtModifier3D::get_secondary_negative_limit_angle() const { … }

void LookAtModifier3D::set_secondary_negative_damp_threshold(float p_power) { … }

float LookAtModifier3D::get_secondary_negative_damp_threshold() const { … }

bool LookAtModifier3D::is_target_within_limitation() const { … }

float LookAtModifier3D::get_interpolation_remaining() const { … }

bool LookAtModifier3D::is_interpolating() const { … }

// General API.

void LookAtModifier3D::_bind_methods() { … }

void LookAtModifier3D::_process_modification() { … }

bool LookAtModifier3D::is_intersecting_axis(const Vector3 &p_prev, const Vector3 &p_current, Vector3::Axis p_flipping_axis, Vector3::Axis p_check_axis, bool p_check_plane) const { … }

Vector3 LookAtModifier3D::get_basis_vector_from_bone_axis(const Basis &p_basis, LookAtModifier3D::BoneAxis p_axis) const { … }

Vector3 LookAtModifier3D::get_vector_from_bone_axis(const LookAtModifier3D::BoneAxis &p_axis) const { … }

Vector3 LookAtModifier3D::get_vector_from_axis(const Vector3::Axis &p_axis) const { … }

Vector3::Axis LookAtModifier3D::get_axis_from_bone_axis(BoneAxis p_axis) const { … }

Vector2 LookAtModifier3D::get_projection_vector(const Vector3 &p_vector, Vector3::Axis p_axis) const { … }

float LookAtModifier3D::remap_damped(float p_from, float p_to, float p_damp_threshold, float p_value) const { … }

double LookAtModifier3D::get_bspline_y(const Vector2 &p_from, const Vector2 &p_control, const Vector2 &p_to, double p_x) const { … }

Transform3D LookAtModifier3D::look_at_with_axes(const Transform3D &p_rest) { … }

void LookAtModifier3D::init_transition() { … }
godot/scene/3d/look_at_modifier_3d.cpp
