d95794ec8a
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".
384 lines
17 KiB
C++
384 lines
17 KiB
C++
/**************************************************************************/
|
|
/* renderer_scene_render_rd.h */
|
|
/**************************************************************************/
|
|
/* 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. */
|
|
/**************************************************************************/
|
|
|
|
#ifndef RENDERER_SCENE_RENDER_RD_H
|
|
#define RENDERER_SCENE_RENDER_RD_H
|
|
|
|
#include "core/templates/local_vector.h"
|
|
#include "core/templates/rid_owner.h"
|
|
#include "servers/rendering/renderer_compositor.h"
|
|
#include "servers/rendering/renderer_rd/cluster_builder_rd.h"
|
|
#include "servers/rendering/renderer_rd/effects/bokeh_dof.h"
|
|
#include "servers/rendering/renderer_rd/effects/copy_effects.h"
|
|
#include "servers/rendering/renderer_rd/effects/fsr.h"
|
|
#include "servers/rendering/renderer_rd/effects/tone_mapper.h"
|
|
#include "servers/rendering/renderer_rd/effects/vrs.h"
|
|
#include "servers/rendering/renderer_rd/environment/fog.h"
|
|
#include "servers/rendering/renderer_rd/environment/gi.h"
|
|
#include "servers/rendering/renderer_rd/environment/sky.h"
|
|
#include "servers/rendering/renderer_rd/framebuffer_cache_rd.h"
|
|
#include "servers/rendering/renderer_rd/storage_rd/light_storage.h"
|
|
#include "servers/rendering/renderer_rd/storage_rd/render_scene_buffers_rd.h"
|
|
#include "servers/rendering/renderer_rd/storage_rd/render_scene_data_rd.h"
|
|
#include "servers/rendering/renderer_scene_render.h"
|
|
#include "servers/rendering/rendering_device.h"
|
|
#include "servers/rendering/rendering_method.h"
|
|
|
|
// For RenderDataRD, possibly inherited from RefCounted and add proper getters for our implementation classes
|
|
|
|
struct RenderDataRD {
|
|
Ref<RenderSceneBuffersRD> render_buffers;
|
|
RenderSceneDataRD *scene_data;
|
|
|
|
const PagedArray<RenderGeometryInstance *> *instances = nullptr;
|
|
const PagedArray<RID> *lights = nullptr;
|
|
const PagedArray<RID> *reflection_probes = nullptr;
|
|
const PagedArray<RID> *voxel_gi_instances = nullptr;
|
|
const PagedArray<RID> *decals = nullptr;
|
|
const PagedArray<RID> *lightmaps = nullptr;
|
|
const PagedArray<RID> *fog_volumes = nullptr;
|
|
RID environment;
|
|
RID camera_attributes;
|
|
RID shadow_atlas;
|
|
RID occluder_debug_tex;
|
|
RID reflection_atlas;
|
|
RID reflection_probe;
|
|
int reflection_probe_pass = 0;
|
|
|
|
RID cluster_buffer;
|
|
uint32_t cluster_size = 0;
|
|
uint32_t cluster_max_elements = 0;
|
|
|
|
uint32_t directional_light_count = 0;
|
|
bool directional_light_soft_shadows = false;
|
|
|
|
RenderingMethod::RenderInfo *render_info = nullptr;
|
|
|
|
/* Shadow data */
|
|
const RendererSceneRender::RenderShadowData *render_shadows = nullptr;
|
|
int render_shadow_count = 0;
|
|
|
|
LocalVector<int> cube_shadows;
|
|
LocalVector<int> shadows;
|
|
LocalVector<int> directional_shadows;
|
|
|
|
/* GI info */
|
|
const RendererSceneRender::RenderSDFGIData *render_sdfgi_regions = nullptr;
|
|
int render_sdfgi_region_count = 0;
|
|
const RendererSceneRender::RenderSDFGIUpdateData *sdfgi_update_data = nullptr;
|
|
|
|
uint32_t voxel_gi_count = 0;
|
|
};
|
|
|
|
class RendererSceneRenderRD : public RendererSceneRender {
|
|
friend RendererRD::SkyRD;
|
|
friend RendererRD::GI;
|
|
|
|
protected:
|
|
RendererRD::ForwardIDStorage *forward_id_storage = nullptr;
|
|
RendererRD::BokehDOF *bokeh_dof = nullptr;
|
|
RendererRD::CopyEffects *copy_effects = nullptr;
|
|
RendererRD::ToneMapper *tone_mapper = nullptr;
|
|
RendererRD::FSR *fsr = nullptr;
|
|
RendererRD::VRS *vrs = nullptr;
|
|
double time = 0.0;
|
|
double time_step = 0.0;
|
|
|
|
/* ENVIRONMENT */
|
|
|
|
bool glow_bicubic_upscale = false;
|
|
|
|
bool use_physical_light_units = false;
|
|
|
|
////////////////////////////////
|
|
|
|
virtual RendererRD::ForwardIDStorage *create_forward_id_storage() { return memnew(RendererRD::ForwardIDStorage); };
|
|
|
|
void _update_vrs(Ref<RenderSceneBuffersRD> p_render_buffers);
|
|
|
|
virtual void setup_render_buffer_data(Ref<RenderSceneBuffersRD> p_render_buffers) = 0;
|
|
|
|
virtual void _render_scene(RenderDataRD *p_render_data, const Color &p_default_color) = 0;
|
|
virtual void _render_buffers_debug_draw(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_shadow_atlas, RID p_occlusion_buffer);
|
|
|
|
virtual void _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, float p_exposure_normalization) = 0;
|
|
virtual void _render_uv2(const PagedArray<RenderGeometryInstance *> &p_instances, RID p_framebuffer, const Rect2i &p_region) = 0;
|
|
virtual void _render_sdfgi(Ref<RenderSceneBuffersRD> p_render_buffers, const Vector3i &p_from, const Vector3i &p_size, const AABB &p_bounds, const PagedArray<RenderGeometryInstance *> &p_instances, const RID &p_albedo_texture, const RID &p_emission_texture, const RID &p_emission_aniso_texture, const RID &p_geom_facing_texture, float p_exposure_normalization) = 0;
|
|
virtual void _render_particle_collider_heightfield(RID p_fb, const Transform3D &p_cam_transform, const Projection &p_cam_projection, const PagedArray<RenderGeometryInstance *> &p_instances) = 0;
|
|
|
|
void _debug_sdfgi_probes(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_framebuffer, uint32_t p_view_count, const Projection *p_camera_with_transforms, bool p_will_continue_color, bool p_will_continue_depth);
|
|
|
|
virtual RID _render_buffers_get_normal_texture(Ref<RenderSceneBuffersRD> p_render_buffers) = 0;
|
|
virtual RID _render_buffers_get_velocity_texture(Ref<RenderSceneBuffersRD> p_render_buffers) = 0;
|
|
|
|
bool _needs_post_prepass_render(RenderDataRD *p_render_data, bool p_use_gi);
|
|
void _post_prepass_render(RenderDataRD *p_render_data, bool p_use_gi);
|
|
void _pre_resolve_render(RenderDataRD *p_render_data, bool p_use_gi);
|
|
|
|
void _render_buffers_copy_screen_texture(const RenderDataRD *p_render_data);
|
|
void _render_buffers_copy_depth_texture(const RenderDataRD *p_render_data);
|
|
void _render_buffers_post_process_and_tonemap(const RenderDataRD *p_render_data);
|
|
void _post_process_subpass(RID p_source_texture, RID p_framebuffer, const RenderDataRD *p_render_data);
|
|
void _disable_clear_request(const RenderDataRD *p_render_data);
|
|
|
|
// needed for a single argument calls (material and uv2)
|
|
PagedArrayPool<RenderGeometryInstance *> cull_argument_pool;
|
|
PagedArray<RenderGeometryInstance *> cull_argument; //need this to exist
|
|
|
|
RendererRD::SkyRD sky;
|
|
RendererRD::GI gi;
|
|
|
|
virtual void _update_shader_quality_settings() {}
|
|
|
|
private:
|
|
RS::ViewportDebugDraw debug_draw = RS::VIEWPORT_DEBUG_DRAW_DISABLED;
|
|
static RendererSceneRenderRD *singleton;
|
|
|
|
/* Shadow atlas */
|
|
RS::ShadowQuality shadows_quality = RS::SHADOW_QUALITY_MAX; //So it always updates when first set
|
|
RS::ShadowQuality directional_shadow_quality = RS::SHADOW_QUALITY_MAX;
|
|
float shadows_quality_radius = 1.0;
|
|
float directional_shadow_quality_radius = 1.0;
|
|
|
|
float *directional_penumbra_shadow_kernel = nullptr;
|
|
float *directional_soft_shadow_kernel = nullptr;
|
|
float *penumbra_shadow_kernel = nullptr;
|
|
float *soft_shadow_kernel = nullptr;
|
|
int directional_penumbra_shadow_samples = 0;
|
|
int directional_soft_shadow_samples = 0;
|
|
int penumbra_shadow_samples = 0;
|
|
int soft_shadow_samples = 0;
|
|
RS::DecalFilter decals_filter = RS::DECAL_FILTER_LINEAR_MIPMAPS;
|
|
RS::LightProjectorFilter light_projectors_filter = RS::LIGHT_PROJECTOR_FILTER_LINEAR_MIPMAPS;
|
|
|
|
/* RENDER BUFFERS */
|
|
|
|
// TODO move into effects/luminance.h/cpp
|
|
void _allocate_luminance_textures(Ref<RenderSceneBuffersRD> rb);
|
|
|
|
/* GI */
|
|
bool screen_space_roughness_limiter = false;
|
|
float screen_space_roughness_limiter_amount = 0.25;
|
|
float screen_space_roughness_limiter_limit = 0.18;
|
|
|
|
/* Light data */
|
|
|
|
uint64_t scene_pass = 0;
|
|
|
|
uint32_t max_cluster_elements = 512;
|
|
|
|
/* Volumetric Fog */
|
|
|
|
uint32_t volumetric_fog_size = 128;
|
|
uint32_t volumetric_fog_depth = 128;
|
|
bool volumetric_fog_filter_active = true;
|
|
|
|
public:
|
|
static RendererSceneRenderRD *get_singleton() { return singleton; }
|
|
|
|
/* LIGHTING */
|
|
|
|
virtual void setup_added_reflection_probe(const Transform3D &p_transform, const Vector3 &p_half_extents){};
|
|
virtual void setup_added_light(const RS::LightType p_type, const Transform3D &p_transform, float p_radius, float p_spot_aperture){};
|
|
virtual void setup_added_decal(const Transform3D &p_transform, const Vector3 &p_half_extents){};
|
|
|
|
/* GI */
|
|
|
|
RendererRD::GI *get_gi() { return &gi; }
|
|
|
|
/* SKY */
|
|
|
|
RendererRD::SkyRD *get_sky() { return &sky; }
|
|
|
|
/* SKY API */
|
|
|
|
virtual RID sky_allocate() override;
|
|
virtual void sky_initialize(RID p_rid) override;
|
|
|
|
virtual void sky_set_radiance_size(RID p_sky, int p_radiance_size) override;
|
|
virtual void sky_set_mode(RID p_sky, RS::SkyMode p_mode) override;
|
|
virtual void sky_set_material(RID p_sky, RID p_material) override;
|
|
virtual Ref<Image> sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irradiance, const Size2i &p_size) override;
|
|
|
|
/* ENVIRONMENT API */
|
|
|
|
virtual void environment_glow_set_use_bicubic_upscale(bool p_enable) override;
|
|
|
|
virtual void environment_set_volumetric_fog_volume_size(int p_size, int p_depth) override;
|
|
virtual void environment_set_volumetric_fog_filter_active(bool p_enable) override;
|
|
|
|
virtual void environment_set_sdfgi_ray_count(RS::EnvironmentSDFGIRayCount p_ray_count) override;
|
|
virtual void environment_set_sdfgi_frames_to_converge(RS::EnvironmentSDFGIFramesToConverge p_frames) override;
|
|
virtual void environment_set_sdfgi_frames_to_update_light(RS::EnvironmentSDFGIFramesToUpdateLight p_update) override;
|
|
|
|
virtual Ref<Image> environment_bake_panorama(RID p_env, bool p_bake_irradiance, const Size2i &p_size) override;
|
|
|
|
_FORCE_INLINE_ bool is_using_physical_light_units() {
|
|
return use_physical_light_units;
|
|
}
|
|
|
|
/* REFLECTION PROBE */
|
|
|
|
virtual RID reflection_probe_create_framebuffer(RID p_color, RID p_depth);
|
|
|
|
/* FOG VOLUMES */
|
|
|
|
uint32_t get_volumetric_fog_size() const { return volumetric_fog_size; }
|
|
uint32_t get_volumetric_fog_depth() const { return volumetric_fog_depth; }
|
|
bool get_volumetric_fog_filter_active() const { return volumetric_fog_filter_active; }
|
|
|
|
virtual RID fog_volume_instance_create(RID p_fog_volume) override;
|
|
virtual void fog_volume_instance_set_transform(RID p_fog_volume_instance, const Transform3D &p_transform) override;
|
|
virtual void fog_volume_instance_set_active(RID p_fog_volume_instance, bool p_active) override;
|
|
virtual RID fog_volume_instance_get_volume(RID p_fog_volume_instance) const override;
|
|
virtual Vector3 fog_volume_instance_get_position(RID p_fog_volume_instance) const override;
|
|
|
|
/* gi light probes */
|
|
|
|
virtual RID voxel_gi_instance_create(RID p_base) override;
|
|
virtual void voxel_gi_instance_set_transform_to_data(RID p_probe, const Transform3D &p_xform) override;
|
|
virtual bool voxel_gi_needs_update(RID p_probe) const override;
|
|
virtual void voxel_gi_update(RID p_probe, bool p_update_light_instances, const Vector<RID> &p_light_instances, const PagedArray<RenderGeometryInstance *> &p_dynamic_objects) override;
|
|
virtual void voxel_gi_set_quality(RS::VoxelGIQuality p_quality) override { gi.voxel_gi_quality = p_quality; }
|
|
|
|
/* render buffers */
|
|
|
|
virtual float _render_buffers_get_luminance_multiplier();
|
|
virtual RD::DataFormat _render_buffers_get_color_format();
|
|
virtual bool _render_buffers_can_be_storage();
|
|
virtual Ref<RenderSceneBuffers> render_buffers_create() override;
|
|
virtual void gi_set_use_half_resolution(bool p_enable) override;
|
|
|
|
RID render_buffers_get_default_voxel_gi_buffer();
|
|
|
|
virtual void base_uniforms_changed() = 0;
|
|
virtual void update_uniform_sets(){};
|
|
|
|
virtual void 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 = nullptr, RenderingMethod::RenderInfo *r_render_info = nullptr) override;
|
|
|
|
virtual void 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) override;
|
|
|
|
virtual void render_particle_collider_heightfield(RID p_collider, const Transform3D &p_transform, const PagedArray<RenderGeometryInstance *> &p_instances) override;
|
|
|
|
virtual void set_scene_pass(uint64_t p_pass) override {
|
|
scene_pass = p_pass;
|
|
}
|
|
_FORCE_INLINE_ uint64_t get_scene_pass() {
|
|
return scene_pass;
|
|
}
|
|
|
|
virtual void screen_space_roughness_limiter_set_active(bool p_enable, float p_amount, float p_limit) override;
|
|
virtual bool screen_space_roughness_limiter_is_active() const override;
|
|
virtual float screen_space_roughness_limiter_get_amount() const;
|
|
virtual float screen_space_roughness_limiter_get_limit() const;
|
|
|
|
virtual void positional_soft_shadow_filter_set_quality(RS::ShadowQuality p_quality) override;
|
|
virtual void directional_soft_shadow_filter_set_quality(RS::ShadowQuality p_quality) override;
|
|
|
|
virtual void decals_set_filter(RS::DecalFilter p_filter) override;
|
|
virtual void light_projectors_set_filter(RS::LightProjectorFilter p_filter) override;
|
|
|
|
_FORCE_INLINE_ RS::ShadowQuality shadows_quality_get() const {
|
|
return shadows_quality;
|
|
}
|
|
_FORCE_INLINE_ RS::ShadowQuality directional_shadow_quality_get() const {
|
|
return directional_shadow_quality;
|
|
}
|
|
_FORCE_INLINE_ float shadows_quality_radius_get() const {
|
|
return shadows_quality_radius;
|
|
}
|
|
_FORCE_INLINE_ float directional_shadow_quality_radius_get() const {
|
|
return directional_shadow_quality_radius;
|
|
}
|
|
|
|
_FORCE_INLINE_ float *directional_penumbra_shadow_kernel_get() {
|
|
return directional_penumbra_shadow_kernel;
|
|
}
|
|
_FORCE_INLINE_ float *directional_soft_shadow_kernel_get() {
|
|
return directional_soft_shadow_kernel;
|
|
}
|
|
_FORCE_INLINE_ float *penumbra_shadow_kernel_get() {
|
|
return penumbra_shadow_kernel;
|
|
}
|
|
_FORCE_INLINE_ float *soft_shadow_kernel_get() {
|
|
return soft_shadow_kernel;
|
|
}
|
|
|
|
_FORCE_INLINE_ int directional_penumbra_shadow_samples_get() const {
|
|
return directional_penumbra_shadow_samples;
|
|
}
|
|
_FORCE_INLINE_ int directional_soft_shadow_samples_get() const {
|
|
return directional_soft_shadow_samples;
|
|
}
|
|
_FORCE_INLINE_ int penumbra_shadow_samples_get() const {
|
|
return penumbra_shadow_samples;
|
|
}
|
|
_FORCE_INLINE_ int soft_shadow_samples_get() const {
|
|
return soft_shadow_samples;
|
|
}
|
|
|
|
_FORCE_INLINE_ RS::LightProjectorFilter light_projectors_get_filter() const {
|
|
return light_projectors_filter;
|
|
}
|
|
_FORCE_INLINE_ RS::DecalFilter decals_get_filter() const {
|
|
return decals_filter;
|
|
}
|
|
|
|
int get_roughness_layers() const;
|
|
bool is_using_radiance_cubemap_array() const;
|
|
|
|
virtual TypedArray<Image> bake_render_uv2(RID p_base, const TypedArray<RID> &p_material_overrides, const Size2i &p_image_size) override;
|
|
|
|
virtual bool free(RID p_rid) override;
|
|
|
|
virtual void update() override;
|
|
|
|
virtual void set_debug_draw_mode(RS::ViewportDebugDraw p_debug_draw) override;
|
|
_FORCE_INLINE_ RS::ViewportDebugDraw get_debug_draw_mode() const {
|
|
return debug_draw;
|
|
}
|
|
|
|
virtual void set_time(double p_time, double p_step) override;
|
|
|
|
virtual void sdfgi_set_debug_probe_select(const Vector3 &p_position, const Vector3 &p_dir) override;
|
|
|
|
virtual bool is_vrs_supported() const;
|
|
virtual bool is_dynamic_gi_supported() const;
|
|
virtual bool is_volumetric_supported() const;
|
|
virtual uint32_t get_max_elements() const;
|
|
|
|
void init();
|
|
|
|
RendererSceneRenderRD();
|
|
~RendererSceneRenderRD();
|
|
};
|
|
|
|
#endif // RENDERER_SCENE_RENDER_RD_H
|