godot/servers/rendering/renderer_rd/renderer_scene_render_rd.cpp

/**************************************************************************/
/*  renderer_scene_render_rd.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.                 */
/**************************************************************************/

#include "renderer_scene_render_rd.h"

#include "core/config/project_settings.h"
#include "core/io/image.h"
#include "core/os/os.h"
#include "renderer_compositor_rd.h"
#include "servers/rendering/renderer_rd/environment/fog.h"
#include "servers/rendering/renderer_rd/storage_rd/material_storage.h"
#include "servers/rendering/renderer_rd/storage_rd/texture_storage.h"
#include "servers/rendering/rendering_server_default.h"
#include "servers/rendering/storage/camera_attributes_storage.h"

void get_vogel_disk(float *r_kernel, int p_sample_count) { … }

RID RendererSceneRenderRD::sky_allocate() { … }
void RendererSceneRenderRD::sky_initialize(RID p_rid) { … }

void RendererSceneRenderRD::sky_set_radiance_size(RID p_sky, int p_radiance_size) { … }

void RendererSceneRenderRD::sky_set_mode(RID p_sky, RS::SkyMode p_mode) { … }

void RendererSceneRenderRD::sky_set_material(RID p_sky, RID p_material) { … }

Ref<Image> RendererSceneRenderRD::sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irradiance, const Size2i &p_size) { … }

void RendererSceneRenderRD::environment_glow_set_use_bicubic_upscale(bool p_enable) { … }

void RendererSceneRenderRD::environment_set_volumetric_fog_volume_size(int p_size, int p_depth) { … }

void RendererSceneRenderRD::environment_set_volumetric_fog_filter_active(bool p_enable) { … }

void RendererSceneRenderRD::environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count) { … }

void RendererSceneRenderRD::environment_set_sdfgi_frames_to_converge(RS::EnvironmentSDFGIFramesToConverge p_frames) { … }
void RendererSceneRenderRD::environment_set_sdfgi_frames_to_update_light(RS::EnvironmentSDFGIFramesToUpdateLight p_update) { … }

Ref<Image> RendererSceneRenderRD::environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) { … }

/* REFLECTION PROBE */

RID RendererSceneRenderRD::reflection_probe_create_framebuffer(RID p_color, RID p_depth) { … }

/* FOG VOLUME INSTANCE */

RID RendererSceneRenderRD::fog_volume_instance_create(RID p_fog_volume) { … }

void RendererSceneRenderRD::fog_volume_instance_set_transform(RID p_fog_volume_instance, const Transform3D &p_transform) { … }

void RendererSceneRenderRD::fog_volume_instance_set_active(RID p_fog_volume_instance, bool p_active) { … }

RID RendererSceneRenderRD::fog_volume_instance_get_volume(RID p_fog_volume_instance) const { … }

Vector3 RendererSceneRenderRD::fog_volume_instance_get_position(RID p_fog_volume_instance) const { … }

/* VOXEL GI */

RID RendererSceneRenderRD::voxel_gi_instance_create(RID p_base) { … }

void RendererSceneRenderRD::voxel_gi_instance_set_transform_to_data(RID p_probe, const Transform3D &p_xform) { … }

bool RendererSceneRenderRD::voxel_gi_needs_update(RID p_probe) const { … }

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) { … }

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) { … }

////////////////////////////////
Ref<RenderSceneBuffers> RendererSceneRenderRD::render_buffers_create() { … }

bool RendererSceneRenderRD::_compositor_effects_has_flag(const RenderDataRD *p_render_data, RS::CompositorEffectFlags p_flag, RS::CompositorEffectCallbackType p_callback_type) { … }

bool RendererSceneRenderRD::_has_compositor_effect(RS::CompositorEffectCallbackType p_callback_type, const RenderDataRD *p_render_data) { … }

void RendererSceneRenderRD::_process_compositor_effects(RS::CompositorEffectCallbackType p_callback_type, const RenderDataRD *p_render_data) { … }

void RendererSceneRenderRD::_render_buffers_copy_screen_texture(const RenderDataRD *p_render_data) { … }

void RendererSceneRenderRD::_render_buffers_copy_depth_texture(const RenderDataRD *p_render_data) { … }

void RendererSceneRenderRD::_render_buffers_post_process_and_tonemap(const RenderDataRD *p_render_data) { … }

void RendererSceneRenderRD::_post_process_subpass(RID p_source_texture, RID p_framebuffer, const RenderDataRD *p_render_data) { … }

void RendererSceneRenderRD::_disable_clear_request(const RenderDataRD *p_render_data) { … }

bool RendererSceneRenderRD::_debug_draw_can_use_effects(RS::ViewportDebugDraw p_debug_draw) { … }

void RendererSceneRenderRD::_render_buffers_debug_draw(const RenderDataRD *p_render_data) { … }

RID RendererSceneRenderRD::render_buffers_get_default_voxel_gi_buffer() { … }

float RendererSceneRenderRD::_render_buffers_get_luminance_multiplier() { … }

RD::DataFormat RendererSceneRenderRD::_render_buffers_get_color_format() { … }

bool RendererSceneRenderRD::_render_buffers_can_be_storage() { … }

void RendererSceneRenderRD::gi_set_use_half_resolution(bool p_enable) { … }

void RendererSceneRenderRD::positional_soft_shadow_filter_set_quality(RS::ShadowQuality p_quality) { … }

void RendererSceneRenderRD::directional_soft_shadow_filter_set_quality(RS::ShadowQuality p_quality) { … }

void RendererSceneRenderRD::decals_set_filter(RenderingServer::DecalFilter p_filter) { … }
void RendererSceneRenderRD::light_projectors_set_filter(RenderingServer::LightProjectorFilter p_filter) { … }

void RendererSceneRenderRD::lightmaps_set_bicubic_filter(bool p_enable) { … }

int RendererSceneRenderRD::get_roughness_layers() const { … }

bool RendererSceneRenderRD::is_using_radiance_cubemap_array() const { … }

void RendererSceneRenderRD::_update_vrs(Ref<RenderSceneBuffersRD> p_render_buffers) { … }

bool RendererSceneRenderRD::_needs_post_prepass_render(RenderDataRD *p_render_data, bool p_use_gi) { … }

void RendererSceneRenderRD::_post_prepass_render(RenderDataRD *p_render_data, bool p_use_gi) { … }

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_compositor, 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) { … }

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) { … }

void RendererSceneRenderRD::render_particle_collider_heightfield(RID p_collider, const Transform3D &p_transform, const PagedArray<RenderGeometryInstance *> &p_instances) { … }

bool RendererSceneRenderRD::free(RID p_rid) { … }

void RendererSceneRenderRD::set_debug_draw_mode(RS::ViewportDebugDraw p_debug_draw) { … }

void RendererSceneRenderRD::update() { … }

void RendererSceneRenderRD::set_time(double p_time, double p_step) { … }

void RendererSceneRenderRD::screen_space_roughness_limiter_set_active(bool p_enable, float p_amount, float p_limit) { … }

bool RendererSceneRenderRD::screen_space_roughness_limiter_is_active() const { … }

float RendererSceneRenderRD::screen_space_roughness_limiter_get_amount() const { … }

float RendererSceneRenderRD::screen_space_roughness_limiter_get_limit() const { … }

TypedArray<Image> RendererSceneRenderRD::bake_render_uv2(RID p_base, const TypedArray<RID> &p_material_overrides, const Size2i &p_image_size) { … }

void RendererSceneRenderRD::sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir) { … }

RendererSceneRenderRD *RendererSceneRenderRD::singleton = …;

bool RendererSceneRenderRD::is_vrs_supported() const { … }

bool RendererSceneRenderRD::is_dynamic_gi_supported() const { … }

bool RendererSceneRenderRD::is_volumetric_supported() const { … }

uint32_t RendererSceneRenderRD::get_max_elements() const { … }

RendererSceneRenderRD::RendererSceneRenderRD() { … }

void RendererSceneRenderRD::init() { … }

RendererSceneRenderRD::~RendererSceneRenderRD() { … }