godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
4b3d6f04a8
godot/scene/3d/visual_instance_3d.cpp

506 lines
23 KiB
C++
Raw Normal View History

GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
/* visual_instance_3d.cpp */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
Use HTTPS URL for Godot's website in the headers
2017-08-27 12:16:55 +00:00
/* https://godotengine.org */
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
/*************************************************************************/
Update copyright statements to 2022 Happy new year to the wonderful Godot community!
2022-01-03 20:27:34 +00:00
/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md). */
GODOT IS OPEN SOURCE
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. */
/*************************************************************************/
Add missing copyright headers and fix formatting Using `misc/scripts/fix_headers.py` on all Godot files. Some missing header guards were added, and the header inclusion order was fixed in the Bullet module.
2018-01-04 23:50:27 +00:00
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
#include "visual_instance_3d.h"
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
#include "scene/scene_string_names.h"
Discern between virtual and abstract class bindings * Previous "virtual" classes (which can't be instantiated) are not corretly named "abstract". * Added a new "virtual" category for classes, they can't be instantiated from the editor, but can be inherited from script and extensions. * Converted a large amount of classes from "abstract" to "virtual" where it makes sense. Most classes that make sense have been converted. Missing: * Physics servers * VideoStream * Script* classes. which will go in a separate PR due to the complexity involved.
2022-03-10 07:17:38 +00:00
AABB VisualInstance3D::get_aabb() const {
AABB ret;
if (GDVIRTUAL_CALL(_get_aabb, ret)) {
return ret;
}
return AABB();
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
AABB VisualInstance3D::get_transformed_aabb() const {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
return get_global_transform().xform(get_aabb());
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
void VisualInstance3D::_update_visibility() {
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
if (!is_inside_tree()) {
-Conversion of most properties to a simpler syntax, easier to use by script -Modified help to display properties GDScript can still not make use of them, though.
2017-01-04 04:16:14 +00:00
return;
Style: Enforce braces around if blocks and loops Using clang-tidy's `readability-braces-around-statements`. https://clang.llvm.org/extra/clang-tidy/checks/readability-braces-around-statements.html
2020-05-14 14:41:43 +00:00
}
-Conversion of most properties to a simpler syntax, easier to use by script -Modified help to display properties GDScript can still not make use of them, though.
2017-01-04 04:16:14 +00:00
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
RS::get_singleton()->instance_set_visible(get_instance(), is_visible_in_tree());
-Conversion of most properties to a simpler syntax, easier to use by script -Modified help to display properties GDScript can still not make use of them, though.
2017-01-04 04:16:14 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
void VisualInstance3D::_notification(int p_what) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
switch (p_what) {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case NOTIFICATION_ENTER_WORLD: {
Change non-existent World to World3D
2020-04-18 09:00:51 +00:00
ERR_FAIL_COND(get_world_3d().is_null());
RenderingServer::get_singleton()->instance_set_scenario(instance, get_world_3d()->get_scenario());
-Conversion of most properties to a simpler syntax, easier to use by script -Modified help to display properties GDScript can still not make use of them, though.
2017-01-04 04:16:14 +00:00
_update_visibility();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
Use `switch` consistently in `_notification` (`scene` folder)
2022-02-15 17:06:48 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case NOTIFICATION_TRANSFORM_CHANGED: {
Rename Transform to Transform3D in core
2020-10-17 05:08:21 +00:00
Transform3D gt = get_global_transform();
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
RenderingServer::get_singleton()->instance_set_transform(instance, gt);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
Use `switch` consistently in `_notification` (`scene` folder)
2022-02-15 17:06:48 +00:00
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
case NOTIFICATION_EXIT_WORLD: {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
RenderingServer::get_singleton()->instance_set_scenario(instance, RID());
RenderingServer::get_singleton()->instance_attach_skeleton(instance, RID());
-Conversion of most properties to a simpler syntax, easier to use by script -Modified help to display properties GDScript can still not make use of them, though.
2017-01-04 04:16:14 +00:00
} break;
Use `switch` consistently in `_notification` (`scene` folder)
2022-02-15 17:06:48 +00:00
-Conversion of most properties to a simpler syntax, easier to use by script -Modified help to display properties GDScript can still not make use of them, though.
2017-01-04 04:16:14 +00:00
case NOTIFICATION_VISIBILITY_CHANGED: {
_update_visibility();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
} break;
}
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
RID VisualInstance3D::get_instance() const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return instance;
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
RID VisualInstance3D::_get_visual_instance_rid() const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return instance;
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
void VisualInstance3D::set_layer_mask(uint32_t p_mask) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
layers = p_mask;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
RenderingServer::get_singleton()->instance_set_layer_mask(instance, p_mask);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
uint32_t VisualInstance3D::get_layer_mask() const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return layers;
}
Uniformize layer names, script methods and documentation - Back to 1-based layer names to make it clearer in editor UI - Layer bit accessors are renamed to layer value and 1-based too - Uniform errors and documentation in render and physics - Fix a few remaining collision_layer used in place of collision_mask
2021-08-11 23:01:38 +00:00
void VisualInstance3D::set_layer_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_layer_mask();
if (p_value) {
mask |= 1 << (p_layer_number - 1);
Add extra functions to toggle bits in visualinstance and camera, same as physics. Helps with #6685
2018-07-29 23:05:16 +00:00
} else {
Uniformize layer names, script methods and documentation - Back to 1-based layer names to make it clearer in editor UI - Layer bit accessors are renamed to layer value and 1-based too - Uniform errors and documentation in render and physics - Fix a few remaining collision_layer used in place of collision_mask
2021-08-11 23:01:38 +00:00
mask &= ~(1 << (p_layer_number - 1));
Add extra functions to toggle bits in visualinstance and camera, same as physics. Helps with #6685
2018-07-29 23:05:16 +00:00
}
Uniformize layer names, script methods and documentation - Back to 1-based layer names to make it clearer in editor UI - Layer bit accessors are renamed to layer value and 1-based too - Uniform errors and documentation in render and physics - Fix a few remaining collision_layer used in place of collision_mask
2021-08-11 23:01:38 +00:00
set_layer_mask(mask);
Add extra functions to toggle bits in visualinstance and camera, same as physics. Helps with #6685
2018-07-29 23:05:16 +00:00
}
Uniformize layer names, script methods and documentation - Back to 1-based layer names to make it clearer in editor UI - Layer bit accessors are renamed to layer value and 1-based too - Uniform errors and documentation in render and physics - Fix a few remaining collision_layer used in place of collision_mask
2021-08-11 23:01:38 +00:00
bool VisualInstance3D::get_layer_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));
Add extra functions to toggle bits in visualinstance and camera, same as physics. Helps with #6685
2018-07-29 23:05:16 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
void VisualInstance3D::_bind_methods() {
ClassDB::bind_method(D_METHOD("_get_visual_instance_rid"), &VisualInstance3D::_get_visual_instance_rid);
ClassDB::bind_method(D_METHOD("set_base", "base"), &VisualInstance3D::set_base);
ClassDB::bind_method(D_METHOD("get_base"), &VisualInstance3D::get_base);
ClassDB::bind_method(D_METHOD("get_instance"), &VisualInstance3D::get_instance);
ClassDB::bind_method(D_METHOD("set_layer_mask", "mask"), &VisualInstance3D::set_layer_mask);
ClassDB::bind_method(D_METHOD("get_layer_mask"), &VisualInstance3D::get_layer_mask);
Uniformize layer names, script methods and documentation - Back to 1-based layer names to make it clearer in editor UI - Layer bit accessors are renamed to layer value and 1-based too - Uniform errors and documentation in render and physics - Fix a few remaining collision_layer used in place of collision_mask
2021-08-11 23:01:38 +00:00
ClassDB::bind_method(D_METHOD("set_layer_mask_value", "layer_number", "value"), &VisualInstance3D::set_layer_mask_value);
ClassDB::bind_method(D_METHOD("get_layer_mask_value", "layer_number"), &VisualInstance3D::get_layer_mask_value);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
ClassDB::bind_method(D_METHOD("get_transformed_aabb"), &VisualInstance3D::get_transformed_aabb);
expose GeometryInstance.get_aabb() etc fixes #6587 expose ``GeometryInstance.get_aabb();`` to gdscript expose ``VisualInstance.get_transformed_aabb();`` to gdscript and debug ``ImmediateGeometry::add_vertex()``;
2016-09-22 21:01:44 +00:00
Discern between virtual and abstract class bindings * Previous "virtual" classes (which can't be instantiated) are not corretly named "abstract". * Added a new "virtual" category for classes, they can't be instantiated from the editor, but can be inherited from script and extensions. * Converted a large amount of classes from "abstract" to "virtual" where it makes sense. Most classes that make sense have been converted. Missing: * Physics servers * VideoStream * Script* classes. which will go in a separate PR due to the complexity involved.
2022-03-10 07:17:38 +00:00
GDVIRTUAL_BIND(_get_aabb);
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "layers", PROPERTY_HINT_LAYERS_3D_RENDER), "set_layer_mask", "get_layer_mask");
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
void VisualInstance3D::set_base(const RID &p_base) {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
RenderingServer::get_singleton()->instance_set_base(instance, p_base);
Added bindings for methods related to obtaining base an instance from VisualInstance
2019-04-22 22:27:30 +00:00
base = p_base;
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
RID VisualInstance3D::get_base() const {
Added bindings for methods related to obtaining base an instance from VisualInstance
2019-04-22 22:27:30 +00:00
return base;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
VisualInstance3D::VisualInstance3D() {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
instance = RenderingServer::get_singleton()->instance_create();
RenderingServer::get_singleton()->instance_attach_object_instance_id(instance, get_instance_id());
Must now register with set_transform_notify() to get NOTIFICATION_TRANSFORM_CHANGED
2017-01-12 23:35:46 +00:00
set_notify_transform(true);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
VisualInstance3D::~VisualInstance3D() {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
RenderingServer::get_singleton()->free(instance);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
void GeometryInstance3D::set_material_override(const Ref<Material> &p_material) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
material_override = p_material;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
RS::get_singleton()->instance_geometry_set_material_override(get_instance(), p_material.is_valid() ? p_material->get_rid() : RID());
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
Ref<Material> GeometryInstance3D::get_material_override() const {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
return material_override;
}
Added material_overlay property to MeshInstance3D Applying overlay materials into multi-surface meshes currently requires adding a next pass material to all the surfaces, which might be cumbersome when the material is to be applied to a range of different geometries. This also makes it not trivial to use AnimationPlayer to control the material in case of visual effects. The material_override property is not an option as it works replacing the active material for the surfaces, not adding a new pass. This commit adds the material_overlay property to GeometryInstance3D (and therefore MeshInstance3D), having the same reach as material_override (that is, all surfaces) but adding a new material pass on top of the active materials, instead of replacing them.
2021-09-25 18:40:26 +00:00
void GeometryInstance3D::set_material_overlay(const Ref<Material> &p_material) {
material_overlay = p_material;
RS::get_singleton()->instance_geometry_set_material_overlay(get_instance(), p_material.is_valid() ? p_material->get_rid() : RID());
}
Ref<Material> GeometryInstance3D::get_material_overlay() const {
return material_overlay;
}
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
void GeometryInstance3D::set_transparecy(float p_transparency) {
transparency = CLAMP(p_transparency, 0.0f, 1.0f);
RS::get_singleton()->instance_geometry_set_transparency(get_instance(), transparency);
}
float GeometryInstance3D::get_transparency() const {
return transparency;
}
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
void GeometryInstance3D::set_visibility_range_begin(float p_dist) {
visibility_range_begin = p_dist;
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
RS::get_singleton()->instance_geometry_set_visibility_range(get_instance(), visibility_range_begin, visibility_range_end, visibility_range_begin_margin, visibility_range_end_margin, (RS::VisibilityRangeFadeMode)visibility_range_fade_mode);
Add node configuration warning for GeometryInstance3D distance
2021-07-28 17:33:14 +00:00
update_configuration_warnings();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
float GeometryInstance3D::get_visibility_range_begin() const {
return visibility_range_begin;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
void GeometryInstance3D::set_visibility_range_end(float p_dist) {
visibility_range_end = p_dist;
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
RS::get_singleton()->instance_geometry_set_visibility_range(get_instance(), visibility_range_begin, visibility_range_end, visibility_range_begin_margin, visibility_range_end_margin, (RS::VisibilityRangeFadeMode)visibility_range_fade_mode);
Add node configuration warning for GeometryInstance3D distance
2021-07-28 17:33:14 +00:00
update_configuration_warnings();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
float GeometryInstance3D::get_visibility_range_end() const {
return visibility_range_end;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
void GeometryInstance3D::set_visibility_range_begin_margin(float p_dist) {
visibility_range_begin_margin = p_dist;
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
RS::get_singleton()->instance_geometry_set_visibility_range(get_instance(), visibility_range_begin, visibility_range_end, visibility_range_begin_margin, visibility_range_end_margin, (RS::VisibilityRangeFadeMode)visibility_range_fade_mode);
Emit node configuration warnings for GeometryInstance3D distance fade The visibility range begin/end margin properties must be set above 0.0 for the fade transition to be visible.
2021-11-26 20:46:32 +00:00
update_configuration_warnings();
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 19:33:42 +00:00
}
Light Baker! -=-=-=-=-=-= -Support for lightmap baker, have fun figuring out how it works before tutorial is published.
2014-06-11 13:41:03 +00:00
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
float GeometryInstance3D::get_visibility_range_begin_margin() const {
return visibility_range_begin_margin;
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Light Baker! -=-=-=-=-=-= -Support for lightmap baker, have fun figuring out how it works before tutorial is published.
2014-06-11 13:41:03 +00:00
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
void GeometryInstance3D::set_visibility_range_end_margin(float p_dist) {
visibility_range_end_margin = p_dist;
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
RS::get_singleton()->instance_geometry_set_visibility_range(get_instance(), visibility_range_begin, visibility_range_end, visibility_range_begin_margin, visibility_range_end_margin, (RS::VisibilityRangeFadeMode)visibility_range_fade_mode);
Emit node configuration warnings for GeometryInstance3D distance fade The visibility range begin/end margin properties must be set above 0.0 for the fade transition to be visible.
2021-11-26 20:46:32 +00:00
update_configuration_warnings();
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Light Baker! -=-=-=-=-=-= -Support for lightmap baker, have fun figuring out how it works before tutorial is published.
2014-06-11 13:41:03 +00:00
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
float GeometryInstance3D::get_visibility_range_end_margin() const {
return visibility_range_end_margin;
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 19:33:42 +00:00
}
Light Baker! -=-=-=-=-=-= -Support for lightmap baker, have fun figuring out how it works before tutorial is published.
2014-06-11 13:41:03 +00:00
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
void GeometryInstance3D::set_visibility_range_fade_mode(VisibilityRangeFadeMode p_mode) {
visibility_range_fade_mode = p_mode;
RS::get_singleton()->instance_geometry_set_visibility_range(get_instance(), visibility_range_begin, visibility_range_end, visibility_range_begin_margin, visibility_range_end_margin, (RS::VisibilityRangeFadeMode)visibility_range_fade_mode);
Emit node configuration warnings for GeometryInstance3D distance fade The visibility range begin/end margin properties must be set above 0.0 for the fade transition to be visible.
2021-11-26 20:46:32 +00:00
update_configuration_warnings();
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
}
GeometryInstance3D::VisibilityRangeFadeMode GeometryInstance3D::get_visibility_range_fade_mode() const {
return visibility_range_fade_mode;
}
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 02:52:00 +00:00
const StringName *GeometryInstance3D::_instance_uniform_get_remap(const StringName p_name) const {
StringName *r = instance_uniform_property_remap.getptr(p_name);
if (!r) {
String s = p_name;
if (s.begins_with("shader_params/")) {
StringName name = s.replace("shader_params/", "");
instance_uniform_property_remap[p_name] = name;
return instance_uniform_property_remap.getptr(p_name);
}
return nullptr;
}
return r;
}
bool GeometryInstance3D::_set(const StringName &p_name, const Variant &p_value) {
const StringName *r = _instance_uniform_get_remap(p_name);
if (r) {
set_shader_instance_uniform(*r, p_value);
return true;
}
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 12:34:23 +00:00
#ifndef DISABLE_DEPRECATED
if (p_name == SceneStringNames::get_singleton()->use_in_baked_light && bool(p_value)) {
Rename and reorder bake mode properties for consistency The order now goes from least to most computationally expensive: - Disabled - Static - Dynamic
2021-11-26 16:47:37 +00:00
set_gi_mode(GI_MODE_STATIC);
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 12:34:23 +00:00
return true;
}
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 02:52:00 +00:00
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 12:34:23 +00:00
if (p_name == SceneStringNames::get_singleton()->use_dynamic_gi && bool(p_value)) {
set_gi_mode(GI_MODE_DYNAMIC);
return true;
}
#endif
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 02:52:00 +00:00
return false;
}
bool GeometryInstance3D::_get(const StringName &p_name, Variant &r_ret) const {
const StringName *r = _instance_uniform_get_remap(p_name);
if (r) {
r_ret = get_shader_instance_uniform(*r);
return true;
}
return false;
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 02:52:00 +00:00
void GeometryInstance3D::_get_property_list(List<PropertyInfo> *p_list) const {
List<PropertyInfo> pinfo;
RS::get_singleton()->instance_geometry_get_shader_parameter_list(get_instance(), &pinfo);
Use C++ iterators for Lists in many situations
2021-07-16 03:45:57 +00:00
for (PropertyInfo &pi : pinfo) {
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 02:52:00 +00:00
bool has_def_value = false;
Variant def_value = RS::get_singleton()->instance_geometry_get_shader_parameter_default_value(get_instance(), pi.name);
if (def_value.get_type() != Variant::NIL) {
has_def_value = true;
}
if (instance_uniforms.has(pi.name)) {
Use PROPERTY_USAGE_NONE instead of 0 for no property usage Also use const more often.
2021-07-01 01:24:34 +00:00
pi.usage = PROPERTY_USAGE_EDITOR | PROPERTY_USAGE_STORAGE | (has_def_value ? (PROPERTY_USAGE_CHECKABLE | PROPERTY_USAGE_CHECKED) : PROPERTY_USAGE_NONE);
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 02:52:00 +00:00
} else {
Use PROPERTY_USAGE_NONE instead of 0 for no property usage Also use const more often.
2021-07-01 01:24:34 +00:00
pi.usage = PROPERTY_USAGE_EDITOR | (has_def_value ? PROPERTY_USAGE_CHECKABLE : PROPERTY_USAGE_NONE); //do not save if not changed
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 02:52:00 +00:00
}
pi.name = "shader_params/" + pi.name;
p_list->push_back(pi);
}
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
void GeometryInstance3D::set_cast_shadows_setting(ShadowCastingSetting p_shadow_casting_setting) {
Added extra controls to GeometryInstances to control how they should cast shadows: double-sided and shadows only. Conflicts: servers/visual/visual_server_raster.h
2016-03-07 23:00:55 +00:00
shadow_casting_setting = p_shadow_casting_setting;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
RS::get_singleton()->instance_geometry_set_cast_shadows_setting(get_instance(), (RS::ShadowCastingSetting)p_shadow_casting_setting);
Added extra controls to GeometryInstances to control how they should cast shadows: double-sided and shadows only. Conflicts: servers/visual/visual_server_raster.h
2016-03-07 23:00:55 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
GeometryInstance3D::ShadowCastingSetting GeometryInstance3D::get_cast_shadows_setting() const {
Added extra controls to GeometryInstances to control how they should cast shadows: double-sided and shadows only. Conflicts: servers/visual/visual_server_raster.h
2016-03-07 23:00:55 +00:00
return shadow_casting_setting;
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
void GeometryInstance3D::set_extra_cull_margin(float p_margin) {
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND(p_margin < 0);
extra_cull_margin = p_margin;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
RS::get_singleton()->instance_set_extra_visibility_margin(get_instance(), extra_cull_margin);
support for 2D shadow casters Added support for 2D shadow casters. *DANGER* Shaders in CanvasItem CHANGED, if you are using shader in a CanvasItem and pull this, you will lose them. Shaders now work through a 2D material system similar to 3D. If you don't want to lose the 2D shader code, save the shader as a .shd, then create a material in CanvasItem and re-assign the shader.
2015-03-02 03:54:10 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
float GeometryInstance3D::get_extra_cull_margin() const {
support for 2D shadow casters Added support for 2D shadow casters. *DANGER* Shaders in CanvasItem CHANGED, if you are using shader in a CanvasItem and pull this, you will lose them. Shaders now work through a 2D material system similar to 3D. If you don't want to lose the 2D shader code, save the shader as a .shd, then create a material in CanvasItem and re-assign the shader.
2015-03-02 03:54:10 +00:00
return extra_cull_margin;
}
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Implement automatic LOD (Level of Detail) -Happens on import by default for all models -Just works (tm) -Biasing can be later adjusted per node or per viewport (as well as globally) -Disabled AABB.get_support test because its broken
2020-12-17 18:56:59 +00:00
void GeometryInstance3D::set_lod_bias(float p_bias) {
ERR_FAIL_COND(p_bias < 0.0);
lod_bias = p_bias;
RS::get_singleton()->instance_geometry_set_lod_bias(get_instance(), lod_bias);
}
float GeometryInstance3D::get_lod_bias() const {
return lod_bias;
}
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 02:52:00 +00:00
void GeometryInstance3D::set_shader_instance_uniform(const StringName &p_uniform, const Variant &p_value) {
if (p_value.get_type() == Variant::NIL) {
Variant def_value = RS::get_singleton()->instance_geometry_get_shader_parameter_default_value(get_instance(), p_uniform);
RS::get_singleton()->instance_geometry_set_shader_parameter(get_instance(), p_uniform, def_value);
instance_uniforms.erase(p_value);
} else {
instance_uniforms[p_uniform] = p_value;
Fix Command Queue Crash * No longer allow sending an object (texture) to the server as material parameter * Keep a parameter cache locally in ShaderMaterial
2021-07-06 01:40:29 +00:00
if (p_value.get_type() == Variant::OBJECT) {
RID tex_id = p_value;
RS::get_singleton()->instance_geometry_set_shader_parameter(get_instance(), p_uniform, tex_id);
} else {
RS::get_singleton()->instance_geometry_set_shader_parameter(get_instance(), p_uniform, p_value);
}
Implement global and per instance shader uniforms. Adds two keywords to shader language for uniforms: -'global' -'instance' This allows them to reference values outside the material.
2020-04-17 02:52:00 +00:00
}
}
Variant GeometryInstance3D::get_shader_instance_uniform(const StringName &p_uniform) const {
return RS::get_singleton()->instance_geometry_get_shader_parameter(get_instance(), p_uniform);
}
Style: Enforce separation line between function definitions I couldn't find a tool that enforces it, so I went the manual route: ``` find -name "thirdparty" -prune \ -o -name "*.cpp" -o -name "*.h" -o -name "*.m" -o -name "*.mm" \ -o -name "*.glsl" > files perl -0777 -pi -e 's/\n}\n([^#])/\n}\n\n\1/g' $(cat files) misc/scripts/fix_style.sh -c ``` This adds a newline after all `}` on the first column, unless they are followed by `#` (typically `#endif`). This leads to having lots of places with two lines between function/class definitions, but clang-format then fixes it as we enforce max one line of separation. This doesn't fix potential occurrences of function definitions which are indented (e.g. for a helper class defined in a .cpp), but it's better than nothing. Also can't be made to run easily on CI/hooks so we'll have to be careful with new code. Part of #33027.
2020-05-14 12:29:06 +00:00
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
void GeometryInstance3D::set_custom_aabb(AABB aabb) {
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 18:21:27 +00:00
RS::get_singleton()->instance_set_custom_aabb(get_instance(), aabb);
Exposed custom AABB setter on GeometryInstance
2019-01-31 16:54:00 +00:00
}
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 12:34:23 +00:00
void GeometryInstance3D::set_lightmap_scale(LightmapScale p_scale) {
ERR_FAIL_INDEX(p_scale, LIGHTMAP_SCALE_MAX);
lightmap_scale = p_scale;
}
GeometryInstance3D::LightmapScale GeometryInstance3D::get_lightmap_scale() const {
return lightmap_scale;
}
void GeometryInstance3D::set_gi_mode(GIMode p_mode) {
switch (p_mode) {
case GI_MODE_DISABLED: {
RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_DYNAMIC_GI, false);
} break;
Rename and reorder bake mode properties for consistency The order now goes from least to most computationally expensive: - Disabled - Static - Dynamic
2021-11-26 16:47:37 +00:00
case GI_MODE_STATIC: {
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 12:34:23 +00:00
RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_BAKED_LIGHT, true);
RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_DYNAMIC_GI, false);
} break;
case GI_MODE_DYNAMIC: {
RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_BAKED_LIGHT, false);
RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_USE_DYNAMIC_GI, true);
} break;
}
gi_mode = p_mode;
}
GeometryInstance3D::GIMode GeometryInstance3D::get_gi_mode() const {
return gi_mode;
}
Implement occlusion culling Added an occlusion culling system with support for static occluder meshes. It can be enabled via `Project Settings > Rendering > Occlusion Culling > Use Occlusion Culling`. Occluders are defined via the new `Occluder3D` resource and instanced using the new `OccluderInstance3D` node. The occluders can also be automatically baked from a scene using the built-in editor plugin.
2021-04-20 16:40:24 +00:00
void GeometryInstance3D::set_ignore_occlusion_culling(bool p_enabled) {
ignore_occlusion_culling = p_enabled;
RS::get_singleton()->instance_geometry_set_flag(get_instance(), RS::INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING, ignore_occlusion_culling);
}
bool GeometryInstance3D::is_ignoring_occlusion_culling() {
return ignore_occlusion_culling;
}
Add node configuration warning for GeometryInstance3D distance
2021-07-28 17:33:14 +00:00
TypedArray<String> GeometryInstance3D::get_configuration_warnings() const {
TypedArray<String> warnings = Node::get_configuration_warnings();
if (!Math::is_zero_approx(visibility_range_end) && visibility_range_end <= visibility_range_begin) {
String: Remove TTR and DTR defines in non-tools build This ensures we don't use TTR in runtime code, as it's specifically meant to source translations for the editor.
2022-03-28 13:24:14 +00:00
warnings.push_back(RTR("The GeometryInstance3D visibility range's End distance is set to a non-zero value, but is lower than the Begin distance.\nThis means the GeometryInstance3D will never be visible.\nTo resolve this, set the End distance to 0 or to a value greater than the Begin distance."));
Add node configuration warning for GeometryInstance3D distance
2021-07-28 17:33:14 +00:00
}
Emit node configuration warnings for GeometryInstance3D distance fade The visibility range begin/end margin properties must be set above 0.0 for the fade transition to be visible.
2021-11-26 20:46:32 +00:00
if ((visibility_range_fade_mode == VISIBILITY_RANGE_FADE_SELF || visibility_range_fade_mode == VISIBILITY_RANGE_FADE_DEPENDENCIES) && !Math::is_zero_approx(visibility_range_begin) && Math::is_zero_approx(visibility_range_begin_margin)) {
String: Remove TTR and DTR defines in non-tools build This ensures we don't use TTR in runtime code, as it's specifically meant to source translations for the editor.
2022-03-28 13:24:14 +00:00
warnings.push_back(RTR("The GeometryInstance3D is configured to fade in smoothly over distance, but the fade transition distance is set to 0.\nTo resolve this, increase Visibility Range Begin Margin above 0."));
Emit node configuration warnings for GeometryInstance3D distance fade The visibility range begin/end margin properties must be set above 0.0 for the fade transition to be visible.
2021-11-26 20:46:32 +00:00
}
if ((visibility_range_fade_mode == VISIBILITY_RANGE_FADE_SELF || visibility_range_fade_mode == VISIBILITY_RANGE_FADE_DEPENDENCIES) && !Math::is_zero_approx(visibility_range_end) && Math::is_zero_approx(visibility_range_end_margin)) {
String: Remove TTR and DTR defines in non-tools build This ensures we don't use TTR in runtime code, as it's specifically meant to source translations for the editor.
2022-03-28 13:24:14 +00:00
warnings.push_back(RTR("The GeometryInstance3D is configured to fade out smoothly over distance, but the fade transition distance is set to 0.\nTo resolve this, increase Visibility Range End Margin above 0."));
Emit node configuration warnings for GeometryInstance3D distance fade The visibility range begin/end margin properties must be set above 0.0 for the fade transition to be visible.
2021-11-26 20:46:32 +00:00
}
Add node configuration warning for GeometryInstance3D distance
2021-07-28 17:33:14 +00:00
return warnings;
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
void GeometryInstance3D::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_material_override", "material"), &GeometryInstance3D::set_material_override);
ClassDB::bind_method(D_METHOD("get_material_override"), &GeometryInstance3D::get_material_override);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Added material_overlay property to MeshInstance3D Applying overlay materials into multi-surface meshes currently requires adding a next pass material to all the surfaces, which might be cumbersome when the material is to be applied to a range of different geometries. This also makes it not trivial to use AnimationPlayer to control the material in case of visual effects. The material_override property is not an option as it works replacing the active material for the surfaces, not adding a new pass. This commit adds the material_overlay property to GeometryInstance3D (and therefore MeshInstance3D), having the same reach as material_override (that is, all surfaces) but adding a new material pass on top of the active materials, instead of replacing them.
2021-09-25 18:40:26 +00:00
ClassDB::bind_method(D_METHOD("set_material_overlay", "material"), &GeometryInstance3D::set_material_overlay);
ClassDB::bind_method(D_METHOD("get_material_overlay"), &GeometryInstance3D::get_material_overlay);
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
ClassDB::bind_method(D_METHOD("set_cast_shadows_setting", "shadow_casting_setting"), &GeometryInstance3D::set_cast_shadows_setting);
ClassDB::bind_method(D_METHOD("get_cast_shadows_setting"), &GeometryInstance3D::get_cast_shadows_setting);
Added extra controls to GeometryInstances to control how they should cast shadows: double-sided and shadows only. Conflicts: servers/visual/visual_server_raster.h
2016-03-07 23:00:55 +00:00
Implement occlusion culling Added an occlusion culling system with support for static occluder meshes. It can be enabled via `Project Settings > Rendering > Occlusion Culling > Use Occlusion Culling`. Occluders are defined via the new `Occluder3D` resource and instanced using the new `OccluderInstance3D` node. The occluders can also be automatically baked from a scene using the built-in editor plugin.
2021-04-20 16:40:24 +00:00
ClassDB::bind_method(D_METHOD("set_lod_bias", "bias"), &GeometryInstance3D::set_lod_bias);
ClassDB::bind_method(D_METHOD("get_lod_bias"), &GeometryInstance3D::get_lod_bias);
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
ClassDB::bind_method(D_METHOD("set_transparency", "transparency"), &GeometryInstance3D::set_transparecy);
ClassDB::bind_method(D_METHOD("get_transparency"), &GeometryInstance3D::get_transparency);
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
ClassDB::bind_method(D_METHOD("set_visibility_range_end_margin", "distance"), &GeometryInstance3D::set_visibility_range_end_margin);
ClassDB::bind_method(D_METHOD("get_visibility_range_end_margin"), &GeometryInstance3D::get_visibility_range_end_margin);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 19:33:42 +00:00
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
ClassDB::bind_method(D_METHOD("set_visibility_range_end", "distance"), &GeometryInstance3D::set_visibility_range_end);
ClassDB::bind_method(D_METHOD("get_visibility_range_end"), &GeometryInstance3D::get_visibility_range_end);
Begining of GLES3 renderer: -Most 2D drawing is implemented -Missing shaders -Missing all 3D -Editor needs to be set on update always to be used, otherwise it does not refresh -Large parts of editor not working
2016-10-03 19:33:42 +00:00
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
ClassDB::bind_method(D_METHOD("set_visibility_range_begin_margin", "distance"), &GeometryInstance3D::set_visibility_range_begin_margin);
ClassDB::bind_method(D_METHOD("get_visibility_range_begin_margin"), &GeometryInstance3D::get_visibility_range_begin_margin);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
ClassDB::bind_method(D_METHOD("set_visibility_range_begin", "distance"), &GeometryInstance3D::set_visibility_range_begin);
ClassDB::bind_method(D_METHOD("get_visibility_range_begin"), &GeometryInstance3D::get_visibility_range_begin);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
ClassDB::bind_method(D_METHOD("set_visibility_range_fade_mode", "mode"), &GeometryInstance3D::set_visibility_range_fade_mode);
ClassDB::bind_method(D_METHOD("get_visibility_range_fade_mode"), &GeometryInstance3D::get_visibility_range_fade_mode);
Implement occlusion culling Added an occlusion culling system with support for static occluder meshes. It can be enabled via `Project Settings > Rendering > Occlusion Culling > Use Occlusion Culling`. Occluders are defined via the new `Occluder3D` resource and instanced using the new `OccluderInstance3D` node. The occluders can also be automatically baked from a scene using the built-in editor plugin.
2021-04-20 16:40:24 +00:00
ClassDB::bind_method(D_METHOD("set_shader_instance_uniform", "uniform", "value"), &GeometryInstance3D::set_shader_instance_uniform);
ClassDB::bind_method(D_METHOD("get_shader_instance_uniform", "uniform"), &GeometryInstance3D::get_shader_instance_uniform);
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
ClassDB::bind_method(D_METHOD("set_extra_cull_margin", "margin"), &GeometryInstance3D::set_extra_cull_margin);
ClassDB::bind_method(D_METHOD("get_extra_cull_margin"), &GeometryInstance3D::get_extra_cull_margin);
support for 2D shadow casters Added support for 2D shadow casters. *DANGER* Shaders in CanvasItem CHANGED, if you are using shader in a CanvasItem and pull this, you will lose them. Shaders now work through a 2D material system similar to 3D. If you don't want to lose the 2D shader code, save the shader as a .shd, then create a material in CanvasItem and re-assign the shader.
2015-03-02 03:54:10 +00:00
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 12:34:23 +00:00
ClassDB::bind_method(D_METHOD("set_lightmap_scale", "scale"), &GeometryInstance3D::set_lightmap_scale);
ClassDB::bind_method(D_METHOD("get_lightmap_scale"), &GeometryInstance3D::get_lightmap_scale);
ClassDB::bind_method(D_METHOD("set_gi_mode", "mode"), &GeometryInstance3D::set_gi_mode);
ClassDB::bind_method(D_METHOD("get_gi_mode"), &GeometryInstance3D::get_gi_mode);
Implement occlusion culling Added an occlusion culling system with support for static occluder meshes. It can be enabled via `Project Settings > Rendering > Occlusion Culling > Use Occlusion Culling`. Occluders are defined via the new `Occluder3D` resource and instanced using the new `OccluderInstance3D` node. The occluders can also be automatically baked from a scene using the built-in editor plugin.
2021-04-20 16:40:24 +00:00
ClassDB::bind_method(D_METHOD("set_ignore_occlusion_culling", "ignore_culling"), &GeometryInstance3D::set_ignore_occlusion_culling);
ClassDB::bind_method(D_METHOD("is_ignoring_occlusion_culling"), &GeometryInstance3D::is_ignoring_occlusion_culling);
Implement automatic LOD (Level of Detail) -Happens on import by default for all models -Just works (tm) -Biasing can be later adjusted per node or per viewport (as well as globally) -Disabled AABB.get_support test because its broken
2020-12-17 18:56:59 +00:00
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
ClassDB::bind_method(D_METHOD("set_custom_aabb", "aabb"), &GeometryInstance3D::set_custom_aabb);
Exposed custom AABB setter on GeometryInstance
2019-01-31 16:54:00 +00:00
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
ClassDB::bind_method(D_METHOD("get_aabb"), &GeometryInstance3D::get_aabb);
expose GeometryInstance.get_aabb() etc fixes #6587 expose ``GeometryInstance.get_aabb();`` to gdscript expose ``VisualInstance.get_transformed_aabb();`` to gdscript and debug ``ImmediateGeometry::add_vertex()``;
2016-09-22 21:01:44 +00:00
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
ADD_GROUP("Geometry", "");
Allow using ORMMaterial3D by using BaseMaterial3D as a resource hint Previously, only StandardMaterial3D could be defined as an alternative to ShaderMaterial. This also reorders the CanvasItemMaterial property hints to follow alphabetical order (which is enforced by the inspector).
2021-07-04 15:49:36 +00:00
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material_override", PROPERTY_HINT_RESOURCE_TYPE, "BaseMaterial3D,ShaderMaterial", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_DEFERRED_SET_RESOURCE), "set_material_override", "get_material_override");
Added material_overlay property to MeshInstance3D Applying overlay materials into multi-surface meshes currently requires adding a next pass material to all the surfaces, which might be cumbersome when the material is to be applied to a range of different geometries. This also makes it not trivial to use AnimationPlayer to control the material in case of visual effects. The material_override property is not an option as it works replacing the active material for the surfaces, not adding a new pass. This commit adds the material_overlay property to GeometryInstance3D (and therefore MeshInstance3D), having the same reach as material_override (that is, all surfaces) but adding a new material pass on top of the active materials, instead of replacing them.
2021-09-25 18:40:26 +00:00
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material_overlay", PROPERTY_HINT_RESOURCE_TYPE, "BaseMaterial3D,ShaderMaterial", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_DEFERRED_SET_RESOURCE), "set_material_overlay", "get_material_overlay");
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "transparency", PROPERTY_HINT_RANGE, "0.0,1.0,0.01"), "set_transparency", "get_transparency");
Remove use of _SCS from ADD_METHOD This saves typing and is a step towards fixing #56
2017-02-12 00:11:37 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "cast_shadow", PROPERTY_HINT_ENUM, "Off,On,Double-Sided,Shadows Only"), "set_cast_shadows_setting", "get_cast_shadows_setting");
Use suffixes for units in nodes and resources
2021-12-03 00:09:19 +00:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "extra_cull_margin", PROPERTY_HINT_RANGE, "0,16384,0.01,suffix:m"), "set_extra_cull_margin", "get_extra_cull_margin");
Implement automatic LOD (Level of Detail) -Happens on import by default for all models -Just works (tm) -Biasing can be later adjusted per node or per viewport (as well as globally) -Disabled AABB.get_support test because its broken
2020-12-17 18:56:59 +00:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "lod_bias", PROPERTY_HINT_RANGE, "0.001,128,0.001"), "set_lod_bias", "get_lod_bias");
Implement occlusion culling Added an occlusion culling system with support for static occluder meshes. It can be enabled via `Project Settings > Rendering > Occlusion Culling > Use Occlusion Culling`. Occluders are defined via the new `Occluder3D` resource and instanced using the new `OccluderInstance3D` node. The occluders can also be automatically baked from a scene using the built-in editor plugin.
2021-04-20 16:40:24 +00:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "ignore_occlusion_culling"), "set_ignore_occlusion_culling", "is_ignoring_occlusion_culling");
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 12:34:23 +00:00
ADD_GROUP("Global Illumination", "gi_");
Rename and reorder bake mode properties for consistency The order now goes from least to most computationally expensive: - Disabled - Static - Dynamic
2021-11-26 16:47:37 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "gi_mode", PROPERTY_HINT_ENUM, "Disabled,Static (VoxelGI/SDFGI/LightmapGI),Dynamic (VoxelGI only)"), "set_gi_mode", "get_gi_mode");
Use the Unicode multiplication symbol where relevant
2021-08-12 19:45:33 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "gi_lightmap_scale", PROPERTY_HINT_ENUM, String::utf8("1×,2×,4×,8×")), "set_lightmap_scale", "get_lightmap_scale");
A Whole New World (clang-format edition) I can show you the code Pretty, with proper whitespace Tell me, coder, now when did You last write readable code? I can open your eyes Make you see your bad indent Force you to respect the style The core devs agreed upon A whole new world A new fantastic code format A de facto standard With some sugar Enforced with clang-format A whole new world A dazzling style we all dreamed of And when we read it through It's crystal clear That now we're in a whole new world of code
2017-03-05 15:44:50 +00:00
Implement visibility range and dependencies. This commit adds the following properties to GeometryInstance3D: `visibility_range_begin`, `visibility_range_begin_margin`, `visibility_range_end`, `visibility_range_end_margin`. Together they define a range in which the GeometryInstance3D will be visible from the camera, taking hysteresis into account for state changes. A begin or end value of 0 will be ignored, so the visibility range can be open-ended in both directions. This commit also adds the `visibility_parent` property to 'Node3D'. Which defines the visibility parents of the node and its subtree (until another parent is defined). Visual instances with a visibility parent will only be visible when the parent, and all of its ancestors recursively, are hidden because they are closer to the camera than their respective `visibility_range_begin` thresholds. Combining visibility ranges and visibility parents users can set-up a quick HLOD system that shows high detail meshes when close (i.e buildings, trees) and merged low detail meshes for far away groups (i.e. cities, woods).
2021-05-09 16:23:20 +00:00
ADD_GROUP("Visibility Range", "visibility_range_");
Add suffixes to all nodes and resources
2022-05-20 05:24:41 +00:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "visibility_range_begin", PROPERTY_HINT_RANGE, "0.0,4096.0,0.01,suffix:m"), "set_visibility_range_begin", "get_visibility_range_begin");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "visibility_range_begin_margin", PROPERTY_HINT_RANGE, "0.0,4096.0,0.01,suffix:m"), "set_visibility_range_begin_margin", "get_visibility_range_begin_margin");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "visibility_range_end", PROPERTY_HINT_RANGE, "0.0,4096.0,0.01,suffix:m"), "set_visibility_range_end", "get_visibility_range_end");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "visibility_range_end_margin", PROPERTY_HINT_RANGE, "0.0,4096.0,0.01,suffix:m"), "set_visibility_range_end_margin", "get_visibility_range_end_margin");
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
ADD_PROPERTY(PropertyInfo(Variant::INT, "visibility_range_fade_mode", PROPERTY_HINT_ENUM, "Disabled,Self,Dependencies"), "set_visibility_range_fade_mode", "get_visibility_range_fade_mode");
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
Fix enums bindings Add missed bindings for enums Move some enums to class to have correct output of api.json
2017-09-12 19:09:06 +00:00
BIND_ENUM_CONSTANT(SHADOW_CASTING_SETTING_OFF);
BIND_ENUM_CONSTANT(SHADOW_CASTING_SETTING_ON);
BIND_ENUM_CONSTANT(SHADOW_CASTING_SETTING_DOUBLE_SIDED);
BIND_ENUM_CONSTANT(SHADOW_CASTING_SETTING_SHADOWS_ONLY);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 12:34:23 +00:00
BIND_ENUM_CONSTANT(GI_MODE_DISABLED);
Rename and reorder bake mode properties for consistency The order now goes from least to most computationally expensive: - Disabled - Static - Dynamic
2021-11-26 16:47:37 +00:00
BIND_ENUM_CONSTANT(GI_MODE_STATIC);
New lightmapper -Added LocalVector (needed it) -Added stb_rect_pack (It's pretty cool, we could probably use it for other stuff too) -Fixes and changes all around the place -Added library for 128 bits fixed point (required for Delaunay3D)
2020-05-01 12:34:23 +00:00
BIND_ENUM_CONSTANT(GI_MODE_DYNAMIC);
BIND_ENUM_CONSTANT(LIGHTMAP_SCALE_1X);
BIND_ENUM_CONSTANT(LIGHTMAP_SCALE_2X);
BIND_ENUM_CONSTANT(LIGHTMAP_SCALE_4X);
BIND_ENUM_CONSTANT(LIGHTMAP_SCALE_8X);
BIND_ENUM_CONSTANT(LIGHTMAP_SCALE_MAX);
Implement distance fade and transparency The built-in ALPHA in spatial shaders comes pre-set with a per-instance transparency value. Multiply by it if you want to keep it. The transparency value of any given GeometryInstance3D is affected by: - Its new "transparency" property. - Its own visiblity range when the new "visibility_range_fade_mode" property is set to "Self". - Its parent visibility range when the parent's fade mode is set to "Dependencies". The "Self" mode will fade-out the instance when reaching the visibility range limits, while the "Dependencies" mode will fade-in its dependencies. Per-instance transparency is only implemented in the forward clustered renderer, support for mobile should be added in the future. Co-authored-by: reduz <reduzio@gmail.com>
2021-07-20 18:17:34 +00:00
BIND_ENUM_CONSTANT(VISIBILITY_RANGE_FADE_DISABLED);
BIND_ENUM_CONSTANT(VISIBILITY_RANGE_FADE_SELF);
BIND_ENUM_CONSTANT(VISIBILITY_RANGE_FADE_DEPENDENCIES);
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Renamed 2D and 3D nodes to make their types explicit Fixes #30736.
2020-03-26 21:49:16 +00:00
GeometryInstance3D::GeometryInstance3D() {
GODOT IS OPEN SOURCE
2014-02-10 01:10:30 +00:00
}
Fix errors when materials attached to 3d object are not freed
2022-05-26 06:12:20 +00:00
GeometryInstance3D::~GeometryInstance3D() {
if (material_overlay.is_valid()) {
set_material_overlay(Ref<Material>());
}
if (material_override.is_valid()) {
set_material_override(Ref<Material>());
}
}
Reference in New Issue Copy Permalink