renderer_scene_render_rd.cpp 60 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404
  1. /**************************************************************************/
  2. /* renderer_scene_render_rd.cpp */
  3. /**************************************************************************/
  4. /* This file is part of: */
  5. /* GODOT ENGINE */
  6. /* https://godotengine.org */
  7. /**************************************************************************/
  8. /* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
  9. /* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
  10. /* */
  11. /* Permission is hereby granted, free of charge, to any person obtaining */
  12. /* a copy of this software and associated documentation files (the */
  13. /* "Software"), to deal in the Software without restriction, including */
  14. /* without limitation the rights to use, copy, modify, merge, publish, */
  15. /* distribute, sublicense, and/or sell copies of the Software, and to */
  16. /* permit persons to whom the Software is furnished to do so, subject to */
  17. /* the following conditions: */
  18. /* */
  19. /* The above copyright notice and this permission notice shall be */
  20. /* included in all copies or substantial portions of the Software. */
  21. /* */
  22. /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */
  23. /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */
  24. /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. */
  25. /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */
  26. /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */
  27. /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */
  28. /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */
  29. /**************************************************************************/
  30. #include "renderer_scene_render_rd.h"
  31. #include "core/config/project_settings.h"
  32. #include "core/os/os.h"
  33. #include "renderer_compositor_rd.h"
  34. #include "servers/rendering/renderer_rd/environment/fog.h"
  35. #include "servers/rendering/renderer_rd/storage_rd/material_storage.h"
  36. #include "servers/rendering/renderer_rd/storage_rd/texture_storage.h"
  37. #include "servers/rendering/rendering_server_default.h"
  38. #include "servers/rendering/storage/camera_attributes_storage.h"
  39. void get_vogel_disk(float *r_kernel, int p_sample_count) {
  40. const float golden_angle = 2.4;
  41. for (int i = 0; i < p_sample_count; i++) {
  42. float r = Math::sqrt(float(i) + 0.5) / Math::sqrt(float(p_sample_count));
  43. float theta = float(i) * golden_angle;
  44. r_kernel[i * 4] = Math::cos(theta) * r;
  45. r_kernel[i * 4 + 1] = Math::sin(theta) * r;
  46. }
  47. }
  48. RID RendererSceneRenderRD::sky_allocate() {
  49. return sky.allocate_sky_rid();
  50. }
  51. void RendererSceneRenderRD::sky_initialize(RID p_rid) {
  52. sky.initialize_sky_rid(p_rid);
  53. }
  54. void RendererSceneRenderRD::sky_set_radiance_size(RID p_sky, int p_radiance_size) {
  55. sky.sky_set_radiance_size(p_sky, p_radiance_size);
  56. }
  57. void RendererSceneRenderRD::sky_set_mode(RID p_sky, RS::SkyMode p_mode) {
  58. sky.sky_set_mode(p_sky, p_mode);
  59. }
  60. void RendererSceneRenderRD::sky_set_material(RID p_sky, RID p_material) {
  61. sky.sky_set_material(p_sky, p_material);
  62. }
  63. Ref<Image> RendererSceneRenderRD::sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irradiance, const Size2i &p_size) {
  64. return sky.sky_bake_panorama(p_sky, p_energy, p_bake_irradiance, p_size);
  65. }
  66. void RendererSceneRenderRD::environment_glow_set_use_bicubic_upscale(bool p_enable) {
  67. glow_bicubic_upscale = p_enable;
  68. }
  69. void RendererSceneRenderRD::environment_set_volumetric_fog_volume_size(int p_size, int p_depth) {
  70. volumetric_fog_size = p_size;
  71. volumetric_fog_depth = p_depth;
  72. }
  73. void RendererSceneRenderRD::environment_set_volumetric_fog_filter_active(bool p_enable) {
  74. volumetric_fog_filter_active = p_enable;
  75. }
  76. void RendererSceneRenderRD::environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count) {
  77. gi.sdfgi_ray_count = p_ray_count;
  78. }
  79. void RendererSceneRenderRD::environment_set_sdfgi_frames_to_converge(RS::EnvironmentSDFGIFramesToConverge p_frames) {
  80. gi.sdfgi_frames_to_converge = p_frames;
  81. }
  82. void RendererSceneRenderRD::environment_set_sdfgi_frames_to_update_light(RS::EnvironmentSDFGIFramesToUpdateLight p_update) {
  83. gi.sdfgi_frames_to_update_light = p_update;
  84. }
  85. Ref<Image> RendererSceneRenderRD::environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) {
  86. ERR_FAIL_COND_V(p_env.is_null(), Ref<Image>());
  87. RS::EnvironmentBG environment_background = environment_get_background(p_env);
  88. if (environment_background == RS::ENV_BG_CAMERA_FEED || environment_background == RS::ENV_BG_CANVAS || environment_background == RS::ENV_BG_KEEP) {
  89. return Ref<Image>(); //nothing to bake
  90. }
  91. RS::EnvironmentAmbientSource ambient_source = environment_get_ambient_source(p_env);
  92. bool use_ambient_light = false;
  93. bool use_cube_map = false;
  94. if (ambient_source == RS::ENV_AMBIENT_SOURCE_BG && (environment_background == RS::ENV_BG_CLEAR_COLOR || environment_background == RS::ENV_BG_COLOR)) {
  95. use_ambient_light = true;
  96. } else {
  97. use_cube_map = (ambient_source == RS::ENV_AMBIENT_SOURCE_BG && environment_background == RS::ENV_BG_SKY) || ambient_source == RS::ENV_AMBIENT_SOURCE_SKY;
  98. use_ambient_light = use_cube_map || ambient_source == RS::ENV_AMBIENT_SOURCE_COLOR;
  99. }
  100. use_cube_map = use_cube_map || (environment_background == RS::ENV_BG_SKY && environment_get_sky(p_env).is_valid());
  101. Color ambient_color;
  102. float ambient_color_sky_mix = 0.0;
  103. if (use_ambient_light) {
  104. ambient_color_sky_mix = environment_get_ambient_sky_contribution(p_env);
  105. const float ambient_energy = environment_get_ambient_light_energy(p_env);
  106. ambient_color = environment_get_ambient_light(p_env);
  107. ambient_color = ambient_color.srgb_to_linear();
  108. ambient_color.r *= ambient_energy;
  109. ambient_color.g *= ambient_energy;
  110. ambient_color.b *= ambient_energy;
  111. }
  112. if (use_cube_map) {
  113. Ref<Image> panorama = sky_bake_panorama(environment_get_sky(p_env), environment_get_bg_energy_multiplier(p_env), p_bake_irradiance, p_size);
  114. if (use_ambient_light) {
  115. for (int x = 0; x < p_size.width; x++) {
  116. for (int y = 0; y < p_size.height; y++) {
  117. panorama->set_pixel(x, y, ambient_color.lerp(panorama->get_pixel(x, y), ambient_color_sky_mix));
  118. }
  119. }
  120. }
  121. return panorama;
  122. } else {
  123. const float bg_energy_multiplier = environment_get_bg_energy_multiplier(p_env);
  124. Color panorama_color = ((environment_background == RS::ENV_BG_CLEAR_COLOR) ? RSG::texture_storage->get_default_clear_color() : environment_get_bg_color(p_env));
  125. panorama_color = panorama_color.srgb_to_linear();
  126. panorama_color.r *= bg_energy_multiplier;
  127. panorama_color.g *= bg_energy_multiplier;
  128. panorama_color.b *= bg_energy_multiplier;
  129. if (use_ambient_light) {
  130. panorama_color = ambient_color.lerp(panorama_color, ambient_color_sky_mix);
  131. }
  132. Ref<Image> panorama = Image::create_empty(p_size.width, p_size.height, false, Image::FORMAT_RGBAF);
  133. panorama->fill(panorama_color);
  134. return panorama;
  135. }
  136. }
  137. /* REFLECTION PROBE */
  138. RID RendererSceneRenderRD::reflection_probe_create_framebuffer(RID p_color, RID p_depth) {
  139. Vector<RID> fb;
  140. fb.push_back(p_color);
  141. fb.push_back(p_depth);
  142. return RD::get_singleton()->framebuffer_create(fb);
  143. }
  144. /* FOG VOLUME INSTANCE */
  145. RID RendererSceneRenderRD::fog_volume_instance_create(RID p_fog_volume) {
  146. return RendererRD::Fog::get_singleton()->fog_volume_instance_create(p_fog_volume);
  147. }
  148. void RendererSceneRenderRD::fog_volume_instance_set_transform(RID p_fog_volume_instance, const Transform3D &p_transform) {
  149. RendererRD::Fog::get_singleton()->fog_volume_instance_set_transform(p_fog_volume_instance, p_transform);
  150. }
  151. void RendererSceneRenderRD::fog_volume_instance_set_active(RID p_fog_volume_instance, bool p_active) {
  152. RendererRD::Fog::get_singleton()->fog_volume_instance_set_active(p_fog_volume_instance, p_active);
  153. }
  154. RID RendererSceneRenderRD::fog_volume_instance_get_volume(RID p_fog_volume_instance) const {
  155. return RendererRD::Fog::get_singleton()->fog_volume_instance_get_volume(p_fog_volume_instance);
  156. }
  157. Vector3 RendererSceneRenderRD::fog_volume_instance_get_position(RID p_fog_volume_instance) const {
  158. return RendererRD::Fog::get_singleton()->fog_volume_instance_get_position(p_fog_volume_instance);
  159. }
  160. /* VOXEL GI */
  161. RID RendererSceneRenderRD::voxel_gi_instance_create(RID p_base) {
  162. return gi.voxel_gi_instance_create(p_base);
  163. }
  164. void RendererSceneRenderRD::voxel_gi_instance_set_transform_to_data(RID p_probe, const Transform3D &p_xform) {
  165. if (!is_dynamic_gi_supported()) {
  166. return;
  167. }
  168. gi.voxel_gi_instance_set_transform_to_data(p_probe, p_xform);
  169. }
  170. bool RendererSceneRenderRD::voxel_gi_needs_update(RID p_probe) const {
  171. if (!is_dynamic_gi_supported()) {
  172. return false;
  173. }
  174. return gi.voxel_gi_needs_update(p_probe);
  175. }
  176. void RendererSceneRenderRD::voxel_gi_update(RID p_probe, bool p_update_light_instances, const Vector<RID> &p_light_instances, const PagedArray<RenderGeometryInstance *> &p_dynamic_objects) {
  177. if (!is_dynamic_gi_supported()) {
  178. return;
  179. }
  180. gi.voxel_gi_update(p_probe, p_update_light_instances, p_light_instances, p_dynamic_objects);
  181. }
  182. void RendererSceneRenderRD::_debug_sdfgi_probes(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_framebuffer, const uint32_t p_view_count, const Projection *p_camera_with_transforms, bool p_will_continue_color, bool p_will_continue_depth) {
  183. ERR_FAIL_COND(p_render_buffers.is_null());
  184. if (!p_render_buffers->has_custom_data(RB_SCOPE_SDFGI)) {
  185. return; //nothing to debug
  186. }
  187. Ref<RendererRD::GI::SDFGI> sdfgi = p_render_buffers->get_custom_data(RB_SCOPE_SDFGI);
  188. sdfgi->debug_probes(p_framebuffer, p_view_count, p_camera_with_transforms, p_will_continue_color, p_will_continue_depth);
  189. }
  190. ////////////////////////////////
  191. Ref<RenderSceneBuffers> RendererSceneRenderRD::render_buffers_create() {
  192. Ref<RenderSceneBuffersRD> rb;
  193. rb.instantiate();
  194. rb->set_can_be_storage(_render_buffers_can_be_storage());
  195. rb->set_max_cluster_elements(max_cluster_elements);
  196. rb->set_base_data_format(_render_buffers_get_color_format());
  197. if (vrs) {
  198. rb->set_vrs(vrs);
  199. }
  200. setup_render_buffer_data(rb);
  201. return rb;
  202. }
  203. void RendererSceneRenderRD::_render_buffers_copy_screen_texture(const RenderDataRD *p_render_data) {
  204. Ref<RenderSceneBuffersRD> rb = p_render_data->render_buffers;
  205. ERR_FAIL_COND(rb.is_null());
  206. if (!rb->has_internal_texture()) {
  207. // We're likely rendering reflection probes where we can't use our backbuffers.
  208. return;
  209. }
  210. RD::get_singleton()->draw_command_begin_label("Copy screen texture");
  211. StringName texture_name;
  212. bool can_use_storage = _render_buffers_can_be_storage();
  213. Size2i size = rb->get_internal_size();
  214. // When upscaling, the blur texture needs to be at the target size for post-processing to work. We prefer to use a
  215. // dedicated backbuffer copy texture instead if the blur texture is not an option so shader effects work correctly.
  216. Size2i target_size = rb->get_target_size();
  217. bool internal_size_matches = (size.width == target_size.width) && (size.height == target_size.height);
  218. bool reuse_blur_texture = !rb->has_upscaled_texture() || internal_size_matches;
  219. if (reuse_blur_texture) {
  220. rb->allocate_blur_textures();
  221. texture_name = RB_TEX_BLUR_0;
  222. } else {
  223. uint32_t usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_CAN_COPY_TO_BIT;
  224. usage_bits |= can_use_storage ? RD::TEXTURE_USAGE_STORAGE_BIT : RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT;
  225. rb->create_texture(RB_SCOPE_BUFFERS, RB_TEX_BACK_COLOR, rb->get_base_data_format(), usage_bits);
  226. texture_name = RB_TEX_BACK_COLOR;
  227. }
  228. for (uint32_t v = 0; v < rb->get_view_count(); v++) {
  229. RID texture = rb->get_internal_texture(v);
  230. int mipmaps = int(rb->get_texture_format(RB_SCOPE_BUFFERS, texture_name).mipmaps);
  231. RID dest = rb->get_texture_slice(RB_SCOPE_BUFFERS, texture_name, v, 0);
  232. if (can_use_storage) {
  233. copy_effects->copy_to_rect(texture, dest, Rect2i(0, 0, size.x, size.y));
  234. } else {
  235. RID fb = FramebufferCacheRD::get_singleton()->get_cache(dest);
  236. copy_effects->copy_to_fb_rect(texture, fb, Rect2i(0, 0, size.x, size.y));
  237. }
  238. for (int i = 1; i < mipmaps; i++) {
  239. RID source = dest;
  240. dest = rb->get_texture_slice(RB_SCOPE_BUFFERS, texture_name, v, i);
  241. Size2i msize = rb->get_texture_slice_size(RB_SCOPE_BUFFERS, texture_name, i);
  242. if (can_use_storage) {
  243. copy_effects->make_mipmap(source, dest, msize);
  244. } else {
  245. copy_effects->make_mipmap_raster(source, dest, msize);
  246. }
  247. }
  248. }
  249. RD::get_singleton()->draw_command_end_label();
  250. }
  251. void RendererSceneRenderRD::_render_buffers_copy_depth_texture(const RenderDataRD *p_render_data) {
  252. Ref<RenderSceneBuffersRD> rb = p_render_data->render_buffers;
  253. ERR_FAIL_COND(rb.is_null());
  254. if (!rb->has_depth_texture()) {
  255. // We're likely rendering reflection probes where we can't use our backbuffers.
  256. return;
  257. }
  258. RD::get_singleton()->draw_command_begin_label("Copy depth texture");
  259. // note, this only creates our back depth texture if we haven't already created it.
  260. uint32_t usage_bits = RD::TEXTURE_USAGE_SAMPLING_BIT;
  261. usage_bits |= RD::TEXTURE_USAGE_CAN_COPY_TO_BIT | RD::TEXTURE_USAGE_STORAGE_BIT;
  262. usage_bits |= RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT; // set this as color attachment because we're copying data into it, it's not actually used as a depth buffer
  263. rb->create_texture(RB_SCOPE_BUFFERS, RB_TEX_BACK_DEPTH, RD::DATA_FORMAT_R32_SFLOAT, usage_bits, RD::TEXTURE_SAMPLES_1);
  264. bool can_use_storage = _render_buffers_can_be_storage();
  265. Size2i size = rb->get_internal_size();
  266. for (uint32_t v = 0; v < p_render_data->scene_data->view_count; v++) {
  267. RID depth_texture = rb->get_depth_texture(v);
  268. RID depth_back_texture = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_BACK_DEPTH, v, 0);
  269. if (can_use_storage) {
  270. copy_effects->copy_to_rect(depth_texture, depth_back_texture, Rect2i(0, 0, size.x, size.y));
  271. } else {
  272. RID depth_back_fb = FramebufferCacheRD::get_singleton()->get_cache(depth_back_texture);
  273. copy_effects->copy_to_fb_rect(depth_texture, depth_back_fb, Rect2i(0, 0, size.x, size.y));
  274. }
  275. }
  276. RD::get_singleton()->draw_command_end_label();
  277. }
  278. void RendererSceneRenderRD::_render_buffers_post_process_and_tonemap(const RenderDataRD *p_render_data) {
  279. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  280. ERR_FAIL_NULL(p_render_data);
  281. Ref<RenderSceneBuffersRD> rb = p_render_data->render_buffers;
  282. ERR_FAIL_COND(rb.is_null());
  283. ERR_FAIL_COND_MSG(p_render_data->reflection_probe.is_valid(), "Post processes should not be applied on reflection probes.");
  284. // Glow, auto exposure and DoF (if enabled).
  285. Size2i target_size = rb->get_target_size();
  286. bool can_use_effects = target_size.x >= 8 && target_size.y >= 8; // FIXME I think this should check internal size, we do all our post processing at this size...
  287. bool can_use_storage = _render_buffers_can_be_storage();
  288. bool use_fsr = fsr && can_use_effects && rb->get_scaling_3d_mode() == RS::VIEWPORT_SCALING_3D_MODE_FSR;
  289. bool use_upscaled_texture = rb->has_upscaled_texture() && rb->get_scaling_3d_mode() == RS::VIEWPORT_SCALING_3D_MODE_FSR2;
  290. RID render_target = rb->get_render_target();
  291. RID color_texture = use_upscaled_texture ? rb->get_upscaled_texture() : rb->get_internal_texture();
  292. Size2i color_size = use_upscaled_texture ? target_size : rb->get_internal_size();
  293. if (can_use_effects && RSG::camera_attributes->camera_attributes_uses_dof(p_render_data->camera_attributes)) {
  294. RENDER_TIMESTAMP("Depth of Field");
  295. RD::get_singleton()->draw_command_begin_label("DOF");
  296. rb->allocate_blur_textures();
  297. RendererRD::BokehDOF::BokehBuffers buffers;
  298. // Textures we use
  299. buffers.base_texture_size = color_size;
  300. buffers.secondary_texture = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_BLUR_0, 0, 0);
  301. buffers.half_texture[0] = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_BLUR_1, 0, 0);
  302. buffers.half_texture[1] = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_BLUR_0, 0, 1);
  303. if (can_use_storage) {
  304. for (uint32_t i = 0; i < rb->get_view_count(); i++) {
  305. buffers.base_texture = use_upscaled_texture ? rb->get_upscaled_texture(i) : rb->get_internal_texture(i);
  306. buffers.depth_texture = rb->get_depth_texture(i);
  307. // In stereo p_render_data->z_near and p_render_data->z_far can be offset for our combined frustum.
  308. float z_near = p_render_data->scene_data->view_projection[i].get_z_near();
  309. float z_far = p_render_data->scene_data->view_projection[i].get_z_far();
  310. bokeh_dof->bokeh_dof_compute(buffers, p_render_data->camera_attributes, z_near, z_far, p_render_data->scene_data->cam_orthogonal);
  311. };
  312. } else {
  313. // Set framebuffers.
  314. buffers.secondary_fb = rb->weight_buffers[1].fb;
  315. buffers.half_fb[0] = rb->weight_buffers[2].fb;
  316. buffers.half_fb[1] = rb->weight_buffers[3].fb;
  317. buffers.weight_texture[0] = rb->weight_buffers[0].weight;
  318. buffers.weight_texture[1] = rb->weight_buffers[1].weight;
  319. buffers.weight_texture[2] = rb->weight_buffers[2].weight;
  320. buffers.weight_texture[3] = rb->weight_buffers[3].weight;
  321. // Set weight buffers.
  322. buffers.base_weight_fb = rb->weight_buffers[0].fb;
  323. for (uint32_t i = 0; i < rb->get_view_count(); i++) {
  324. buffers.base_texture = use_upscaled_texture ? rb->get_upscaled_texture(i) : rb->get_internal_texture(i);
  325. buffers.depth_texture = rb->get_depth_texture(i);
  326. buffers.base_fb = FramebufferCacheRD::get_singleton()->get_cache(buffers.base_texture); // TODO move this into bokeh_dof_raster, we can do this internally
  327. // In stereo p_render_data->z_near and p_render_data->z_far can be offset for our combined frustum.
  328. float z_near = p_render_data->scene_data->view_projection[i].get_z_near();
  329. float z_far = p_render_data->scene_data->view_projection[i].get_z_far();
  330. bokeh_dof->bokeh_dof_raster(buffers, p_render_data->camera_attributes, z_near, z_far, p_render_data->scene_data->cam_orthogonal);
  331. }
  332. }
  333. RD::get_singleton()->draw_command_end_label();
  334. }
  335. float auto_exposure_scale = 1.0;
  336. if (can_use_effects && RSG::camera_attributes->camera_attributes_uses_auto_exposure(p_render_data->camera_attributes)) {
  337. RENDER_TIMESTAMP("Auto exposure");
  338. RD::get_singleton()->draw_command_begin_label("Auto exposure");
  339. Ref<RendererRD::Luminance::LuminanceBuffers> luminance_buffers = luminance->get_luminance_buffers(rb);
  340. uint64_t auto_exposure_version = RSG::camera_attributes->camera_attributes_get_auto_exposure_version(p_render_data->camera_attributes);
  341. bool set_immediate = auto_exposure_version != rb->get_auto_exposure_version();
  342. rb->set_auto_exposure_version(auto_exposure_version);
  343. double step = RSG::camera_attributes->camera_attributes_get_auto_exposure_adjust_speed(p_render_data->camera_attributes) * time_step;
  344. float auto_exposure_min_sensitivity = RSG::camera_attributes->camera_attributes_get_auto_exposure_min_sensitivity(p_render_data->camera_attributes);
  345. float auto_exposure_max_sensitivity = RSG::camera_attributes->camera_attributes_get_auto_exposure_max_sensitivity(p_render_data->camera_attributes);
  346. luminance->luminance_reduction(rb->get_internal_texture(), rb->get_internal_size(), luminance_buffers, auto_exposure_min_sensitivity, auto_exposure_max_sensitivity, step, set_immediate);
  347. // Swap final reduce with prev luminance.
  348. auto_exposure_scale = RSG::camera_attributes->camera_attributes_get_auto_exposure_scale(p_render_data->camera_attributes);
  349. RenderingServerDefault::redraw_request(); // Redraw all the time if auto exposure rendering is on.
  350. RD::get_singleton()->draw_command_end_label();
  351. }
  352. int max_glow_level = -1;
  353. if (can_use_effects && p_render_data->environment.is_valid() && environment_get_glow_enabled(p_render_data->environment)) {
  354. RENDER_TIMESTAMP("Glow");
  355. RD::get_singleton()->draw_command_begin_label("Gaussian Glow");
  356. rb->allocate_blur_textures();
  357. for (int i = 0; i < RS::MAX_GLOW_LEVELS; i++) {
  358. if (environment_get_glow_levels(p_render_data->environment)[i] > 0.0) {
  359. int mipmaps = int(rb->get_texture_format(RB_SCOPE_BUFFERS, RB_TEX_BLUR_1).mipmaps);
  360. if (i >= mipmaps) {
  361. max_glow_level = mipmaps - 1;
  362. } else {
  363. max_glow_level = i;
  364. }
  365. }
  366. }
  367. float luminance_multiplier = _render_buffers_get_luminance_multiplier();
  368. for (uint32_t l = 0; l < rb->get_view_count(); l++) {
  369. for (int i = 0; i < (max_glow_level + 1); i++) {
  370. Size2i vp_size = rb->get_texture_slice_size(RB_SCOPE_BUFFERS, RB_TEX_BLUR_1, i);
  371. if (i == 0) {
  372. RID luminance_texture;
  373. if (RSG::camera_attributes->camera_attributes_uses_auto_exposure(p_render_data->camera_attributes)) {
  374. luminance_texture = luminance->get_current_luminance_buffer(rb); // this will return and empty RID if we don't have an auto exposure buffer
  375. }
  376. RID source = rb->get_internal_texture(l);
  377. RID dest = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_BLUR_1, l, i);
  378. if (can_use_storage) {
  379. copy_effects->gaussian_glow(source, dest, vp_size, environment_get_glow_strength(p_render_data->environment), true, environment_get_glow_hdr_luminance_cap(p_render_data->environment), environment_get_exposure(p_render_data->environment), environment_get_glow_bloom(p_render_data->environment), environment_get_glow_hdr_bleed_threshold(p_render_data->environment), environment_get_glow_hdr_bleed_scale(p_render_data->environment), luminance_texture, auto_exposure_scale);
  380. } else {
  381. RID half = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_HALF_BLUR, 0, i); // we can reuse this for each view
  382. copy_effects->gaussian_glow_raster(source, half, dest, luminance_multiplier, vp_size, environment_get_glow_strength(p_render_data->environment), true, environment_get_glow_hdr_luminance_cap(p_render_data->environment), environment_get_exposure(p_render_data->environment), environment_get_glow_bloom(p_render_data->environment), environment_get_glow_hdr_bleed_threshold(p_render_data->environment), environment_get_glow_hdr_bleed_scale(p_render_data->environment), luminance_texture, auto_exposure_scale);
  383. }
  384. } else {
  385. RID source = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_BLUR_1, l, i - 1);
  386. RID dest = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_BLUR_1, l, i);
  387. if (can_use_storage) {
  388. copy_effects->gaussian_glow(source, dest, vp_size, environment_get_glow_strength(p_render_data->environment));
  389. } else {
  390. RID half = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_HALF_BLUR, 0, i); // we can reuse this for each view
  391. copy_effects->gaussian_glow_raster(source, half, dest, luminance_multiplier, vp_size, environment_get_glow_strength(p_render_data->environment));
  392. }
  393. }
  394. }
  395. }
  396. RD::get_singleton()->draw_command_end_label();
  397. }
  398. {
  399. RENDER_TIMESTAMP("Tonemap");
  400. RD::get_singleton()->draw_command_begin_label("Tonemap");
  401. RendererRD::ToneMapper::TonemapSettings tonemap;
  402. tonemap.exposure_texture = luminance->get_current_luminance_buffer(rb);
  403. if (can_use_effects && RSG::camera_attributes->camera_attributes_uses_auto_exposure(p_render_data->camera_attributes) && tonemap.exposure_texture.is_valid()) {
  404. tonemap.use_auto_exposure = true;
  405. tonemap.auto_exposure_scale = auto_exposure_scale;
  406. } else {
  407. tonemap.exposure_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE);
  408. }
  409. if (can_use_effects && p_render_data->environment.is_valid() && environment_get_glow_enabled(p_render_data->environment)) {
  410. tonemap.use_glow = true;
  411. tonemap.glow_mode = RendererRD::ToneMapper::TonemapSettings::GlowMode(environment_get_glow_blend_mode(p_render_data->environment));
  412. tonemap.glow_intensity = environment_get_glow_blend_mode(p_render_data->environment) == RS::ENV_GLOW_BLEND_MODE_MIX ? environment_get_glow_mix(p_render_data->environment) : environment_get_glow_intensity(p_render_data->environment);
  413. for (int i = 0; i < RS::MAX_GLOW_LEVELS; i++) {
  414. tonemap.glow_levels[i] = environment_get_glow_levels(p_render_data->environment)[i];
  415. }
  416. Size2i msize = rb->get_texture_slice_size(RB_SCOPE_BUFFERS, RB_TEX_BLUR_1, 0);
  417. tonemap.glow_texture_size.x = msize.width;
  418. tonemap.glow_texture_size.y = msize.height;
  419. tonemap.glow_use_bicubic_upscale = glow_bicubic_upscale;
  420. tonemap.glow_texture = rb->get_texture(RB_SCOPE_BUFFERS, RB_TEX_BLUR_1);
  421. if (environment_get_glow_map(p_render_data->environment).is_valid()) {
  422. tonemap.glow_map_strength = environment_get_glow_map_strength(p_render_data->environment);
  423. tonemap.glow_map = texture_storage->texture_get_rd_texture(environment_get_glow_map(p_render_data->environment));
  424. } else {
  425. tonemap.glow_map_strength = 0.0f;
  426. tonemap.glow_map = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE);
  427. }
  428. } else {
  429. tonemap.glow_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_BLACK);
  430. tonemap.glow_map = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE);
  431. }
  432. if (rb->get_screen_space_aa() == RS::VIEWPORT_SCREEN_SPACE_AA_FXAA) {
  433. tonemap.use_fxaa = true;
  434. }
  435. tonemap.use_debanding = rb->get_use_debanding();
  436. tonemap.texture_size = Vector2i(color_size.x, color_size.y);
  437. if (p_render_data->environment.is_valid()) {
  438. tonemap.tonemap_mode = environment_get_tone_mapper(p_render_data->environment);
  439. tonemap.white = environment_get_white(p_render_data->environment);
  440. tonemap.exposure = environment_get_exposure(p_render_data->environment);
  441. }
  442. tonemap.use_color_correction = false;
  443. tonemap.use_1d_color_correction = false;
  444. tonemap.color_correction_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_3D_WHITE);
  445. if (can_use_effects && p_render_data->environment.is_valid()) {
  446. tonemap.use_bcs = environment_get_adjustments_enabled(p_render_data->environment);
  447. tonemap.brightness = environment_get_adjustments_brightness(p_render_data->environment);
  448. tonemap.contrast = environment_get_adjustments_contrast(p_render_data->environment);
  449. tonemap.saturation = environment_get_adjustments_saturation(p_render_data->environment);
  450. if (environment_get_adjustments_enabled(p_render_data->environment) && environment_get_color_correction(p_render_data->environment).is_valid()) {
  451. tonemap.use_color_correction = true;
  452. tonemap.use_1d_color_correction = environment_get_use_1d_color_correction(p_render_data->environment);
  453. tonemap.color_correction_texture = texture_storage->texture_get_rd_texture(environment_get_color_correction(p_render_data->environment));
  454. }
  455. }
  456. tonemap.luminance_multiplier = _render_buffers_get_luminance_multiplier();
  457. tonemap.view_count = rb->get_view_count();
  458. tonemap.convert_to_srgb = !texture_storage->render_target_is_using_hdr(render_target);
  459. RID dest_fb;
  460. bool use_intermediate_fb = use_fsr;
  461. if (use_intermediate_fb) {
  462. // If we use FSR to upscale we need to write our result into an intermediate buffer.
  463. // Note that this is cached so we only create the texture the first time.
  464. RID dest_texture = rb->create_texture(SNAME("Tonemapper"), SNAME("destination"), _render_buffers_get_color_format(), RD::TEXTURE_USAGE_SAMPLING_BIT | RD::TEXTURE_USAGE_STORAGE_BIT | RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT);
  465. dest_fb = FramebufferCacheRD::get_singleton()->get_cache(dest_texture);
  466. } else {
  467. // If we do a bilinear upscale we just render into our render target and our shader will upscale automatically.
  468. // Target size in this case is lying as we never get our real target size communicated.
  469. // Bit nasty but...
  470. dest_fb = texture_storage->render_target_get_rd_framebuffer(render_target);
  471. }
  472. tone_mapper->tonemapper(color_texture, dest_fb, tonemap);
  473. RD::get_singleton()->draw_command_end_label();
  474. }
  475. if (use_fsr) {
  476. RD::get_singleton()->draw_command_begin_label("FSR 1.0 Upscale");
  477. for (uint32_t v = 0; v < rb->get_view_count(); v++) {
  478. RID source_texture = rb->get_texture_slice(SNAME("Tonemapper"), SNAME("destination"), v, 0);
  479. RID dest_texture = texture_storage->render_target_get_rd_texture_slice(render_target, v);
  480. fsr->fsr_upscale(rb, source_texture, dest_texture);
  481. }
  482. RD::get_singleton()->draw_command_end_label();
  483. }
  484. texture_storage->render_target_disable_clear_request(render_target);
  485. }
  486. void RendererSceneRenderRD::_post_process_subpass(RID p_source_texture, RID p_framebuffer, const RenderDataRD *p_render_data) {
  487. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  488. RD::get_singleton()->draw_command_begin_label("Post Process Subpass");
  489. Ref<RenderSceneBuffersRD> rb = p_render_data->render_buffers;
  490. ERR_FAIL_COND(rb.is_null());
  491. // FIXME: Our input it our internal_texture, shouldn't this be using internal_size ??
  492. // Seeing we don't support FSR in our mobile renderer right now target_size = internal_size...
  493. Size2i target_size = rb->get_target_size();
  494. bool can_use_effects = target_size.x >= 8 && target_size.y >= 8;
  495. RD::DrawListID draw_list = RD::get_singleton()->draw_list_switch_to_next_pass();
  496. RendererRD::ToneMapper::TonemapSettings tonemap;
  497. if (p_render_data->environment.is_valid()) {
  498. tonemap.tonemap_mode = environment_get_tone_mapper(p_render_data->environment);
  499. tonemap.exposure = environment_get_exposure(p_render_data->environment);
  500. tonemap.white = environment_get_white(p_render_data->environment);
  501. }
  502. // We don't support glow or auto exposure here, if they are needed, don't use subpasses!
  503. // The problem is that we need to use the result so far and process them before we can
  504. // apply this to our results.
  505. if (can_use_effects && p_render_data->environment.is_valid() && environment_get_glow_enabled(p_render_data->environment)) {
  506. ERR_FAIL_MSG("Glow is not supported when using subpasses.");
  507. }
  508. if (can_use_effects && RSG::camera_attributes->camera_attributes_uses_auto_exposure(p_render_data->camera_attributes)) {
  509. ERR_FAIL_MSG("Auto Exposure is not supported when using subpasses.");
  510. }
  511. tonemap.use_glow = false;
  512. tonemap.glow_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_BLACK);
  513. tonemap.glow_map = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE);
  514. tonemap.use_auto_exposure = false;
  515. tonemap.exposure_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_WHITE);
  516. tonemap.use_color_correction = false;
  517. tonemap.use_1d_color_correction = false;
  518. tonemap.color_correction_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_3D_WHITE);
  519. if (can_use_effects && p_render_data->environment.is_valid()) {
  520. tonemap.use_bcs = environment_get_adjustments_enabled(p_render_data->environment);
  521. tonemap.brightness = environment_get_adjustments_brightness(p_render_data->environment);
  522. tonemap.contrast = environment_get_adjustments_contrast(p_render_data->environment);
  523. tonemap.saturation = environment_get_adjustments_saturation(p_render_data->environment);
  524. if (environment_get_adjustments_enabled(p_render_data->environment) && environment_get_color_correction(p_render_data->environment).is_valid()) {
  525. tonemap.use_color_correction = true;
  526. tonemap.use_1d_color_correction = environment_get_use_1d_color_correction(p_render_data->environment);
  527. tonemap.color_correction_texture = texture_storage->texture_get_rd_texture(environment_get_color_correction(p_render_data->environment));
  528. }
  529. }
  530. tonemap.use_debanding = rb->get_use_debanding();
  531. tonemap.texture_size = Vector2i(target_size.x, target_size.y);
  532. tonemap.luminance_multiplier = _render_buffers_get_luminance_multiplier();
  533. tonemap.view_count = rb->get_view_count();
  534. tonemap.convert_to_srgb = !texture_storage->render_target_is_using_hdr(rb->get_render_target());
  535. tone_mapper->tonemapper(draw_list, p_source_texture, RD::get_singleton()->framebuffer_get_format(p_framebuffer), tonemap);
  536. RD::get_singleton()->draw_command_end_label();
  537. }
  538. void RendererSceneRenderRD::_disable_clear_request(const RenderDataRD *p_render_data) {
  539. ERR_FAIL_COND(p_render_data->render_buffers.is_null());
  540. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  541. texture_storage->render_target_disable_clear_request(p_render_data->render_buffers->get_render_target());
  542. }
  543. void RendererSceneRenderRD::_render_buffers_debug_draw(const RenderDataRD *p_render_data) {
  544. RendererRD::LightStorage *light_storage = RendererRD::LightStorage::get_singleton();
  545. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  546. Ref<RenderSceneBuffersRD> rb = p_render_data->render_buffers;
  547. ERR_FAIL_COND(rb.is_null());
  548. RID render_target = rb->get_render_target();
  549. if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_SHADOW_ATLAS) {
  550. if (p_render_data->shadow_atlas.is_valid()) {
  551. RID shadow_atlas_texture = RendererRD::LightStorage::get_singleton()->shadow_atlas_get_texture(p_render_data->shadow_atlas);
  552. if (shadow_atlas_texture.is_null()) {
  553. shadow_atlas_texture = texture_storage->texture_rd_get_default(RendererRD::TextureStorage::DEFAULT_RD_TEXTURE_BLACK);
  554. }
  555. Size2 rtsize = texture_storage->render_target_get_size(render_target);
  556. copy_effects->copy_to_fb_rect(shadow_atlas_texture, texture_storage->render_target_get_rd_framebuffer(render_target), Rect2i(Vector2(), rtsize / 2), false, true);
  557. }
  558. }
  559. if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_DIRECTIONAL_SHADOW_ATLAS) {
  560. if (RendererRD::LightStorage::get_singleton()->directional_shadow_get_texture().is_valid()) {
  561. RID shadow_atlas_texture = RendererRD::LightStorage::get_singleton()->directional_shadow_get_texture();
  562. Size2i rtsize = texture_storage->render_target_get_size(render_target);
  563. RID dest_fb = texture_storage->render_target_get_rd_framebuffer(render_target);
  564. // Determine our display size, try and keep square by using the smallest edge.
  565. Size2i size = 2 * rtsize / 3;
  566. if (size.x < size.y) {
  567. size.y = size.x;
  568. } else if (size.y < size.x) {
  569. size.x = size.y;
  570. }
  571. copy_effects->copy_to_fb_rect(shadow_atlas_texture, dest_fb, Rect2i(Vector2(), size), false, true);
  572. // Visualize our view frustum to show coverage.
  573. for (int i = 0; i < p_render_data->render_shadow_count; i++) {
  574. RID light = p_render_data->render_shadows[i].light;
  575. RID base = light_storage->light_instance_get_base_light(light);
  576. if (light_storage->light_get_type(base) == RS::LIGHT_DIRECTIONAL) {
  577. debug_effects->draw_shadow_frustum(light, p_render_data->scene_data->cam_projection, p_render_data->scene_data->cam_transform, dest_fb, Rect2(Size2(), size));
  578. }
  579. }
  580. }
  581. }
  582. if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_DECAL_ATLAS) {
  583. RID decal_atlas = RendererRD::TextureStorage::get_singleton()->decal_atlas_get_texture();
  584. if (decal_atlas.is_valid()) {
  585. Size2i rtsize = texture_storage->render_target_get_size(render_target);
  586. copy_effects->copy_to_fb_rect(decal_atlas, texture_storage->render_target_get_rd_framebuffer(render_target), Rect2i(Vector2(), rtsize / 2), false, false, true);
  587. }
  588. }
  589. if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_SCENE_LUMINANCE) {
  590. RID luminance_texture = luminance->get_current_luminance_buffer(rb);
  591. if (luminance_texture.is_valid()) {
  592. Size2i rtsize = texture_storage->render_target_get_size(render_target);
  593. copy_effects->copy_to_fb_rect(luminance_texture, texture_storage->render_target_get_rd_framebuffer(render_target), Rect2(Vector2(), rtsize / 8), false, true);
  594. }
  595. }
  596. if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_INTERNAL_BUFFER) {
  597. Size2 rtsize = texture_storage->render_target_get_size(render_target);
  598. copy_effects->copy_to_fb_rect(rb->get_internal_texture(), texture_storage->render_target_get_rd_framebuffer(render_target), Rect2(Vector2(), rtsize), false, false);
  599. }
  600. if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_NORMAL_BUFFER && _render_buffers_get_normal_texture(rb).is_valid()) {
  601. Size2 rtsize = texture_storage->render_target_get_size(render_target);
  602. copy_effects->copy_to_fb_rect(_render_buffers_get_normal_texture(rb), texture_storage->render_target_get_rd_framebuffer(render_target), Rect2(Vector2(), rtsize), false, false);
  603. }
  604. if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_OCCLUDERS) {
  605. if (p_render_data->occluder_debug_tex.is_valid()) {
  606. Size2i rtsize = texture_storage->render_target_get_size(render_target);
  607. copy_effects->copy_to_fb_rect(texture_storage->texture_get_rd_texture(p_render_data->occluder_debug_tex), texture_storage->render_target_get_rd_framebuffer(render_target), Rect2i(Vector2(), rtsize), true, false);
  608. }
  609. }
  610. if (debug_draw == RS::VIEWPORT_DEBUG_DRAW_MOTION_VECTORS && _render_buffers_get_velocity_texture(rb).is_valid()) {
  611. RID velocity = _render_buffers_get_velocity_texture(rb);
  612. RID depth = rb->get_depth_texture();
  613. RID dest_fb = texture_storage->render_target_get_rd_framebuffer(render_target);
  614. Size2i resolution = rb->get_internal_size();
  615. debug_effects->draw_motion_vectors(velocity, depth, dest_fb, p_render_data->scene_data->cam_projection, p_render_data->scene_data->cam_transform, p_render_data->scene_data->prev_cam_projection, p_render_data->scene_data->prev_cam_transform, resolution);
  616. }
  617. }
  618. RID RendererSceneRenderRD::render_buffers_get_default_voxel_gi_buffer() {
  619. return gi.default_voxel_gi_buffer;
  620. }
  621. float RendererSceneRenderRD::_render_buffers_get_luminance_multiplier() {
  622. return 1.0;
  623. }
  624. RD::DataFormat RendererSceneRenderRD::_render_buffers_get_color_format() {
  625. return RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
  626. }
  627. bool RendererSceneRenderRD::_render_buffers_can_be_storage() {
  628. return true;
  629. }
  630. void RendererSceneRenderRD::gi_set_use_half_resolution(bool p_enable) {
  631. gi.half_resolution = p_enable;
  632. }
  633. void RendererSceneRenderRD::positional_soft_shadow_filter_set_quality(RS::ShadowQuality p_quality) {
  634. ERR_FAIL_INDEX_MSG(p_quality, RS::SHADOW_QUALITY_MAX, "Shadow quality too high, please see RenderingServer's ShadowQuality enum");
  635. if (shadows_quality != p_quality) {
  636. shadows_quality = p_quality;
  637. switch (shadows_quality) {
  638. case RS::SHADOW_QUALITY_HARD: {
  639. penumbra_shadow_samples = 4;
  640. soft_shadow_samples = 0;
  641. shadows_quality_radius = 1.0;
  642. } break;
  643. case RS::SHADOW_QUALITY_SOFT_VERY_LOW: {
  644. penumbra_shadow_samples = 4;
  645. soft_shadow_samples = 1;
  646. shadows_quality_radius = 1.5;
  647. } break;
  648. case RS::SHADOW_QUALITY_SOFT_LOW: {
  649. penumbra_shadow_samples = 8;
  650. soft_shadow_samples = 4;
  651. shadows_quality_radius = 2.0;
  652. } break;
  653. case RS::SHADOW_QUALITY_SOFT_MEDIUM: {
  654. penumbra_shadow_samples = 12;
  655. soft_shadow_samples = 8;
  656. shadows_quality_radius = 2.0;
  657. } break;
  658. case RS::SHADOW_QUALITY_SOFT_HIGH: {
  659. penumbra_shadow_samples = 24;
  660. soft_shadow_samples = 16;
  661. shadows_quality_radius = 3.0;
  662. } break;
  663. case RS::SHADOW_QUALITY_SOFT_ULTRA: {
  664. penumbra_shadow_samples = 32;
  665. soft_shadow_samples = 32;
  666. shadows_quality_radius = 4.0;
  667. } break;
  668. case RS::SHADOW_QUALITY_MAX:
  669. break;
  670. }
  671. get_vogel_disk(penumbra_shadow_kernel, penumbra_shadow_samples);
  672. get_vogel_disk(soft_shadow_kernel, soft_shadow_samples);
  673. }
  674. _update_shader_quality_settings();
  675. }
  676. void RendererSceneRenderRD::directional_soft_shadow_filter_set_quality(RS::ShadowQuality p_quality) {
  677. ERR_FAIL_INDEX_MSG(p_quality, RS::SHADOW_QUALITY_MAX, "Shadow quality too high, please see RenderingServer's ShadowQuality enum");
  678. if (directional_shadow_quality != p_quality) {
  679. directional_shadow_quality = p_quality;
  680. switch (directional_shadow_quality) {
  681. case RS::SHADOW_QUALITY_HARD: {
  682. directional_penumbra_shadow_samples = 4;
  683. directional_soft_shadow_samples = 0;
  684. directional_shadow_quality_radius = 1.0;
  685. } break;
  686. case RS::SHADOW_QUALITY_SOFT_VERY_LOW: {
  687. directional_penumbra_shadow_samples = 4;
  688. directional_soft_shadow_samples = 1;
  689. directional_shadow_quality_radius = 1.5;
  690. } break;
  691. case RS::SHADOW_QUALITY_SOFT_LOW: {
  692. directional_penumbra_shadow_samples = 8;
  693. directional_soft_shadow_samples = 4;
  694. directional_shadow_quality_radius = 2.0;
  695. } break;
  696. case RS::SHADOW_QUALITY_SOFT_MEDIUM: {
  697. directional_penumbra_shadow_samples = 12;
  698. directional_soft_shadow_samples = 8;
  699. directional_shadow_quality_radius = 2.0;
  700. } break;
  701. case RS::SHADOW_QUALITY_SOFT_HIGH: {
  702. directional_penumbra_shadow_samples = 24;
  703. directional_soft_shadow_samples = 16;
  704. directional_shadow_quality_radius = 3.0;
  705. } break;
  706. case RS::SHADOW_QUALITY_SOFT_ULTRA: {
  707. directional_penumbra_shadow_samples = 32;
  708. directional_soft_shadow_samples = 32;
  709. directional_shadow_quality_radius = 4.0;
  710. } break;
  711. case RS::SHADOW_QUALITY_MAX:
  712. break;
  713. }
  714. get_vogel_disk(directional_penumbra_shadow_kernel, directional_penumbra_shadow_samples);
  715. get_vogel_disk(directional_soft_shadow_kernel, directional_soft_shadow_samples);
  716. }
  717. _update_shader_quality_settings();
  718. }
  719. void RendererSceneRenderRD::decals_set_filter(RenderingServer::DecalFilter p_filter) {
  720. if (decals_filter == p_filter) {
  721. return;
  722. }
  723. decals_filter = p_filter;
  724. _update_shader_quality_settings();
  725. }
  726. void RendererSceneRenderRD::light_projectors_set_filter(RenderingServer::LightProjectorFilter p_filter) {
  727. if (light_projectors_filter == p_filter) {
  728. return;
  729. }
  730. light_projectors_filter = p_filter;
  731. _update_shader_quality_settings();
  732. }
  733. int RendererSceneRenderRD::get_roughness_layers() const {
  734. return sky.roughness_layers;
  735. }
  736. bool RendererSceneRenderRD::is_using_radiance_cubemap_array() const {
  737. return sky.sky_use_cubemap_array;
  738. }
  739. void RendererSceneRenderRD::_update_vrs(Ref<RenderSceneBuffersRD> p_render_buffers) {
  740. if (p_render_buffers.is_null()) {
  741. return;
  742. }
  743. RID render_target = p_render_buffers->get_render_target();
  744. if (render_target.is_null()) {
  745. // must be rendering reflection probes
  746. return;
  747. }
  748. if (vrs) {
  749. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  750. RS::ViewportVRSMode vrs_mode = texture_storage->render_target_get_vrs_mode(render_target);
  751. if (vrs_mode != RS::VIEWPORT_VRS_DISABLED) {
  752. RID vrs_texture = p_render_buffers->get_texture(RB_SCOPE_VRS, RB_TEXTURE);
  753. // We use get_cache_multipass instead of get_cache_multiview because the default behavior is for
  754. // our vrs_texture to be used as the VRS attachment. In this particular case we're writing to it
  755. // so it needs to be set as our color attachment
  756. Vector<RID> textures;
  757. textures.push_back(vrs_texture);
  758. Vector<RD::FramebufferPass> passes;
  759. RD::FramebufferPass pass;
  760. pass.color_attachments.push_back(0);
  761. passes.push_back(pass);
  762. RID vrs_fb = FramebufferCacheRD::get_singleton()->get_cache_multipass(textures, passes, p_render_buffers->get_view_count());
  763. vrs->update_vrs_texture(vrs_fb, p_render_buffers->get_render_target());
  764. }
  765. }
  766. }
  767. bool RendererSceneRenderRD::_needs_post_prepass_render(RenderDataRD *p_render_data, bool p_use_gi) {
  768. if (p_render_data->render_buffers.is_valid()) {
  769. if (p_render_data->render_buffers->has_custom_data(RB_SCOPE_SDFGI)) {
  770. return true;
  771. }
  772. }
  773. return false;
  774. }
  775. void RendererSceneRenderRD::_post_prepass_render(RenderDataRD *p_render_data, bool p_use_gi) {
  776. if (p_render_data->render_buffers.is_valid() && p_use_gi) {
  777. if (!p_render_data->render_buffers->has_custom_data(RB_SCOPE_SDFGI)) {
  778. return;
  779. }
  780. Ref<RendererRD::GI::SDFGI> sdfgi = p_render_data->render_buffers->get_custom_data(RB_SCOPE_SDFGI);
  781. sdfgi->update_probes(p_render_data->environment, sky.sky_owner.get_or_null(environment_get_sky(p_render_data->environment)));
  782. }
  783. }
  784. void RendererSceneRenderRD::_pre_resolve_render(RenderDataRD *p_render_data, bool p_use_gi) {
  785. if (p_render_data->render_buffers.is_valid()) {
  786. if (p_use_gi) {
  787. RD::get_singleton()->compute_list_end();
  788. }
  789. }
  790. }
  791. void RendererSceneRenderRD::render_scene(const Ref<RenderSceneBuffers> &p_render_buffers, const CameraData *p_camera_data, const CameraData *p_prev_camera_data, const PagedArray<RenderGeometryInstance *> &p_instances, const PagedArray<RID> &p_lights, const PagedArray<RID> &p_reflection_probes, const PagedArray<RID> &p_voxel_gi_instances, const PagedArray<RID> &p_decals, const PagedArray<RID> &p_lightmaps, const PagedArray<RID> &p_fog_volumes, RID p_environment, RID p_camera_attributes, RID p_shadow_atlas, RID p_occluder_debug_tex, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_mesh_lod_threshold, const RenderShadowData *p_render_shadows, int p_render_shadow_count, const RenderSDFGIData *p_render_sdfgi_regions, int p_render_sdfgi_region_count, const RenderSDFGIUpdateData *p_sdfgi_update_data, RenderingMethod::RenderInfo *r_render_info) {
  792. RendererRD::LightStorage *light_storage = RendererRD::LightStorage::get_singleton();
  793. RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();
  794. // getting this here now so we can direct call a bunch of things more easily
  795. ERR_FAIL_COND(p_render_buffers.is_null());
  796. Ref<RenderSceneBuffersRD> rb = p_render_buffers;
  797. ERR_FAIL_COND(rb.is_null());
  798. // setup scene data
  799. RenderSceneDataRD scene_data;
  800. {
  801. // Our first camera is used by default
  802. scene_data.cam_transform = p_camera_data->main_transform;
  803. scene_data.cam_projection = p_camera_data->main_projection;
  804. scene_data.cam_orthogonal = p_camera_data->is_orthogonal;
  805. scene_data.camera_visible_layers = p_camera_data->visible_layers;
  806. scene_data.taa_jitter = p_camera_data->taa_jitter;
  807. scene_data.view_count = p_camera_data->view_count;
  808. for (uint32_t v = 0; v < p_camera_data->view_count; v++) {
  809. scene_data.view_eye_offset[v] = p_camera_data->view_offset[v].origin;
  810. scene_data.view_projection[v] = p_camera_data->view_projection[v];
  811. }
  812. scene_data.prev_cam_transform = p_prev_camera_data->main_transform;
  813. scene_data.prev_cam_projection = p_prev_camera_data->main_projection;
  814. scene_data.prev_taa_jitter = p_prev_camera_data->taa_jitter;
  815. for (uint32_t v = 0; v < p_camera_data->view_count; v++) {
  816. scene_data.prev_view_projection[v] = p_prev_camera_data->view_projection[v];
  817. }
  818. scene_data.z_near = p_camera_data->main_projection.get_z_near();
  819. scene_data.z_far = p_camera_data->main_projection.get_z_far();
  820. // this should be the same for all cameras..
  821. const float lod_distance_multiplier = p_camera_data->main_projection.get_lod_multiplier();
  822. // Also, take into account resolution scaling for the multiplier, since we have more leeway with quality
  823. // degradation visibility. Conversely, allow upwards scaling, too, for increased mesh detail at high res.
  824. const float scaling_3d_scale = GLOBAL_GET("rendering/scaling_3d/scale");
  825. scene_data.lod_distance_multiplier = lod_distance_multiplier * (1.0 / scaling_3d_scale);
  826. if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_DISABLE_LOD) {
  827. scene_data.screen_mesh_lod_threshold = 0.0;
  828. } else {
  829. scene_data.screen_mesh_lod_threshold = p_screen_mesh_lod_threshold;
  830. }
  831. if (p_shadow_atlas.is_valid()) {
  832. int shadow_atlas_size = light_storage->shadow_atlas_get_size(p_shadow_atlas);
  833. scene_data.shadow_atlas_pixel_size.x = 1.0 / shadow_atlas_size;
  834. scene_data.shadow_atlas_pixel_size.y = 1.0 / shadow_atlas_size;
  835. }
  836. {
  837. int directional_shadow_size = light_storage->directional_shadow_get_size();
  838. scene_data.directional_shadow_pixel_size.x = 1.0 / directional_shadow_size;
  839. scene_data.directional_shadow_pixel_size.y = 1.0 / directional_shadow_size;
  840. }
  841. scene_data.time = time;
  842. scene_data.time_step = time_step;
  843. }
  844. //assign render data
  845. RenderDataRD render_data;
  846. {
  847. render_data.render_buffers = rb;
  848. render_data.scene_data = &scene_data;
  849. render_data.instances = &p_instances;
  850. render_data.lights = &p_lights;
  851. render_data.reflection_probes = &p_reflection_probes;
  852. render_data.voxel_gi_instances = &p_voxel_gi_instances;
  853. render_data.decals = &p_decals;
  854. render_data.lightmaps = &p_lightmaps;
  855. render_data.fog_volumes = &p_fog_volumes;
  856. render_data.environment = p_environment;
  857. render_data.camera_attributes = p_camera_attributes;
  858. render_data.shadow_atlas = p_shadow_atlas;
  859. render_data.occluder_debug_tex = p_occluder_debug_tex;
  860. render_data.reflection_atlas = p_reflection_atlas;
  861. render_data.reflection_probe = p_reflection_probe;
  862. render_data.reflection_probe_pass = p_reflection_probe_pass;
  863. render_data.render_shadows = p_render_shadows;
  864. render_data.render_shadow_count = p_render_shadow_count;
  865. render_data.render_sdfgi_regions = p_render_sdfgi_regions;
  866. render_data.render_sdfgi_region_count = p_render_sdfgi_region_count;
  867. render_data.sdfgi_update_data = p_sdfgi_update_data;
  868. render_data.render_info = r_render_info;
  869. }
  870. PagedArray<RID> empty;
  871. if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_UNSHADED) {
  872. render_data.lights = &empty;
  873. render_data.reflection_probes = &empty;
  874. render_data.voxel_gi_instances = &empty;
  875. }
  876. Color clear_color;
  877. if (p_render_buffers.is_valid() && p_reflection_probe.is_null()) {
  878. clear_color = texture_storage->render_target_get_clear_request_color(rb->get_render_target());
  879. } else {
  880. clear_color = RSG::texture_storage->get_default_clear_color();
  881. }
  882. //calls _pre_opaque_render between depth pre-pass and opaque pass
  883. _render_scene(&render_data, clear_color);
  884. }
  885. void RendererSceneRenderRD::render_material(const Transform3D &p_cam_transform, const Projection &p_cam_projection, bool p_cam_orthogonal, const PagedArray<RenderGeometryInstance *> &p_instances, RID p_framebuffer, const Rect2i &p_region) {
  886. _render_material(p_cam_transform, p_cam_projection, p_cam_orthogonal, p_instances, p_framebuffer, p_region, 1.0);
  887. }
  888. void RendererSceneRenderRD::render_particle_collider_heightfield(RID p_collider, const Transform3D &p_transform, const PagedArray<RenderGeometryInstance *> &p_instances) {
  889. RendererRD::ParticlesStorage *particles_storage = RendererRD::ParticlesStorage::get_singleton();
  890. ERR_FAIL_COND(!particles_storage->particles_collision_is_heightfield(p_collider));
  891. Vector3 extents = particles_storage->particles_collision_get_extents(p_collider) * p_transform.basis.get_scale();
  892. Projection cm;
  893. cm.set_orthogonal(-extents.x, extents.x, -extents.z, extents.z, 0, extents.y * 2.0);
  894. Vector3 cam_pos = p_transform.origin;
  895. cam_pos.y += extents.y;
  896. Transform3D cam_xform;
  897. cam_xform.set_look_at(cam_pos, cam_pos - p_transform.basis.get_column(Vector3::AXIS_Y), -p_transform.basis.get_column(Vector3::AXIS_Z).normalized());
  898. RID fb = particles_storage->particles_collision_get_heightfield_framebuffer(p_collider);
  899. _render_particle_collider_heightfield(fb, cam_xform, cm, p_instances);
  900. }
  901. bool RendererSceneRenderRD::free(RID p_rid) {
  902. if (is_environment(p_rid)) {
  903. environment_free(p_rid);
  904. } else if (RSG::camera_attributes->owns_camera_attributes(p_rid)) {
  905. RSG::camera_attributes->camera_attributes_free(p_rid);
  906. } else if (gi.voxel_gi_instance_owns(p_rid)) {
  907. gi.voxel_gi_instance_free(p_rid);
  908. } else if (sky.sky_owner.owns(p_rid)) {
  909. sky.update_dirty_skys();
  910. sky.free_sky(p_rid);
  911. } else if (RendererRD::Fog::get_singleton()->owns_fog_volume_instance(p_rid)) {
  912. RendererRD::Fog::get_singleton()->fog_instance_free(p_rid);
  913. } else {
  914. return false;
  915. }
  916. return true;
  917. }
  918. void RendererSceneRenderRD::set_debug_draw_mode(RS::ViewportDebugDraw p_debug_draw) {
  919. debug_draw = p_debug_draw;
  920. }
  921. void RendererSceneRenderRD::update() {
  922. sky.update_dirty_skys();
  923. }
  924. void RendererSceneRenderRD::set_time(double p_time, double p_step) {
  925. time = p_time;
  926. time_step = p_step;
  927. }
  928. void RendererSceneRenderRD::screen_space_roughness_limiter_set_active(bool p_enable, float p_amount, float p_limit) {
  929. screen_space_roughness_limiter = p_enable;
  930. screen_space_roughness_limiter_amount = p_amount;
  931. screen_space_roughness_limiter_limit = p_limit;
  932. }
  933. bool RendererSceneRenderRD::screen_space_roughness_limiter_is_active() const {
  934. return screen_space_roughness_limiter;
  935. }
  936. float RendererSceneRenderRD::screen_space_roughness_limiter_get_amount() const {
  937. return screen_space_roughness_limiter_amount;
  938. }
  939. float RendererSceneRenderRD::screen_space_roughness_limiter_get_limit() const {
  940. return screen_space_roughness_limiter_limit;
  941. }
  942. TypedArray<Image> RendererSceneRenderRD::bake_render_uv2(RID p_base, const TypedArray<RID> &p_material_overrides, const Size2i &p_image_size) {
  943. ERR_FAIL_COND_V_MSG(p_image_size.width <= 0, TypedArray<Image>(), "Image width must be greater than 0.");
  944. ERR_FAIL_COND_V_MSG(p_image_size.height <= 0, TypedArray<Image>(), "Image height must be greater than 0.");
  945. RD::TextureFormat tf;
  946. tf.format = RD::DATA_FORMAT_R8G8B8A8_UNORM;
  947. tf.width = p_image_size.width; // Always 64x64
  948. tf.height = p_image_size.height;
  949. tf.usage_bits = RD::TEXTURE_USAGE_COLOR_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
  950. RID albedo_alpha_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
  951. RID normal_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
  952. RID orm_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
  953. tf.format = RD::DATA_FORMAT_R16G16B16A16_SFLOAT;
  954. RID emission_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
  955. tf.format = RD::DATA_FORMAT_R32_SFLOAT;
  956. RID depth_write_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
  957. tf.usage_bits = RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT;
  958. tf.format = RD::get_singleton()->texture_is_format_supported_for_usage(RD::DATA_FORMAT_D32_SFLOAT, RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT) ? RD::DATA_FORMAT_D32_SFLOAT : RD::DATA_FORMAT_X8_D24_UNORM_PACK32;
  959. RID depth_tex = RD::get_singleton()->texture_create(tf, RD::TextureView());
  960. Vector<RID> fb_tex;
  961. fb_tex.push_back(albedo_alpha_tex);
  962. fb_tex.push_back(normal_tex);
  963. fb_tex.push_back(orm_tex);
  964. fb_tex.push_back(emission_tex);
  965. fb_tex.push_back(depth_write_tex);
  966. fb_tex.push_back(depth_tex);
  967. RID fb = RD::get_singleton()->framebuffer_create(fb_tex);
  968. //RID sampled_light;
  969. RenderGeometryInstance *gi_inst = geometry_instance_create(p_base);
  970. ERR_FAIL_NULL_V(gi_inst, TypedArray<Image>());
  971. uint32_t sc = RSG::mesh_storage->mesh_get_surface_count(p_base);
  972. Vector<RID> materials;
  973. materials.resize(sc);
  974. for (uint32_t i = 0; i < sc; i++) {
  975. if (i < (uint32_t)p_material_overrides.size()) {
  976. materials.write[i] = p_material_overrides[i];
  977. }
  978. }
  979. gi_inst->set_surface_materials(materials);
  980. if (cull_argument.size() == 0) {
  981. cull_argument.push_back(nullptr);
  982. }
  983. cull_argument[0] = gi_inst;
  984. _render_uv2(cull_argument, fb, Rect2i(0, 0, p_image_size.width, p_image_size.height));
  985. geometry_instance_free(gi_inst);
  986. TypedArray<Image> ret;
  987. {
  988. PackedByteArray data = RD::get_singleton()->texture_get_data(albedo_alpha_tex, 0);
  989. Ref<Image> img = Image::create_from_data(p_image_size.width, p_image_size.height, false, Image::FORMAT_RGBA8, data);
  990. RD::get_singleton()->free(albedo_alpha_tex);
  991. ret.push_back(img);
  992. }
  993. {
  994. PackedByteArray data = RD::get_singleton()->texture_get_data(normal_tex, 0);
  995. Ref<Image> img = Image::create_from_data(p_image_size.width, p_image_size.height, false, Image::FORMAT_RGBA8, data);
  996. RD::get_singleton()->free(normal_tex);
  997. ret.push_back(img);
  998. }
  999. {
  1000. PackedByteArray data = RD::get_singleton()->texture_get_data(orm_tex, 0);
  1001. Ref<Image> img = Image::create_from_data(p_image_size.width, p_image_size.height, false, Image::FORMAT_RGBA8, data);
  1002. RD::get_singleton()->free(orm_tex);
  1003. ret.push_back(img);
  1004. }
  1005. {
  1006. PackedByteArray data = RD::get_singleton()->texture_get_data(emission_tex, 0);
  1007. Ref<Image> img = Image::create_from_data(p_image_size.width, p_image_size.height, false, Image::FORMAT_RGBAH, data);
  1008. RD::get_singleton()->free(emission_tex);
  1009. ret.push_back(img);
  1010. }
  1011. RD::get_singleton()->free(depth_write_tex);
  1012. RD::get_singleton()->free(depth_tex);
  1013. return ret;
  1014. }
  1015. void RendererSceneRenderRD::sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir) {
  1016. gi.sdfgi_debug_probe_pos = p_position;
  1017. gi.sdfgi_debug_probe_dir = p_dir;
  1018. }
  1019. RendererSceneRenderRD *RendererSceneRenderRD::singleton = nullptr;
  1020. bool RendererSceneRenderRD::is_vrs_supported() const {
  1021. return RD::get_singleton()->has_feature(RD::SUPPORTS_ATTACHMENT_VRS);
  1022. }
  1023. bool RendererSceneRenderRD::is_dynamic_gi_supported() const {
  1024. // usable by default (unless low end = true)
  1025. return true;
  1026. }
  1027. bool RendererSceneRenderRD::is_volumetric_supported() const {
  1028. // usable by default (unless low end = true)
  1029. return true;
  1030. }
  1031. uint32_t RendererSceneRenderRD::get_max_elements() const {
  1032. return GLOBAL_GET("rendering/limits/cluster_builder/max_clustered_elements");
  1033. }
  1034. RendererSceneRenderRD::RendererSceneRenderRD() {
  1035. singleton = this;
  1036. }
  1037. void RendererSceneRenderRD::init() {
  1038. max_cluster_elements = get_max_elements();
  1039. RendererRD::LightStorage::get_singleton()->set_max_cluster_elements(max_cluster_elements);
  1040. /* Forward ID */
  1041. forward_id_storage = create_forward_id_storage();
  1042. /* SKY SHADER */
  1043. sky.init();
  1044. /* GI */
  1045. if (is_dynamic_gi_supported()) {
  1046. gi.init(&sky);
  1047. }
  1048. { //decals
  1049. RendererRD::TextureStorage::get_singleton()->set_max_decals(max_cluster_elements);
  1050. }
  1051. { //lights
  1052. }
  1053. if (is_volumetric_supported()) {
  1054. RendererRD::Fog::get_singleton()->init_fog_shader(RendererRD::LightStorage::get_singleton()->get_max_directional_lights(), get_roughness_layers(), is_using_radiance_cubemap_array());
  1055. }
  1056. RSG::camera_attributes->camera_attributes_set_dof_blur_bokeh_shape(RS::DOFBokehShape(int(GLOBAL_GET("rendering/camera/depth_of_field/depth_of_field_bokeh_shape"))));
  1057. RSG::camera_attributes->camera_attributes_set_dof_blur_quality(RS::DOFBlurQuality(int(GLOBAL_GET("rendering/camera/depth_of_field/depth_of_field_bokeh_quality"))), GLOBAL_GET("rendering/camera/depth_of_field/depth_of_field_use_jitter"));
  1058. use_physical_light_units = GLOBAL_GET("rendering/lights_and_shadows/use_physical_light_units");
  1059. screen_space_roughness_limiter = GLOBAL_GET("rendering/anti_aliasing/screen_space_roughness_limiter/enabled");
  1060. screen_space_roughness_limiter_amount = GLOBAL_GET("rendering/anti_aliasing/screen_space_roughness_limiter/amount");
  1061. screen_space_roughness_limiter_limit = GLOBAL_GET("rendering/anti_aliasing/screen_space_roughness_limiter/limit");
  1062. glow_bicubic_upscale = int(GLOBAL_GET("rendering/environment/glow/upscale_mode")) > 0;
  1063. directional_penumbra_shadow_kernel = memnew_arr(float, 128);
  1064. directional_soft_shadow_kernel = memnew_arr(float, 128);
  1065. penumbra_shadow_kernel = memnew_arr(float, 128);
  1066. soft_shadow_kernel = memnew_arr(float, 128);
  1067. positional_soft_shadow_filter_set_quality(RS::ShadowQuality(int(GLOBAL_GET("rendering/lights_and_shadows/positional_shadow/soft_shadow_filter_quality"))));
  1068. directional_soft_shadow_filter_set_quality(RS::ShadowQuality(int(GLOBAL_GET("rendering/lights_and_shadows/directional_shadow/soft_shadow_filter_quality"))));
  1069. environment_set_volumetric_fog_volume_size(GLOBAL_GET("rendering/environment/volumetric_fog/volume_size"), GLOBAL_GET("rendering/environment/volumetric_fog/volume_depth"));
  1070. environment_set_volumetric_fog_filter_active(GLOBAL_GET("rendering/environment/volumetric_fog/use_filter"));
  1071. decals_set_filter(RS::DecalFilter(int(GLOBAL_GET("rendering/textures/decals/filter"))));
  1072. light_projectors_set_filter(RS::LightProjectorFilter(int(GLOBAL_GET("rendering/textures/light_projectors/filter"))));
  1073. cull_argument.set_page_pool(&cull_argument_pool);
  1074. bool can_use_storage = _render_buffers_can_be_storage();
  1075. bool can_use_vrs = is_vrs_supported();
  1076. bokeh_dof = memnew(RendererRD::BokehDOF(!can_use_storage));
  1077. copy_effects = memnew(RendererRD::CopyEffects(!can_use_storage));
  1078. debug_effects = memnew(RendererRD::DebugEffects);
  1079. luminance = memnew(RendererRD::Luminance(!can_use_storage));
  1080. tone_mapper = memnew(RendererRD::ToneMapper);
  1081. if (can_use_vrs) {
  1082. vrs = memnew(RendererRD::VRS);
  1083. }
  1084. if (can_use_storage) {
  1085. fsr = memnew(RendererRD::FSR);
  1086. }
  1087. }
  1088. RendererSceneRenderRD::~RendererSceneRenderRD() {
  1089. if (forward_id_storage) {
  1090. memdelete(forward_id_storage);
  1091. }
  1092. if (bokeh_dof) {
  1093. memdelete(bokeh_dof);
  1094. }
  1095. if (copy_effects) {
  1096. memdelete(copy_effects);
  1097. }
  1098. if (debug_effects) {
  1099. memdelete(debug_effects);
  1100. }
  1101. if (luminance) {
  1102. memdelete(luminance);
  1103. }
  1104. if (tone_mapper) {
  1105. memdelete(tone_mapper);
  1106. }
  1107. if (vrs) {
  1108. memdelete(vrs);
  1109. }
  1110. if (fsr) {
  1111. memdelete(fsr);
  1112. }
  1113. if (sky.sky_scene_state.uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(sky.sky_scene_state.uniform_set)) {
  1114. RD::get_singleton()->free(sky.sky_scene_state.uniform_set);
  1115. }
  1116. if (is_dynamic_gi_supported()) {
  1117. gi.free();
  1118. }
  1119. if (is_volumetric_supported()) {
  1120. RendererRD::Fog::get_singleton()->free_fog_shader();
  1121. }
  1122. memdelete_arr(directional_penumbra_shadow_kernel);
  1123. memdelete_arr(directional_soft_shadow_kernel);
  1124. memdelete_arr(penumbra_shadow_kernel);
  1125. memdelete_arr(soft_shadow_kernel);
  1126. RSG::light_storage->directional_shadow_atlas_set_size(0);
  1127. cull_argument.reset(); //avoid exit error
  1128. }