2014-02-10 01:10:30 +00:00
|
|
|
/*************************************************************************/
|
2020-03-26 21:49:16 +00:00
|
|
|
/* camera_3d.cpp */
|
2014-02-10 01:10:30 +00:00
|
|
|
/*************************************************************************/
|
|
|
|
/* This file is part of: */
|
|
|
|
/* GODOT ENGINE */
|
2017-08-27 12:16:55 +00:00
|
|
|
/* https://godotengine.org */
|
2014-02-10 01:10:30 +00:00
|
|
|
/*************************************************************************/
|
2021-01-01 19:13:46 +00:00
|
|
|
/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */
|
|
|
|
/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */
|
2014-02-10 01:10:30 +00:00
|
|
|
/* */
|
|
|
|
/* Permission is hereby granted, free of charge, to any person obtaining */
|
|
|
|
/* a copy of this software and associated documentation files (the */
|
|
|
|
/* "Software"), to deal in the Software without restriction, including */
|
|
|
|
/* without limitation the rights to use, copy, modify, merge, publish, */
|
|
|
|
/* distribute, sublicense, and/or sell copies of the Software, and to */
|
|
|
|
/* permit persons to whom the Software is furnished to do so, subject to */
|
|
|
|
/* the following conditions: */
|
|
|
|
/* */
|
|
|
|
/* The above copyright notice and this permission notice shall be */
|
|
|
|
/* included in all copies or substantial portions of the Software. */
|
|
|
|
/* */
|
|
|
|
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
|
|
|
|
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
|
|
|
|
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
|
|
|
|
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
|
|
|
|
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
|
|
|
|
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
|
|
|
|
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
|
|
|
|
/*************************************************************************/
|
2018-01-04 23:50:27 +00:00
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
#include "camera_3d.h"
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
#include "collision_object_3d.h"
|
2018-09-11 16:13:45 +00:00
|
|
|
#include "core/math/camera_matrix.h"
|
2021-08-12 23:05:59 +00:00
|
|
|
#include "scene/main/viewport.h"
|
2020-07-01 12:18:13 +00:00
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::_update_audio_listener_state() {
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::_request_camera_update() {
|
2014-02-10 01:10:30 +00:00
|
|
|
_update_camera();
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::_update_camera_mode() {
|
2017-03-05 15:44:50 +00:00
|
|
|
force_change = true;
|
|
|
|
switch (mode) {
|
2014-02-10 01:10:30 +00:00
|
|
|
case PROJECTION_PERSPECTIVE: {
|
2017-03-05 15:44:50 +00:00
|
|
|
set_perspective(fov, near, far);
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
} break;
|
|
|
|
case PROJECTION_ORTHOGONAL: {
|
2017-03-05 15:44:50 +00:00
|
|
|
set_orthogonal(size, near, far);
|
2016-03-08 23:00:52 +00:00
|
|
|
} break;
|
2019-02-19 16:17:02 +00:00
|
|
|
case PROJECTION_FRUSTUM: {
|
|
|
|
set_frustum(size, frustum_offset, near, far);
|
|
|
|
} break;
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::_validate_property(PropertyInfo &p_property) const {
|
2017-12-07 06:31:03 +00:00
|
|
|
if (p_property.name == "fov") {
|
2019-02-19 16:17:02 +00:00
|
|
|
if (mode != PROJECTION_PERSPECTIVE) {
|
2021-11-03 22:06:17 +00:00
|
|
|
p_property.usage = PROPERTY_USAGE_NO_EDITOR;
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
2017-12-07 06:31:03 +00:00
|
|
|
} else if (p_property.name == "size") {
|
2019-02-19 16:17:02 +00:00
|
|
|
if (mode != PROJECTION_ORTHOGONAL && mode != PROJECTION_FRUSTUM) {
|
2021-11-03 22:06:17 +00:00
|
|
|
p_property.usage = PROPERTY_USAGE_NO_EDITOR;
|
2019-02-19 16:17:02 +00:00
|
|
|
}
|
|
|
|
} else if (p_property.name == "frustum_offset") {
|
|
|
|
if (mode != PROJECTION_FRUSTUM) {
|
2021-11-03 22:06:17 +00:00
|
|
|
p_property.usage = PROPERTY_USAGE_NO_EDITOR;
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
}
|
2021-10-21 16:38:20 +00:00
|
|
|
|
|
|
|
Node3D::_validate_property(p_property);
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::_update_camera() {
|
2020-05-14 14:41:43 +00:00
|
|
|
if (!is_inside_tree()) {
|
2017-12-24 16:31:28 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2017-12-24 16:31:28 +00:00
|
|
|
|
2020-03-27 18:21:27 +00:00
|
|
|
RenderingServer::get_singleton()->camera_set_transform(camera, get_camera_transform());
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2017-01-14 11:26:56 +00:00
|
|
|
// here goes listener stuff
|
|
|
|
/*
|
|
|
|
if (viewport_ptr && is_inside_scene() && is_current())
|
2020-04-28 15:04:07 +00:00
|
|
|
get_viewport()->_camera_3d_transform_changed_notify();
|
2017-01-14 11:26:56 +00:00
|
|
|
*/
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2020-05-14 14:41:43 +00:00
|
|
|
if (get_tree()->is_node_being_edited(this) || !is_current()) {
|
2017-12-07 15:13:20 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2017-12-07 15:13:20 +00:00
|
|
|
|
2020-04-28 15:04:07 +00:00
|
|
|
get_viewport()->_camera_3d_transform_changed_notify();
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::_notification(int p_what) {
|
2017-03-05 15:44:50 +00:00
|
|
|
switch (p_what) {
|
2014-02-10 01:10:30 +00:00
|
|
|
case NOTIFICATION_ENTER_WORLD: {
|
2021-03-12 13:35:16 +00:00
|
|
|
// Needs to track the Viewport because it's needed on NOTIFICATION_EXIT_WORLD
|
2019-03-10 03:59:52 +00:00
|
|
|
// and Spatial will handle it first, including clearing its reference to the Viewport,
|
|
|
|
// therefore making it impossible to subclasses to access it
|
|
|
|
viewport = get_viewport();
|
|
|
|
ERR_FAIL_COND(!viewport);
|
|
|
|
|
2020-04-28 15:04:07 +00:00
|
|
|
bool first_camera = viewport->_camera_3d_add(this);
|
2020-05-14 14:41:43 +00:00
|
|
|
if (current || first_camera) {
|
2020-04-28 15:04:07 +00:00
|
|
|
viewport->_camera_3d_set(this);
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-03-08 23:00:52 +00:00
|
|
|
} break;
|
2014-02-10 01:10:30 +00:00
|
|
|
case NOTIFICATION_TRANSFORM_CHANGED: {
|
|
|
|
_request_camera_update();
|
2017-07-15 04:23:10 +00:00
|
|
|
if (doppler_tracking != DOPPLER_TRACKING_DISABLED) {
|
|
|
|
velocity_tracker->update_position(get_global_transform().origin);
|
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
} break;
|
|
|
|
case NOTIFICATION_EXIT_WORLD: {
|
2016-01-02 20:18:45 +00:00
|
|
|
if (!get_tree()->is_node_being_edited(this)) {
|
|
|
|
if (is_current()) {
|
|
|
|
clear_current();
|
2017-03-05 15:44:50 +00:00
|
|
|
current = true; //keep it true
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-01-02 20:18:45 +00:00
|
|
|
} else {
|
2017-03-05 15:44:50 +00:00
|
|
|
current = false;
|
2016-01-02 20:18:45 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
2016-01-02 20:18:45 +00:00
|
|
|
|
2019-03-10 03:59:52 +00:00
|
|
|
if (viewport) {
|
2020-04-28 15:04:07 +00:00
|
|
|
viewport->_camera_3d_remove(this);
|
2020-04-01 23:20:12 +00:00
|
|
|
viewport = nullptr;
|
2019-03-10 03:59:52 +00:00
|
|
|
}
|
2014-10-12 05:13:22 +00:00
|
|
|
|
2014-02-10 01:10:30 +00:00
|
|
|
} break;
|
|
|
|
case NOTIFICATION_BECAME_CURRENT: {
|
2019-03-10 03:59:52 +00:00
|
|
|
if (viewport) {
|
2020-04-18 09:00:51 +00:00
|
|
|
viewport->find_world_3d()->_register_camera(this);
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
} break;
|
|
|
|
case NOTIFICATION_LOST_CURRENT: {
|
2019-03-10 03:59:52 +00:00
|
|
|
if (viewport) {
|
2020-04-18 09:00:51 +00:00
|
|
|
viewport->find_world_3d()->_remove_camera(this);
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
} break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-10-17 05:08:21 +00:00
|
|
|
Transform3D Camera3D::get_camera_transform() const {
|
|
|
|
Transform3D tr = get_global_transform().orthonormalized();
|
2018-07-09 19:07:15 +00:00
|
|
|
tr.origin += tr.basis.get_axis(1) * v_offset;
|
|
|
|
tr.origin += tr.basis.get_axis(0) * h_offset;
|
|
|
|
return tr;
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
void Camera3D::set_perspective(real_t p_fovy_degrees, real_t p_z_near, real_t p_z_far) {
|
2020-05-14 14:41:43 +00:00
|
|
|
if (!force_change && fov == p_fovy_degrees && p_z_near == near && p_z_far == far && mode == PROJECTION_PERSPECTIVE) {
|
2014-02-10 01:10:30 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2017-03-05 15:44:50 +00:00
|
|
|
fov = p_fovy_degrees;
|
|
|
|
near = p_z_near;
|
|
|
|
far = p_z_far;
|
|
|
|
mode = PROJECTION_PERSPECTIVE;
|
2016-03-08 23:00:52 +00:00
|
|
|
|
2020-03-27 18:21:27 +00:00
|
|
|
RenderingServer::get_singleton()->camera_set_perspective(camera, fov, near, far);
|
2021-06-23 14:49:50 +00:00
|
|
|
update_gizmos();
|
2017-03-05 15:44:50 +00:00
|
|
|
force_change = false;
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
2020-05-14 12:29:06 +00:00
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
void Camera3D::set_orthogonal(real_t p_size, real_t p_z_near, real_t p_z_far) {
|
2020-05-14 14:41:43 +00:00
|
|
|
if (!force_change && size == p_size && p_z_near == near && p_z_far == far && mode == PROJECTION_ORTHOGONAL) {
|
2014-02-10 01:10:30 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
size = p_size;
|
2016-03-08 23:00:52 +00:00
|
|
|
|
2017-03-05 15:44:50 +00:00
|
|
|
near = p_z_near;
|
|
|
|
far = p_z_far;
|
|
|
|
mode = PROJECTION_ORTHOGONAL;
|
|
|
|
force_change = false;
|
2016-03-08 23:00:52 +00:00
|
|
|
|
2020-03-27 18:21:27 +00:00
|
|
|
RenderingServer::get_singleton()->camera_set_orthogonal(camera, size, near, far);
|
2021-06-23 14:49:50 +00:00
|
|
|
update_gizmos();
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
void Camera3D::set_frustum(real_t p_size, Vector2 p_offset, real_t p_z_near, real_t p_z_far) {
|
2020-05-14 14:41:43 +00:00
|
|
|
if (!force_change && size == p_size && frustum_offset == p_offset && p_z_near == near && p_z_far == far && mode == PROJECTION_FRUSTUM) {
|
2019-02-19 16:17:02 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2019-02-19 16:17:02 +00:00
|
|
|
|
|
|
|
size = p_size;
|
|
|
|
frustum_offset = p_offset;
|
|
|
|
|
|
|
|
near = p_z_near;
|
|
|
|
far = p_z_far;
|
|
|
|
mode = PROJECTION_FRUSTUM;
|
|
|
|
force_change = false;
|
|
|
|
|
2020-03-27 18:21:27 +00:00
|
|
|
RenderingServer::get_singleton()->camera_set_frustum(camera, size, frustum_offset, near, far);
|
2021-06-23 14:49:50 +00:00
|
|
|
update_gizmos();
|
2019-02-19 16:17:02 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::set_projection(Camera3D::Projection p_mode) {
|
2019-02-19 16:17:02 +00:00
|
|
|
if (p_mode == PROJECTION_PERSPECTIVE || p_mode == PROJECTION_ORTHOGONAL || p_mode == PROJECTION_FRUSTUM) {
|
2017-12-07 06:31:03 +00:00
|
|
|
mode = p_mode;
|
|
|
|
_update_camera_mode();
|
2021-02-10 20:18:45 +00:00
|
|
|
notify_property_list_changed();
|
2017-12-07 06:31:03 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
RID Camera3D::get_camera() const {
|
2014-02-10 01:10:30 +00:00
|
|
|
return camera;
|
|
|
|
};
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::make_current() {
|
2017-03-05 15:44:50 +00:00
|
|
|
current = true;
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2020-05-14 14:41:43 +00:00
|
|
|
if (!is_inside_tree()) {
|
2014-02-10 01:10:30 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2020-04-28 15:04:07 +00:00
|
|
|
get_viewport()->_camera_3d_set(this);
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
//get_scene()->call_group(SceneMainLoop::GROUP_CALL_REALTIME,camera_group,"_camera_make_current",this);
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::clear_current(bool p_enable_next) {
|
2017-03-05 15:44:50 +00:00
|
|
|
current = false;
|
2020-05-14 14:41:43 +00:00
|
|
|
if (!is_inside_tree()) {
|
2014-02-10 01:10:30 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2020-04-28 15:04:07 +00:00
|
|
|
if (get_viewport()->get_camera_3d() == this) {
|
|
|
|
get_viewport()->_camera_3d_set(nullptr);
|
2018-03-16 18:10:26 +00:00
|
|
|
|
|
|
|
if (p_enable_next) {
|
2020-04-28 15:04:07 +00:00
|
|
|
get_viewport()->_camera_3d_make_next_current(this);
|
2018-03-16 18:10:26 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-08 21:26:13 +00:00
|
|
|
void Camera3D::set_current(bool p_enabled) {
|
|
|
|
if (p_enabled) {
|
2017-12-07 06:31:03 +00:00
|
|
|
make_current();
|
|
|
|
} else {
|
|
|
|
clear_current();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
bool Camera3D::is_current() const {
|
2016-01-02 20:18:45 +00:00
|
|
|
if (is_inside_tree() && !get_tree()->is_node_being_edited(this)) {
|
2020-04-28 15:04:07 +00:00
|
|
|
return get_viewport()->get_camera_3d() == this;
|
2020-05-14 14:41:43 +00:00
|
|
|
} else {
|
2014-02-10 01:10:30 +00:00
|
|
|
return current;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Vector3 Camera3D::project_ray_normal(const Point2 &p_pos) const {
|
2014-02-10 01:10:30 +00:00
|
|
|
Vector3 ray = project_local_ray_normal(p_pos);
|
|
|
|
return get_camera_transform().basis.xform(ray).normalized();
|
|
|
|
};
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Vector3 Camera3D::project_local_ray_normal(const Point2 &p_pos) const {
|
2019-08-08 20:11:48 +00:00
|
|
|
ERR_FAIL_COND_V_MSG(!is_inside_tree(), Vector3(), "Camera is not inside scene.");
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-01-02 20:18:45 +00:00
|
|
|
Size2 viewport_size = get_viewport()->get_camera_rect_size();
|
|
|
|
Vector2 cpos = get_viewport()->get_camera_coords(p_pos);
|
2014-02-10 01:10:30 +00:00
|
|
|
Vector3 ray;
|
|
|
|
|
2017-03-05 15:44:50 +00:00
|
|
|
if (mode == PROJECTION_ORTHOGONAL) {
|
|
|
|
ray = Vector3(0, 0, -1);
|
2014-02-10 01:10:30 +00:00
|
|
|
} else {
|
|
|
|
CameraMatrix cm;
|
2017-03-05 15:44:50 +00:00
|
|
|
cm.set_perspective(fov, viewport_size.aspect(), near, far, keep_aspect == KEEP_WIDTH);
|
2020-01-21 18:39:16 +00:00
|
|
|
Vector2 screen_he = cm.get_viewport_half_extents();
|
|
|
|
ray = Vector3(((cpos.x / viewport_size.width) * 2.0 - 1.0) * screen_he.x, ((1.0 - (cpos.y / viewport_size.height)) * 2.0 - 1.0) * screen_he.y, -near).normalized();
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
return ray;
|
|
|
|
};
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Vector3 Camera3D::project_ray_origin(const Point2 &p_pos) const {
|
2019-08-08 20:11:48 +00:00
|
|
|
ERR_FAIL_COND_V_MSG(!is_inside_tree(), Vector3(), "Camera is not inside scene.");
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-01-02 20:18:45 +00:00
|
|
|
Size2 viewport_size = get_viewport()->get_camera_rect_size();
|
|
|
|
Vector2 cpos = get_viewport()->get_camera_coords(p_pos);
|
2017-03-05 15:44:50 +00:00
|
|
|
ERR_FAIL_COND_V(viewport_size.y == 0, Vector3());
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
if (mode == PROJECTION_PERSPECTIVE) {
|
|
|
|
return get_camera_transform().origin;
|
|
|
|
} else {
|
2014-10-28 01:54:32 +00:00
|
|
|
Vector2 pos = cpos / viewport_size;
|
2021-01-30 00:55:54 +00:00
|
|
|
real_t vsize, hsize;
|
2017-03-05 15:44:50 +00:00
|
|
|
if (keep_aspect == KEEP_WIDTH) {
|
|
|
|
vsize = size / viewport_size.aspect();
|
2014-02-10 01:10:30 +00:00
|
|
|
hsize = size;
|
|
|
|
} else {
|
2017-03-05 15:44:50 +00:00
|
|
|
hsize = size * viewport_size.aspect();
|
2014-02-10 01:10:30 +00:00
|
|
|
vsize = size;
|
|
|
|
}
|
|
|
|
|
|
|
|
Vector3 ray;
|
2017-03-05 15:44:50 +00:00
|
|
|
ray.x = pos.x * (hsize)-hsize / 2;
|
|
|
|
ray.y = (1.0 - pos.y) * (vsize)-vsize / 2;
|
2014-02-10 01:10:30 +00:00
|
|
|
ray.z = -near;
|
|
|
|
ray = get_camera_transform().xform(ray);
|
|
|
|
return ray;
|
|
|
|
};
|
|
|
|
};
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
bool Camera3D::is_position_behind(const Vector3 &p_pos) const {
|
2020-10-17 05:08:21 +00:00
|
|
|
Transform3D t = get_global_transform();
|
2020-06-26 14:52:02 +00:00
|
|
|
Vector3 eyedir = -t.basis.get_axis(2).normalized();
|
|
|
|
return eyedir.dot(p_pos - t.origin) < near;
|
2015-04-29 01:05:01 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Vector<Vector3> Camera3D::get_near_plane_points() const {
|
2019-08-08 20:11:48 +00:00
|
|
|
ERR_FAIL_COND_V_MSG(!is_inside_tree(), Vector<Vector3>(), "Camera is not inside scene.");
|
2018-08-21 14:48:17 +00:00
|
|
|
|
|
|
|
Size2 viewport_size = get_viewport()->get_visible_rect().size;
|
|
|
|
|
|
|
|
CameraMatrix cm;
|
|
|
|
|
2020-05-14 14:41:43 +00:00
|
|
|
if (mode == PROJECTION_ORTHOGONAL) {
|
2018-08-21 14:48:17 +00:00
|
|
|
cm.set_orthogonal(size, viewport_size.aspect(), near, far, keep_aspect == KEEP_WIDTH);
|
2020-05-14 14:41:43 +00:00
|
|
|
} else {
|
2018-08-21 14:48:17 +00:00
|
|
|
cm.set_perspective(fov, viewport_size.aspect(), near, far, keep_aspect == KEEP_WIDTH);
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-08-21 14:48:17 +00:00
|
|
|
|
|
|
|
Vector3 endpoints[8];
|
2020-10-17 05:08:21 +00:00
|
|
|
cm.get_endpoints(Transform3D(), endpoints);
|
2018-08-21 14:48:17 +00:00
|
|
|
|
|
|
|
Vector<Vector3> points;
|
|
|
|
points.push_back(Vector3());
|
|
|
|
for (int i = 0; i < 4; i++) {
|
|
|
|
points.push_back(endpoints[i + 4]);
|
|
|
|
}
|
|
|
|
return points;
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Point2 Camera3D::unproject_position(const Vector3 &p_pos) const {
|
2019-08-08 20:11:48 +00:00
|
|
|
ERR_FAIL_COND_V_MSG(!is_inside_tree(), Vector2(), "Camera is not inside scene.");
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-01-02 20:18:45 +00:00
|
|
|
Size2 viewport_size = get_viewport()->get_visible_rect().size;
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
CameraMatrix cm;
|
|
|
|
|
2020-05-14 14:41:43 +00:00
|
|
|
if (mode == PROJECTION_ORTHOGONAL) {
|
2017-03-05 15:44:50 +00:00
|
|
|
cm.set_orthogonal(size, viewport_size.aspect(), near, far, keep_aspect == KEEP_WIDTH);
|
2020-05-14 14:41:43 +00:00
|
|
|
} else {
|
2017-03-05 15:44:50 +00:00
|
|
|
cm.set_perspective(fov, viewport_size.aspect(), near, far, keep_aspect == KEEP_WIDTH);
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2017-03-05 15:44:50 +00:00
|
|
|
Plane p(get_camera_transform().xform_inv(p_pos), 1.0);
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2017-03-05 15:44:50 +00:00
|
|
|
p = cm.xform4(p);
|
2020-05-10 14:47:11 +00:00
|
|
|
p.normal /= p.d;
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
Point2 res;
|
2017-03-05 15:44:50 +00:00
|
|
|
res.x = (p.normal.x * 0.5 + 0.5) * viewport_size.x;
|
|
|
|
res.y = (-p.normal.y * 0.5 + 0.5) * viewport_size.y;
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
Vector3 Camera3D::project_position(const Point2 &p_point, real_t p_z_depth) const {
|
2019-08-08 20:11:48 +00:00
|
|
|
ERR_FAIL_COND_V_MSG(!is_inside_tree(), Vector3(), "Camera is not inside scene.");
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2019-12-09 20:10:09 +00:00
|
|
|
if (p_z_depth == 0 && mode != PROJECTION_ORTHOGONAL) {
|
2019-05-28 13:14:13 +00:00
|
|
|
return get_global_transform().origin;
|
|
|
|
}
|
2016-01-02 20:18:45 +00:00
|
|
|
Size2 viewport_size = get_viewport()->get_visible_rect().size;
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
CameraMatrix cm;
|
|
|
|
|
2020-05-14 14:41:43 +00:00
|
|
|
if (mode == PROJECTION_ORTHOGONAL) {
|
2020-01-09 14:34:31 +00:00
|
|
|
cm.set_orthogonal(size, viewport_size.aspect(), p_z_depth, far, keep_aspect == KEEP_WIDTH);
|
2020-05-14 14:41:43 +00:00
|
|
|
} else {
|
2020-01-09 14:34:31 +00:00
|
|
|
cm.set_perspective(fov, viewport_size.aspect(), p_z_depth, far, keep_aspect == KEEP_WIDTH);
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2020-01-21 18:39:16 +00:00
|
|
|
Vector2 vp_he = cm.get_viewport_half_extents();
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
Vector2 point;
|
2017-03-05 15:44:50 +00:00
|
|
|
point.x = (p_point.x / viewport_size.x) * 2.0 - 1.0;
|
|
|
|
point.y = (1.0 - (p_point.y / viewport_size.y)) * 2.0 - 1.0;
|
2020-01-21 18:39:16 +00:00
|
|
|
point *= vp_he;
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2019-05-28 13:14:13 +00:00
|
|
|
Vector3 p(point.x, point.y, -p_z_depth);
|
2014-02-10 01:10:30 +00:00
|
|
|
|
|
|
|
return get_camera_transform().xform(p);
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::set_environment(const Ref<Environment> &p_environment) {
|
2017-03-05 15:44:50 +00:00
|
|
|
environment = p_environment;
|
2020-05-14 14:41:43 +00:00
|
|
|
if (environment.is_valid()) {
|
2020-03-27 18:21:27 +00:00
|
|
|
RS::get_singleton()->camera_set_environment(camera, environment->get_rid());
|
2020-05-14 14:41:43 +00:00
|
|
|
} else {
|
2020-03-27 18:21:27 +00:00
|
|
|
RS::get_singleton()->camera_set_environment(camera, RID());
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2017-12-07 06:31:03 +00:00
|
|
|
_update_camera_mode();
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Ref<Environment> Camera3D::get_environment() const {
|
2014-02-10 01:10:30 +00:00
|
|
|
return environment;
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::set_effects(const Ref<CameraEffects> &p_effects) {
|
2020-01-13 18:37:24 +00:00
|
|
|
effects = p_effects;
|
2020-05-14 14:41:43 +00:00
|
|
|
if (effects.is_valid()) {
|
2020-03-27 18:21:27 +00:00
|
|
|
RS::get_singleton()->camera_set_camera_effects(camera, effects->get_rid());
|
2020-05-14 14:41:43 +00:00
|
|
|
} else {
|
2020-03-27 18:21:27 +00:00
|
|
|
RS::get_singleton()->camera_set_camera_effects(camera, RID());
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2020-01-13 18:37:24 +00:00
|
|
|
_update_camera_mode();
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Ref<CameraEffects> Camera3D::get_effects() const {
|
2020-01-13 18:37:24 +00:00
|
|
|
return effects;
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::set_keep_aspect_mode(KeepAspect p_aspect) {
|
2017-03-05 15:44:50 +00:00
|
|
|
keep_aspect = p_aspect;
|
2020-03-27 18:21:27 +00:00
|
|
|
RenderingServer::get_singleton()->camera_set_use_vertical_aspect(camera, p_aspect == KEEP_WIDTH);
|
2017-12-07 06:31:03 +00:00
|
|
|
_update_camera_mode();
|
2021-02-10 20:18:45 +00:00
|
|
|
notify_property_list_changed();
|
2014-09-15 23:06:37 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Camera3D::KeepAspect Camera3D::get_keep_aspect_mode() const {
|
2014-09-15 23:06:37 +00:00
|
|
|
return keep_aspect;
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::set_doppler_tracking(DopplerTracking p_tracking) {
|
2020-05-14 14:41:43 +00:00
|
|
|
if (doppler_tracking == p_tracking) {
|
2017-07-15 04:23:10 +00:00
|
|
|
return;
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2017-07-15 04:23:10 +00:00
|
|
|
|
|
|
|
doppler_tracking = p_tracking;
|
|
|
|
if (p_tracking != DOPPLER_TRACKING_DISABLED) {
|
2017-09-30 14:19:07 +00:00
|
|
|
velocity_tracker->set_track_physics_step(doppler_tracking == DOPPLER_TRACKING_PHYSICS_STEP);
|
2019-02-26 12:15:51 +00:00
|
|
|
if (is_inside_tree()) {
|
|
|
|
velocity_tracker->reset(get_global_transform().origin);
|
|
|
|
}
|
2017-07-15 04:23:10 +00:00
|
|
|
}
|
2017-12-07 06:31:03 +00:00
|
|
|
_update_camera_mode();
|
2017-07-15 04:23:10 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Camera3D::DopplerTracking Camera3D::get_doppler_tracking() const {
|
2017-07-15 04:23:10 +00:00
|
|
|
return doppler_tracking;
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::_bind_methods() {
|
|
|
|
ClassDB::bind_method(D_METHOD("project_ray_normal", "screen_point"), &Camera3D::project_ray_normal);
|
|
|
|
ClassDB::bind_method(D_METHOD("project_local_ray_normal", "screen_point"), &Camera3D::project_local_ray_normal);
|
|
|
|
ClassDB::bind_method(D_METHOD("project_ray_origin", "screen_point"), &Camera3D::project_ray_origin);
|
|
|
|
ClassDB::bind_method(D_METHOD("unproject_position", "world_point"), &Camera3D::unproject_position);
|
|
|
|
ClassDB::bind_method(D_METHOD("is_position_behind", "world_point"), &Camera3D::is_position_behind);
|
|
|
|
ClassDB::bind_method(D_METHOD("project_position", "screen_point", "z_depth"), &Camera3D::project_position);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_perspective", "fov", "z_near", "z_far"), &Camera3D::set_perspective);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_orthogonal", "size", "z_near", "z_far"), &Camera3D::set_orthogonal);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_frustum", "size", "offset", "z_near", "z_far"), &Camera3D::set_frustum);
|
|
|
|
ClassDB::bind_method(D_METHOD("make_current"), &Camera3D::make_current);
|
|
|
|
ClassDB::bind_method(D_METHOD("clear_current", "enable_next"), &Camera3D::clear_current, DEFVAL(true));
|
2021-10-08 21:26:13 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_current", "enabled"), &Camera3D::set_current);
|
2020-03-26 21:49:16 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("is_current"), &Camera3D::is_current);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_camera_transform"), &Camera3D::get_camera_transform);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_fov"), &Camera3D::get_fov);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_frustum_offset"), &Camera3D::get_frustum_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_size"), &Camera3D::get_size);
|
2020-12-16 12:40:42 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("get_far"), &Camera3D::get_far);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_near"), &Camera3D::get_near);
|
2021-10-08 21:26:13 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_fov", "fov"), &Camera3D::set_fov);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_frustum_offset", "offset"), &Camera3D::set_frustum_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_size", "size"), &Camera3D::set_size);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_far", "far"), &Camera3D::set_far);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_near", "near"), &Camera3D::set_near);
|
2020-03-26 21:49:16 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("get_projection"), &Camera3D::get_projection);
|
2021-10-08 21:26:13 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_projection", "mode"), &Camera3D::set_projection);
|
2020-03-26 21:49:16 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_h_offset", "ofs"), &Camera3D::set_h_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_h_offset"), &Camera3D::get_h_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_v_offset", "ofs"), &Camera3D::set_v_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_v_offset"), &Camera3D::get_v_offset);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_cull_mask", "mask"), &Camera3D::set_cull_mask);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_cull_mask"), &Camera3D::get_cull_mask);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_environment", "env"), &Camera3D::set_environment);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_environment"), &Camera3D::get_environment);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_effects", "env"), &Camera3D::set_effects);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_effects"), &Camera3D::get_effects);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_keep_aspect_mode", "mode"), &Camera3D::set_keep_aspect_mode);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_keep_aspect_mode"), &Camera3D::get_keep_aspect_mode);
|
|
|
|
ClassDB::bind_method(D_METHOD("set_doppler_tracking", "mode"), &Camera3D::set_doppler_tracking);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_doppler_tracking"), &Camera3D::get_doppler_tracking);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_frustum"), &Camera3D::get_frustum);
|
2021-04-29 01:14:12 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("is_position_in_frustum", "world_point"), &Camera3D::is_position_in_frustum);
|
2020-03-26 21:49:16 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("get_camera_rid"), &Camera3D::get_camera);
|
2021-10-03 11:51:25 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("get_pyramid_shape_rid"), &Camera3D::get_pyramid_shape_rid);
|
2020-03-26 21:49:16 +00:00
|
|
|
|
2021-08-11 23:01:38 +00:00
|
|
|
ClassDB::bind_method(D_METHOD("set_cull_mask_value", "layer_number", "value"), &Camera3D::set_cull_mask_value);
|
|
|
|
ClassDB::bind_method(D_METHOD("get_cull_mask_value", "layer_number"), &Camera3D::get_cull_mask_value);
|
2018-07-29 23:05:16 +00:00
|
|
|
|
2017-02-13 11:47:24 +00:00
|
|
|
//ClassDB::bind_method(D_METHOD("_camera_make_current"),&Camera::_camera_make_current );
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2017-12-07 06:31:03 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "keep_aspect", PROPERTY_HINT_ENUM, "Keep Width,Keep Height"), "set_keep_aspect_mode", "get_keep_aspect_mode");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "cull_mask", PROPERTY_HINT_LAYERS_3D_RENDER), "set_cull_mask", "get_cull_mask");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "environment", PROPERTY_HINT_RESOURCE_TYPE, "Environment"), "set_environment", "get_environment");
|
2020-01-13 18:37:24 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "effects", PROPERTY_HINT_RESOURCE_TYPE, "CameraEffects"), "set_effects", "get_effects");
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "h_offset"), "set_h_offset", "get_h_offset");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "v_offset"), "set_v_offset", "get_v_offset");
|
2017-12-07 06:31:03 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "doppler_tracking", PROPERTY_HINT_ENUM, "Disabled,Idle,Physics"), "set_doppler_tracking", "get_doppler_tracking");
|
2019-02-19 16:17:02 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::INT, "projection", PROPERTY_HINT_ENUM, "Perspective,Orthogonal,Frustum"), "set_projection", "get_projection");
|
2017-12-07 06:31:03 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "current"), "set_current", "is_current");
|
Fix editor suffixes and degrees conversion
* Functions to convert to/from degrees are all gone. Conversion is done by the editor.
* Use PROPERTY_HINT_ANGLE instead of PROPERTY_HINT_RANGE to edit radian angles in degrees.
* Added possibility to add suffixes to range properties, use "min,max[,step][,suffix:<something>]" example "0,100,1,suffix:m"
* In general, can add suffixes for EditorSpinSlider
Not covered by this PR, will have to be addressed by future ones:
* Ability to switch radians/degrees in the inspector for angle properties (if actually wanted).
* Animations previously made will most likely break, need to add a way to make old ones compatible.
* Only added a "px" suffix to 2D position and a "m" one to 3D position, someone needs to go through the rest of the engine and add all remaining suffixes.
* Likely also need to track down usage of EditorSpinSlider outside properties to add suffixes to it too.
2021-06-29 19:42:12 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "fov", PROPERTY_HINT_RANGE, "1,179,0.1,degrees"), "set_fov", "get_fov");
|
Variant: Added 64-bit packed arrays, renamed Variant::REAL to FLOAT.
- Renames PackedIntArray to PackedInt32Array.
- Renames PackedFloatArray to PackedFloat32Array.
- Adds PackedInt64Array and PackedFloat64Array.
- Renames Variant::REAL to Variant::FLOAT for consistency.
Packed arrays are for storing large amount of data and creating stuff like
meshes, buffers. textures, etc. Forcing them to be 64 is a huge waste of
memory. That said, many users requested the ability to have 64 bits packed
arrays for their games, so this is just an optional added type.
For Variant, the float datatype is always 64 bits, and exposed as `float`.
We still have `real_t` which is the datatype that can change from 32 to 64
bits depending on a compile flag (not entirely working right now, but that's
the idea). It affects math related datatypes and code only.
Neither Variant nor PackedArray make use of real_t, which is only intended
for math precision, so the term is removed from there to keep only float.
2020-02-24 18:20:53 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "size", PROPERTY_HINT_RANGE, "0.1,16384,0.01"), "set_size", "get_size");
|
2019-02-19 16:17:02 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::VECTOR2, "frustum_offset"), "set_frustum_offset", "get_frustum_offset");
|
Fix editor suffixes and degrees conversion
* Functions to convert to/from degrees are all gone. Conversion is done by the editor.
* Use PROPERTY_HINT_ANGLE instead of PROPERTY_HINT_RANGE to edit radian angles in degrees.
* Added possibility to add suffixes to range properties, use "min,max[,step][,suffix:<something>]" example "0,100,1,suffix:m"
* In general, can add suffixes for EditorSpinSlider
Not covered by this PR, will have to be addressed by future ones:
* Ability to switch radians/degrees in the inspector for angle properties (if actually wanted).
* Animations previously made will most likely break, need to add a way to make old ones compatible.
* Only added a "px" suffix to 2D position and a "m" one to 3D position, someone needs to go through the rest of the engine and add all remaining suffixes.
* Likely also need to track down usage of EditorSpinSlider outside properties to add suffixes to it too.
2021-06-29 19:42:12 +00:00
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "near", PROPERTY_HINT_RANGE, "0.001,10,0.001,or_greater,exp"), "set_near", "get_near");
|
|
|
|
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "far", PROPERTY_HINT_RANGE, "0.01,4000,0.01,or_greater,exp"), "set_far", "get_far");
|
2017-12-07 06:31:03 +00:00
|
|
|
|
2017-08-20 15:45:01 +00:00
|
|
|
BIND_ENUM_CONSTANT(PROJECTION_PERSPECTIVE);
|
|
|
|
BIND_ENUM_CONSTANT(PROJECTION_ORTHOGONAL);
|
2019-02-19 16:17:02 +00:00
|
|
|
BIND_ENUM_CONSTANT(PROJECTION_FRUSTUM);
|
2014-09-15 23:06:37 +00:00
|
|
|
|
2017-08-20 15:45:01 +00:00
|
|
|
BIND_ENUM_CONSTANT(KEEP_WIDTH);
|
|
|
|
BIND_ENUM_CONSTANT(KEEP_HEIGHT);
|
2017-07-15 04:23:10 +00:00
|
|
|
|
2019-10-02 07:57:12 +00:00
|
|
|
BIND_ENUM_CONSTANT(DOPPLER_TRACKING_DISABLED);
|
|
|
|
BIND_ENUM_CONSTANT(DOPPLER_TRACKING_IDLE_STEP);
|
|
|
|
BIND_ENUM_CONSTANT(DOPPLER_TRACKING_PHYSICS_STEP);
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
real_t Camera3D::get_fov() const {
|
2014-02-10 01:10:30 +00:00
|
|
|
return fov;
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
real_t Camera3D::get_size() const {
|
2014-02-10 01:10:30 +00:00
|
|
|
return size;
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
real_t Camera3D::get_near() const {
|
2014-02-10 01:10:30 +00:00
|
|
|
return near;
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Vector2 Camera3D::get_frustum_offset() const {
|
2019-02-19 16:17:02 +00:00
|
|
|
return frustum_offset;
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
real_t Camera3D::get_far() const {
|
2014-02-10 01:10:30 +00:00
|
|
|
return far;
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Camera3D::Projection Camera3D::get_projection() const {
|
2014-02-10 01:10:30 +00:00
|
|
|
return mode;
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
void Camera3D::set_fov(real_t p_fov) {
|
2019-12-29 03:36:57 +00:00
|
|
|
ERR_FAIL_COND(p_fov < 1 || p_fov > 179);
|
2017-12-07 06:31:03 +00:00
|
|
|
fov = p_fov;
|
|
|
|
_update_camera_mode();
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
void Camera3D::set_size(real_t p_size) {
|
2019-12-29 03:36:57 +00:00
|
|
|
ERR_FAIL_COND(p_size < 0.1 || p_size > 16384);
|
2017-12-07 06:31:03 +00:00
|
|
|
size = p_size;
|
|
|
|
_update_camera_mode();
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
void Camera3D::set_near(real_t p_near) {
|
2020-12-16 12:40:42 +00:00
|
|
|
near = p_near;
|
2017-12-07 06:31:03 +00:00
|
|
|
_update_camera_mode();
|
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::set_frustum_offset(Vector2 p_offset) {
|
2019-02-19 16:17:02 +00:00
|
|
|
frustum_offset = p_offset;
|
|
|
|
_update_camera_mode();
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
void Camera3D::set_far(real_t p_far) {
|
2020-12-16 12:40:42 +00:00
|
|
|
far = p_far;
|
2017-12-07 06:31:03 +00:00
|
|
|
_update_camera_mode();
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
void Camera3D::set_cull_mask(uint32_t p_layers) {
|
2017-03-05 15:44:50 +00:00
|
|
|
layers = p_layers;
|
2020-03-27 18:21:27 +00:00
|
|
|
RenderingServer::get_singleton()->camera_set_cull_mask(camera, layers);
|
2017-12-07 06:31:03 +00:00
|
|
|
_update_camera_mode();
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
uint32_t Camera3D::get_cull_mask() const {
|
2014-02-10 01:10:30 +00:00
|
|
|
return layers;
|
|
|
|
}
|
|
|
|
|
2021-08-11 23:01:38 +00:00
|
|
|
void Camera3D::set_cull_mask_value(int p_layer_number, bool p_value) {
|
|
|
|
ERR_FAIL_COND_MSG(p_layer_number < 1, "Render layer number must be between 1 and 20 inclusive.");
|
|
|
|
ERR_FAIL_COND_MSG(p_layer_number > 20, "Render layer number must be between 1 and 20 inclusive.");
|
|
|
|
uint32_t mask = get_cull_mask();
|
|
|
|
if (p_value) {
|
|
|
|
mask |= 1 << (p_layer_number - 1);
|
2018-07-29 23:05:16 +00:00
|
|
|
} else {
|
2021-08-11 23:01:38 +00:00
|
|
|
mask &= ~(1 << (p_layer_number - 1));
|
2018-07-29 23:05:16 +00:00
|
|
|
}
|
2021-08-11 23:01:38 +00:00
|
|
|
set_cull_mask(mask);
|
2018-07-29 23:05:16 +00:00
|
|
|
}
|
|
|
|
|
2021-08-11 23:01:38 +00:00
|
|
|
bool Camera3D::get_cull_mask_value(int p_layer_number) const {
|
|
|
|
ERR_FAIL_COND_V_MSG(p_layer_number < 1, false, "Render layer number must be between 1 and 20 inclusive.");
|
|
|
|
ERR_FAIL_COND_V_MSG(p_layer_number > 20, false, "Render layer number must be between 1 and 20 inclusive.");
|
|
|
|
return layers & (1 << (p_layer_number - 1));
|
2018-07-29 23:05:16 +00:00
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Vector<Plane> Camera3D::get_frustum() const {
|
2017-03-05 15:44:50 +00:00
|
|
|
ERR_FAIL_COND_V(!is_inside_world(), Vector<Plane>());
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2016-01-02 20:18:45 +00:00
|
|
|
Size2 viewport_size = get_viewport()->get_visible_rect().size;
|
2014-02-10 01:10:30 +00:00
|
|
|
CameraMatrix cm;
|
2020-05-14 14:41:43 +00:00
|
|
|
if (mode == PROJECTION_PERSPECTIVE) {
|
2017-03-05 15:44:50 +00:00
|
|
|
cm.set_perspective(fov, viewport_size.aspect(), near, far, keep_aspect == KEEP_WIDTH);
|
2020-05-14 14:41:43 +00:00
|
|
|
} else {
|
2017-03-05 15:44:50 +00:00
|
|
|
cm.set_orthogonal(size, viewport_size.aspect(), near, far, keep_aspect == KEEP_WIDTH);
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2014-02-10 01:10:30 +00:00
|
|
|
|
2014-10-03 03:10:51 +00:00
|
|
|
return cm.get_projection_planes(get_camera_transform());
|
2014-02-10 01:10:30 +00:00
|
|
|
}
|
|
|
|
|
2021-04-29 01:14:12 +00:00
|
|
|
bool Camera3D::is_position_in_frustum(const Vector3 &p_position) const {
|
|
|
|
Vector<Plane> frustum = get_frustum();
|
|
|
|
for (int i = 0; i < frustum.size(); i++) {
|
|
|
|
if (frustum[i].is_point_over(p_position)) {
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
void Camera3D::set_v_offset(real_t p_offset) {
|
2017-03-05 15:44:50 +00:00
|
|
|
v_offset = p_offset;
|
2017-01-14 17:03:38 +00:00
|
|
|
_update_camera();
|
2015-01-03 14:06:53 +00:00
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
real_t Camera3D::get_v_offset() const {
|
2015-01-03 14:06:53 +00:00
|
|
|
return v_offset;
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
void Camera3D::set_h_offset(real_t p_offset) {
|
2017-03-05 15:44:50 +00:00
|
|
|
h_offset = p_offset;
|
2015-01-03 14:06:53 +00:00
|
|
|
_update_camera();
|
|
|
|
}
|
|
|
|
|
2021-01-30 00:55:54 +00:00
|
|
|
real_t Camera3D::get_h_offset() const {
|
2015-01-03 14:06:53 +00:00
|
|
|
return h_offset;
|
|
|
|
}
|
|
|
|
|
2020-03-26 21:49:16 +00:00
|
|
|
Vector3 Camera3D::get_doppler_tracked_velocity() const {
|
2017-07-15 04:23:10 +00:00
|
|
|
if (doppler_tracking != DOPPLER_TRACKING_DISABLED) {
|
|
|
|
return velocity_tracker->get_tracked_linear_velocity();
|
|
|
|
} else {
|
|
|
|
return Vector3();
|
|
|
|
}
|
|
|
|
}
|
2020-05-14 12:29:06 +00:00
|
|
|
|
2021-10-03 11:51:25 +00:00
|
|
|
RID Camera3D::get_pyramid_shape_rid() {
|
2021-10-11 14:16:48 +00:00
|
|
|
ERR_FAIL_COND_V_MSG(!is_inside_tree(), RID(), "Camera is not inside scene.");
|
2021-10-03 11:51:25 +00:00
|
|
|
if (pyramid_shape == RID()) {
|
|
|
|
pyramid_shape_points = get_near_plane_points();
|
|
|
|
pyramid_shape = PhysicsServer3D::get_singleton()->convex_polygon_shape_create();
|
|
|
|
PhysicsServer3D::get_singleton()->shape_set_data(pyramid_shape, pyramid_shape_points);
|
2018-08-21 14:48:17 +00:00
|
|
|
|
2021-10-03 11:51:25 +00:00
|
|
|
} else { //check if points changed
|
|
|
|
Vector<Vector3> local_points = get_near_plane_points();
|
2018-08-21 14:48:17 +00:00
|
|
|
|
2021-10-03 11:51:25 +00:00
|
|
|
bool all_equal = true;
|
2018-08-21 14:48:17 +00:00
|
|
|
|
2021-10-03 11:51:25 +00:00
|
|
|
for (int i = 0; i < 5; i++) {
|
|
|
|
if (local_points[i] != pyramid_shape_points[i]) {
|
|
|
|
all_equal = false;
|
|
|
|
break;
|
2018-08-21 14:48:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-03 11:51:25 +00:00
|
|
|
if (!all_equal) {
|
|
|
|
PhysicsServer3D::get_singleton()->shape_set_data(pyramid_shape, local_points);
|
|
|
|
pyramid_shape_points = local_points;
|
2018-08-21 14:48:17 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-10-03 11:51:25 +00:00
|
|
|
return pyramid_shape;
|
2018-08-21 14:48:17 +00:00
|
|
|
}
|
|
|
|
|
2021-10-03 11:51:25 +00:00
|
|
|
Camera3D::Camera3D() {
|
|
|
|
camera = RenderingServer::get_singleton()->camera_create();
|
|
|
|
set_perspective(75.0, 0.05, 4000.0);
|
|
|
|
RenderingServer::get_singleton()->camera_set_cull_mask(camera, layers);
|
|
|
|
//active=false;
|
|
|
|
velocity_tracker.instantiate();
|
|
|
|
set_notify_transform(true);
|
|
|
|
set_disable_scale(true);
|
2018-08-21 14:48:17 +00:00
|
|
|
}
|
|
|
|
|
2021-10-03 11:51:25 +00:00
|
|
|
Camera3D::~Camera3D() {
|
|
|
|
RenderingServer::get_singleton()->free(camera);
|
|
|
|
if (pyramid_shape.is_valid()) {
|
|
|
|
PhysicsServer3D::get_singleton()->free(pyramid_shape);
|
2020-05-14 14:41:43 +00:00
|
|
|
}
|
2018-08-21 14:48:17 +00:00
|
|
|
}
|