Stowage/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2025-11-03 23:21:15 +00:00
Code Issues Projects Releases Packages Wiki Activity
godot/scene/resources/sky_material.cpp

Ignoring revisions in .git-blame-ignore-revs. Click here to bypass and see the normal blame view.

768 lines
31 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 13:25:55 +01:00
/**************************************************************************/
/* sky_material.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* Permission is hereby granted, free of charge, to any person obtaining */
/* a copy of this software and associated documentation files (the */
/* "Software"), to deal in the Software without restriction, including */
/* without limitation the rights to use, copy, modify, merge, publish, */
/* distribute, sublicense, and/or sell copies of the Software, and to */
/* permit persons to whom the Software is furnished to do so, subject to */
/* the following conditions: */
/* */
/* The above copyright notice and this permission notice shall be */
/* included in all copies or substantial portions of the Software. */
/* */
/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
/**************************************************************************/
Add shader based background mode
2019-09-15 19:58:38 +10:00
#include "sky_material.h"
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
#include "core/config/project_settings.h"
Add a comment at the top of generated shaders This comment is useful to determine the origin of ShaderMaterials converted from built-in material types (such as CanvasItemMaterial or StandardMaterial3D). The Godot version is also included in case the shader needs to be regenerated with a newer engine version.
2021-07-04 17:26:25 +02:00
#include "core/version.h"
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
Mutex ProceduralSkyMaterial::shader_mutex;
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
RID ProceduralSkyMaterial::shader_cache[2];
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void ProceduralSkyMaterial::set_sky_top_color(const Color &p_sky_top) {
sky_top_color = p_sky_top;
Fix ProceduralSkyMaterial colors due to double sRGB -> linear conversion
2021-11-20 17:26:06 +01:00
RS::get_singleton()->material_set_param(_get_material(), "sky_top_color", sky_top_color);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Color ProceduralSkyMaterial::get_sky_top_color() const {
return sky_top_color;
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void ProceduralSkyMaterial::set_sky_horizon_color(const Color &p_sky_horizon) {
sky_horizon_color = p_sky_horizon;
Fix ProceduralSkyMaterial colors due to double sRGB -> linear conversion
2021-11-20 17:26:06 +01:00
RS::get_singleton()->material_set_param(_get_material(), "sky_horizon_color", sky_horizon_color);
Add shader based background mode
2019-09-15 19:58:38 +10:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Color ProceduralSkyMaterial::get_sky_horizon_color() const {
return sky_horizon_color;
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void ProceduralSkyMaterial::set_sky_curve(float p_curve) {
sky_curve = p_curve;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
RS::get_singleton()->material_set_param(_get_material(), "sky_curve", sky_curve);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
float ProceduralSkyMaterial::get_sky_curve() const {
return sky_curve;
Add shader based background mode
2019-09-15 19:58:38 +10:00
}
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
void ProceduralSkyMaterial::set_sky_energy_multiplier(float p_multiplier) {
sky_energy_multiplier = p_multiplier;
RS::get_singleton()->material_set_param(_get_material(), "sky_energy", sky_energy_multiplier);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
float ProceduralSkyMaterial::get_sky_energy_multiplier() const {
return sky_energy_multiplier;
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Add sky cover texture for ProceduralSkyMaterial This brings PhysicalSkyMaterial's Night Sky functionality to ProceduralSkyMaterial, but in a more powerful and general fashion. This can be used to display stars at night, or clouds at day and night. For clouds, it won't be physically accurate, but it can look good still. The Sky Cover Modulate property can be used to adjust the sky cover's colors and opacity in real-time, which is useful for day/night or weather transitions.
2022-02-12 18:38:05 +01:00
void ProceduralSkyMaterial::set_sky_cover(const Ref<Texture2D> &p_sky_cover) {
sky_cover = p_sky_cover;
RID tex_rid = p_sky_cover.is_valid() ? p_sky_cover->get_rid() : RID();
RS::get_singleton()->material_set_param(_get_material(), "sky_cover", tex_rid);
}
Ref<Texture2D> ProceduralSkyMaterial::get_sky_cover() const {
return sky_cover;
}
void ProceduralSkyMaterial::set_sky_cover_modulate(const Color &p_sky_cover_modulate) {
sky_cover_modulate = p_sky_cover_modulate;
RS::get_singleton()->material_set_param(_get_material(), "sky_cover_modulate", sky_cover_modulate);
}
Color ProceduralSkyMaterial::get_sky_cover_modulate() const {
return sky_cover_modulate;
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void ProceduralSkyMaterial::set_ground_bottom_color(const Color &p_ground_bottom) {
ground_bottom_color = p_ground_bottom;
Fix ProceduralSkyMaterial colors due to double sRGB -> linear conversion
2021-11-20 17:26:06 +01:00
RS::get_singleton()->material_set_param(_get_material(), "ground_bottom_color", ground_bottom_color);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Color ProceduralSkyMaterial::get_ground_bottom_color() const {
return ground_bottom_color;
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void ProceduralSkyMaterial::set_ground_horizon_color(const Color &p_ground_horizon) {
ground_horizon_color = p_ground_horizon;
Fix ProceduralSkyMaterial colors due to double sRGB -> linear conversion
2021-11-20 17:26:06 +01:00
RS::get_singleton()->material_set_param(_get_material(), "ground_horizon_color", ground_horizon_color);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Color ProceduralSkyMaterial::get_ground_horizon_color() const {
return ground_horizon_color;
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void ProceduralSkyMaterial::set_ground_curve(float p_curve) {
ground_curve = p_curve;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
RS::get_singleton()->material_set_param(_get_material(), "ground_curve", ground_curve);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
float ProceduralSkyMaterial::get_ground_curve() const {
return ground_curve;
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
void ProceduralSkyMaterial::set_ground_energy_multiplier(float p_multiplier) {
ground_energy_multiplier = p_multiplier;
RS::get_singleton()->material_set_param(_get_material(), "ground_energy", ground_energy_multiplier);
Add shader based background mode
2019-09-15 19:58:38 +10:00
}
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 14:29:06 +02:00
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
float ProceduralSkyMaterial::get_ground_energy_multiplier() const {
return ground_energy_multiplier;
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void ProceduralSkyMaterial::set_sun_angle_max(float p_angle) {
sun_angle_max = p_angle;
Rename `str2var` to `str_to_var` and similar Affects the Math class, a good chunk of the audio code, and a lot of other miscellaneous classes, too. - `var2str` -> `var_to_str` - `str2var` -> `str_to_var` - `bytes2var` -> `bytes_to_var` - `bytes2var_with_objects` -> `bytes_to_var_with_objects` - `var2bytes` -> `var_to_bytes` - `var2bytes_with_objects` -> `var_to_bytes_with_objects` - `linear2db` -> `linear_to_db` - `db2linear` -> `db_to_linear` - `deg2rad` -> `deg_to_rad` - `rad2deg` -> `rad_to_deg` - `dict2inst` -> `dict_to_inst` - `inst2dict` -> `inst_to_dict`
2022-08-13 17:45:42 +02:00
RS::get_singleton()->material_set_param(_get_material(), "sun_angle_max", Math::deg_to_rad(sun_angle_max));
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
float ProceduralSkyMaterial::get_sun_angle_max() const {
return sun_angle_max;
Add shader based background mode
2019-09-15 19:58:38 +10:00
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void ProceduralSkyMaterial::set_sun_curve(float p_curve) {
sun_curve = p_curve;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
RS::get_singleton()->material_set_param(_get_material(), "sun_curve", sun_curve);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
float ProceduralSkyMaterial::get_sun_curve() const {
return sun_curve;
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Use IGN instead of white noise for sky dithering
2022-04-29 12:46:29 -07:00
void ProceduralSkyMaterial::set_use_debanding(bool p_use_debanding) {
use_debanding = p_use_debanding;
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
_update_shader();
// Only set if shader already compiled
if (shader_set) {
RS::get_singleton()->material_set_shader(_get_material(), shader_cache[int(use_debanding)]);
}
Add dithering to ProceduralSkyMaterial to combat banding Dithering was already present in PhysicalSkyMaterial. This brings it to ProceduralSkyMaterial as well, with the same algorithm and default intensity.
2022-04-09 18:23:20 +02:00
}
Use IGN instead of white noise for sky dithering
2022-04-29 12:46:29 -07:00
bool ProceduralSkyMaterial::get_use_debanding() const {
return use_debanding;
Add dithering to ProceduralSkyMaterial to combat banding Dithering was already present in PhysicalSkyMaterial. This brings it to ProceduralSkyMaterial as well, with the same algorithm and default intensity.
2022-04-09 18:23:20 +02:00
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Shader::Mode ProceduralSkyMaterial::get_shader_mode() const {
return Shader::MODE_SKY;
}
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
RID ProceduralSkyMaterial::get_rid() const {
_update_shader();
if (!shader_set) {
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
RS::get_singleton()->material_set_shader(_get_material(), shader_cache[1 - int(use_debanding)]);
RS::get_singleton()->material_set_shader(_get_material(), shader_cache[int(use_debanding)]);
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
shader_set = true;
}
return _get_material();
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
RID ProceduralSkyMaterial::get_shader_rid() const {
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
_update_shader();
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
return shader_cache[int(use_debanding)];
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
void ProceduralSkyMaterial::_validate_property(PropertyInfo &p_property) const {
if ((p_property.name == "sky_luminance" || p_property.name == "ground_luminance") && !GLOBAL_GET("rendering/lights_and_shadows/use_physical_light_units")) {
p_property.usage = PROPERTY_USAGE_NO_EDITOR;
}
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void ProceduralSkyMaterial::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_sky_top_color", "color"), &ProceduralSkyMaterial::set_sky_top_color);
ClassDB::bind_method(D_METHOD("get_sky_top_color"), &ProceduralSkyMaterial::get_sky_top_color);
ClassDB::bind_method(D_METHOD("set_sky_horizon_color", "color"), &ProceduralSkyMaterial::set_sky_horizon_color);
ClassDB::bind_method(D_METHOD("get_sky_horizon_color"), &ProceduralSkyMaterial::get_sky_horizon_color);
ClassDB::bind_method(D_METHOD("set_sky_curve", "curve"), &ProceduralSkyMaterial::set_sky_curve);
ClassDB::bind_method(D_METHOD("get_sky_curve"), &ProceduralSkyMaterial::get_sky_curve);
Add shader based background mode
2019-09-15 19:58:38 +10:00
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
ClassDB::bind_method(D_METHOD("set_sky_energy_multiplier", "multiplier"), &ProceduralSkyMaterial::set_sky_energy_multiplier);
ClassDB::bind_method(D_METHOD("get_sky_energy_multiplier"), &ProceduralSkyMaterial::get_sky_energy_multiplier);
Add shader based background mode
2019-09-15 19:58:38 +10:00
Add sky cover texture for ProceduralSkyMaterial This brings PhysicalSkyMaterial's Night Sky functionality to ProceduralSkyMaterial, but in a more powerful and general fashion. This can be used to display stars at night, or clouds at day and night. For clouds, it won't be physically accurate, but it can look good still. The Sky Cover Modulate property can be used to adjust the sky cover's colors and opacity in real-time, which is useful for day/night or weather transitions.
2022-02-12 18:38:05 +01:00
ClassDB::bind_method(D_METHOD("set_sky_cover", "sky_cover"), &ProceduralSkyMaterial::set_sky_cover);
ClassDB::bind_method(D_METHOD("get_sky_cover"), &ProceduralSkyMaterial::get_sky_cover);
ClassDB::bind_method(D_METHOD("set_sky_cover_modulate", "color"), &ProceduralSkyMaterial::set_sky_cover_modulate);
ClassDB::bind_method(D_METHOD("get_sky_cover_modulate"), &ProceduralSkyMaterial::get_sky_cover_modulate);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ClassDB::bind_method(D_METHOD("set_ground_bottom_color", "color"), &ProceduralSkyMaterial::set_ground_bottom_color);
ClassDB::bind_method(D_METHOD("get_ground_bottom_color"), &ProceduralSkyMaterial::get_ground_bottom_color);
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ClassDB::bind_method(D_METHOD("set_ground_horizon_color", "color"), &ProceduralSkyMaterial::set_ground_horizon_color);
ClassDB::bind_method(D_METHOD("get_ground_horizon_color"), &ProceduralSkyMaterial::get_ground_horizon_color);
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ClassDB::bind_method(D_METHOD("set_ground_curve", "curve"), &ProceduralSkyMaterial::set_ground_curve);
ClassDB::bind_method(D_METHOD("get_ground_curve"), &ProceduralSkyMaterial::get_ground_curve);
Add shader based background mode
2019-09-15 19:58:38 +10:00
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
ClassDB::bind_method(D_METHOD("set_ground_energy_multiplier", "energy"), &ProceduralSkyMaterial::set_ground_energy_multiplier);
ClassDB::bind_method(D_METHOD("get_ground_energy_multiplier"), &ProceduralSkyMaterial::get_ground_energy_multiplier);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ClassDB::bind_method(D_METHOD("set_sun_angle_max", "degrees"), &ProceduralSkyMaterial::set_sun_angle_max);
ClassDB::bind_method(D_METHOD("get_sun_angle_max"), &ProceduralSkyMaterial::get_sun_angle_max);
ClassDB::bind_method(D_METHOD("set_sun_curve", "curve"), &ProceduralSkyMaterial::set_sun_curve);
ClassDB::bind_method(D_METHOD("get_sun_curve"), &ProceduralSkyMaterial::get_sun_curve);
Use IGN instead of white noise for sky dithering
2022-04-29 12:46:29 -07:00
ClassDB::bind_method(D_METHOD("set_use_debanding", "use_debanding"), &ProceduralSkyMaterial::set_use_debanding);
ClassDB::bind_method(D_METHOD("get_use_debanding"), &ProceduralSkyMaterial::get_use_debanding);
Add dithering to ProceduralSkyMaterial to combat banding Dithering was already present in PhysicalSkyMaterial. This brings it to ProceduralSkyMaterial as well, with the same algorithm and default intensity.
2022-04-09 18:23:20 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ADD_GROUP("Sky", "sky_");
Don't allow translucent colors in built-in sky material properties The colors' alpha channel is ignored, so there's no point in exposing it in the editor.
2021-10-07 18:10:54 +02:00
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "sky_top_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_sky_top_color", "get_sky_top_color");
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "sky_horizon_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_sky_horizon_color", "get_sky_horizon_color");
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "sky_curve", PROPERTY_HINT_EXP_EASING), "set_sky_curve", "get_sky_curve");
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "sky_energy_multiplier", PROPERTY_HINT_RANGE, "0,64,0.01"), "set_sky_energy_multiplier", "get_sky_energy_multiplier");
Add sky cover texture for ProceduralSkyMaterial This brings PhysicalSkyMaterial's Night Sky functionality to ProceduralSkyMaterial, but in a more powerful and general fashion. This can be used to display stars at night, or clouds at day and night. For clouds, it won't be physically accurate, but it can look good still. The Sky Cover Modulate property can be used to adjust the sky cover's colors and opacity in real-time, which is useful for day/night or weather transitions.
2022-02-12 18:38:05 +01:00
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "sky_cover", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_sky_cover", "get_sky_cover");
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "sky_cover_modulate"), "set_sky_cover_modulate", "get_sky_cover_modulate");
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ADD_GROUP("Ground", "ground_");
Don't allow translucent colors in built-in sky material properties The colors' alpha channel is ignored, so there's no point in exposing it in the editor.
2021-10-07 18:10:54 +02:00
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "ground_bottom_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_ground_bottom_color", "get_ground_bottom_color");
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "ground_horizon_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_ground_horizon_color", "get_ground_horizon_color");
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "ground_curve", PROPERTY_HINT_EXP_EASING), "set_ground_curve", "get_ground_curve");
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "ground_energy_multiplier", PROPERTY_HINT_RANGE, "0,64,0.01"), "set_ground_energy_multiplier", "get_ground_energy_multiplier");
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ADD_GROUP("Sun", "sun_");
Use suffixes for units in nodes and resources
2021-12-02 18:09:19 -06:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "sun_angle_max", PROPERTY_HINT_RANGE, "0,360,0.01,degrees"), "set_sun_angle_max", "get_sun_angle_max");
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "sun_curve", PROPERTY_HINT_EXP_EASING), "set_sun_curve", "get_sun_curve");
Add dithering to ProceduralSkyMaterial to combat banding Dithering was already present in PhysicalSkyMaterial. This brings it to ProceduralSkyMaterial as well, with the same algorithm and default intensity.
2022-04-09 18:23:20 +02:00
ADD_GROUP("", "");
Use IGN instead of white noise for sky dithering
2022-04-29 12:46:29 -07:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_debanding"), "set_use_debanding", "get_use_debanding");
Add shader based background mode
2019-09-15 19:58:38 +10:00
}
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
void ProceduralSkyMaterial::cleanup_shader() {
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
if (shader_cache[0].is_valid()) {
RS::get_singleton()->free(shader_cache[0]);
RS::get_singleton()->free(shader_cache[1]);
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
}
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
void ProceduralSkyMaterial::_update_shader() {
shader_mutex.lock();
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
if (shader_cache[0].is_null()) {
for (int i = 0; i < 2; i++) {
shader_cache[i] = RS::get_singleton()->shader_create();
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
// Add a comment to describe the shader origin (useful when converting to ShaderMaterial).
RS::get_singleton()->shader_set_code(shader_cache[i], vformat(R"(
Add a comment at the top of generated shaders This comment is useful to determine the origin of ShaderMaterials converted from built-in material types (such as CanvasItemMaterial or StandardMaterial3D). The Godot version is also included in case the shader needs to be regenerated with a newer engine version.
2021-07-04 17:26:25 +02:00
// NOTE: Shader automatically converted from )" VERSION_NAME " " VERSION_FULL_CONFIG R"('s ProceduralSkyMaterial.
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
shader_type sky;
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
%s
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
uniform vec4 sky_top_color : source_color = vec4(0.385, 0.454, 0.55, 1.0);
uniform vec4 sky_horizon_color : source_color = vec4(0.646, 0.656, 0.67, 1.0);
Tweak default ProceduralSkyMaterial and PhysicalSkyMaterial appearance - Tweak colors to be less saturated and more balanced (in terms of hue). The cool blue sky is balanced by a warm brown ground, which makes reflections look closer to how they'd look like when using an HDRI panorama texture. - Make the ground color dark on both ProceduralSkyMaterial and PhysicalSkyMaterial to reduce indoor light leaking, especially when using GI. - Tweak the PhysicalSkyMaterial colors to be as close as possible to ProceduralSkyMaterial (with the default sun orientation). - Tweak editor environment defaults to be identical to the default ProceduralSkyMaterial colors. Previously, the default editor sky color was different from the colors of a newly created ProceduralSkyMaterial resource. Both new skies were tested without GI, with SDFGI and with VoxelGI. They were tuned to look best when using ACES tonemapping with a whitepoint set to 6, but they still look good with other tonemapping operators.
2022-02-11 22:59:35 +01:00
uniform float sky_curve : hint_range(0, 1) = 0.15;
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
uniform float sky_energy = 1.0; // In Lux.
Use linear filtering without mipmaps for ProceduralSkyMaterial and PhysicalSkyMaterial
2023-03-10 10:48:45 -08:00
uniform sampler2D sky_cover : filter_linear, source_color, hint_default_black;
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
uniform vec4 sky_cover_modulate : source_color = vec4(1.0, 1.0, 1.0, 1.0);
uniform vec4 ground_bottom_color : source_color = vec4(0.2, 0.169, 0.133, 1.0);
uniform vec4 ground_horizon_color : source_color = vec4(0.646, 0.656, 0.67, 1.0);
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
uniform float ground_curve : hint_range(0, 1) = 0.02;
uniform float ground_energy = 1.0;
Tweak default ProceduralSkyMaterial and PhysicalSkyMaterial appearance - Tweak colors to be less saturated and more balanced (in terms of hue). The cool blue sky is balanced by a warm brown ground, which makes reflections look closer to how they'd look like when using an HDRI panorama texture. - Make the ground color dark on both ProceduralSkyMaterial and PhysicalSkyMaterial to reduce indoor light leaking, especially when using GI. - Tweak the PhysicalSkyMaterial colors to be as close as possible to ProceduralSkyMaterial (with the default sun orientation). - Tweak editor environment defaults to be identical to the default ProceduralSkyMaterial colors. Previously, the default editor sky color was different from the colors of a newly created ProceduralSkyMaterial resource. Both new skies were tested without GI, with SDFGI and with VoxelGI. They were tuned to look best when using ACES tonemapping with a whitepoint set to 6, but they still look good with other tonemapping operators.
2022-02-11 22:59:35 +01:00
uniform float sun_angle_max = 30.0;
uniform float sun_curve : hint_range(0, 1) = 0.15;
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
void sky() {
float v_angle = acos(clamp(EYEDIR.y, -1.0, 1.0));
float c = (1.0 - v_angle / (PI * 0.5));
vec3 sky = mix(sky_horizon_color.rgb, sky_top_color.rgb, clamp(1.0 - pow(1.0 - c, 1.0 / sky_curve), 0.0, 1.0));
sky *= sky_energy;
if (LIGHT0_ENABLED) {
float sun_angle = acos(dot(LIGHT0_DIRECTION, EYEDIR));
if (sun_angle < LIGHT0_SIZE) {
sky = LIGHT0_COLOR * LIGHT0_ENERGY;
} else if (sun_angle < sun_angle_max) {
float c2 = (sun_angle - LIGHT0_SIZE) / (sun_angle_max - LIGHT0_SIZE);
sky = mix(LIGHT0_COLOR * LIGHT0_ENERGY, sky, clamp(1.0 - pow(1.0 - c2, 1.0 / sun_curve), 0.0, 1.0));
}
}
if (LIGHT1_ENABLED) {
float sun_angle = acos(dot(LIGHT1_DIRECTION, EYEDIR));
if (sun_angle < LIGHT1_SIZE) {
sky = LIGHT1_COLOR * LIGHT1_ENERGY;
} else if (sun_angle < sun_angle_max) {
float c2 = (sun_angle - LIGHT1_SIZE) / (sun_angle_max - LIGHT1_SIZE);
sky = mix(LIGHT1_COLOR * LIGHT1_ENERGY, sky, clamp(1.0 - pow(1.0 - c2, 1.0 / sun_curve), 0.0, 1.0));
}
}
if (LIGHT2_ENABLED) {
float sun_angle = acos(dot(LIGHT2_DIRECTION, EYEDIR));
if (sun_angle < LIGHT2_SIZE) {
sky = LIGHT2_COLOR * LIGHT2_ENERGY;
} else if (sun_angle < sun_angle_max) {
float c2 = (sun_angle - LIGHT2_SIZE) / (sun_angle_max - LIGHT2_SIZE);
sky = mix(LIGHT2_COLOR * LIGHT2_ENERGY, sky, clamp(1.0 - pow(1.0 - c2, 1.0 / sun_curve), 0.0, 1.0));
}
}
if (LIGHT3_ENABLED) {
float sun_angle = acos(dot(LIGHT3_DIRECTION, EYEDIR));
if (sun_angle < LIGHT3_SIZE) {
sky = LIGHT3_COLOR * LIGHT3_ENERGY;
} else if (sun_angle < sun_angle_max) {
float c2 = (sun_angle - LIGHT3_SIZE) / (sun_angle_max - LIGHT3_SIZE);
sky = mix(LIGHT3_COLOR * LIGHT3_ENERGY, sky, clamp(1.0 - pow(1.0 - c2, 1.0 / sun_curve), 0.0, 1.0));
}
}
Add sky cover texture for ProceduralSkyMaterial This brings PhysicalSkyMaterial's Night Sky functionality to ProceduralSkyMaterial, but in a more powerful and general fashion. This can be used to display stars at night, or clouds at day and night. For clouds, it won't be physically accurate, but it can look good still. The Sky Cover Modulate property can be used to adjust the sky cover's colors and opacity in real-time, which is useful for day/night or weather transitions.
2022-02-12 18:38:05 +01:00
vec4 sky_cover_texture = texture(sky_cover, SKY_COORDS);
sky += (sky_cover_texture.rgb * sky_cover_modulate.rgb) * sky_cover_texture.a * sky_cover_modulate.a * sky_energy;
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
c = (v_angle - (PI * 0.5)) / (PI * 0.5);
vec3 ground = mix(ground_horizon_color.rgb, ground_bottom_color.rgb, clamp(1.0 - pow(1.0 - c, 1.0 / ground_curve), 0.0, 1.0));
ground *= ground_energy;
COLOR = mix(ground, sky, step(0.0, EYEDIR.y));
}
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
)",
i ? "render_mode use_debanding;" : ""));
}
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
}
shader_mutex.unlock();
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
ProceduralSkyMaterial::ProceduralSkyMaterial() {
Tweak default ProceduralSkyMaterial and PhysicalSkyMaterial appearance - Tweak colors to be less saturated and more balanced (in terms of hue). The cool blue sky is balanced by a warm brown ground, which makes reflections look closer to how they'd look like when using an HDRI panorama texture. - Make the ground color dark on both ProceduralSkyMaterial and PhysicalSkyMaterial to reduce indoor light leaking, especially when using GI. - Tweak the PhysicalSkyMaterial colors to be as close as possible to ProceduralSkyMaterial (with the default sun orientation). - Tweak editor environment defaults to be identical to the default ProceduralSkyMaterial colors. Previously, the default editor sky color was different from the colors of a newly created ProceduralSkyMaterial resource. Both new skies were tested without GI, with SDFGI and with VoxelGI. They were tuned to look best when using ACES tonemapping with a whitepoint set to 6, but they still look good with other tonemapping operators.
2022-02-11 22:59:35 +01:00
set_sky_top_color(Color(0.385, 0.454, 0.55));
set_sky_horizon_color(Color(0.6463, 0.6558, 0.6708));
set_sky_curve(0.15);
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
set_sky_energy_multiplier(1.0);
Add sky cover texture for ProceduralSkyMaterial This brings PhysicalSkyMaterial's Night Sky functionality to ProceduralSkyMaterial, but in a more powerful and general fashion. This can be used to display stars at night, or clouds at day and night. For clouds, it won't be physically accurate, but it can look good still. The Sky Cover Modulate property can be used to adjust the sky cover's colors and opacity in real-time, which is useful for day/night or weather transitions.
2022-02-12 18:38:05 +01:00
set_sky_cover_modulate(Color(1, 1, 1));
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Tweak default ProceduralSkyMaterial and PhysicalSkyMaterial appearance - Tweak colors to be less saturated and more balanced (in terms of hue). The cool blue sky is balanced by a warm brown ground, which makes reflections look closer to how they'd look like when using an HDRI panorama texture. - Make the ground color dark on both ProceduralSkyMaterial and PhysicalSkyMaterial to reduce indoor light leaking, especially when using GI. - Tweak the PhysicalSkyMaterial colors to be as close as possible to ProceduralSkyMaterial (with the default sun orientation). - Tweak editor environment defaults to be identical to the default ProceduralSkyMaterial colors. Previously, the default editor sky color was different from the colors of a newly created ProceduralSkyMaterial resource. Both new skies were tested without GI, with SDFGI and with VoxelGI. They were tuned to look best when using ACES tonemapping with a whitepoint set to 6, but they still look good with other tonemapping operators.
2022-02-11 22:59:35 +01:00
set_ground_bottom_color(Color(0.2, 0.169, 0.133));
set_ground_horizon_color(Color(0.6463, 0.6558, 0.6708));
Working sky shader implementation
2020-03-19 17:32:19 -07:00
set_ground_curve(0.02);
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
set_ground_energy_multiplier(1.0);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Tweak default ProceduralSkyMaterial and PhysicalSkyMaterial appearance - Tweak colors to be less saturated and more balanced (in terms of hue). The cool blue sky is balanced by a warm brown ground, which makes reflections look closer to how they'd look like when using an HDRI panorama texture. - Make the ground color dark on both ProceduralSkyMaterial and PhysicalSkyMaterial to reduce indoor light leaking, especially when using GI. - Tweak the PhysicalSkyMaterial colors to be as close as possible to ProceduralSkyMaterial (with the default sun orientation). - Tweak editor environment defaults to be identical to the default ProceduralSkyMaterial colors. Previously, the default editor sky color was different from the colors of a newly created ProceduralSkyMaterial resource. Both new skies were tested without GI, with SDFGI and with VoxelGI. They were tuned to look best when using ACES tonemapping with a whitepoint set to 6, but they still look good with other tonemapping operators.
2022-02-11 22:59:35 +01:00
set_sun_angle_max(30.0);
set_sun_curve(0.15);
Use IGN instead of white noise for sky dithering
2022-04-29 12:46:29 -07:00
set_use_debanding(true);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ProceduralSkyMaterial::~ProceduralSkyMaterial() {
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
/////////////////////////////////////////
/* PanoramaSkyMaterial */
void PanoramaSkyMaterial::set_panorama(const Ref<Texture2D> &p_panorama) {
panorama = p_panorama;
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-05 22:40:29 -03:00
RID tex_rid = p_panorama.is_valid() ? p_panorama->get_rid() : RID();
RS::get_singleton()->material_set_param(_get_material(), "source_panorama", tex_rid);
Add shader based background mode
2019-09-15 19:58:38 +10:00
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Ref<Texture2D> PanoramaSkyMaterial::get_panorama() const {
return panorama;
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Add shader cache and filter variable to PanoramaSkyMaterial
2022-01-14 20:42:25 -05:00
void PanoramaSkyMaterial::set_filtering_enabled(bool p_enabled) {
filter = p_enabled;
notify_property_list_changed();
_update_shader();
// Only set if shader already compiled
if (shader_set) {
RS::get_singleton()->material_set_shader(_get_material(), shader_cache[int(filter)]);
}
}
bool PanoramaSkyMaterial::is_filtering_enabled() const {
return filter;
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Shader::Mode PanoramaSkyMaterial::get_shader_mode() const {
Add shader based background mode
2019-09-15 19:58:38 +10:00
return Shader::MODE_SKY;
}
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
RID PanoramaSkyMaterial::get_rid() const {
_update_shader();
Add shader cache and filter variable to PanoramaSkyMaterial
2022-01-14 20:42:25 -05:00
// Don't compile shaders until first use, then compile both
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
if (!shader_set) {
Add shader cache and filter variable to PanoramaSkyMaterial
2022-01-14 20:42:25 -05:00
RS::get_singleton()->material_set_shader(_get_material(), shader_cache[1 - int(filter)]);
RS::get_singleton()->material_set_shader(_get_material(), shader_cache[int(filter)]);
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
shader_set = true;
}
return _get_material();
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
RID PanoramaSkyMaterial::get_shader_rid() const {
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
_update_shader();
Add shader cache and filter variable to PanoramaSkyMaterial
2022-01-14 20:42:25 -05:00
return shader_cache[int(filter)];
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
void PanoramaSkyMaterial::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_panorama", "texture"), &PanoramaSkyMaterial::set_panorama);
ClassDB::bind_method(D_METHOD("get_panorama"), &PanoramaSkyMaterial::get_panorama);
Add shader cache and filter variable to PanoramaSkyMaterial
2022-01-14 20:42:25 -05:00
ClassDB::bind_method(D_METHOD("set_filtering_enabled", "enabled"), &PanoramaSkyMaterial::set_filtering_enabled);
ClassDB::bind_method(D_METHOD("is_filtering_enabled"), &PanoramaSkyMaterial::is_filtering_enabled);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "panorama", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_panorama", "get_panorama");
Add shader cache and filter variable to PanoramaSkyMaterial
2022-01-14 20:42:25 -05:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "filter"), "set_filtering_enabled", "is_filtering_enabled");
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
Mutex PanoramaSkyMaterial::shader_mutex;
Add shader cache and filter variable to PanoramaSkyMaterial
2022-01-14 20:42:25 -05:00
RID PanoramaSkyMaterial::shader_cache[2];
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
void PanoramaSkyMaterial::cleanup_shader() {
Add shader cache and filter variable to PanoramaSkyMaterial
2022-01-14 20:42:25 -05:00
if (shader_cache[0].is_valid()) {
RS::get_singleton()->free(shader_cache[0]);
RS::get_singleton()->free(shader_cache[1]);
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
}
}
void PanoramaSkyMaterial::_update_shader() {
shader_mutex.lock();
Add shader cache and filter variable to PanoramaSkyMaterial
2022-01-14 20:42:25 -05:00
if (shader_cache[0].is_null()) {
for (int i = 0; i < 2; i++) {
shader_cache[i] = RS::get_singleton()->shader_create();
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
Add shader cache and filter variable to PanoramaSkyMaterial
2022-01-14 20:42:25 -05:00
// Add a comment to describe the shader origin (useful when converting to ShaderMaterial).
RS::get_singleton()->shader_set_code(shader_cache[i], vformat(R"(
Add a comment at the top of generated shaders This comment is useful to determine the origin of ShaderMaterials converted from built-in material types (such as CanvasItemMaterial or StandardMaterial3D). The Godot version is also included in case the shader needs to be regenerated with a newer engine version.
2021-07-04 17:26:25 +02:00
// NOTE: Shader automatically converted from )" VERSION_NAME " " VERSION_FULL_CONFIG R"('s PanoramaSkyMaterial.
Default PanoramaSkyMaterial texture to black instead of white This prevents blinding the user while the user is still setting up the panorama sky texture.
2022-02-13 22:03:09 +01:00
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
shader_type sky;
Default PanoramaSkyMaterial texture to black instead of white This prevents blinding the user while the user is still setting up the panorama sky texture.
2022-02-13 22:03:09 +01:00
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
uniform sampler2D source_panorama : %s, source_color, hint_default_black;
Default PanoramaSkyMaterial texture to black instead of white This prevents blinding the user while the user is still setting up the panorama sky texture.
2022-02-13 22:03:09 +01:00
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
void sky() {
COLOR = texture(source_panorama, SKY_COORDS).rgb;
}
Add shader cache and filter variable to PanoramaSkyMaterial
2022-01-14 20:42:25 -05:00
)",
i ? "filter_linear" : "filter_nearest"));
}
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
shader_mutex.unlock();
}
PanoramaSkyMaterial::PanoramaSkyMaterial() {
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
PanoramaSkyMaterial::~PanoramaSkyMaterial() {
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
//////////////////////////////////
/* PhysicalSkyMaterial */
void PhysicalSkyMaterial::set_rayleigh_coefficient(float p_rayleigh) {
rayleigh = p_rayleigh;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
RS::get_singleton()->material_set_param(_get_material(), "rayleigh", rayleigh);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
float PhysicalSkyMaterial::get_rayleigh_coefficient() const {
return rayleigh;
}
void PhysicalSkyMaterial::set_rayleigh_color(Color p_rayleigh_color) {
rayleigh_color = p_rayleigh_color;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
RS::get_singleton()->material_set_param(_get_material(), "rayleigh_color", rayleigh_color);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Color PhysicalSkyMaterial::get_rayleigh_color() const {
return rayleigh_color;
}
void PhysicalSkyMaterial::set_mie_coefficient(float p_mie) {
mie = p_mie;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
RS::get_singleton()->material_set_param(_get_material(), "mie", mie);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
float PhysicalSkyMaterial::get_mie_coefficient() const {
return mie;
}
void PhysicalSkyMaterial::set_mie_eccentricity(float p_eccentricity) {
mie_eccentricity = p_eccentricity;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
RS::get_singleton()->material_set_param(_get_material(), "mie_eccentricity", mie_eccentricity);
Add shader based background mode
2019-09-15 19:58:38 +10:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
float PhysicalSkyMaterial::get_mie_eccentricity() const {
return mie_eccentricity;
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void PhysicalSkyMaterial::set_mie_color(Color p_mie_color) {
mie_color = p_mie_color;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
RS::get_singleton()->material_set_param(_get_material(), "mie_color", mie_color);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Color PhysicalSkyMaterial::get_mie_color() const {
return mie_color;
Add shader based background mode
2019-09-15 19:58:38 +10:00
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void PhysicalSkyMaterial::set_turbidity(float p_turbidity) {
turbidity = p_turbidity;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
RS::get_singleton()->material_set_param(_get_material(), "turbidity", turbidity);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
float PhysicalSkyMaterial::get_turbidity() const {
return turbidity;
}
void PhysicalSkyMaterial::set_sun_disk_scale(float p_sun_disk_scale) {
sun_disk_scale = p_sun_disk_scale;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
RS::get_singleton()->material_set_param(_get_material(), "sun_disk_scale", sun_disk_scale);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
float PhysicalSkyMaterial::get_sun_disk_scale() const {
return sun_disk_scale;
}
void PhysicalSkyMaterial::set_ground_color(Color p_ground_color) {
ground_color = p_ground_color;
Renaming of servers for coherency. VisualServer -> RenderingServer PhysicsServer -> PhysicsServer3D Physics2DServer -> PhysicsServer2D NavigationServer -> NavigationServer3D Navigation2DServer -> NavigationServer2D Also renamed corresponding files.
2020-03-27 15:21:27 -03:00
RS::get_singleton()->material_set_param(_get_material(), "ground_color", ground_color);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Color PhysicalSkyMaterial::get_ground_color() const {
return ground_color;
}
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
void PhysicalSkyMaterial::set_energy_multiplier(float p_multiplier) {
energy_multiplier = p_multiplier;
RS::get_singleton()->material_set_param(_get_material(), "exposure", energy_multiplier);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
float PhysicalSkyMaterial::get_energy_multiplier() const {
return energy_multiplier;
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Use IGN instead of white noise for sky dithering
2022-04-29 12:46:29 -07:00
void PhysicalSkyMaterial::set_use_debanding(bool p_use_debanding) {
use_debanding = p_use_debanding;
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
_update_shader();
// Only set if shader already compiled
if (shader_set) {
RS::get_singleton()->material_set_shader(_get_material(), shader_cache[int(use_debanding)]);
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
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 14:29:06 +02:00
Use IGN instead of white noise for sky dithering
2022-04-29 12:46:29 -07:00
bool PhysicalSkyMaterial::get_use_debanding() const {
return use_debanding;
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
Add night sky to PhysicalSkyMaterial
2020-05-16 12:55:25 -07:00
void PhysicalSkyMaterial::set_night_sky(const Ref<Texture2D> &p_night_sky) {
night_sky = p_night_sky;
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-05 22:40:29 -03:00
RID tex_rid = p_night_sky.is_valid() ? p_night_sky->get_rid() : RID();
RS::get_singleton()->material_set_param(_get_material(), "night_sky", tex_rid);
Add night sky to PhysicalSkyMaterial
2020-05-16 12:55:25 -07:00
}
Ref<Texture2D> PhysicalSkyMaterial::get_night_sky() const {
return night_sky;
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Shader::Mode PhysicalSkyMaterial::get_shader_mode() const {
return Shader::MODE_SKY;
}
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
RID PhysicalSkyMaterial::get_rid() const {
_update_shader();
if (!shader_set) {
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
RS::get_singleton()->material_set_shader(_get_material(), shader_cache[1 - int(use_debanding)]);
RS::get_singleton()->material_set_shader(_get_material(), shader_cache[int(use_debanding)]);
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
shader_set = true;
}
return _get_material();
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
RID PhysicalSkyMaterial::get_shader_rid() const {
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
_update_shader();
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
return shader_cache[int(use_debanding)];
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
void PhysicalSkyMaterial::_validate_property(PropertyInfo &p_property) const {
if (p_property.name == "exposure_value" && !GLOBAL_GET("rendering/lights_and_shadows/use_physical_light_units")) {
p_property.usage = PROPERTY_USAGE_NO_EDITOR;
}
}
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
Mutex PhysicalSkyMaterial::shader_mutex;
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
RID PhysicalSkyMaterial::shader_cache[2];
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
void PhysicalSkyMaterial::_bind_methods() {
ClassDB::bind_method(D_METHOD("set_rayleigh_coefficient", "rayleigh"), &PhysicalSkyMaterial::set_rayleigh_coefficient);
ClassDB::bind_method(D_METHOD("get_rayleigh_coefficient"), &PhysicalSkyMaterial::get_rayleigh_coefficient);
ClassDB::bind_method(D_METHOD("set_rayleigh_color", "color"), &PhysicalSkyMaterial::set_rayleigh_color);
ClassDB::bind_method(D_METHOD("get_rayleigh_color"), &PhysicalSkyMaterial::get_rayleigh_color);
ClassDB::bind_method(D_METHOD("set_mie_coefficient", "mie"), &PhysicalSkyMaterial::set_mie_coefficient);
ClassDB::bind_method(D_METHOD("get_mie_coefficient"), &PhysicalSkyMaterial::get_mie_coefficient);
ClassDB::bind_method(D_METHOD("set_mie_eccentricity", "eccentricity"), &PhysicalSkyMaterial::set_mie_eccentricity);
ClassDB::bind_method(D_METHOD("get_mie_eccentricity"), &PhysicalSkyMaterial::get_mie_eccentricity);
ClassDB::bind_method(D_METHOD("set_mie_color", "color"), &PhysicalSkyMaterial::set_mie_color);
ClassDB::bind_method(D_METHOD("get_mie_color"), &PhysicalSkyMaterial::get_mie_color);
ClassDB::bind_method(D_METHOD("set_turbidity", "turbidity"), &PhysicalSkyMaterial::set_turbidity);
ClassDB::bind_method(D_METHOD("get_turbidity"), &PhysicalSkyMaterial::get_turbidity);
ClassDB::bind_method(D_METHOD("set_sun_disk_scale", "scale"), &PhysicalSkyMaterial::set_sun_disk_scale);
ClassDB::bind_method(D_METHOD("get_sun_disk_scale"), &PhysicalSkyMaterial::get_sun_disk_scale);
ClassDB::bind_method(D_METHOD("set_ground_color", "color"), &PhysicalSkyMaterial::set_ground_color);
ClassDB::bind_method(D_METHOD("get_ground_color"), &PhysicalSkyMaterial::get_ground_color);
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
ClassDB::bind_method(D_METHOD("set_energy_multiplier", "multiplier"), &PhysicalSkyMaterial::set_energy_multiplier);
ClassDB::bind_method(D_METHOD("get_energy_multiplier"), &PhysicalSkyMaterial::get_energy_multiplier);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Use IGN instead of white noise for sky dithering
2022-04-29 12:46:29 -07:00
ClassDB::bind_method(D_METHOD("set_use_debanding", "use_debanding"), &PhysicalSkyMaterial::set_use_debanding);
ClassDB::bind_method(D_METHOD("get_use_debanding"), &PhysicalSkyMaterial::get_use_debanding);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Add night sky to PhysicalSkyMaterial
2020-05-16 12:55:25 -07:00
ClassDB::bind_method(D_METHOD("set_night_sky", "night_sky"), &PhysicalSkyMaterial::set_night_sky);
ClassDB::bind_method(D_METHOD("get_night_sky"), &PhysicalSkyMaterial::get_night_sky);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ADD_GROUP("Rayleigh", "rayleigh_");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "rayleigh_coefficient", PROPERTY_HINT_RANGE, "0,64,0.01"), "set_rayleigh_coefficient", "get_rayleigh_coefficient");
Don't allow translucent colors in built-in sky material properties The colors' alpha channel is ignored, so there's no point in exposing it in the editor.
2021-10-07 18:10:54 +02:00
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "rayleigh_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_rayleigh_color", "get_rayleigh_color");
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ADD_GROUP("Mie", "mie_");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "mie_coefficient", PROPERTY_HINT_RANGE, "0,1,0.001"), "set_mie_coefficient", "get_mie_coefficient");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "mie_eccentricity", PROPERTY_HINT_RANGE, "-1,1,0.01"), "set_mie_eccentricity", "get_mie_eccentricity");
Don't allow translucent colors in built-in sky material properties The colors' alpha channel is ignored, so there's no point in exposing it in the editor.
2021-10-07 18:10:54 +02:00
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "mie_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_mie_color", "get_mie_color");
Working sky shader implementation
2020-03-19 17:32:19 -07:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "turbidity", PROPERTY_HINT_RANGE, "0,1000,0.01"), "set_turbidity", "get_turbidity");
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "sun_disk_scale", PROPERTY_HINT_RANGE, "0,360,0.01"), "set_sun_disk_scale", "get_sun_disk_scale");
Don't allow translucent colors in built-in sky material properties The colors' alpha channel is ignored, so there's no point in exposing it in the editor.
2021-10-07 18:10:54 +02:00
ADD_PROPERTY(PropertyInfo(Variant::COLOR, "ground_color", PROPERTY_HINT_COLOR_NO_ALPHA), "set_ground_color", "get_ground_color");
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
ADD_PROPERTY(PropertyInfo(Variant::FLOAT, "energy_multiplier", PROPERTY_HINT_RANGE, "0,128,0.01"), "set_energy_multiplier", "get_energy_multiplier");
Use IGN instead of white noise for sky dithering
2022-04-29 12:46:29 -07:00
ADD_PROPERTY(PropertyInfo(Variant::BOOL, "use_debanding"), "set_use_debanding", "get_use_debanding");
Add night sky to PhysicalSkyMaterial
2020-05-16 12:55:25 -07:00
ADD_PROPERTY(PropertyInfo(Variant::OBJECT, "night_sky", PROPERTY_HINT_RESOURCE_TYPE, "Texture2D"), "set_night_sky", "get_night_sky");
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
void PhysicalSkyMaterial::cleanup_shader() {
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
if (shader_cache[0].is_valid()) {
RS::get_singleton()->free(shader_cache[0]);
RS::get_singleton()->free(shader_cache[1]);
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
}
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
void PhysicalSkyMaterial::_update_shader() {
shader_mutex.lock();
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
if (shader_cache[0].is_null()) {
for (int i = 0; i < 2; i++) {
shader_cache[i] = RS::get_singleton()->shader_create();
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
// Add a comment to describe the shader origin (useful when converting to ShaderMaterial).
RS::get_singleton()->shader_set_code(shader_cache[i], vformat(R"(
Add a comment at the top of generated shaders This comment is useful to determine the origin of ShaderMaterials converted from built-in material types (such as CanvasItemMaterial or StandardMaterial3D). The Godot version is also included in case the shader needs to be regenerated with a newer engine version.
2021-07-04 17:26:25 +02:00
// NOTE: Shader automatically converted from )" VERSION_NAME " " VERSION_FULL_CONFIG R"('s PhysicalSkyMaterial.
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
shader_type sky;
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
%s
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
uniform float rayleigh : hint_range(0, 64) = 2.0;
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
uniform vec4 rayleigh_color : source_color = vec4(0.3, 0.405, 0.6, 1.0);
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
uniform float mie : hint_range(0, 1) = 0.005;
uniform float mie_eccentricity : hint_range(-1, 1) = 0.8;
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
uniform vec4 mie_color : source_color = vec4(0.69, 0.729, 0.812, 1.0);
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
uniform float turbidity : hint_range(0, 1000) = 10.0;
uniform float sun_disk_scale : hint_range(0, 360) = 1.0;
Rename `hint_albedo`, `hint_white/black` in shaders
2022-05-05 21:23:40 +03:00
uniform vec4 ground_color : source_color = vec4(0.1, 0.07, 0.034, 1.0);
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
uniform float exposure : hint_range(0, 128) = 1.0;
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
Use linear filtering without mipmaps for ProceduralSkyMaterial and PhysicalSkyMaterial
2023-03-10 10:48:45 -08:00
uniform sampler2D night_sky : filter_linear, source_color, hint_default_black;
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
const vec3 UP = vec3( 0.0, 1.0, 0.0 );
// Optical length at zenith for molecules.
const float rayleigh_zenith_size = 8.4e3;
const float mie_zenith_size = 1.25e3;
float henyey_greenstein(float cos_theta, float g) {
const float k = 0.0795774715459;
return k * (1.0 - g * g) / (pow(1.0 + g * g - 2.0 * g * cos_theta, 1.5));
}
void sky() {
if (LIGHT0_ENABLED) {
float zenith_angle = clamp( dot(UP, normalize(LIGHT0_DIRECTION)), -1.0, 1.0 );
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
float sun_energy = max(0.0, 1.0 - exp(-((PI * 0.5) - acos(zenith_angle)))) * LIGHT0_ENERGY;
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
float sun_fade = 1.0 - clamp(1.0 - exp(LIGHT0_DIRECTION.y), 0.0, 1.0);
// Rayleigh coefficients.
float rayleigh_coefficient = rayleigh - ( 1.0 * ( 1.0 - sun_fade ) );
vec3 rayleigh_beta = rayleigh_coefficient * rayleigh_color.rgb * 0.0001;
// mie coefficients from Preetham
vec3 mie_beta = turbidity * mie * mie_color.rgb * 0.000434;
// Optical length.
float zenith = acos(max(0.0, dot(UP, EYEDIR)));
float optical_mass = 1.0 / (cos(zenith) + 0.15 * pow(93.885 - degrees(zenith), -1.253));
float rayleigh_scatter = rayleigh_zenith_size * optical_mass;
float mie_scatter = mie_zenith_size * optical_mass;
// Light extinction based on thickness of atmosphere.
vec3 extinction = exp(-(rayleigh_beta * rayleigh_scatter + mie_beta * mie_scatter));
// In scattering.
float cos_theta = dot(EYEDIR, normalize(LIGHT0_DIRECTION));
float rayleigh_phase = (3.0 / (16.0 * PI)) * (1.0 + pow(cos_theta * 0.5 + 0.5, 2.0));
vec3 betaRTheta = rayleigh_beta * rayleigh_phase;
float mie_phase = henyey_greenstein(cos_theta, mie_eccentricity);
vec3 betaMTheta = mie_beta * mie_phase;
vec3 Lin = pow(sun_energy * ((betaRTheta + betaMTheta) / (rayleigh_beta + mie_beta)) * (1.0 - extinction), vec3(1.5));
// Hack from https://github.com/mrdoob/three.js/blob/master/examples/jsm/objects/Sky.js
Lin *= mix(vec3(1.0), pow(sun_energy * ((betaRTheta + betaMTheta) / (rayleigh_beta + mie_beta)) * extinction, vec3(0.5)), clamp(pow(1.0 - zenith_angle, 5.0), 0.0, 1.0));
// Hack in the ground color.
Lin *= mix(ground_color.rgb, vec3(1.0), smoothstep(-0.1, 0.1, dot(UP, EYEDIR)));
// Solar disk and out-scattering.
float sunAngularDiameterCos = cos(LIGHT0_SIZE * sun_disk_scale);
float sunAngularDiameterCos2 = cos(LIGHT0_SIZE * sun_disk_scale*0.5);
float sundisk = smoothstep(sunAngularDiameterCos, sunAngularDiameterCos2, cos_theta);
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
vec3 L0 = (sun_energy * extinction) * sundisk * LIGHT0_COLOR;
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
L0 += texture(night_sky, SKY_COORDS).xyz * extinction;
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
vec3 color = Lin + L0;
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
COLOR = pow(color, vec3(1.0 / (1.2 + (1.2 * sun_fade))));
COLOR *= exposure;
} else {
// There is no sun, so display night_sky and nothing else.
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
COLOR = texture(night_sky, SKY_COORDS).xyz;
Use C++11 raw literals for shader code to improve readability In files that have lots of branching, `\t` was replaced with a tab character instead.
2021-07-19 08:06:51 +02:00
COLOR *= exposure;
}
}
Move debanding into internal sky shader code so that it is applied after everything else. This ensures that the debanding does not scale with exposure or any other effect.
2022-09-13 10:39:04 -07:00
)",
i ? "render_mode use_debanding;" : ""));
}
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
shader_mutex.unlock();
}
Working sky shader implementation
2020-03-19 17:32:19 -07:00
Make Sky initialize shaders only once * Create the shader on demand. * Makes sure compilation happens only once, then shader is cached. * Speeds up scene loading times. * Speeds up editor initialization.
2021-07-21 08:47:49 -03:00
PhysicalSkyMaterial::PhysicalSkyMaterial() {
Working sky shader implementation
2020-03-19 17:32:19 -07:00
set_rayleigh_coefficient(2.0);
Tweak default ProceduralSkyMaterial and PhysicalSkyMaterial appearance - Tweak colors to be less saturated and more balanced (in terms of hue). The cool blue sky is balanced by a warm brown ground, which makes reflections look closer to how they'd look like when using an HDRI panorama texture. - Make the ground color dark on both ProceduralSkyMaterial and PhysicalSkyMaterial to reduce indoor light leaking, especially when using GI. - Tweak the PhysicalSkyMaterial colors to be as close as possible to ProceduralSkyMaterial (with the default sun orientation). - Tweak editor environment defaults to be identical to the default ProceduralSkyMaterial colors. Previously, the default editor sky color was different from the colors of a newly created ProceduralSkyMaterial resource. Both new skies were tested without GI, with SDFGI and with VoxelGI. They were tuned to look best when using ACES tonemapping with a whitepoint set to 6, but they still look good with other tonemapping operators.
2022-02-11 22:59:35 +01:00
set_rayleigh_color(Color(0.3, 0.405, 0.6));
Working sky shader implementation
2020-03-19 17:32:19 -07:00
set_mie_coefficient(0.005);
set_mie_eccentricity(0.8);
Tweak default ProceduralSkyMaterial and PhysicalSkyMaterial appearance - Tweak colors to be less saturated and more balanced (in terms of hue). The cool blue sky is balanced by a warm brown ground, which makes reflections look closer to how they'd look like when using an HDRI panorama texture. - Make the ground color dark on both ProceduralSkyMaterial and PhysicalSkyMaterial to reduce indoor light leaking, especially when using GI. - Tweak the PhysicalSkyMaterial colors to be as close as possible to ProceduralSkyMaterial (with the default sun orientation). - Tweak editor environment defaults to be identical to the default ProceduralSkyMaterial colors. Previously, the default editor sky color was different from the colors of a newly created ProceduralSkyMaterial resource. Both new skies were tested without GI, with SDFGI and with VoxelGI. They were tuned to look best when using ACES tonemapping with a whitepoint set to 6, but they still look good with other tonemapping operators.
2022-02-11 22:59:35 +01:00
set_mie_color(Color(0.69, 0.729, 0.812));
Working sky shader implementation
2020-03-19 17:32:19 -07:00
set_turbidity(10.0);
set_sun_disk_scale(1.0);
Tweak default ProceduralSkyMaterial and PhysicalSkyMaterial appearance - Tweak colors to be less saturated and more balanced (in terms of hue). The cool blue sky is balanced by a warm brown ground, which makes reflections look closer to how they'd look like when using an HDRI panorama texture. - Make the ground color dark on both ProceduralSkyMaterial and PhysicalSkyMaterial to reduce indoor light leaking, especially when using GI. - Tweak the PhysicalSkyMaterial colors to be as close as possible to ProceduralSkyMaterial (with the default sun orientation). - Tweak editor environment defaults to be identical to the default ProceduralSkyMaterial colors. Previously, the default editor sky color was different from the colors of a newly created ProceduralSkyMaterial resource. Both new skies were tested without GI, with SDFGI and with VoxelGI. They were tuned to look best when using ACES tonemapping with a whitepoint set to 6, but they still look good with other tonemapping operators.
2022-02-11 22:59:35 +01:00
set_ground_color(Color(0.1, 0.07, 0.034));
Implement Physical Light Units as an optional setting. This allows light sources to be specified in physical light units in addition to the regular energy multiplier. In order to avoid loss of precision at high values, brightness values are premultiplied by an exposure normalization value. In support of Physical Light Units this PR also renames CameraEffects to CameraAttributes.
2022-07-31 16:20:24 -07:00
set_energy_multiplier(1.0);
Use IGN instead of white noise for sky dithering
2022-04-29 12:46:29 -07:00
set_use_debanding(true);
Working sky shader implementation
2020-03-19 17:32:19 -07:00
}
Add shader based background mode
2019-09-15 19:58:38 +10:00
Working sky shader implementation
2020-03-19 17:32:19 -07:00
PhysicalSkyMaterial::~PhysicalSkyMaterial() {
Add shader based background mode
2019-09-15 19:58:38 +10:00
}
Reference in a new issue Copy permalink