maxmustermann/godot
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity

Refactor FogVolume, VoxelGI, ReflectionProbe code

Browse source 
Refactor FogVolume code

Fix FogVolume refactoring

Refactor VoxelGI code

Refactor ReflectionProbe code
This commit is contained in:
Dominic-ATOR 2021-11-08 20:00:17 +00:00 committed by ator-dev
parent 9df4d11fef
commit 9c1ea56539
30 changed files with 141 additions and 187 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
doc/classes/EditorProperty.xml
View file

@ -110,7 +110,7 @@
</signal>
<signal name="property_checked">
<argument index="0" name="property" type="StringName" />
<argument index="1" name="checked" type="bool" />
<argument index="1" name="bool" type="String" />
<description>
Emitted when a property was checked. Used internally.
</description>
@ -134,14 +134,6 @@
Emit it if you want to key a property with a single value.
</description>
</signal>
<signal name="property_pinned">
<argument index="0" name="property" type="StringName" />
<argument index="1" name="pinned" type="bool" />
<description>
Emit it if you want to mark (or unmark) the value of a property for being saved regardless of being equal to the default value.
The default value is the one the property will get when the node is just instantiated and can come from an ancestor scene in the inheritance/instancing chain, a script or a builtin class.
</description>
</signal>
<signal name="resource_selected">
<argument index="0" name="path" type="String" />
<argument index="1" name="resource" type="Resource" />

1
doc/classes/FogVolume.xml
View file

@ -11,7 +11,6 @@
</tutorials>
<members>
<member name="extents" type="Vector3" setter="set_extents" getter="get_extents" default="Vector3(1, 1, 1)">
Sets the size of the [FogVolume] when [member shape] is [constant RenderingServer.FOG_VOLUME_SHAPE_ELLIPSOID] or [constant RenderingServer.FOG_VOLUME_SHAPE_BOX].
</member>
<member name="material" type="Material" setter="set_material" getter="get_material">
Sets the [Material] to be used by the [FogVolume]. Can be either a [FogMaterial] or a custom [ShaderMaterial].

20
doc/classes/Gradient.xml
View file

@ -51,12 +51,6 @@
Removes the color at the index [code]point[/code].
</description>
</method>
<method name="reverse">
<return type="void" />
<description>
Reverses/mirrors the gradient.
</description>
</method>
<method name="set_color">
<return type="void" />
<argument index="0" name="point" type="int" />
@ -78,22 +72,8 @@
<member name="colors" type="PackedColorArray" setter="set_colors" getter="get_colors" default="PackedColorArray(0, 0, 0, 1, 1, 1, 1, 1)">
Gradient's colors returned as a [PackedColorArray].
</member>
<member name="interpolation_mode" type="int" setter="set_interpolation_mode" getter="get_interpolation_mode" enum="Gradient.InterpolationMode" default="0">
Defines how the colors between points of the gradient are interpolated. See [enum InterpolationMode] for available modes.
</member>
<member name="offsets" type="PackedFloat32Array" setter="set_offsets" getter="get_offsets" default="PackedFloat32Array(0, 1)">
Gradient's offsets returned as a [PackedFloat32Array].
</member>
</members>
<constants>
<constant name="GRADIENT_INTERPOLATE_LINEAR" value="0" enum="InterpolationMode">
Linear interpolation.
</constant>
<constant name="GRADIENT_INTERPOLATE_CONSTANT" value="1" enum="InterpolationMode">
Constant interpolation, color changes abruptly at each point and stays uniform between. This might cause visible aliasing when used for a gradient texture in some cases.
</constant>
<constant name="GRADIENT_INTERPOLATE_CUBIC" value="2" enum="InterpolationMode">
Cubic interpolation.
</constant>
</constants>
</class>

5
doc/classes/GradientTexture1D.xml
View file

@ -1,22 +1,17 @@
<?xml version="1.0" encoding="UTF-8" ?>
<class name="GradientTexture1D" inherits="Texture2D" version="4.0">
<brief_description>
Gradient-filled texture.
</brief_description>
<description>
GradientTexture1D uses a [Gradient] to fill the texture data. The gradient will be filled from left to right using colors obtained from the gradient. This means the texture does not necessarily represent an exact copy of the gradient, but instead an interpolation of samples obtained from the gradient at fixed steps (see [member width]).
</description>
<tutorials>
</tutorials>
<members>
<member name="gradient" type="Gradient" setter="set_gradient" getter="get_gradient">
The [Gradient] that will be used to fill the texture.
</member>
<member name="use_hdr" type="bool" setter="set_use_hdr" getter="is_using_hdr" default="false">
If [code]true[/code], the generated texture will support high dynamic range ([constant Image.FORMAT_RGBAF] format). This allows for glow effects to work if [member Environment.glow_enabled] is [code]true[/code]. If [code]false[/code], the generated texture will use low dynamic range; overbright colors will be clamped ([constant Image.FORMAT_RGBA8] format).
</member>
<member name="width" type="int" setter="set_width" getter="get_width" default="2048">
The number of color samples that will be obtained from the [Gradient].
</member>
</members>
</class>

4
doc/classes/PackedScene.xml
View file

@ -121,9 +121,5 @@
If passed to [method instantiate], provides local scene resources to the local scene. Only the main scene should receive the main edit state.
[b]Note:[/b] Only available in editor builds.
</constant>
<constant name="GEN_EDIT_STATE_MAIN_INHERITED" value="3" enum="GenEditState">
It's similar to [constant GEN_EDIT_STATE_MAIN], but for the case where the scene is being instantiated to be the base of another one.
[b]Note:[/b] Only available in editor builds.
</constant>
</constants>
</class>

1
doc/classes/ReflectionProbe.xml
View file

@ -27,7 +27,6 @@
If [code]true[/code], computes shadows in the reflection probe. This makes the reflection probe slower to render; you may want to disable this if using the [constant UPDATE_ALWAYS] [member update_mode].
</member>
<member name="extents" type="Vector3" setter="set_extents" getter="get_extents" default="Vector3(10, 10, 10)">
The size of the reflection probe. The larger the extents, the more space covered by the probe, which will lower the perceived resolution. It is best to keep the extents only as large as you need them.
</member>
<member name="intensity" type="float" setter="set_intensity" getter="get_intensity" default="1.0">
Defines the reflection intensity. Intensity modulates the strength of the reflection.

2
doc/classes/RenderingServer.xml
View file

@ -1159,7 +1159,6 @@
<argument index="0" name="fog_volume" type="RID" />
<argument index="1" name="extents" type="Vector3" />
<description>
Sets the size of the fog volume when shape is [constant FOG_VOLUME_SHAPE_ELLIPSOID] or [constant FOG_VOLUME_SHAPE_BOX].
</description>
</method>
<method name="fog_volume_set_material">
@ -2524,7 +2523,6 @@
<argument index="0" name="probe" type="RID" />
<argument index="1" name="extents" type="Vector3" />
<description>
Sets the size of the area that the reflection probe will capture. Equivalent to [member ReflectionProbe.extents].
</description>
</method>
<method name="reflection_probe_set_intensity">

4
doc/classes/SceneState.xml
View file

@ -168,9 +168,5 @@
If passed to [method PackedScene.instantiate], provides local scene resources to the local scene. Only the main scene should receive the main edit state.
[b]Note:[/b] Only available in editor builds.
</constant>
<constant name="GEN_EDIT_STATE_MAIN_INHERITED" value="3" enum="GenEditState">
If passed to [method PackedScene.instantiate], it's similar to [constant GEN_EDIT_STATE_MAIN], but for the case where the scene is being instantiated to be the base of another one.
[b]Note:[/b] Only available in editor builds.
</constant>
</constants>
</class>

1
doc/classes/VoxelGI.xml
View file

@ -33,7 +33,6 @@
The [VoxelGIData] resource that holds the data for this [VoxelGI].
</member>
<member name="extents" type="Vector3" setter="set_extents" getter="get_extents" default="Vector3(10, 10, 10)">
The size of the area covered by the [VoxelGI]. If you make the extents larger without increasing the subdivisions with [member subdiv], the size of each cell will increase and result in lower detailed lighting.
</member>
<member name="subdiv" type="int" setter="set_subdiv" getter="get_subdiv" enum="VoxelGI.Subdiv" default="1">
Number of times to subdivide the grid that the [VoxelGI] operates on. A higher number results in finer detail and thus higher visual quality, while lower numbers result in better performance.

6
drivers/gles3/rasterizer_storage_gles3.cpp
View file

@ -2583,7 +2583,7 @@ void RasterizerStorageGLES3::reflection_probe_set_ambient_energy(RID p_probe, fl
void RasterizerStorageGLES3::reflection_probe_set_max_distance(RID p_probe, float p_distance) {
}
void RasterizerStorageGLES3::reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) {
void RasterizerStorageGLES3::reflection_probe_set_size(RID p_probe, const Vector3 &p_size) {
}
void RasterizerStorageGLES3::reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) {
@ -2616,7 +2616,7 @@ uint32_t RasterizerStorageGLES3::reflection_probe_get_cull_mask(RID p_probe) con
return 0;
}
Vector3 RasterizerStorageGLES3::reflection_probe_get_extents(RID p_probe) const {
Vector3 RasterizerStorageGLES3::reflection_probe_get_size(RID p_probe) const {
return Vector3();
}
@ -3033,7 +3033,7 @@ void RasterizerStorageGLES3::fog_volume_initialize(RID p_rid) {
void RasterizerStorageGLES3::fog_volume_set_shape(RID p_fog_volume, RS::FogVolumeShape p_shape) {
}
void RasterizerStorageGLES3::fog_volume_set_extents(RID p_fog_volume, const Vector3 &p_extents) {
void RasterizerStorageGLES3::fog_volume_set_size(RID p_fog_volume, const Vector3 &p_size) {
}
void RasterizerStorageGLES3::fog_volume_set_material(RID p_fog_volume, RID p_material) {

6
drivers/gles3/rasterizer_storage_gles3.h
View file

@ -926,7 +926,7 @@ public:
void reflection_probe_set_ambient_color(RID p_probe, const Color &p_color) override;
void reflection_probe_set_ambient_energy(RID p_probe, float p_energy) override;
void reflection_probe_set_max_distance(RID p_probe, float p_distance) override;
void reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) override;
void reflection_probe_set_size(RID p_probe, const Vector3 &p_size) override;
void reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) override;
void reflection_probe_set_as_interior(RID p_probe, bool p_enable) override;
void reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) override;
@ -937,7 +937,7 @@ public:
AABB reflection_probe_get_aabb(RID p_probe) const override;
RS::ReflectionProbeUpdateMode reflection_probe_get_update_mode(RID p_probe) const override;
uint32_t reflection_probe_get_cull_mask(RID p_probe) const override;
Vector3 reflection_probe_get_extents(RID p_probe) const override;
Vector3 reflection_probe_get_size(RID p_probe) const override;
Vector3 reflection_probe_get_origin_offset(RID p_probe) const override;
float reflection_probe_get_origin_max_distance(RID p_probe) const override;
bool reflection_probe_renders_shadows(RID p_probe) const override;
@ -1104,7 +1104,7 @@ public:
void fog_volume_initialize(RID p_rid) override;
void fog_volume_set_shape(RID p_fog_volume, RS::FogVolumeShape p_shape) override;
void fog_volume_set_extents(RID p_fog_volume, const Vector3 &p_extents) override;
void fog_volume_set_size(RID p_fog_volume, const Vector3 &p_size) override;
void fog_volume_set_material(RID p_fog_volume, RID p_material) override;
AABB fog_volume_get_aabb(RID p_fog_volume) const override;
RS::FogVolumeShape fog_volume_get_shape(RID p_fog_volume) const override;

82
editor/plugins/node_3d_editor_gizmos.cpp
View file

@ -3029,11 +3029,11 @@ int ReflectionProbeGizmoPlugin::get_priority() const {
String ReflectionProbeGizmoPlugin::get_handle_name(const EditorNode3DGizmo *p_gizmo, int p_id) const {
switch (p_id) {
case 0:
return "Extents X";
return "Size X";
case 1:
return "Extents Y";
return "Size Y";
case 2:
return "Extents Z";
return "Size Z";
case 3:
return "Origin X";
case 4:
@ -3047,7 +3047,7 @@ String ReflectionProbeGizmoPlugin::get_handle_name(const EditorNode3DGizmo *p_gi
Variant ReflectionProbeGizmoPlugin::get_handle_value(const EditorNode3DGizmo *p_gizmo, int p_id) const {
ReflectionProbe *probe = Object::cast_to<ReflectionProbe>(p_gizmo->get_spatial_node());
return AABB(probe->get_extents(), probe->get_origin_offset());
return AABB(probe->get_size() / 2, probe->get_origin_offset());
}
void ReflectionProbeGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, int p_id, Camera3D *p_camera, const Point2 &p_point) {
@ -3057,7 +3057,7 @@ void ReflectionProbeGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, in
Transform3D gi = gt.affine_inverse();
if (p_id < 3) {
Vector3 extents = probe->get_extents();
Vector3 size = probe->get_size();
Vector3 ray_from = p_camera->project_ray_origin(p_point);
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
@ -3069,7 +3069,7 @@ void ReflectionProbeGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, in
Vector3 ra, rb;
Geometry3D::get_closest_points_between_segments(Vector3(), axis * 16384, sg[0], sg[1], ra, rb);
float d = ra[p_id];
float d = ra[p_id] * 2.0;
if (Node3DEditor::get_singleton()->is_snap_enabled()) {
d = Math::snapped(d, Node3DEditor::get_singleton()->get_translate_snap());
}
@ -3078,8 +3078,8 @@ void ReflectionProbeGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, in
d = 0.001;
}
extents[p_id] = d;
probe->set_extents(extents);
size[p_id] = d;
probe->set_size(size);
} else {
p_id -= 3;
@ -3113,16 +3113,16 @@ void ReflectionProbeGizmoPlugin::commit_handle(const EditorNode3DGizmo *p_gizmo,
AABB restore = p_restore;
if (p_cancel) {
probe->set_extents(restore.position);
probe->set_size(restore.position);
probe->set_origin_offset(restore.size);
return;
}
UndoRedo *ur = Node3DEditor::get_singleton()->get_undo_redo();
ur->create_action(TTR("Change Probe Extents"));
ur->add_do_method(probe, "set_extents", probe->get_extents());
ur->create_action(TTR("Change Probe Size"));
ur->add_do_method(probe, "set_size", probe->get_size());
ur->add_do_method(probe, "set_origin_offset", probe->get_origin_offset());
ur->add_undo_method(probe, "set_extents", restore.position);
ur->add_undo_method(probe, "set_size", restore.position);
ur->add_undo_method(probe, "set_origin_offset", restore.size);
ur->commit_action();
}
@ -3134,11 +3134,11 @@ void ReflectionProbeGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
Vector<Vector3> lines;
Vector<Vector3> internal_lines;
Vector3 extents = probe->get_extents();
Vector3 size = probe->get_size();
AABB aabb;
aabb.position = -extents;
aabb.size = extents * 2;
aabb.position = -size / 2;
aabb.size = size;
for (int i = 0; i < 12; i++) {
Vector3 a, b;
@ -3180,7 +3180,7 @@ void ReflectionProbeGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
if (p_gizmo->is_selected()) {
Ref<Material> solid_material = get_material("reflection_probe_solid_material", p_gizmo);
p_gizmo->add_solid_box(solid_material, probe->get_extents() * 2.0);
p_gizmo->add_solid_box(solid_material, probe->get_size());
}
p_gizmo->add_unscaled_billboard(icon, 0.05);
@ -3354,11 +3354,11 @@ int VoxelGIGizmoPlugin::get_priority() const {
String VoxelGIGizmoPlugin::get_handle_name(const EditorNode3DGizmo *p_gizmo, int p_id) const {
switch (p_id) {
case 0:
return "Extents X";
return "Size X";
case 1:
return "Extents Y";
return "Size Y";
case 2:
return "Extents Z";
return "Size Z";
}
return "";
@ -3366,7 +3366,7 @@ String VoxelGIGizmoPlugin::get_handle_name(const EditorNode3DGizmo *p_gizmo, int
Variant VoxelGIGizmoPlugin::get_handle_value(const EditorNode3DGizmo *p_gizmo, int p_id) const {
VoxelGI *probe = Object::cast_to<VoxelGI>(p_gizmo->get_spatial_node());
return probe->get_extents();
return probe->get_size();
}
void VoxelGIGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, int p_id, Camera3D *p_camera, const Point2 &p_point) {
@ -3375,7 +3375,7 @@ void VoxelGIGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, int p_id,
Transform3D gt = probe->get_global_transform();
Transform3D gi = gt.affine_inverse();
Vector3 extents = probe->get_extents();
Vector3 size = probe->get_size();
Vector3 ray_from = p_camera->project_ray_origin(p_point);
Vector3 ray_dir = p_camera->project_ray_normal(p_point);
@ -3387,7 +3387,7 @@ void VoxelGIGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, int p_id,
Vector3 ra, rb;
Geometry3D::get_closest_points_between_segments(Vector3(), axis * 16384, sg[0], sg[1], ra, rb);
float d = ra[p_id];
float d = ra[p_id] * 2.0;
if (Node3DEditor::get_singleton()->is_snap_enabled()) {
d = Math::snapped(d, Node3DEditor::get_singleton()->get_translate_snap());
}
@ -3396,8 +3396,8 @@ void VoxelGIGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, int p_id,
d = 0.001;
}
extents[p_id] = d;
probe->set_extents(extents);
size[p_id] = d;
probe->set_size(size);
}
void VoxelGIGizmoPlugin::commit_handle(const EditorNode3DGizmo *p_gizmo, int p_id, const Variant &p_restore, bool p_cancel) {
@ -3406,14 +3406,14 @@ void VoxelGIGizmoPlugin::commit_handle(const EditorNode3DGizmo *p_gizmo, int p_i
Vector3 restore = p_restore;
if (p_cancel) {
probe->set_extents(restore);
probe->set_size(restore);
return;
}
UndoRedo *ur = Node3DEditor::get_singleton()->get_undo_redo();
ur->create_action(TTR("Change Probe Extents"));
ur->add_do_method(probe, "set_extents", probe->get_extents());
ur->add_undo_method(probe, "set_extents", restore);
ur->create_action(TTR("Change Probe Size"));
ur->add_do_method(probe, "set_size", probe->get_size());
ur->add_undo_method(probe, "set_size", restore);
ur->commit_action();
}
@ -3427,11 +3427,11 @@ void VoxelGIGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
p_gizmo->clear();
Vector<Vector3> lines;
Vector3 extents = probe->get_extents();
Vector3 size = probe->get_size();
static const int subdivs[VoxelGI::SUBDIV_MAX] = { 64, 128, 256, 512 };
AABB aabb = AABB(-extents, extents * 2);
AABB aabb = AABB(-size / 2, size);
int subdiv = subdivs[probe->get_subdiv()];
float cell_size = aabb.get_longest_axis_size() / subdiv;
@ -5298,11 +5298,11 @@ int FogVolumeGizmoPlugin::get_priority() const {
}
String FogVolumeGizmoPlugin::get_handle_name(const EditorNode3DGizmo *p_gizmo, int p_id) const {
return "Extents";
return "Size";
}
Variant FogVolumeGizmoPlugin::get_handle_value(const EditorNode3DGizmo *p_gizmo, int p_id) const {
return Vector3(p_gizmo->get_spatial_node()->call("get_extents"));
return Vector3(p_gizmo->get_spatial_node()->call("get_size"));
}
void FogVolumeGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, int p_id, Camera3D *p_camera, const Point2 &p_point) {
@ -5320,7 +5320,7 @@ void FogVolumeGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, int p_id
axis[p_id] = 1.0;
Vector3 ra, rb;
Geometry3D::get_closest_points_between_segments(Vector3(), axis * 4096, sg[0], sg[1], ra, rb);
float d = ra[p_id];
float d = ra[p_id] * 2.0;
if (Node3DEditor::get_singleton()->is_snap_enabled()) {
d = Math::snapped(d, Node3DEditor::get_singleton()->get_translate_snap());
}
@ -5329,23 +5329,23 @@ void FogVolumeGizmoPlugin::set_handle(const EditorNode3DGizmo *p_gizmo, int p_id
d = 0.001;
}
Vector3 he = sn->call("get_extents");
Vector3 he = sn->call("get_size");
he[p_id] = d;
sn->call("set_extents", he);
sn->call("set_size", he);
}
void FogVolumeGizmoPlugin::commit_handle(const EditorNode3DGizmo *p_gizmo, int p_id, const Variant &p_restore, bool p_cancel) {
Node3D *sn = p_gizmo->get_spatial_node();
if (p_cancel) {
sn->call("set_extents", p_restore);
sn->call("set_size", p_restore);
return;
}
UndoRedo *ur = Node3DEditor::get_singleton()->get_undo_redo();
ur->create_action(TTR("Change Fog Volume Extents"));
ur->add_do_method(sn, "set_extents", sn->call("get_extents"));
ur->add_undo_method(sn, "set_extents", p_restore);
ur->create_action(TTR("Change Fog Volume Size"));
ur->add_do_method(sn, "set_size", sn->call("get_size"));
ur->add_undo_method(sn, "set_size", p_restore);
ur->commit_action();
}
@ -5364,7 +5364,7 @@ void FogVolumeGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
Vector<Vector3> lines;
AABB aabb;
aabb.position = -cs->call("get_extents").operator Vector3();
aabb.position = -cs->call("get_size").operator Vector3() / 2;
aabb.size = aabb.position * -2;
for (int i = 0; i < 12; i++) {
@ -5378,7 +5378,7 @@ void FogVolumeGizmoPlugin::redraw(EditorNode3DGizmo *p_gizmo) {
for (int i = 0; i < 3; i++) {
Vector3 ax;
ax[i] = cs->call("get_extents").operator Vector3()[i];
ax[i] = cs->call("get_size").operator Vector3()[i] / 2;
handles.push_back(ax);
}

2
editor/plugins/visual_shader_editor_plugin.cpp
View file

@ -4509,7 +4509,7 @@ VisualShaderEditor::VisualShaderEditor() {
add_options.push_back(AddOption("WorldPosition", "Input", "Fog", "VisualShaderNodeInput", vformat(input_param_for_fog_shader_mode, "world_position"), "world_position", VisualShaderNode::PORT_TYPE_VECTOR, TYPE_FLAGS_FOG, Shader::MODE_FOG));
add_options.push_back(AddOption("ObjectPosition", "Input", "Fog", "VisualShaderNodeInput", vformat(input_param_for_fog_shader_mode, "object_position"), "object_position", VisualShaderNode::PORT_TYPE_VECTOR, TYPE_FLAGS_FOG, Shader::MODE_FOG));
add_options.push_back(AddOption("UVW", "Input", "Fog", "VisualShaderNodeInput", vformat(input_param_for_fog_shader_mode, "uvw"), "uvw", VisualShaderNode::PORT_TYPE_VECTOR, TYPE_FLAGS_FOG, Shader::MODE_FOG));
add_options.push_back(AddOption("Extents", "Input", "Fog", "VisualShaderNodeInput", vformat(input_param_for_fog_shader_mode, "extents"), "extents", VisualShaderNode::PORT_TYPE_VECTOR, TYPE_FLAGS_FOG, Shader::MODE_FOG));
add_options.push_back(AddOption("Size", "Input", "Fog", "VisualShaderNodeInput", vformat(input_param_for_fog_shader_mode, "size"), "size", VisualShaderNode::PORT_TYPE_VECTOR, TYPE_FLAGS_FOG, Shader::MODE_FOG));
add_options.push_back(AddOption("Transform", "Input", "Fog", "VisualShaderNodeInput", vformat(input_param_for_fog_shader_mode, "transform"), "transform", VisualShaderNode::PORT_TYPE_TRANSFORM, TYPE_FLAGS_FOG, Shader::MODE_FOG));
add_options.push_back(AddOption("SDF", "Input", "Fog", "VisualShaderNodeInput", vformat(input_param_for_fog_shader_mode, "sdf"), "sdf", VisualShaderNode::PORT_TYPE_SCALAR, TYPE_FLAGS_FOG, Shader::MODE_FOG));
add_options.push_back(AddOption("Time", "Input", "Fog", "VisualShaderNodeInput", vformat(input_param_for_fog_shader_mode, "time"), "time", VisualShaderNode::PORT_TYPE_SCALAR, TYPE_FLAGS_FOG, Shader::MODE_FOG));

26
scene/3d/fog_volume.cpp
View file

@ -33,37 +33,37 @@
///////////////////////////
void FogVolume::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_extents", "extents"), &FogVolume::set_extents);
ClassDB::bind_method(D_METHOD("get_extents"), &FogVolume::get_extents);
ClassDB::bind_method(D_METHOD("set_size", "size"), &FogVolume::set_size);
ClassDB::bind_method(D_METHOD("get_size"), &FogVolume::get_size);
ClassDB::bind_method(D_METHOD("set_shape", "shape"), &FogVolume::set_shape);
ClassDB::bind_method(D_METHOD("get_shape"), &FogVolume::get_shape);
ClassDB::bind_method(D_METHOD("set_material", "material"), &FogVolume::set_material);
ClassDB::bind_method(D_METHOD("get_material"), &FogVolume::get_material);
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "extents", PROPERTY_HINT_RANGE, "0.01,1024,0.01,or_greater"), "set_extents", "get_extents");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "size", PROPERTY_HINT_RANGE, "0.01,1024,0.01,or_greater"), "set_size", "get_size");
ADD_PROPERTY(PropertyInfo(Variant::INT, "shape", PROPERTY_HINT_ENUM, "Ellipsoid,Box,World"), "set_shape", "get_shape");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "material", PROPERTY_HINT_RESOURCE_TYPE, "FogMaterial,ShaderMaterial"), "set_material", "get_material");
}
void FogVolume::_validate_property(PropertyInfo &property) const {
if (property.name == "extents" && shape == RS::FOG_VOLUME_SHAPE_WORLD) {
if (property.name == "size" && shape == RS::FOG_VOLUME_SHAPE_WORLD) {
property.usage = PROPERTY_USAGE_NONE;
return;
}
VisualInstance3D::_validate_property(property);
}
void FogVolume::set_extents(const Vector3 &p_extents) {
extents = p_extents;
extents.x = MAX(0.0, extents.x);
extents.y = MAX(0.0, extents.y);
extents.z = MAX(0.0, extents.z);
RS::get_singleton()->fog_volume_set_extents(_get_volume(), extents);
void FogVolume::set_size(const Vector3 &p_size) {
size = p_size;
size.x = MAX(0.0, size.x);
size.y = MAX(0.0, size.y);
size.z = MAX(0.0, size.z);
RS::get_singleton()->fog_volume_set_size(_get_volume(), size);
update_gizmos();
}
Vector3 FogVolume::get_extents() const {
return extents;
Vector3 FogVolume::get_size() const {
return size;
}
void FogVolume::set_shape(RS::FogVolumeShape p_type) {
@ -94,7 +94,7 @@ Ref<Material> FogVolume::get_material() const {
AABB FogVolume::get_aabb() const {
if (shape != RS::FOG_VOLUME_SHAPE_WORLD) {
return AABB(-extents, extents * 2);
return AABB(-size / 2.0, size);
}
return AABB();
}

6
scene/3d/fog_volume.h
View file

@ -40,7 +40,7 @@
class FogVolume : public VisualInstance3D {
GDCLASS(FogVolume, VisualInstance3D);
Vector3 extents = Vector3(1, 1, 1);
Vector3 size = Vector3(2, 2, 2);
Ref<Material> material;
RS::FogVolumeShape shape = RS::FOG_VOLUME_SHAPE_BOX;
@ -52,8 +52,8 @@ protected:
virtual void _validate_property(PropertyInfo &property) const override;
public:
void set_extents(const Vector3 &p_extents);
Vector3 get_extents() const;
void set_size(const Vector3 &p_size);
Vector3 get_size() const;
void set_shape(RS::FogVolumeShape p_type);
RS::FogVolumeShape get_shape() const;

32
scene/3d/reflection_probe.cpp
View file

@ -85,38 +85,38 @@ float ReflectionProbe::get_lod_threshold() const {
return lod_threshold;
}
void ReflectionProbe::set_extents(const Vector3 &p_extents) {
extents = p_extents;
void ReflectionProbe::set_size(const Vector3 &p_size) {
size = p_size;
for (int i = 0; i < 3; i++) {
if (extents[i] < 0.01) {
extents[i] = 0.01;
if (size[i] < 0.01) {
size[i] = 0.01;
}
if (extents[i] - 0.01 < ABS(origin_offset[i])) {
origin_offset[i] = SGN(origin_offset[i]) * (extents[i] - 0.01);
if ((size[i] - 0.01) / 2 < ABS(origin_offset[i])) {
origin_offset[i] = SGN(origin_offset[i]) * (size[i] - 0.01) / 2;
}
}
RS::get_singleton()->reflection_probe_set_extents(probe, extents);
RS::get_singleton()->reflection_probe_set_size(probe, size);
RS::get_singleton()->reflection_probe_set_origin_offset(probe, origin_offset);
update_gizmos();
}
Vector3 ReflectionProbe::get_extents() const {
return extents;
Vector3 ReflectionProbe::get_size() const {
return size;
}
void ReflectionProbe::set_origin_offset(const Vector3 &p_extents) {
origin_offset = p_extents;
for (int i = 0; i < 3; i++) {
if (extents[i] - 0.01 < ABS(origin_offset[i])) {
origin_offset[i] = SGN(origin_offset[i]) * (extents[i] - 0.01);
if ((size[i] - 0.01) / 2 < ABS(origin_offset[i])) {
origin_offset[i] = SGN(origin_offset[i]) * (size[i] - 0.01) / 2;
}
}
RS::get_singleton()->reflection_probe_set_extents(probe, extents);
RS::get_singleton()->reflection_probe_set_size(probe, size);
RS::get_singleton()->reflection_probe_set_origin_offset(probe, origin_offset);
update_gizmos();
@ -174,7 +174,7 @@ ReflectionProbe::UpdateMode ReflectionProbe::get_update_mode() const {
AABB ReflectionProbe::get_aabb() const {
AABB aabb;
aabb.position = -origin_offset;
aabb.size = origin_offset + extents;
aabb.size = origin_offset + size / 2;
return aabb;
}
@ -210,8 +210,8 @@ void ReflectionProbe::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_lod_threshold", "ratio"), &ReflectionProbe::set_lod_threshold);
ClassDB::bind_method(D_METHOD("get_lod_threshold"), &ReflectionProbe::get_lod_threshold);
ClassDB::bind_method(D_METHOD("set_extents", "extents"), &ReflectionProbe::set_extents);
ClassDB::bind_method(D_METHOD("get_extents"), &ReflectionProbe::get_extents);
ClassDB::bind_method(D_METHOD("set_size", "size"), &ReflectionProbe::set_size);
ClassDB::bind_method(D_METHOD("get_size"), &ReflectionProbe::get_size);
ClassDB::bind_method(D_METHOD("set_origin_offset", "origin_offset"), &ReflectionProbe::set_origin_offset);
ClassDB::bind_method(D_METHOD("get_origin_offset"), &ReflectionProbe::get_origin_offset);
@ -234,7 +234,7 @@ void ReflectionProbe::_bind_methods() {
ADD_PROPERTY(PropertyInfo(Variant::INT, "update_mode", PROPERTY_HINT_ENUM, "Once (Fast),Always (Slow)"), "set_update_mode", "get_update_mode");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "intensity", PROPERTY_HINT_RANGE, "0,1,0.01"), "set_intensity", "get_intensity");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "max_distance", PROPERTY_HINT_RANGE, "0,16384,0.1,or_greater,exp"), "set_max_distance", "get_max_distance");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "extents"), "set_extents", "get_extents");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "size"), "set_size", "get_size");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "origin_offset"), "set_origin_offset", "get_origin_offset");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "box_projection"), "set_enable_box_projection", "is_box_projection_enabled");
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "interior"), "set_as_interior", "is_set_as_interior");

6
scene/3d/reflection_probe.h
View file

@ -52,7 +52,7 @@ private:
RID probe;
float intensity = 1.0;
float max_distance = 0.0;
Vector3 extents = Vector3(10, 10, 10);
Vector3 size = Vector3(20, 20, 20);
Vector3 origin_offset = Vector3(0, 0, 0);
bool box_projection = false;
bool enable_shadows = false;
@ -91,8 +91,8 @@ public:
void set_lod_threshold(float p_pixels);
float get_lod_threshold() const;
void set_extents(const Vector3 &p_extents);
Vector3 get_extents() const;
void set_size(const Vector3 &p_size);
Vector3 get_size() const;
void set_origin_offset(const Vector3 &p_extents);
Vector3 get_origin_offset() const;

26
scene/3d/voxel_gi.cpp
View file

@ -271,13 +271,13 @@ VoxelGI::Subdiv VoxelGI::get_subdiv() const {
return subdiv;
}
void VoxelGI::set_extents(const Vector3 &p_extents) {
extents = p_extents;
void VoxelGI::set_size(const Vector3 &p_size) {
size = p_size;
update_gizmos();
}
Vector3 VoxelGI::get_extents() const {
return extents;
Vector3 VoxelGI::get_size() const {
return size;
}
void VoxelGI::_find_meshes(Node *p_at_node, List<PlotMesh> &plot_meshes) {
@ -289,7 +289,7 @@ void VoxelGI::_find_meshes(Node *p_at_node, List<PlotMesh> &plot_meshes) {
Transform3D xf = get_global_transform().affine_inverse() * mi->get_global_transform();
if (AABB(-extents, extents * 2).intersects(xf.xform(aabb))) {
if (AABB(-size / 2, size).intersects(xf.xform(aabb))) {
PlotMesh pm;
pm.local_xform = xf;
pm.mesh = mesh;
@ -317,7 +317,7 @@ void VoxelGI::_find_meshes(Node *p_at_node, List<PlotMesh> &plot_meshes) {
Transform3D xf = get_global_transform().affine_inverse() * (s->get_global_transform() * mxf);
if (AABB(-extents, extents * 2).intersects(xf.xform(aabb))) {
if (AABB(-size / 2, size).intersects(xf.xform(aabb))) {
PlotMesh pm;
pm.local_xform = xf;
pm.mesh = mesh;
@ -341,7 +341,7 @@ Vector3i VoxelGI::get_estimated_cell_size() const {
static const int subdiv_value[SUBDIV_MAX] = { 6, 7, 8, 9 };
int cell_subdiv = subdiv_value[subdiv];
int axis_cell_size[3];
AABB bounds = AABB(-extents, extents * 2.0);
AABB bounds = AABB(-size / 2.0, size);
int longest_axis = bounds.get_longest_axis_index();
axis_cell_size[longest_axis] = 1 << cell_subdiv;
@ -371,7 +371,7 @@ void VoxelGI::bake(Node *p_from_node, bool p_create_visual_debug) {
Voxelizer baker;
baker.begin_bake(subdiv_value[subdiv], AABB(-extents, extents * 2.0));
baker.begin_bake(subdiv_value[subdiv], AABB(-size / 2.0, size));
List<PlotMesh> mesh_list;
@ -427,7 +427,7 @@ void VoxelGI::bake(Node *p_from_node, bool p_create_visual_debug) {
Vector<uint8_t> df = baker.get_sdf_3d_image();
probe_data->allocate(baker.get_to_cell_space_xform(), AABB(-extents, extents * 2.0), baker.get_voxel_gi_octree_size(), baker.get_voxel_gi_octree_cells(), baker.get_voxel_gi_data_cells(), df, baker.get_voxel_gi_level_cell_count());
probe_data->allocate(baker.get_to_cell_space_xform(), AABB(-size / 2.0, size), baker.get_voxel_gi_octree_size(), baker.get_voxel_gi_octree_cells(), baker.get_voxel_gi_data_cells(), df, baker.get_voxel_gi_level_cell_count());
set_probe_data(probe_data);
#ifdef TOOLS_ENABLED
@ -447,7 +447,7 @@ void VoxelGI::_debug_bake() {
}
AABB VoxelGI::get_aabb() const {
return AABB(-extents, extents * 2);
return AABB(-size / 2, size);
}
Vector<Face3> VoxelGI::get_faces(uint32_t p_usage_flags) const {
@ -472,15 +472,15 @@ void VoxelGI::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_subdiv", "subdiv"), &VoxelGI::set_subdiv);
ClassDB::bind_method(D_METHOD("get_subdiv"), &VoxelGI::get_subdiv);
ClassDB::bind_method(D_METHOD("set_extents", "extents"), &VoxelGI::set_extents);
ClassDB::bind_method(D_METHOD("get_extents"), &VoxelGI::get_extents);
ClassDB::bind_method(D_METHOD("set_size", "size"), &VoxelGI::set_size);
ClassDB::bind_method(D_METHOD("get_size"), &VoxelGI::get_size);
ClassDB::bind_method(D_METHOD("bake", "from_node", "create_visual_debug"), &VoxelGI::bake, DEFVAL(Variant()), DEFVAL(false));
ClassDB::bind_method(D_METHOD("debug_bake"), &VoxelGI::_debug_bake);
ClassDB::set_method_flags(get_class_static(), _scs_create("debug_bake"), METHOD_FLAGS_DEFAULT | METHOD_FLAG_EDITOR);
ADD_PROPERTY(PropertyInfo(Variant::INT, "subdiv", PROPERTY_HINT_ENUM, "64,128,256,512"), "set_subdiv", "get_subdiv");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "extents"), "set_extents", "get_extents");
ADD_PROPERTY(PropertyInfo(Variant::VECTOR3, "size"), "set_size", "get_size");
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "data", PROPERTY_HINT_RESOURCE_TYPE, "VoxelGIData", PROPERTY_USAGE_DEFAULT | PROPERTY_USAGE_DO_NOT_SHARE_ON_DUPLICATE), "set_probe_data", "get_probe_data");
BIND_ENUM_CONSTANT(SUBDIV_64);

6
scene/3d/voxel_gi.h
View file

@ -116,7 +116,7 @@ private:
RID voxel_gi;
Subdiv subdiv = SUBDIV_128;
Vector3 extents = Vector3(10, 10, 10);
Vector3 size = Vector3(20, 20, 20);
struct PlotMesh {
Ref<Material> override_material;
@ -142,8 +142,8 @@ public:
void set_subdiv(Subdiv p_subdiv);
Subdiv get_subdiv() const;
void set_extents(const Vector3 &p_extents);
Vector3 get_extents() const;
void set_size(const Vector3 &p_size);
Vector3 get_size() const;
Vector3i get_estimated_cell_size() const;
void bake(Node *p_from_node = nullptr, bool p_create_visual_debug = false);

2
scene/resources/visual_shader.cpp
View file

@ -2322,7 +2322,7 @@ const VisualShaderNodeInput::Port VisualShaderNodeInput::ports[] = {
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_VECTOR, "world_position", "WORLD_POSITION" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_VECTOR, "object_position", "OBJECT_POSITION" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_VECTOR, "uvw", "UVW" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_VECTOR, "extents", "EXTENTS" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_VECTOR, "size", "SIZE" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_TRANSFORM, "transform", "TRANSFORM" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_SCALAR, "sdf", "SDF" },
{ Shader::MODE_FOG, VisualShader::TYPE_FOG, VisualShaderNode::PORT_TYPE_SCALAR, "time", "TIME" },

6
servers/rendering/rasterizer_dummy.h
View file

@ -444,7 +444,7 @@ public:
void reflection_probe_set_ambient_color(RID p_probe, const Color &p_color) override {}
void reflection_probe_set_ambient_energy(RID p_probe, float p_energy) override {}
void reflection_probe_set_max_distance(RID p_probe, float p_distance) override {}
void reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) override {}
void reflection_probe_set_size(RID p_probe, const Vector3 &p_size) override {}
void reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) override {}
void reflection_probe_set_as_interior(RID p_probe, bool p_enable) override {}
void reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) override {}
@ -455,7 +455,7 @@ public:
AABB reflection_probe_get_aabb(RID p_probe) const override { return AABB(); }
RS::ReflectionProbeUpdateMode reflection_probe_get_update_mode(RID p_probe) const override { return RenderingServer::REFLECTION_PROBE_UPDATE_ONCE; }
uint32_t reflection_probe_get_cull_mask(RID p_probe) const override { return 0; }
Vector3 reflection_probe_get_extents(RID p_probe) const override { return Vector3(); }
Vector3 reflection_probe_get_size(RID p_probe) const override { return Vector3(); }
Vector3 reflection_probe_get_origin_offset(RID p_probe) const override { return Vector3(); }
float reflection_probe_get_origin_max_distance(RID p_probe) const override { return 0.0; }
bool reflection_probe_renders_shadows(RID p_probe) const override { return false; }
@ -622,7 +622,7 @@ public:
void fog_volume_initialize(RID p_rid) override {}
void fog_volume_set_shape(RID p_fog_volume, RS::FogVolumeShape p_shape) override {}
void fog_volume_set_extents(RID p_fog_volume, const Vector3 &p_extents) override {}
void fog_volume_set_size(RID p_fog_volume, const Vector3 &p_size) override {}
void fog_volume_set_material(RID p_fog_volume, RID p_material) override {}
AABB fog_volume_get_aabb(RID p_fog_volume) const override { return AABB(); }
RS::FogVolumeShape fog_volume_get_shape(RID p_fog_volume) const override { return RS::FOG_VOLUME_SHAPE_BOX; }

12
servers/rendering/renderer_rd/renderer_scene_render_rd.cpp
View file

@ -2876,13 +2876,13 @@ void RendererSceneRenderRD::_setup_reflections(const PagedArray<RID> &p_reflecti
Cluster::ReflectionData &reflection_ubo = cluster.reflections[i];
Vector3 extents = storage->reflection_probe_get_extents(base_probe);
Vector3 size = storage->reflection_probe_get_size(base_probe);
rpi->cull_mask = storage->reflection_probe_get_cull_mask(base_probe);
reflection_ubo.box_extents[0] = extents.x;
reflection_ubo.box_extents[1] = extents.y;
reflection_ubo.box_extents[2] = extents.z;
reflection_ubo.box_extents[0] = size.x / 2;
reflection_ubo.box_extents[1] = size.y / 2;
reflection_ubo.box_extents[2] = size.z / 2;
reflection_ubo.index = rpi->atlas_index;
Vector3 origin_offset = storage->reflection_probe_get_origin_offset(base_probe);
@ -2909,7 +2909,7 @@ void RendererSceneRenderRD::_setup_reflections(const PagedArray<RID> &p_reflecti
RendererStorageRD::store_transform(proj, reflection_ubo.local_matrix);
if (current_cluster_builder != nullptr) {
current_cluster_builder->add_box(ClusterBuilderRD::BOX_TYPE_REFLECTION_PROBE, transform, extents);
current_cluster_builder->add_box(ClusterBuilderRD::BOX_TYPE_REFLECTION_PROBE, transform, size / 2);
}
rpi->last_pass = RSG::rasterizer->get_frame_number();
@ -3925,7 +3925,7 @@ void RendererSceneRenderRD::_update_volumetric_fog(RID p_render_buffers, RID p_e
Vector3 position = fog_volume_instance->transform.get_origin();
RS::FogVolumeShape volume_type = storage->fog_volume_get_shape(fog_volume);
Vector3 extents = storage->fog_volume_get_extents(fog_volume);
Vector3 extents = storage->fog_volume_get_size(fog_volume) / 2;
if (volume_type == RS::FOG_VOLUME_SHAPE_BOX || volume_type == RS::FOG_VOLUME_SHAPE_ELLIPSOID) {
Vector3i points[8];

26
servers/rendering/renderer_rd/renderer_storage_rd.cpp
View file

@ -6062,11 +6062,11 @@ void RendererStorageRD::fog_volume_set_shape(RID p_fog_volume, RS::FogVolumeShap
fog_volume->dependency.changed_notify(DEPENDENCY_CHANGED_AABB);
}
void RendererStorageRD::fog_volume_set_extents(RID p_fog_volume, const Vector3 &p_extents) {
void RendererStorageRD::fog_volume_set_size(RID p_fog_volume, const Vector3 &p_size) {
FogVolume *fog_volume = fog_volume_owner.get_or_null(p_fog_volume);
ERR_FAIL_COND(!fog_volume);
fog_volume->extents = p_extents;
fog_volume->size = p_size;
fog_volume->dependency.changed_notify(DEPENDENCY_CHANGED_AABB);
}
@ -6098,8 +6098,8 @@ AABB RendererStorageRD::fog_volume_get_aabb(RID p_fog_volume) const {
case RS::FOG_VOLUME_SHAPE_ELLIPSOID:
case RS::FOG_VOLUME_SHAPE_BOX: {
AABB aabb;
aabb.position = -fog_volume->extents;
aabb.size = fog_volume->extents * 2;
aabb.position = -fog_volume->size / 2;
aabb.size = fog_volume->size;
return aabb;
}
default: {
@ -6111,10 +6111,10 @@ AABB RendererStorageRD::fog_volume_get_aabb(RID p_fog_volume) const {
return AABB();
}
Vector3 RendererStorageRD::fog_volume_get_extents(RID p_fog_volume) const {
Vector3 RendererStorageRD::fog_volume_get_size(RID p_fog_volume) const {
const FogVolume *fog_volume = fog_volume_owner.get_or_null(p_fog_volume);
ERR_FAIL_COND_V(!fog_volume, Vector3());
return fog_volume->extents;
return fog_volume->size;
}
/* VISIBILITY NOTIFIER */
@ -6695,14 +6695,14 @@ void RendererStorageRD::reflection_probe_set_max_distance(RID p_probe, float p_d
reflection_probe->dependency.changed_notify(DEPENDENCY_CHANGED_REFLECTION_PROBE);
}
void RendererStorageRD::reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) {
void RendererStorageRD::reflection_probe_set_size(RID p_probe, const Vector3 &p_size) {
ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
ERR_FAIL_COND(!reflection_probe);
if (reflection_probe->extents == p_extents) {
if (reflection_probe->size == p_size) {
return;
}
reflection_probe->extents = p_extents;
reflection_probe->size = p_size;
reflection_probe->dependency.changed_notify(DEPENDENCY_CHANGED_REFLECTION_PROBE);
}
@ -6767,8 +6767,8 @@ AABB RendererStorageRD::reflection_probe_get_aabb(RID p_probe) const {
ERR_FAIL_COND_V(!reflection_probe, AABB());
AABB aabb;
aabb.position = -reflection_probe->extents;
aabb.size = reflection_probe->extents * 2.0;
aabb.position = -reflection_probe->size / 2.0;
aabb.size = reflection_probe->size;
return aabb;
}
@ -6787,11 +6787,11 @@ uint32_t RendererStorageRD::reflection_probe_get_cull_mask(RID p_probe) const {
return reflection_probe->cull_mask;
}
Vector3 RendererStorageRD::reflection_probe_get_extents(RID p_probe) const {
Vector3 RendererStorageRD::reflection_probe_get_size(RID p_probe) const {
const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe);
ERR_FAIL_COND_V(!reflection_probe, Vector3());
return reflection_probe->extents;
return reflection_probe->size;
}
Vector3 RendererStorageRD::reflection_probe_get_origin_offset(RID p_probe) const {

12
servers/rendering/renderer_rd/renderer_storage_rd.h
View file

@ -963,7 +963,7 @@ private:
struct FogVolume {
RID material;
Vector3 extents = Vector3(1, 1, 1);
Vector3 size = Vector3(1, 1, 1);
RS::FogVolumeShape shape = RS::FOG_VOLUME_SHAPE_BOX;
@ -1046,7 +1046,7 @@ private:
Color ambient_color;
float ambient_color_energy = 1.0;
float max_distance = 0;
Vector3 extents = Vector3(1, 1, 1);
Vector3 size = Vector3(2, 2, 2);
Vector3 origin_offset;
bool interior = false;
bool box_projection = false;
@ -1940,7 +1940,7 @@ public:
void reflection_probe_set_ambient_color(RID p_probe, const Color &p_color);
void reflection_probe_set_ambient_energy(RID p_probe, float p_energy);
void reflection_probe_set_max_distance(RID p_probe, float p_distance);
void reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents);
void reflection_probe_set_size(RID p_probe, const Vector3 &p_size);
void reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset);
void reflection_probe_set_as_interior(RID p_probe, bool p_enable);
void reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable);
@ -1952,7 +1952,7 @@ public:
AABB reflection_probe_get_aabb(RID p_probe) const;
RS::ReflectionProbeUpdateMode reflection_probe_get_update_mode(RID p_probe) const;
uint32_t reflection_probe_get_cull_mask(RID p_probe) const;
Vector3 reflection_probe_get_extents(RID p_probe) const;
Vector3 reflection_probe_get_size(RID p_probe) const;
Vector3 reflection_probe_get_origin_offset(RID p_probe) const;
float reflection_probe_get_origin_max_distance(RID p_probe) const;
float reflection_probe_get_lod_threshold(RID p_probe) const;
@ -2280,12 +2280,12 @@ public:
virtual void fog_volume_initialize(RID p_rid);
virtual void fog_volume_set_shape(RID p_fog_volume, RS::FogVolumeShape p_shape);
virtual void fog_volume_set_extents(RID p_fog_volume, const Vector3 &p_extents);
virtual void fog_volume_set_size(RID p_fog_volume, const Vector3 &p_size);
virtual void fog_volume_set_material(RID p_fog_volume, RID p_material);
virtual RS::FogVolumeShape fog_volume_get_shape(RID p_fog_volume) const;
virtual RID fog_volume_get_material(RID p_fog_volume) const;
virtual AABB fog_volume_get_aabb(RID p_fog_volume) const;
virtual Vector3 fog_volume_get_extents(RID p_fog_volume) const;
virtual Vector3 fog_volume_get_size(RID p_fog_volume) const;
/* VISIBILITY NOTIFIER */

4
servers/rendering/renderer_scene_cull.cpp
View file

@ -3286,13 +3286,13 @@ bool RendererSceneCull::_render_reflection_probe_step(Instance *p_instance, int
Vector3(0, -1, 0)
};
Vector3 extents = RSG::storage->reflection_probe_get_extents(p_instance->base);
Vector3 size_vector = RSG::storage->reflection_probe_get_size(p_instance->base);
Vector3 origin_offset = RSG::storage->reflection_probe_get_origin_offset(p_instance->base);
float max_distance = RSG::storage->reflection_probe_get_origin_max_distance(p_instance->base);
float size = scene_render->reflection_atlas_get_size(scenario->reflection_atlas);
float lod_threshold = RSG::storage->reflection_probe_get_lod_threshold(p_instance->base) / size;
Vector3 edge = view_normals[p_step] * extents;
Vector3 edge = view_normals[p_step] * size_vector / 2;
float distance = ABS(view_normals[p_step].dot(edge) - view_normals[p_step].dot(origin_offset)); //distance from origin offset to actual view distance limit
max_distance = MAX(max_distance, distance);

6
servers/rendering/renderer_storage.h
View file

@ -360,7 +360,7 @@ public:
virtual void reflection_probe_set_ambient_color(RID p_probe, const Color &p_color) = 0;
virtual void reflection_probe_set_ambient_energy(RID p_probe, float p_energy) = 0;
virtual void reflection_probe_set_max_distance(RID p_probe, float p_distance) = 0;
virtual void reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) = 0;
virtual void reflection_probe_set_size(RID p_probe, const Vector3 &p_size) = 0;
virtual void reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) = 0;
virtual void reflection_probe_set_as_interior(RID p_probe, bool p_enable) = 0;
virtual void reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) = 0;
@ -371,7 +371,7 @@ public:
virtual AABB reflection_probe_get_aabb(RID p_probe) const = 0;
virtual RS::ReflectionProbeUpdateMode reflection_probe_get_update_mode(RID p_probe) const = 0;
virtual uint32_t reflection_probe_get_cull_mask(RID p_probe) const = 0;
virtual Vector3 reflection_probe_get_extents(RID p_probe) const = 0;
virtual Vector3 reflection_probe_get_size(RID p_probe) const = 0;
virtual Vector3 reflection_probe_get_origin_offset(RID p_probe) const = 0;
virtual float reflection_probe_get_origin_max_distance(RID p_probe) const = 0;
virtual bool reflection_probe_renders_shadows(RID p_probe) const = 0;
@ -541,7 +541,7 @@ public:
virtual void fog_volume_initialize(RID p_rid) = 0;
virtual void fog_volume_set_shape(RID p_fog_volume, RS::FogVolumeShape p_shape) = 0;
virtual void fog_volume_set_extents(RID p_fog_volume, const Vector3 &p_extents) = 0;
virtual void fog_volume_set_size(RID p_fog_volume, const Vector3 &p_size) = 0;
virtual void fog_volume_set_material(RID p_fog_volume, RID p_material) = 0;
virtual AABB fog_volume_get_aabb(RID p_fog_volume) const = 0;
virtual RS::FogVolumeShape fog_volume_get_shape(RID p_fog_volume) const = 0;

4
servers/rendering/rendering_server_default.h
View file

@ -367,7 +367,7 @@ public:
FUNC2(reflection_probe_set_ambient_energy, RID, float)
FUNC2(reflection_probe_set_ambient_mode, RID, ReflectionProbeAmbientMode)
FUNC2(reflection_probe_set_max_distance, RID, float)
FUNC2(reflection_probe_set_extents, RID, const Vector3 &)
FUNC2(reflection_probe_set_size, RID, const Vector3 &)
FUNC2(reflection_probe_set_origin_offset, RID, const Vector3 &)
FUNC2(reflection_probe_set_as_interior, RID, bool)
FUNC2(reflection_probe_set_enable_box_projection, RID, bool)
@ -486,7 +486,7 @@ public:
FUNCRIDSPLIT(fog_volume)
FUNC2(fog_volume_set_shape, RID, FogVolumeShape)
FUNC2(fog_volume_set_extents, RID, const Vector3 &)
FUNC2(fog_volume_set_size, RID, const Vector3 &)
FUNC2(fog_volume_set_material, RID, RID)
/* VISIBILITY_NOTIFIER */

2
servers/rendering/shader_types.cpp
View file

@ -453,7 +453,7 @@ ShaderTypes::ShaderTypes() {
shader_modes[RS::SHADER_FOG].functions["fog"].built_ins["WORLD_POSITION"] = constt(ShaderLanguage::TYPE_VEC3);
shader_modes[RS::SHADER_FOG].functions["fog"].built_ins["OBJECT_POSITION"] = constt(ShaderLanguage::TYPE_VEC3);
shader_modes[RS::SHADER_FOG].functions["fog"].built_ins["UVW"] = constt(ShaderLanguage::TYPE_VEC3);
shader_modes[RS::SHADER_FOG].functions["fog"].built_ins["EXTENTS"] = constt(ShaderLanguage::TYPE_VEC3);
shader_modes[RS::SHADER_FOG].functions["fog"].built_ins["SIZE"] = constt(ShaderLanguage::TYPE_VEC3);
shader_modes[RS::SHADER_FOG].functions["fog"].built_ins["TRANSFORM"] = constt(ShaderLanguage::TYPE_MAT4);
shader_modes[RS::SHADER_FOG].functions["fog"].built_ins["SDF"] = constt(ShaderLanguage::TYPE_FLOAT);
shader_modes[RS::SHADER_FOG].functions["fog"].built_ins["ALBEDO"] = ShaderLanguage::TYPE_VEC3;

4
servers/rendering_server.cpp
View file

@ -1959,7 +1959,7 @@ void RenderingServer::_bind_methods() {
ClassDB::bind_method(D_METHOD("reflection_probe_set_ambient_color", "probe", "color"), &RenderingServer::reflection_probe_set_ambient_color);
ClassDB::bind_method(D_METHOD("reflection_probe_set_ambient_energy", "probe", "energy"), &RenderingServer::reflection_probe_set_ambient_energy);
ClassDB::bind_method(D_METHOD("reflection_probe_set_max_distance", "probe", "distance"), &RenderingServer::reflection_probe_set_max_distance);
ClassDB::bind_method(D_METHOD("reflection_probe_set_extents", "probe", "extents"), &RenderingServer::reflection_probe_set_extents);
ClassDB::bind_method(D_METHOD("reflection_probe_set_size", "probe", "size"), &RenderingServer::reflection_probe_set_size);
ClassDB::bind_method(D_METHOD("reflection_probe_set_origin_offset", "probe", "offset"), &RenderingServer::reflection_probe_set_origin_offset);
ClassDB::bind_method(D_METHOD("reflection_probe_set_as_interior", "probe", "enable"), &RenderingServer::reflection_probe_set_as_interior);
ClassDB::bind_method(D_METHOD("reflection_probe_set_enable_box_projection", "probe", "enable"), &RenderingServer::reflection_probe_set_enable_box_projection);
@ -2131,7 +2131,7 @@ void RenderingServer::_bind_methods() {
ClassDB::bind_method(D_METHOD("fog_volume_create"), &RenderingServer::fog_volume_create);
ClassDB::bind_method(D_METHOD("fog_volume_set_shape", "fog_volume", "shape"), &RenderingServer::fog_volume_set_shape);
ClassDB::bind_method(D_METHOD("fog_volume_set_extents", "fog_volume", "extents"), &RenderingServer::fog_volume_set_extents);
ClassDB::bind_method(D_METHOD("fog_volume_set_size", "fog_volume", "size"), &RenderingServer::fog_volume_set_size);
ClassDB::bind_method(D_METHOD("fog_volume_set_material", "fog_volume", "material"), &RenderingServer::fog_volume_set_material);
BIND_ENUM_CONSTANT(FOG_VOLUME_SHAPE_ELLIPSOID);

4
servers/rendering_server.h
View file

@ -518,7 +518,7 @@ public:
virtual void reflection_probe_set_ambient_color(RID p_probe, const Color &p_color) = 0;
virtual void reflection_probe_set_ambient_energy(RID p_probe, float p_energy) = 0;
virtual void reflection_probe_set_max_distance(RID p_probe, float p_distance) = 0;
virtual void reflection_probe_set_extents(RID p_probe, const Vector3 &p_extents) = 0;
virtual void reflection_probe_set_size(RID p_probe, const Vector3 &p_size) = 0;
virtual void reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) = 0;
virtual void reflection_probe_set_as_interior(RID p_probe, bool p_enable) = 0;
virtual void reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) = 0;
@ -721,7 +721,7 @@ public:
};
virtual void fog_volume_set_shape(RID p_fog_volume, FogVolumeShape p_shape) = 0;
virtual void fog_volume_set_extents(RID p_fog_volume, const Vector3 &p_extents) = 0;
virtual void fog_volume_set_size(RID p_fog_volume, const Vector3 &p_size) = 0;
virtual void fog_volume_set_material(RID p_fog_volume, RID p_material) = 0;
/* VISIBILITY NOTIFIER API */