SConscript("forward_clustered/SCsub")

SConscript("forward_mobile/SCsub")

SConscript("shaders/SCsub")

SConscript("storage_rd/SCsub")

blur_modes.push_back("\n#define MODE_GAUSSIAN_GLOW\n"); // BLUR_MODE_GAUSSIAN_GLOW

blur_modes.push_back("\n#define MODE_GAUSSIAN_GLOW\n#define GLOW_USE_AUTO_EXPOSURE\n"); // BLUR_MODE_GAUSSIAN_GLOW_AUTO_EXPOSURE

blur_modes.push_back("\n#define MODE_COPY\n"); // BLUR_MODE_COPY

blur_raster.shader.initialize(blur_modes);

memset(&blur_raster.push_constant, 0, sizeof(BlurRasterPushConstant));

copy_modes.push_back("\n#define MODE_TWO_SOURCES\n"); // COPY_TO_FB_COPY2

copy_modes.push_back("\n#define MULTIVIEW\n"); // COPY_TO_FB_MULTIVIEW

copy_modes.push_back("\n#define MULTIVIEW\n#define MODE_TWO_SOURCES\n"); // COPY_TO_FB_MULTIVIEW_WITH_DEPTH

copy_to_fb.shader.initialize(copy_modes);

copy.push_constant.flags |= COPY_FLAG_ALPHA_TO_ONE;

}

copy.push_constant.section[2] = p_rect.size.width;

copy.push_constant.section[3] = p_rect.size.height;

copy.push_constant.target[0] = p_rect.position.x;

memset(&copy_to_fb.push_constant, 0, sizeof(CopyToFbPushConstant));

copy_to_fb.push_constant.section[0] = p_uv_rect.position.x;

copy_to_fb.push_constant.section[1] = p_uv_rect.position.y;

copy_to_fb.push_constant.section[2] = p_uv_rect.size.x;

copy_to_fb.push_constant.section[3] = p_uv_rect.size.y;

if (p_flip_y) {

}

// setup our uniforms

RID default_sampler = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);

RD::get_singleton()->draw_list_draw(draw_list, true);

}

UniformSetCacheRD *uniform_set_cache = UniformSetCacheRD::get_singleton();

ERR_FAIL_NULL(uniform_set_cache);

MaterialStorage *material_storage = MaterialStorage::get_singleton();

ERR_FAIL_NULL(material_storage);

memset(&copy_to_fb.push_constant, 0, sizeof(CopyToFbPushConstant));

if (p_flip_y) {

}

if (p_force_luminance) {

}

if (p_alpha_to_zero) {

}

if (p_srgb) {

}

// setup our uniforms

RD::get_singleton()->draw_list_bind_render_pipeline(draw_list, blur_raster.pipelines[BLUR_MODE_COPY].get_render_pipeline(RD::INVALID_ID, RD::get_singleton()->framebuffer_get_format(p_dest_framebuffer)));

RD::get_singleton()->draw_list_bind_uniform_set(draw_list, uniform_set_cache->get_cache(shader, 0, u_source_texture), 0);

RD::get_singleton()->draw_list_bind_index_array(draw_list, material_storage->get_quad_index_array());

RD::get_singleton()->draw_list_set_push_constant(draw_list, &blur_raster.push_constant, sizeof(BlurRasterPushConstant));

RD::get_singleton()->draw_list_draw(draw_list, true);

RD::get_singleton()->draw_list_end();

}

ERR_FAIL_COND_MSG(prefer_raster_effects, "Can't use the compute version of the gaussian blur with the mobile renderer.");

UniformSetCacheRD *uniform_set_cache = UniformSetCacheRD::get_singleton();

copy.push_constant.section[0] = p_region.position.x;

copy.push_constant.section[1] = p_region.position.y;

// setup our uniforms

RID default_sampler = material_storage->sampler_rd_get_default(RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);

RID shader = copy.shader.version_get_shader(copy.shader_version, mode);

ERR_FAIL_COND(shader.is_null());

RD::DrawListID compute_list = RD::get_singleton()->compute_list_begin();

RD::get_singleton()->compute_list_bind_compute_pipeline(compute_list, copy.pipelines[mode]);

RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 0, u_source_rd_texture), 0);

RD::get_singleton()->compute_list_end();

}

ERR_FAIL_COND_MSG(prefer_raster_effects, "Can't use the compute version of the gaussian glow with the mobile renderer.");

UniformSetCacheRD *uniform_set_cache = UniformSetCacheRD::get_singleton();

RD::get_singleton()->compute_list_bind_uniform_set(compute_list, uniform_set_cache->get_cache(shader, 1, u_auto_exposure), 1);

}

RD::get_singleton()->compute_list_set_push_constant(compute_list, &copy.push_constant, sizeof(CopyPushConstant));

RD::get_singleton()->compute_list_dispatch_threads(compute_list, p_size.width, p_size.height, 1);

RD::get_singleton()->compute_list_end();

}

ERR_FAIL_COND_MSG(!prefer_raster_effects, "Can't use the raster version of the gaussian glow with the clustered renderer.");

UniformSetCacheRD *uniform_set_cache = UniformSetCacheRD::get_singleton();

RD::get_singleton()->compute_list_end();

}

void CopyEffects::copy_cubemap_to_dp(RID p_source_rd_texture, RID p_dst_framebuffer, const Rect2 &p_rect, const Vector2 &p_dst_size, float p_z_near, float p_z_far, bool p_dp_flip) {

UniformSetCacheRD *uniform_set_cache = UniformSetCacheRD::get_singleton();

ERR_FAIL_NULL(uniform_set_cache);

memset(&roughness.push_constant, 0, sizeof(CubemapRoughnessPushConstant));

roughness.push_constant.face_id = p_face_id > 9 ? 0 : p_face_id;

roughness.push_constant.sample_count = p_sample_count;

roughness.push_constant.use_direct_write = p_roughness == 0.0;

roughness.push_constant.face_size = p_size;

roughness.push_constant.use_direct_write = p_roughness == 0.0;

roughness.push_constant.face_size = p_size;

RD::Uniform u_source_rd_texture(RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE, 0, Vector<RID>({ default_sampler, p_source_rd_texture }));

BLUR_MODE_GAUSSIAN_GLOW_AUTO_EXPOSURE,

BLUR_MODE_COPY,

BLUR_MODE_MAX

};

COPY_FLAG_FLIP_Y = (1 << 5),

COPY_FLAG_FORCE_LUMINANCE = (1 << 6),

COPY_FLAG_ALL_SOURCE = (1 << 7),

};

struct CopyPushConstant {

COPY_TO_FB_MULTIVIEW,

COPY_TO_FB_MULTIVIEW_WITH_DEPTH,

COPY_TO_FB_MAX,

};

struct CopyToFbPushConstant {

float section[4];

float pixel_size[2];

};

struct CopyToFb {

void copy_cubemap_to_panorama(RID p_source_cube, RID p_dest_panorama, const Size2i &p_panorama_size, float p_lod, bool p_is_array);

void copy_depth_to_rect(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2i &p_rect, bool p_flip_y = false);

void copy_depth_to_rect_and_linearize(RID p_source_rd_texture, RID p_dest_texture, const Rect2i &p_rect, bool p_flip_y, float p_z_near, float p_z_far);

void copy_to_atlas_fb(RID p_source_rd_texture, RID p_dest_framebuffer, const Rect2 &p_uv_rect, RD::DrawListID p_draw_list, bool p_flip_y = false, bool p_panorama = false);

void copy_raster(RID p_source_texture, RID p_dest_framebuffer);

void make_mipmap(RID p_source_rd_texture, RID p_dest_texture, const Size2i &p_size);

void make_mipmap_raster(RID p_source_rd_texture, RID p_dest_texture, const Size2i &p_size);

void set_color(RID p_dest_texture, const Color &p_color, const Rect2i &p_region, bool p_8bit_dst = false);

void copy_cubemap_to_dp(RID p_source_rd_texture, RID p_dst_framebuffer, const Rect2 &p_rect, const Vector2 &p_dst_size, float p_z_near, float p_z_far, bool p_dp_flip);

void cubemap_downsample(RID p_source_cubemap, RID p_dest_cubemap, const Size2i &p_size);

Resolve();

~Resolve();

};

} // namespace RendererRD

for (int pass = 0; pass < blur_passes; pass++) {

int blur_pipeline = SSAO_BLUR_PASS;

if (ssao_quality > RS::ENV_SSAO_QUALITY_VERY_LOW) {

if (pass < blur_passes - 2) {

blur_pipeline = SSAO_BLUR_PASS_WIDE;

} else {

float sharpness = 0.98;

float normal_rejection = 1.0;

};

void ssil_allocate_buffers(SSILRenderBuffers &p_ssil_buffers, const SSILSettings &p_settings, RID p_linear_depth);

float horizon = 0.06;

float sharpness = 0.98;

};

void ssao_allocate_buffers(SSAORenderBuffers &p_ssao_buffers, const SSAOSettings &p_settings, RID p_linear_depth);

}

Size2i VRS::get_vrs_texture_size(const Size2i p_base_size) const {

width++;

}

height++;

}

return Size2i(width, height);

material_storage->material_free(volumetric_fog.default_material);

}

void Fog::FogShaderData::set_code(const String &p_code) {

//compile

valid = true;

}

bool Fog::FogShaderData::is_animated() const {

return false;

}

return false;

}

RS::ShaderNativeSourceCode Fog::FogShaderData::get_native_source_code() const {

Fog *fog_singleton = Fog::get_singleton();

any_uses_time |= shader_data->uses_time;

Vector3 position = fog_volume_instance->transform.get_origin();

RS::FogVolumeShape volume_type = RendererRD::Fog::get_singleton()->fog_volume_get_shape(fog_volume);

RD::get_singleton()->compute_list_bind_uniform_set(compute_list, volumetric_fog.base_uniform_set, VolumetricFogShader::FogSet::FOG_SET_BASE);

if (material->uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(material->uniform_set)) { // Material may not have a uniform set.

RD::get_singleton()->compute_list_bind_uniform_set(compute_list, material->uniform_set, VolumetricFogShader::FogSet::FOG_SET_MATERIAL);

}

RD::get_singleton()->compute_list_dispatch_threads(compute_list, kernel_size.x, kernel_size.y, kernel_size.z);

RID version;

RID pipeline;

Vector<ShaderCompiler::GeneratedCode::Texture> texture_uniforms;

Vector<uint32_t> ubo_offsets;

uint32_t ubo_size = 0;

String code;

bool uses_time = false;

virtual void set_code(const String &p_Code);

virtual bool is_animated() const;

virtual bool casts_shadows() const;

virtual RS::ShaderNativeSourceCode get_native_source_code() const;

FogShaderData() {}

{

Transform3D to_cell = gi->voxel_gi_get_to_cell_xform(probe);

//update lights

for (uint32_t i = 0; i < light_count; i++) {

{

//calculate tables

String defines = "\n#define SDFGI_OCT_SIZE " + itos(SDFGI::LIGHTPROBE_OCT_SIZE) + "\n";

Vector<String> gi_modes;

gi_modes.push_back("\n#define USE_VOXEL_GI_INSTANCES\n"); // MODE_VOXEL_GI

u.append_id(rbgi->scene_data_ubo);

uniforms.push_back(u);

}

RD::Uniform u;

u.uniform_type = RD::UNIFORM_TYPE_IMAGE;

u.binding = 19;

#include "core/config/project_settings.h"

#include "core/math/math_defs.h"

#include "servers/rendering/renderer_rd/effects/copy_effects.h"

#include "servers/rendering/renderer_rd/renderer_compositor_rd.h"

#include "servers/rendering/renderer_rd/renderer_scene_render_rd.h"

#include "servers/rendering/renderer_rd/storage_rd/material_storage.h"

#include "servers/rendering/renderer_rd/storage_rd/render_scene_buffers_rd.h"

#include "servers/rendering/renderer_rd/storage_rd/texture_storage.h"

#include "servers/rendering/rendering_server_default.h"

#include "servers/rendering/rendering_server_globals.h"

using namespace RendererRD;

////////////////////////////////////////////////////////////////////////////////

// SKY SHADER

void SkyRD::SkyShaderData::set_code(const String &p_code) {

//compile

valid = true;

}

bool SkyRD::SkyShaderData::is_animated() const {

return false;

}

return false;

}

RS::ShaderNativeSourceCode SkyRD::SkyShaderData::get_native_source_code() const {

RendererSceneRenderRD *scene_singleton = static_cast<RendererSceneRenderRD *>(RendererSceneRenderRD::singleton);

p_array[11] = 0;

}

SkyPushConstant sky_push_constant;

memset(&sky_push_constant, 0, sizeof(SkyPushConstant));

sky_push_constant.position[0] = p_position.x;

sky_push_constant.position[1] = p_position.y;

sky_push_constant.position[2] = p_position.z;

uint32_t w = p_size, h = p_size;

EffectsRD *effects = RendererCompositorRD::singleton->get_effects();

bool prefer_raster_effects = effects->get_prefer_raster_effects();

if (p_use_array) {

void SkyRD::ReflectionData::create_reflection_fast_filter(bool p_use_arrays) {

RendererRD::CopyEffects *copy_effects = RendererRD::CopyEffects::get_singleton();

bool prefer_raster_effects = copy_effects->get_prefer_raster_effects();

if (prefer_raster_effects) {

void SkyRD::ReflectionData::create_reflection_importance_sample(bool p_use_arrays, int p_cube_side, int p_base_layer, uint32_t p_sky_ggx_samples_quality) {

RendererRD::CopyEffects *copy_effects = RendererRD::CopyEffects::get_singleton();

bool prefer_raster_effects = copy_effects->get_prefer_raster_effects();

if (prefer_raster_effects) {

void SkyRD::ReflectionData::update_reflection_mipmaps(int p_start, int p_end) {

RendererRD::CopyEffects *copy_effects = RendererRD::CopyEffects::get_singleton();

bool prefer_raster_effects = copy_effects->get_prefer_raster_effects();

RD::get_singleton()->draw_command_begin_label("Update Radiance Cubemap Array Mipmaps");

uniform_buffer = RID();

}

if (material.is_valid()) {

RSG::material_storage->material_free(material);

material = RID();

}

}

RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();

Vector<RD::Uniform> uniforms;

{

RD::Uniform u;

RD::Uniform u;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.binding = 1; // half res

u.append_id(reflection.layers[0].views[1]);

} else {

}

} else {

} else {

}

}

uniforms.push_back(u);

RD::Uniform u;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

u.binding = 2; // quarter res

u.append_id(reflection.layers[0].views[2]);

} else {

}

} else {

} else {

}

}

uniforms.push_back(u);

}

}

bool SkyRD::Sky::set_radiance_size(int p_radiance_size) {

RD::get_singleton()->free(index_buffer); //array gets freed as dependency

}

RendererRD::LightStorage *light_storage = RendererRD::LightStorage::get_singleton();

RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();

ERR_FAIL_COND(p_env.is_null());

SkyMaterialData *material = nullptr;

Sky *sky = get_sky(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env));

ERR_FAIL_COND(!shader_data);

invalidate_sky(sky);

update_dirty_skys();

}

sky->reflection.dirty = true;

}

sky->reflection.dirty = true;

}

}

}

sky_scene_state.ubo.fog_enabled = RendererSceneRenderRD::get_singleton()->environment_get_fog_enabled(p_env);

sky_scene_state.ubo.fog_density = RendererSceneRenderRD::get_singleton()->environment_get_fog_density(p_env);

sky_scene_state.ubo.fog_aerial_perspective = RendererSceneRenderRD::get_singleton()->environment_get_fog_aerial_perspective(p_env);

RD::get_singleton()->buffer_update(sky_scene_state.uniform_buffer, 0, sizeof(SkySceneState::UBO), &sky_scene_state.ubo);

}

RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();

ERR_FAIL_COND(p_env.is_null());

correction.set_depth_correction(true);

cm = correction * cm;

if (shader_data->uses_quarter_res) {

RD::get_singleton()->draw_command_begin_label("Render Sky to Quarter Res Cubemap");

PipelineCacheRD *pipeline = &shader_data->pipelines[SKY_VERSION_CUBEMAP_QUARTER_RES];

for (int i = 0; i < 6; i++) {

Basis local_view = Basis::looking_at(view_normals[i], view_up[i]);

cubemap_draw_list = RD::get_singleton()->draw_list_begin(sky->reflection.layers[0].mipmaps[2].framebuffers[i], RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_DISCARD);

RD::get_singleton()->draw_list_end();

}

RD::get_singleton()->draw_command_end_label();

for (int i = 0; i < 6; i++) {

Basis local_view = Basis::looking_at(view_normals[i], view_up[i]);

cubemap_draw_list = RD::get_singleton()->draw_list_begin(sky->reflection.layers[0].mipmaps[1].framebuffers[i], RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_DISCARD);

RD::get_singleton()->draw_list_end();

}

RD::get_singleton()->draw_command_end_label();

RD::get_singleton()->draw_command_begin_label("Render Sky Cubemap");

for (int i = 0; i < 6; i++) {

Basis local_view = Basis::looking_at(view_normals[i], view_up[i]);

cubemap_draw_list = RD::get_singleton()->draw_list_begin(sky->reflection.layers[0].mipmaps[0].framebuffers[i], RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_DISCARD);

RD::get_singleton()->draw_list_end();

}

RD::get_singleton()->draw_command_end_label();

}

}

RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();

ERR_FAIL_COND(p_env.is_null());

Sky *sky = get_sky(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env));

SkyMaterialData *material = nullptr;

ERR_FAIL_COND(!material);

SkyShaderData *shader_data = material->shader_data;

ERR_FAIL_COND(!shader_data);

}

Basis sky_transform = RendererSceneRenderRD::get_singleton()->environment_get_sky_orientation(p_env);

sky_transform.invert();

float custom_fov = RendererSceneRenderRD::get_singleton()->environment_get_sky_custom_fov(p_env);

// Camera

// With custom fov we don't support stereo...

}

if (shader_data->uses_quarter_res) {

Vector<Color> clear_colors;

clear_colors.push_back(Color(0.0, 0.0, 0.0));

RD::get_singleton()->draw_list_end();

}

if (shader_data->uses_half_res) {

Vector<Color> clear_colors;

clear_colors.push_back(Color(0.0, 0.0, 0.0));

RD::get_singleton()->draw_list_end();

}

}

RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();

ERR_FAIL_COND(p_env.is_null());

Sky *sky = get_sky(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env));

SkyMaterialData *material = nullptr;

ERR_FAIL_COND(!material);

SkyShaderData *shader_data = material->shader_data;

ERR_FAIL_COND(!shader_data);

Basis sky_transform = RendererSceneRenderRD::get_singleton()->environment_get_sky_orientation(p_env);

sky_transform.invert();

float custom_fov = RendererSceneRenderRD::get_singleton()->environment_get_sky_custom_fov(p_env);

// Camera

// With custom fov we don't support stereo...

}

RID texture_uniform_set;

if (sky) {

} else {

texture_uniform_set = sky_scene_state.fog_only_texture_uniform_set;

}

}

void SkyRD::invalidate_sky(Sky *p_sky) {

Sky *sky = dirty_sky_list;

while (sky) {

//update sky configuration if texture is missing

if (sky->radiance.is_null()) {

int mipmaps = Image::get_image_required_mipmaps(sky->radiance_size, sky->radiance_size, Image::FORMAT_RGBAH) + 1;

sky->reflection.update_reflection_data(sky->radiance_size, MIN(mipmaps, layers), false, sky->radiance, 0, sky->mode == RS::SKY_MODE_REALTIME, roughness_layers, texture_format);

}

}

sky->reflection.dirty = true;

struct SkyPushConstant {

float orientation[12]; // 48 - 48

// 128 is the max size of a push constant. We can replace "pad" but we can't add any more.

};

RID version;

PipelineCacheRD pipelines[SKY_VERSION_MAX];

Vector<ShaderCompiler::GeneratedCode::Texture> texture_uniforms;

Vector<uint32_t> ubo_offsets;

uint32_t ubo_size = 0;

String code;

bool uses_time = false;

bool uses_position = false;

bool uses_light = false;

virtual void set_code(const String &p_Code);

virtual bool is_animated() const;

virtual bool casts_shadows() const;

virtual RS::ShaderNativeSourceCode get_native_source_code() const;

SkyShaderData() {}

virtual ~SkyShaderData();

};

public:

struct SkySceneState {

struct UBO {

};

UBO ubo;

SkyDirectionalLightData *directional_lights = nullptr;

SkyDirectionalLightData *last_frame_directional_lights = nullptr;

uint32_t max_directional_lights;

struct Sky {

RID radiance;

RID quarter_res_pass;

RID quarter_res_framebuffer;

Size2i screen_size;

RID uniform_set;

RID material;

void free();

bool set_radiance_size(int p_radiance_size);

bool set_mode(RS::SkyMode p_mode);

bool set_material(RID p_material);

void set_texture_format(RD::DataFormat p_texture_format);

~SkyRD();

void invalidate_sky(Sky *p_sky);

void update_dirty_skys();

#endif

material_uniform_set = surf->material_uniform_set;

shader = surf->shader;

#ifdef DEBUG_ENABLED

}

#endif

for (int i = 0; i < (int)p_render_data->instances->size(); i++) {

GeometryInstanceForwardClustered *inst = static_cast<GeometryInstanceForwardClustered *>((*p_render_data->instances)[i]);

uint32_t depth_layer = CLAMP(int(inst->depth * 16 / z_max), 0, 15);

uint32_t flags = inst->base_flags; //fill flags if appropriate

distance = 1.0;

}

if (p_render_data->render_info) {

indices = _indices_to_primitives(surf->primitive, indices);

if (p_render_list == RENDER_LIST_OPAQUE) { //opaque

}

//full barrier here, we need raster, transfer and compute and it depends from the previous work

if (current_cluster_builder) {

current_cluster_builder->begin(p_render_data->scene_data->cam_transform, p_render_data->scene_data->cam_projection, !p_render_data->reflection_probe.is_valid());

bool using_ssr = false;

bool using_sdfgi = false;

bool using_voxelgi = false;

bool using_ssil = p_render_data->environment.is_valid() && environment_get_ssil_enabled(p_render_data->environment);

screen_size = rb->get_internal_size();

if (rb->get_use_taa() || get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_MOTION_VECTORS) {

color_framebuffer = rb_data->get_color_pass_fb(color_pass_flags);

color_only_framebuffer = rb_data->get_color_only_fb();

} else {

ERR_FAIL(); //bug?

}

draw_sky = true;

} break;

case RS::ENV_BG_CANVAS: {

keep_color = true;

} break;

case RS::ENV_BG_KEEP: {

default: {

}

}

// setup sky if used for ambient, reflections, or background

if (draw_sky || draw_sky_fog_only || environment_get_reflection_source(p_render_data->environment) == RS::ENV_REFLECTION_SOURCE_SKY || environment_get_ambient_source(p_render_data->environment) == RS::ENV_AMBIENT_SOURCE_SKY) {

RENDER_TIMESTAMP("Setup Sky");

RD::get_singleton()->draw_command_begin_label("Setup Sky");

if (p_render_data->reflection_probe.is_valid()) {

Projection correction;

correction.set_depth_correction(true);

sky_energy_multiplier *= bg_energy_multiplier;

RID sky_rid = environment_get_sky(p_render_data->environment);

if (sky_rid.is_valid()) {

radiance_texture = sky.sky_get_radiance_texture_rd(sky_rid);

} else {

// do not try to draw sky if invalid

draw_sky = false;

}

RD::get_singleton()->draw_command_end_label();

}

} else {

RENDER_TIMESTAMP("Render Sky");

RD::get_singleton()->draw_command_begin_label("Draw Sky");

RD::get_singleton()->draw_command_end_label();

}

scene_data.lod_distance_multiplier = p_lod_distance_multiplier;

scene_data.dual_paraboloid_side = p_use_dp_flip ? -1 : 1;

scene_data.opaque_prepass_threshold = 0.1f;

RenderDataRD render_data;

render_data.scene_data = &scene_data;

scene_data.z_far = p_cam_projection.get_z_far();

scene_data.dual_paraboloid_side = 0;

scene_data.opaque_prepass_threshold = 0.0;

RenderDataRD render_data;

render_data.scene_data = &scene_data;

scene_data.material_uv2_mode = false;

scene_data.opaque_prepass_threshold = 0.0f;

scene_data.emissive_exposure_normalization = p_exposure_normalization;

RenderDataRD render_data;

render_data.scene_data = &scene_data;

RD::Uniform u;

u.binding = 19;

u.uniform_type = RD::UNIFORM_TYPE_TEXTURE;

if (rb_data.is_valid() && rb->has_custom_data(RB_SCOPE_FOG)) {

Ref<RendererRD::Fog::VolumetricFog> fog = rb->get_custom_data(RB_SCOPE_FOG);

vfog = fog->fog_map;

RenderForwardClustered *RenderForwardClustered::singleton = nullptr;

void RenderForwardClustered::GeometryInstanceForwardClustered::_mark_dirty() {

if (dirty_list_element.in_list()) {

return;

SceneShaderForwardClustered::MaterialData *material_shadow = nullptr;

void *surface_shadow = nullptr;

flags |= GeometryInstanceSurfaceDataCache::FLAG_USES_SHARED_SHADOW_MATERIAL;

material_shadow = static_cast<SceneShaderForwardClustered::MaterialData *>(RendererRD::MaterialStorage::get_singleton()->material_get_data(scene_shader.default_material, RendererRD::MaterialStorage::SHADER_TYPE_3D));

sdcache->flags = flags;

sdcache->shader = p_material->shader_data;

sdcache->material_uniform_set = p_material->uniform_set;

sdcache->surface = mesh_storage->mesh_get_surface(p_mesh, p_surface);

sdcache->primitive = mesh_storage->mesh_surface_get_primitive(sdcache->surface);

}

ginstance->transforms_uniform_set = particles_storage->particles_get_instance_buffer_uniform_set(ginstance->data->base, scene_shader.default_shader_rd, TRANSFORMS_UNIFORM_SET);

} else if (ginstance->data->base_type == RS::INSTANCE_MESH) {

if (mesh_storage->skeleton_is_valid(ginstance->data->skeleton)) {

ginstance->transforms_uniform_set = mesh_storage->skeleton_get_3d_uniform_set(ginstance->data->skeleton, scene_shader.default_shader_rd, TRANSFORMS_UNIFORM_SET);

float screen_mesh_lod_threshold = 0.0;

RD::FramebufferFormatID framebuffer_format = 0;

uint32_t element_offset = 0;

bool use_directional_soft_shadow = false;

elements = p_elements;

element_info = p_element_info;

element_count = p_element_count;

void *surface = nullptr;

RID material_uniform_set;

SceneShaderForwardClustered::ShaderData *shader = nullptr;

void *surface_shadow = nullptr;

RID material_uniform_set_shadow;

void _render_shadow_begin();

void _render_shadow_append(RID p_framebuffer, const PagedArray<RenderGeometryInstance *> &p_instances, const Projection &p_projection, const Transform3D &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool p_use_dp_flip, bool p_use_pancake, const Plane &p_camera_plane = Plane(), float p_lod_distance_multiplier = 0.0, float p_screen_mesh_lod_threshold = 0.0, const Rect2i &p_rect = Rect2i(), bool p_flip_y = false, bool p_clear_region = true, bool p_begin = true, bool p_end = true, RenderingMethod::RenderInfo *p_render_info = nullptr);

void _render_shadow_process();

/* Render Scene */

void _process_ssao(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_environment, RID p_normal_buffer, const Projection &p_projection);

_update_render_base_uniform_set();

}

virtual RenderGeometryInstance *geometry_instance_create(RID p_base) override;

virtual void geometry_instance_free(RenderGeometryInstance *p_geometry_instance) override;

using namespace RendererSceneRenderImplementation;

void SceneShaderForwardClustered::ShaderData::set_code(const String &p_code) {

//compile

actions.usage_flag_pointers["ALPHA"] = &uses_alpha;

actions.usage_flag_pointers["ALPHA_SCISSOR_THRESHOLD"] = &uses_alpha_clip;

actions.render_mode_flags["depth_prepass_alpha"] = &uses_depth_pre_pass;

actions.usage_flag_pointers["SSS_STRENGTH"] = &uses_sss;

depth_test = DepthTest(depth_testi);

cull_mode = Cull(cull_modei);

uses_screen_texture_mipmaps = gen_code.uses_screen_texture_mipmaps;

#if 0

print_line("**compiling shader:");

depth_stencil_state.depth_compare_operator = RD::COMPARE_OP_LESS_OR_EQUAL;

depth_stencil_state.enable_depth_write = depth_draw != DEPTH_DRAW_DISABLED ? true : false;

}

for (int i = 0; i < CULL_VARIANT_MAX; i++) {

RD::PolygonCullMode cull_mode_rd_table[CULL_VARIANT_MAX][3] = {

continue;

}

RD::PipelineDepthStencilState depth_stencil = depth_stencil_state;

RD::PipelineMultisampleState multisample_state;

int shader_flags = 0;

valid = true;

}

bool SceneShaderForwardClustered::ShaderData::is_animated() const {

}

bool SceneShaderForwardClustered::ShaderData::casts_shadows() const {

}

RS::ShaderNativeSourceCode SceneShaderForwardClustered::ShaderData::get_native_source_code() const {

actions.renames["CUSTOM3"] = "custom3_attrib";

actions.renames["OUTPUT_IS_SRGB"] = "SHADER_IS_SRGB";

actions.renames["CAMERA_POSITION_WORLD"] = "scene_data.inv_view_matrix[3].xyz";

actions.renames["CAMERA_DIRECTION_WORLD"] = "scene_data.view_matrix[3].xyz";

actions.renames["VIEW_INDEX"] = "ViewIndex";

actions.renames["VIEW_MONO_LEFT"] = "0";

PipelineCacheRD pipelines[CULL_VARIANT_MAX][RS::PRIMITIVE_MAX][PIPELINE_VERSION_MAX];

PipelineCacheRD color_pipelines[CULL_VARIANT_MAX][RS::PRIMITIVE_MAX][PIPELINE_COLOR_PASS_FLAG_COUNT];

Vector<ShaderCompiler::GeneratedCode::Texture> texture_uniforms;

Vector<uint32_t> ubo_offsets;

uint32_t ubo_size = 0;

String code;

bool uses_point_size = false;

bool uses_alpha = false;

bool uses_depth_texture = false;

bool uses_normal_texture = false;

bool uses_time = false;

bool writes_modelview_or_projection = false;

bool uses_world_coordinates = false;

bool uses_screen_texture_mipmaps = false;

uint32_t index = 0;

virtual void set_code(const String &p_Code);

virtual bool is_animated() const;

virtual bool casts_shadows() const;

virtual RS::ShaderNativeSourceCode get_native_source_code() const;

SelfList<ShaderData> shader_list_element;

void RenderForwardMobile::ForwardIDStorageMobile::fill_push_constant_instance_indices(GeometryInstanceForwardMobile::PushConstant *p_push_constant, uint32_t &spec_constants, const GeometryInstanceForwardMobile *p_instance) {

// first zero out our indices

if (p_instance->omni_light_count == 0) {

spec_constants |= 1 << SPEC_CONSTANT_DISABLE_OMNI_LIGHTS;

render_buffers->create_texture(RB_SCOPE_MOBILE, RB_TEX_COLOR_MSAA, format, usage_bits, texture_samples);

usage_bits = RD::TEXTURE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | RD::TEXTURE_USAGE_CAN_COPY_FROM_BIT | RD::TEXTURE_USAGE_SAMPLING_BIT;

render_buffers->create_texture(RB_SCOPE_MOBILE, RB_TEX_DEPTH_MSAA, format, usage_bits, texture_samples);

}

Ref<RenderSceneBuffersRD> rb;

if (p_render_data && p_render_data->render_buffers.is_valid()) {

rb = p_render_data->render_buffers;

}

// default render buffer and scene state uniform set

}

//full barrier here, we need raster, transfer and compute and it depends from the previous work

bool using_shadows = true;

Ref<RenderBufferDataForwardMobile> rb_data;

if (p_render_data->render_buffers.is_valid()) {

rb = p_render_data->render_buffers;

}

RENDER_TIMESTAMP("Prepare 3D Scene");

Size2i screen_size;

RID framebuffer;

bool using_subpass_transparent = true;

bool using_subpass_post_process = true;

p_render_data->render_info->info[RS::VIEWPORT_RENDER_INFO_TYPE_VISIBLE][RS::VIEWPORT_RENDER_INFO_OBJECTS_IN_FRAME] = p_render_data->instances->size();

}

// setup rendering to render buffer

screen_size = p_render_data->render_buffers->get_internal_size();

// only opaque and sky as subpasses

framebuffer = rb_data->get_color_fbs(RenderBufferDataForwardMobile::FB_CONFIG_TWO_SUBPASSES);

}

} else {

ERR_FAIL(); //bug?

}

draw_sky = true;

} break;

case RS::ENV_BG_CANVAS: {

keep_color = true;

} break;

case RS::ENV_BG_KEEP: {

default: {

}

}

// setup sky if used for ambient, reflections, or background

if (draw_sky || draw_sky_fog_only || environment_get_reflection_source(p_render_data->environment) == RS::ENV_REFLECTION_SOURCE_SKY || environment_get_ambient_source(p_render_data->environment) == RS::ENV_AMBIENT_SOURCE_SKY) {

RENDER_TIMESTAMP("Setup Sky");

RD::get_singleton()->draw_command_begin_label("Setup Sky");

if (p_render_data->reflection_probe.is_valid()) {

Projection correction;

correction.set_depth_correction(true);

sky_energy_multiplier *= bg_energy_multiplier;

RID sky_rid = environment_get_sky(p_render_data->environment);

if (sky_rid.is_valid()) {

radiance_texture = sky.sky_get_radiance_texture_rd(sky_rid);

} else {

// do not try to draw sky if invalid

draw_sky = false;

}

RD::get_singleton()->draw_command_end_label(); // Setup Sky

}

} else {

clear_color = p_default_bg_color;

}

_pre_opaque_render(p_render_data);

uint32_t spec_constant_base_flags = 0;

if (draw_sky || draw_sky_fog_only) {

RD::get_singleton()->draw_command_begin_label("Draw Sky Subpass");

RD::DrawListID draw_list = RD::get_singleton()->draw_list_switch_to_next_pass();

RD::get_singleton()->draw_command_end_label(); // Draw Sky Subpass

if (!using_subpass_transparent) {

// We're done with our subpasses so end our container pass

RD::get_singleton()->draw_command_end_label(); // Render 3D Pass / Render Reflection Probe Pass

}

RD::get_singleton()->draw_command_end_label(); // Render 3D Pass / Render Reflection Probe Pass

} else {

RENDER_TIMESTAMP("Render Transparent");

// this may be needed if we re-introduced steps that change info, not sure which do so in the previous implementation

// _setup_environment(p_render_data, p_render_data->reflection_probe.is_valid(), screen_size, !p_render_data->reflection_probe.is_valid(), p_default_bg_color, false);

WorkerThreadPool::GroupID group_task = WorkerThreadPool::get_singleton()->add_template_group_task(this, &RenderForwardMobile::_render_list_thread_function, &render_list_params, thread_draw_lists.size(), -1, true, SNAME("ForwardMobileRenderSubpass"));

WorkerThreadPool::get_singleton()->wait_for_group_task_completion(group_task);

} else {

//single threaded

RD::DrawListID draw_list = RD::get_singleton()->draw_list_begin(framebuffer, can_continue_color ? RD::INITIAL_ACTION_CONTINUE : RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ, can_continue_depth ? RD::INITIAL_ACTION_CONTINUE : RD::INITIAL_ACTION_KEEP, RD::FINAL_ACTION_READ);

_render_list(draw_list, fb_format, &render_list_params, 0, render_list_params.element_count);

}

RD::get_singleton()->draw_command_end_label(); // Render Transparent Subpass

scene_data.lod_distance_multiplier = p_lod_distance_multiplier;

scene_data.dual_paraboloid_side = p_use_dp_flip ? -1 : 1;

scene_data.opaque_prepass_threshold = 0.1;

RenderDataRD render_data;

render_data.scene_data = &scene_data;

scene_data.material_uv2_mode = false;

scene_data.opaque_prepass_threshold = 0.0f;

scene_data.emissive_exposure_normalization = p_exposure_normalization;

RenderDataRD render_data;

render_data.scene_data = &scene_data;

scene_data.z_far = p_cam_projection.get_z_far();

scene_data.dual_paraboloid_side = 0;

scene_data.opaque_prepass_threshold = 0.0;

RenderDataRD render_data;

render_data.scene_data = &scene_data;

for (int i = 0; i < (int)p_render_data->instances->size(); i++) {

GeometryInstanceForwardMobile *inst = static_cast<GeometryInstanceForwardMobile *>((*p_render_data->instances)[i]);

uint32_t depth_layer = CLAMP(int(inst->depth * 16 / z_max), 0, 15);

uint32_t flags = inst->base_flags; //fill flags if appropriate

distance = 1.0;

}

if (p_render_data->render_info) {

indices = _indices_to_primitives(surf->primitive, indices);

if (p_render_list == RENDER_LIST_OPAQUE) { //opaque

RID prev_index_array_rd;

RID prev_pipeline_rd;

RID prev_xforms_uniform_set;

bool shadow_pass = (p_params->pass_mode == PASS_MODE_SHADOW) || (p_params->pass_mode == PASS_MODE_SHADOW_DP);

#endif

material_uniform_set = surf->material_uniform_set;

shader = surf->shader;

#ifdef DEBUG_ENABLED

}

#endif

continue;

}

//find cull variant

SceneShaderForwardMobile::ShaderData::CullVariant cull_variant;

RD::get_singleton()->draw_list_draw(draw_list, index_array_rd.is_valid(), instance_count);

}

}

/* Geometry instance */

sdcache->flags = flags;

sdcache->shader = p_material->shader_data;

sdcache->material_uniform_set = p_material->uniform_set;

sdcache->surface = mesh_storage->mesh_get_surface(p_mesh, p_surface);

sdcache->primitive = mesh_storage->mesh_surface_get_primitive(sdcache->surface);

}

ginstance->transforms_uniform_set = particles_storage->particles_get_instance_buffer_uniform_set(ginstance->data->base, scene_shader.default_shader_rd, TRANSFORMS_UNIFORM_SET);

} else if (ginstance->data->base_type == RS::INSTANCE_MESH) {

if (mesh_storage->skeleton_is_valid(ginstance->data->skeleton)) {

ginstance->transforms_uniform_set = mesh_storage->skeleton_get_3d_uniform_set(ginstance->data->skeleton, scene_shader.default_shader_rd, TRANSFORMS_UNIFORM_SET);

float screen_mesh_lod_threshold = 0.0;

RD::FramebufferFormatID framebuffer_format = 0;

uint32_t element_offset = 0;

uint32_t subpass = 0;

elements = p_elements;

element_info = p_element_info;

element_count = p_element_count;

void _render_shadow_begin();

void _render_shadow_append(RID p_framebuffer, const PagedArray<RenderGeometryInstance *> &p_instances, const Projection &p_projection, const Transform3D &p_transform, float p_zfar, float p_bias, float p_normal_bias, bool p_use_dp, bool p_use_dp_flip, bool p_use_pancake, const Plane &p_camera_plane = Plane(), float p_lod_distance_multiplier = 0.0, float p_screen_mesh_lod_threshold = 0.0, const Rect2i &p_rect = Rect2i(), bool p_flip_y = false, bool p_clear_region = true, bool p_begin = true, bool p_end = true, RenderingMethod::RenderInfo *p_render_info = nullptr);

void _render_shadow_process();

/* Render Scene */

void *surface = nullptr;

RID material_uniform_set;

SceneShaderForwardMobile::ShaderData *shader = nullptr;

void *surface_shadow = nullptr;

RID material_uniform_set_shadow;

virtual RID reflection_probe_create_framebuffer(RID p_color, RID p_depth) override;

static void _geometry_instance_dependency_changed(Dependency::DependencyChangedNotification p_notification, DependencyTracker *p_tracker);

static void _geometry_instance_dependency_deleted(const RID &p_dependency, DependencyTracker *p_tracker);

/* ShaderData */

void SceneShaderForwardMobile::ShaderData::set_code(const String &p_code) {

//compile

actions.usage_flag_pointers["ALPHA"] = &uses_alpha;

actions.usage_flag_pointers["ALPHA_SCISSOR_THRESHOLD"] = &uses_alpha_clip;

actions.render_mode_flags["depth_prepass_alpha"] = &uses_depth_pre_pass;

// actions.usage_flag_pointers["SSS_STRENGTH"] = &uses_sss;

depth_draw = DepthDraw(depth_drawi);

depth_test = DepthTest(depth_testi);

#if 0

print_line("**compiling shader:");

valid = true;

}

bool SceneShaderForwardMobile::ShaderData::is_animated() const {

}

bool SceneShaderForwardMobile::ShaderData::casts_shadows() const {

}

RS::ShaderNativeSourceCode SceneShaderForwardMobile::ShaderData::get_native_source_code() const {

actions.renames["CUSTOM3"] = "custom3_attrib";

actions.renames["OUTPUT_IS_SRGB"] = "SHADER_IS_SRGB";

actions.renames["CAMERA_POSITION_WORLD"] = "scene_data.inv_view_matrix[3].xyz";

actions.renames["CAMERA_DIRECTION_WORLD"] = "scene_data.view_matrix[3].xyz";

actions.renames["VIEW_INDEX"] = "ViewIndex";

actions.renames["VIEW_MONO_LEFT"] = "0";

uint32_t vertex_input_mask = 0;

PipelineCacheRD pipelines[CULL_VARIANT_MAX][RS::PRIMITIVE_MAX][SHADER_VERSION_MAX];

Vector<ShaderCompiler::GeneratedCode::Texture> texture_uniforms;

Vector<uint32_t> ubo_offsets;

uint32_t ubo_size = 0;

String code;

DepthDraw depth_draw;

DepthTest depth_test;

bool uses_depth_texture = false;

bool uses_normal_texture = false;

bool uses_time = false;

bool writes_modelview_or_projection = false;

bool uses_world_coordinates = false;

uint32_t index = 0;

virtual void set_code(const String &p_Code);

virtual bool is_animated() const;

virtual bool casts_shadows() const;

virtual RS::ShaderNativeSourceCode get_native_source_code() const;

SelfList<ShaderData> shader_list_element;

RID get_cache_multipass(const Vector<RID> &p_textures, const Vector<RD::FramebufferPass> &p_passes, uint32_t p_views = 1) {

uint32_t h = hash_murmur3_one_32(p_views);

for (int i = 0; i < p_textures.size(); i++) {

h = hash_murmur3_one_64(p_textures[i].get_id(), h);

}

for (int i = 0; i < p_passes.size(); i++) {

h = _hash_pass(p_passes[i], h);

}

r_last_texture = p_texture;

}

//create an empty push constant

RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();

RendererRD::MeshStorage *mesh_storage = RendererRD::MeshStorage::get_singleton();

//bind textures

RD::get_singleton()->draw_list_bind_index_array(p_draw_list, primitive_arrays.index_array[MIN(3u, primitive->point_count) - 1]);

ERR_BREAK(particles_storage->particles_get_mode(pt->particles) != RS::PARTICLES_MODE_2D);

particles_storage->particles_request_process(pt->particles);

break;

}

RenderingServerDefault::redraw_request(); // active particles means redraw request

int dpc = particles_storage->particles_get_draw_passes(pt->particles);

if (dpc == 0) {

break; //nothing to draw

if (particles_storage->particles_has_collision(pt->particles) && texture_storage->render_target_is_sdf_enabled(p_render_target)) {

//pass collision information

RID sdf_texture = texture_storage->render_target_get_sdf_texture(p_render_target);

} else {

particles_storage->particles_set_canvas_sdf_collision(pt->particles, false, Transform2D(), Rect2(), RID());

}

}

if (mesh.is_null()) {

return uniform_set;

}

RendererRD::MaterialStorage *material_storage = RendererRD::MaterialStorage::get_singleton();

RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();

RID material = ci->material_owner == nullptr ? ci->material : ci->material_owner->material;

}

if (material != prev_material) {

// Update uniform set.

if (material_data->uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(material_data->uniform_set)) { // Material may not have a uniform set.

RD::get_singleton()->draw_list_bind_uniform_set(draw_list, material_data->uniform_set, MATERIAL_UNIFORM_SET);

}

} else {

pipeline_variants = &shader.pipeline_variants;

}

}

prev_material = material;

}

update_skeletons = false;

}

item_count = 0;

texture_storage->render_target_copy_to_back_buffer(p_to_render_target, group_rect, false);

} else if (!backbuffer_cleared) {

texture_storage->render_target_clear_back_buffer(p_to_render_target, Rect2i(), Color(0, 0, 0, 0));

backbuffer_cleared = true;

update_skeletons = false;

}

item_count = 0;

if (ci->canvas_group->blur_mipmaps) {

update_skeletons = false;

}

item_count = 0;

texture_storage->render_target_copy_to_back_buffer(p_to_render_target, back_buffer_rect, backbuffer_gen_mipmaps);

update_skeletons = false;

}

//then reset

item_count = 0;

}

projection.set_frustum(xmin, xmax, ymin, ymax, nearp, farp);

}

projection = projection * Projection(Transform3D().looking_at(cam_target, Vector3(0, 0, -1)).affine_inverse());

ShadowRenderPushConstant push_constant;

}

}

if (oc->vertex_array.is_null()) {

//create from scratch

//vertices

oc->vertex_buffer = RD::get_singleton()->vertex_buffer_create(lc * 6 * sizeof(real_t), geometry);

Vector<RID> buffer;

oc->cull_mode = p_mode;

}

void RendererCanvasRenderRD::CanvasShaderData::set_code(const String &p_code) {

//compile

valid = true;

}

bool RendererCanvasRenderRD::CanvasShaderData::is_animated() const {

return false;

}

return false;

}

RS::ShaderNativeSourceCode RendererCanvasRenderRD::CanvasShaderData::get_native_source_code() const {

RendererCanvasRenderRD *canvas_singleton = static_cast<RendererCanvasRenderRD *>(RendererCanvasRender::singleton);

return canvas_singleton->shader.canvas_shader.version_get_native_source_code(version);

primitive_arrays.index_array[3] = shader.quad_index_array = RD::get_singleton()->index_array_create(shader.quad_index_buffer, 0, 6);

}

{

//default shadow texture to keep uniform set happy

RD::TextureFormat tf;

material_storage->material_set_shader(default_canvas_group_material, default_canvas_group_shader);

}

static_assert(sizeof(PushConstant) == 128);

}

material_storage->material_free(default_canvas_group_material);

material_storage->shader_free(default_canvas_group_shader);

{

if (state.canvas_state_buffer.is_valid()) {

RD::get_singleton()->free(state.canvas_state_buffer);

memdelete_arr(state.light_uniforms);

RD::get_singleton()->free(state.lights_uniform_buffer);

}

//shadow rendering

RID quad_index_array;

PipelineVariants pipeline_variants;

ShaderCompiler compiler;

} shader;

bool valid = false;

RID version;

PipelineVariants pipeline_variants;

Vector<ShaderCompiler::GeneratedCode::Texture> texture_uniforms;

Vector<uint32_t> ubo_offsets;

uint32_t ubo_size = 0;

String code;

bool uses_screen_texture = false;

bool uses_screen_texture_mipmaps = false;

bool uses_time = false;

virtual void set_code(const String &p_Code);

virtual bool is_animated() const;

virtual bool casts_shadows() const;

virtual RS::ShaderNativeSourceCode get_native_source_code() const;

CanvasShaderData() {}

uint32_t lights[4];

};

Item *items[MAX_RENDER_ITEMS];

bool using_directional_lights = false;

RID default_canvas_group_shader;

RID default_canvas_group_material;

RS::CanvasItemTextureFilter default_filter = RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR;

RS::CanvasItemTextureRepeat default_repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED;

RID _create_base_uniform_set(RID p_to_render_target, bool p_backbuffer);

inline void _bind_canvas_texture(RD::DrawListID p_draw_list, RID p_texture, RS::CanvasItemTextureFilter p_base_filter, RS::CanvasItemTextureRepeat p_base_repeat, RID &r_last_texture, PushConstant &push_constant, Size2 &r_texpixel_size); //recursive, so regular inline used instead.

_FORCE_INLINE_ void _update_transform_2d_to_mat2x4(const Transform2D &p_transform, float *p_mat2x4);

_FORCE_INLINE_ void _update_transform_2d_to_mat2x3(const Transform2D &p_transform, float *p_mat2x3);

void canvas_render_items(RID p_to_render_target, Item *p_item_list, const Color &p_modulate, Light *p_light_list, Light *p_directional_light_list, const Transform2D &p_canvas_transform, RS::CanvasItemTextureFilter p_default_filter, RS::CanvasItemTextureRepeat p_default_repeat, bool p_snap_2d_vertices_to_pixel, bool &r_sdf_used);

virtual void set_shadow_texture_size(int p_size);

void set_time(double p_time);

texture_storage->texture_2d_initialize(texture, p_image);

RID rd_texture = texture_storage->texture_get_rd_texture(texture);

RID uset;

{

Vector<RD::Uniform> uniforms;

RD::Uniform u;

u.uniform_type = RD::UNIFORM_TYPE_SAMPLER_WITH_TEXTURE;

u.binding = 0;

u.append_id(rd_texture);

uniforms.push_back(u);

uset = RD::get_singleton()->uniform_set_create(uniforms, blit.shader.version_get_shader(blit.shader_version, BLIT_MODE_NORMAL), 0);

RD::get_singleton()->swap_buffers();

texture_storage->texture_free(texture);

}

RendererCompositorRD *RendererCompositorRD::singleton = nullptr;

}

}

RID RendererSceneRenderRD::sky_allocate() {

return sky.allocate_sky_rid();

}

glow_bicubic_upscale = p_enable;

}

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

volumetric_fog_size = p_size;

volumetric_fog_depth = p_depth;

RID source = rb->get_internal_texture(l);

RID dest = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_BLUR_1, l, i);

if (can_use_storage) {

} else {

RID half = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_HALF_BLUR, 0, i); // we can reuse this for each view

}

} else {

RID source = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_BLUR_1, l, i - 1);

RID dest = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_BLUR_1, l, i);

if (can_use_storage) {

} else {

RID half = rb->get_texture_slice(RB_SCOPE_BUFFERS, RB_TEX_HALF_BLUR, 0, i); // we can reuse this for each view

}

}

}

}

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

RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton();

if (vrs_mode != RS::VIEWPORT_VRS_DISABLED) {

RID vrs_texture = p_render_buffers->get_texture(RB_SCOPE_VRS, RB_TEXTURE);

scene_data.cam_transform = p_camera_data->main_transform;

scene_data.cam_projection = p_camera_data->main_projection;

scene_data.cam_orthogonal = p_camera_data->is_orthogonal;

scene_data.taa_jitter = p_camera_data->taa_jitter;

scene_data.view_count = p_camera_data->view_count;

}

Color clear_color;

clear_color = texture_storage->render_target_get_clear_request_color(rb->get_render_target());

} else {

clear_color = RSG::texture_storage->get_default_clear_color();

screen_space_roughness_limiter_amount = GLOBAL_GET("rendering/anti_aliasing/screen_space_roughness_limiter/amount");

screen_space_roughness_limiter_limit = GLOBAL_GET("rendering/anti_aliasing/screen_space_roughness_limiter/limit");

glow_bicubic_upscale = int(GLOBAL_GET("rendering/environment/glow/upscale_mode")) > 0;

directional_penumbra_shadow_kernel = memnew_arr(float, 128);

directional_soft_shadow_kernel = memnew_arr(float, 128);

cull_argument.set_page_pool(&cull_argument_pool);

bool can_use_storage = _render_buffers_can_be_storage();

bokeh_dof = memnew(RendererRD::BokehDOF(!can_use_storage));

copy_effects = memnew(RendererRD::CopyEffects(!can_use_storage));

tone_mapper = memnew(RendererRD::ToneMapper);

if (can_use_storage) {

fsr = memnew(RendererRD::FSR);

}

/* ENVIRONMENT */

bool glow_bicubic_upscale = false;

bool use_physical_light_units = false;

RendererRD::SkyRD *get_sky() { return &sky; }

/* SKY API */

virtual RID sky_allocate() 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;

uv += 1e-5;

}

vertex = (canvas_data.canvas_transform * vec4(vertex, 0.0, 1.0)).xy;

vertex_interp = vertex;

if (i >= light_count) {

break;

}

light_base >>= (i & 3) * 8;

light_base &= 0xFF;

#version 450

#VERSION_DEFINES

#if defined(has_GL_KHR_shader_subgroup_ballot) && defined(has_GL_KHR_shader_subgroup_arithmetic) && defined(has_GL_KHR_shader_subgroup_vote)

#extension GL_KHR_shader_subgroup_ballot : enable

#define USE_SUBGROUPS

#endif

layout(location = 0) in float depth_interp;

layout(location = 1) in flat uint element_index;

}

}

#else

atomicOr(cluster_render.data[usage_write_offset], usage_write_bit);

}

#endif

}

}

#else

atomicOr(cluster_render.data[z_write_offset], z_write_bit);

}

#endif

#ifdef MODE_GAUSSIAN_BLUR

#endif

#ifdef MODE_GAUSSIAN_GLOW

#define FLAG_FLIP_Y (1 << 5)

#define FLAG_FORCE_LUMINANCE (1 << 6)

#define FLAG_COPY_ALL_SOURCE (1 << 7)

layout(push_constant, std430) uniform Params {

ivec4 section;

#ifdef MODE_GAUSSIAN_BLUR

// First pass copy texture into 16x16 local memory for every 8x8 thread block

uint dest_index = gl_LocalInvocationID.x * 2 + gl_LocalInvocationID.y * 2 * 16;

#ifdef MODE_GLOW

if (bool(params.flags & FLAG_GLOW_FIRST_PASS)) {

// Tonemap initial samples to reduce weight of fireflies: https://graphicrants.blogspot.com/2013/12/tone-mapping.html

color = min(color * feedback, vec4(params.glow_luminance_cap));

}

imageStore(dest_buffer, pos + params.target, color);

#ifdef MODE_SIMPLE_COPY

imageStore(dest_buffer, pos + params.target, color);

#ifdef MODE_SIMPLE_COPY_DEPTH

imageStore(dest_buffer, pos + params.target, vec4(color.r));

#ifdef MODE_LINEARIZE_DEPTH_COPY

}

imageStore(dest_buffer, pos + params.target, color);

#if defined(MODE_CUBEMAP_TO_PANORAMA) || defined(MODE_CUBEMAP_ARRAY_TO_PANORAMA)

vec4 color = textureLod(source_color, vec4(normal, params.camera_z_far), 0.0); //the biggest the lod the least the acne

#endif

imageStore(dest_buffer, pos + params.target, color);

#ifdef MODE_SET_COLOR

imageStore(dest_buffer, pos + params.target, params.set_color);

#endif // has_VK_KHR_multiview

#endif //MULTIVIEW

#ifdef MULTIVIEW

layout(location = 0) out vec3 uv_interp;

#else

layout(push_constant, std430) uniform Params {

vec4 section;

vec2 pixel_size;

}

params;

uv_interp.z = ViewIndex;

#endif

vec2 vpos = uv_interp.xy;

vpos = params.section.xy + vpos * params.section.zw;

}

gl_Position = vec4(vpos * 2.0 - 1.0, 0.0, 1.0);

uv_interp.y = 1.0 - uv_interp.y;

}

}

#endif // has_VK_KHR_multiview

#endif //MULTIVIEW

layout(push_constant, std430) uniform Params {

vec4 section;

vec2 pixel_size;

}

params;

#ifdef MULTIVIEW

layout(location = 0) in vec3 uv_interp;

#else

layout(set = 1, binding = 0) uniform sampler2D source_color2;

#endif /* MODE_TWO_SOURCES */

#endif /* MULTIVIEW */

layout(location = 0) out vec4 frag_color;

return mix((vec3(1.0f) + a) * pow(color.rgb, vec3(1.0f / 2.4f)) - a, 12.92f * color.rgb, lessThan(color.rgb, vec3(0.0031308f)));

}

void main() {

#ifdef MULTIVIEW

vec3 uv = uv_interp;

#else

#endif /* MODE_TWO_SOURCES */

#endif /* MULTIVIEW */

color.rgb = vec3(max(max(color.r, color.g), color.b));

}

color.rgb *= color.a;

}

color.rgb = linear_to_srgb(color.rgb);

}

}

return roughness4 / denom;

}

float radicalInverse_VdC(uint bits) {

bits = (bits << 16u) | (bits >> 16u);

bits = ((bits & 0x55555555u) << 1u) | ((bits & 0xAAAAAAAAu) >> 1u);

vec4 normal_roughness = imageLoad(source_normal_roughness, ssC);

vec3 normal = normal_roughness.xyz * 2.0 - 1.0;

normal = normalize(normal);

normal.y = -normal.y; //because this code reads flipped

imageStore(ssr_image, ssC, vec4(0.0));

return;

}

////////////////

float grad = (steps_taken + 1.0) / float(params.num_steps);

float initial_fade = params.curve_fade_in == 0.0 ? 1.0 : pow(clamp(grad, 0.0, 1.0), params.curve_fade_in);

float fade = pow(clamp(1.0 - grad, 0.0, 1.0), params.distance_fade) * initial_fade;

final_pos = pos;

vec4 final_color;

// if roughness is enabled, do screen space cone tracing

float blur_radius = 0.0;

if (roughness > 0.001) {

float cone_angle = min(roughness, 0.999) * M_PI * 0.5;

#endif // MODE_ROUGH

// Schlick term.

float metallic = texelFetch(source_metallic, ssC << 1, 0).w;

// Based on Spartan Engine's TAA implementation (without TAA upscale).

// <https://github.com/PanosK92/SpartanEngine/blob/a8338d0609b85dc32f3732a5c27fb4463816a3b9/Data/shaders/temporal_antialiasing.hlsl>

#define USE_SUBGROUPS

#define GROUP_SIZE 8

#define FLT_MIN 0.00000001

#ifdef MULTIVIEW

vec4 color = textureLod(source_color, uv, 0.0);

#else /* MULTIVIEW */

vec4 color = textureLod(source_color, uv, 0.0);

}

}

scene_data;

layout(r8ui, set = 0, binding = 19) uniform restrict readonly uimage2D vrs_buffer;

layout(push_constant, std430) uniform Params {

uint max_voxel_gi_instances;

ivec2 pos = ivec2(gl_GlobalInvocationID.xy);

uint vrs_x, vrs_y;

if (sc_use_vrs) {

ivec2 vrs_pos;

return;

}

}

if (sc_half_res) {

pos <<= 1;

imageStore(ambient_buffer, pos, ambient_light);

imageStore(reflection_buffer, pos, reflection_light);

if (sc_use_vrs) {

if (vrs_x > 1) {

imageStore(ambient_buffer, pos + ivec2(1, 0), ambient_light);

imageStore(reflection_buffer, pos + ivec2(3, 3), reflection_light);

}

}

}

layout(push_constant, std430) uniform Params {

mat3 orientation;

vec3 position;

float time;

vec3 pad;

layout(push_constant, std430) uniform Params {

mat3 orientation;

vec3 position;

float time;

vec3 pad;

}

global_shader_uniforms;

bool volumetric_fog_enabled; // 4 - 4

float volumetric_fog_inv_length; // 4 - 8

float volumetric_fog_detail_spread; // 4 - 12

uint pad1; // 4 - 60

uint pad2; // 4 - 64

}

struct DirectionalLightData {

vec4 direction_energy;

#ifdef USE_CUBEMAP_PASS

layout(set = 2, binding = 1) uniform textureCube half_res;

layout(set = 2, binding = 2) uniform textureCube quarter_res;

#else

layout(set = 2, binding = 1) uniform texture2D half_res;

layout(set = 2, binding = 2) uniform texture2D quarter_res;

}

vec4 fog_process(vec3 view, vec3 sky_color) {

vec4 sun_scatter = vec4(0.0);

float sun_total = 0.0;

vec3 light_color = directional_lights.data[i].color_size.xyz * directional_lights.data[i].direction_energy.w;

float light_amount = pow(max(dot(view, directional_lights.data[i].direction_energy.xyz), 0.0), 8.0);

}

}

void main() {

vec3 cube_normal;

cube_normal.z = -1.0;

cube_normal = mat3(params.orientation) * cube_normal;

cube_normal = normalize(cube_normal);

vec4 custom_fog = vec4(0.0);

#ifdef USE_CUBEMAP_PASS

#ifdef USES_HALF_RES_COLOR

half_res_color = texture(samplerCube(half_res, material_samplers[SAMPLER_LINEAR_WITH_MIPMAPS_CLAMP]), cube_normal) / params.luminance_multiplier;

#endif

#ifdef USES_QUARTER_RES_COLOR

quarter_res_color = texture(samplerCube(quarter_res, material_samplers[SAMPLER_LINEAR_WITH_MIPMAPS_CLAMP]), cube_normal) / params.luminance_multiplier;

#endif

#else

#ifdef USES_HALF_RES_COLOR

half_res_color = textureLod(sampler2D(half_res, material_samplers[SAMPLER_LINEAR_CLAMP]), uv, 0.0) / params.luminance_multiplier;

#ifdef USES_QUARTER_RES_COLOR

quarter_res_color = textureLod(sampler2D(quarter_res, material_samplers[SAMPLER_LINEAR_CLAMP]), uv, 0.0) / params.luminance_multiplier;

{

#if !defined(DISABLE_FOG) && !defined(USE_CUBEMAP_PASS)

// Draw "fixed" fog before volumetric fog to ensure volumetric fog can appear in front of the sky.

vec4 fog = fog_process(cube_normal, frag_color.rgb);

}

vec4 fog = volumetric_fog_process(uv);

}

if (custom_fog.a > 0.0) {

vec3 v = vec3(e.xy, 1.0 - abs(e.x) - abs(e.y));

float t = max(-v.z, 0.0);

v.xy += t * -sign(v.xy);

}

/* Varyings */

#ifdef MATERIAL_UNIFORMS_USED

layout(set = MATERIAL_UNIFORM_SET, binding = 0, std140) uniform MaterialUniforms{

#MATERIAL_UNIFORMS

} material;

#endif

void cluster_get_item_range(uint p_offset, out uint item_min, out uint item_max, out uint item_from, out uint item_to) {

uint item_min_max = cluster_buffer.data[p_offset];

item_max = item_min_max >> 16;

item_from = item_min >> 5;

// alpha hash can be used in unison with alpha antialiasing

#ifdef ALPHA_HASH_USED

discard;

}

#endif // ALPHA_HASH_USED

while (merged_mask != 0) {

uint bit = findMSB(merged_mask);

#ifdef USE_SUBGROUPS

continue;

}

#endif

#ifdef USE_RADIANCE_CUBEMAP_ARRAY

float lod, blend;

specular_light = texture(samplerCubeArray(radiance_cubemap, material_samplers[SAMPLER_LINEAR_WITH_MIPMAPS_CLAMP]), vec4(ref_vec, lod)).rgb;

specular_light = mix(specular_light, texture(samplerCubeArray(radiance_cubemap, material_samplers[SAMPLER_LINEAR_WITH_MIPMAPS_CLAMP]), vec4(ref_vec, lod + 1)).rgb, blend);

#else

#endif //USE_RADIANCE_CUBEMAP_ARRAY

specular_light *= scene_data.IBL_exposure_normalization;

ref_vec = mix(ref_vec, n, clearcoat_roughness * clearcoat_roughness);

float horizon = min(1.0 + dot(ref_vec, normal), 1.0);

ref_vec = scene_data.radiance_inverse_xform * ref_vec;

#ifdef USE_RADIANCE_CUBEMAP_ARRAY

float lod, blend;

while (merged_mask != 0) {

uint bit = findMSB(merged_mask);

#ifdef USE_SUBGROUPS

continue;

}

#endif

}

//finalize ambient light here

// convert ao to direct light ao

ao = mix(1.0, ao, ao_light_affect);

//this saves some VGPRs

vec3 f0 = F0(metallic, specular, albedo);

float a004 = min(r.x * r.x, exp2(-9.28 * ndotv)) * r.x + r.y;

vec2 env = vec2(-1.04, 1.04) * a004 + r.zw;

#endif

}

float shadow = 1.0;

#ifndef SHADOWS_DISABLED

if (i < 4) {

} else {

}

shadow = shadow * directional_lights.data[i].shadow_opacity + 1.0 - directional_lights.data[i].shadow_opacity;

while (merged_mask != 0) {

uint bit = findMSB(merged_mask);

#ifdef USE_SUBGROUPS

continue;

}

#endif

while (merged_mask != 0) {

uint bit = findMSB(merged_mask);

#ifdef USE_SUBGROUPS

continue;

}

#endif

float sGreen = floor((cGreen / pow(2.0f, exps - B - N)) + 0.5f);

float sBlue = floor((cBlue / pow(2.0f, exps - B - N)) + 0.5f);

//store as 8985 to have 2 extra neighbour bits

imageStore(emission_grid, grid_pos, uvec4(light_rgbe));

imageStore(emission_aniso_grid, grid_pos, uvec4(light_aniso));

if (bool(instances.data[instance_index].flags & INSTANCE_FLAGS_USE_VOXEL_GI)) { // process voxel_gi_instances

uint index1 = instances.data[instance_index].gi_offset & 0xFFFF;

uint index2 = instances.data[instance_index].gi_offset >> 16;

} else {

voxel_gi_buffer.x = 0xFF;

voxel_gi_buffer.y = 0xFF;

#define MAX_VOXEL_GI_INSTANCES 8

#define MAX_VIEWS 2

#if defined(has_GL_KHR_shader_subgroup_ballot) && defined(has_GL_KHR_shader_subgroup_arithmetic)

#extension GL_KHR_shader_subgroup_ballot : enable

#extension GL_KHR_shader_subgroup_arithmetic : enable

#define USE_SUBGROUPS

#endif

#if defined(USE_MULTIVIEW) && defined(has_VK_KHR_multiview)

#extension GL_EXT_multiview : enable

vec3 v = vec3(e.xy, 1.0 - abs(e.x) - abs(e.y));

float t = max(-v.z, 0.0);

v.xy += t * -sign(v.xy);

}

/* Varyings */

// alpha hash can be used in unison with alpha antialiasing

#ifdef ALPHA_HASH_USED

discard;

}

#endif // ALPHA_HASH_USED

#ifdef USE_RADIANCE_CUBEMAP_ARRAY

float lod, blend;

specular_light = texture(samplerCubeArray(radiance_cubemap, material_samplers[SAMPLER_LINEAR_WITH_MIPMAPS_CLAMP]), vec4(ref_vec, lod)).rgb;

specular_light = mix(specular_light, texture(samplerCubeArray(radiance_cubemap, material_samplers[SAMPLER_LINEAR_WITH_MIPMAPS_CLAMP]), vec4(ref_vec, lod + 1)).rgb, blend);

#else // USE_RADIANCE_CUBEMAP_ARRAY

#endif //USE_RADIANCE_CUBEMAP_ARRAY

specular_light *= sc_luminance_multiplier;

float horizon = min(1.0 + dot(ref_vec, normal), 1.0);

ref_vec = scene_data.radiance_inverse_xform * ref_vec;

#ifdef USE_RADIANCE_CUBEMAP_ARRAY

float lod, blend;

} //Reflection probes

// finalize ambient light here

// convert ao to direct light ao

ao = mix(1.0, ao, ao_light_affect);

float a004 = min(r.x * r.x, exp2(-9.28 * ndotv)) * r.x + r.y;

vec2 env = vec2(-1.04, 1.04) * a004 + r.zw;

#endif

}

if (params.trail_size > 1) {

if (params.trail_pass) {

particle += (particle / (params.trail_size - 1)) + 1;

} else {

particle *= params.trail_size;

}

}

PARTICLE.flags = PARTICLE_FLAG_TRAILED | ((frame_history.data[0].frame & PARTICLE_FRAME_MASK) << PARTICLE_FRAME_SHIFT); //mark it as trailed, save in which frame it will start

PARTICLE.xform = particles.data[src_idx].xform;

}

if (bool(PARTICLE.flags & PARTICLE_FLAG_TRAILED) && ((PARTICLE.flags >> PARTICLE_FRAME_SHIFT) == (FRAME.frame & PARTICLE_FRAME_MASK))) { //check this is trailed and see if it should start now

// we just assume that this is the first frame of the particle, the rest is deterministic

PARTICLE.flags = PARTICLE_FLAG_ACTIVE | (particles.data[src_idx].flags & (PARTICLE_FRAME_MASK << PARTICLE_FRAME_SHIFT));

return; //- this appears like it should be correct, but it seems not to be.. wonder why.

}

} else {

PARTICLE.flags &= ~PARTICLE_FLAG_STARTED;

}

if (any(lessThan(uvw_pos, vec3(0.0))) || any(greaterThan(uvw_pos, vec3(1.0)))) {

continue;

}

dir = mat3(FRAME.attractors[i].transform) * safe_normalize(s); //revert direction

amount = length(s);

float IBL_exposure_normalization;

bool pancake_shadows;

uint pad2;

uint pad3;

};

float compute_alpha_hash_threshold(vec3 pos, float hash_scale) {

vec3 dx = dFdx(pos);

float delta_max_sqr = max(length(dx), length(dy));

float pix_scale = 1.0 / (hash_scale * delta_max_sqr);

1.0 - ((1.0 - a_interp) * (1.0 - a_interp) / (2.0 * min_lerp * (1.0 - min_lerp))));

float alpha_hash_threshold =

}

#endif // ALPHA_HASH_USED

#endif

#if defined(LIGHT_RIM_USED)

diffuse_light += rim_light * rim * mix(vec3(1.0), albedo, rim_tint) * light_color;

#endif

float cLdotH5 = SchlickFresnel(cLdotH);

// Calculate Fresnel using specular occlusion term from Filament:

// https://google.github.io/filament/Filament.html#lighting/occlusion/specularocclusion

vec3 F = f0 + (f90 - f0) * cLdotH5;

vec3 specular_brdf_NL = cNdotL * D * F * G;

vec3 v = vec3(oct.xy, 1.0 - abs(oct.x) - abs(oct.y));

float t = max(-v.z, 0.0);

v.xy += t * -sign(v.xy);

}

vec3 decode_uint_oct_to_norm(uint base) {

uint skin_offset = params.skin_stride * index;

uvec2 bones = uvec2(src_bone_weights.data[skin_offset + 0], src_bone_weights.data[skin_offset + 1]);

skin_offset += params.skin_weight_offset;

//reverse order because its transposed

vertex = (vec4(vertex, 0.0, 1.0) * m).xy;

}

#else

vec3 vertex;

vec3 normal;

if (light_data.shadow_opacity > 0.001) {

RS::LightDirectionalShadowMode smode = light->directional_shadow_mode;

int limit = smode == RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL ? 0 : (smode == RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS ? 1 : 3);

light_data.blend_splits = (smode != RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL) && light->directional_blend_splits;

for (int j = 0; j < 4; j++) {

Projection shadow_mtx = rectm * bias * matrix * modelview;

light_data.shadow_split_offsets[j] = split;

light_data.shadow_bias[j] = light->param[RS::LIGHT_PARAM_SHADOW_BIAS] / 100.0 * bias_scale;

light_data.shadow_normal_bias[j] = light->param[RS::LIGHT_PARAM_SHADOW_NORMAL_BIAS] * light_instance->shadow_transform[j].shadow_texel_size;

light_data.shadow_transmittance_bias[j] = light->param[RS::LIGHT_PARAM_TRANSMITTANCE_BIAS] * bias_scale;

float fade_start = light->param[RS::LIGHT_PARAM_SHADOW_FADE_START];

light_data.fade_from = -light_data.shadow_split_offsets[3] * MIN(fade_start, 0.999); //using 1.0 would break smoothstep

light_data.fade_to = -light_data.shadow_split_offsets[3];

}

r_directional_light_count++;

light_data.soft_shadow_size = 0.0;

light_data.soft_shadow_scale *= RendererSceneRenderRD::get_singleton()->shadows_quality_radius_get(); // Only use quality radius for PCF

}

}

} else {

light_data.shadow_opacity = 0.0;

ra->reflections.clear();

}

}

int LightStorage::reflection_atlas_get_size(RID p_ref_atlas) const {

ERR_FAIL_COND(!atlas);

ERR_FAIL_INDEX(rpi->atlas_index, atlas->reflections.size());

atlas->reflections.write[rpi->atlas_index].owner = RID();

rpi->atlas_index = -1;

rpi->atlas = RID();

}

ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);

ERR_FAIL_COND_V(!rpi, false);

RD::get_singleton()->draw_command_begin_label("Reflection probe render");

if (LightStorage::get_singleton()->reflection_probe_get_update_mode(rpi->probe) == RS::REFLECTION_PROBE_UPDATE_ALWAYS && atlas->reflection.is_valid() && atlas->size != 256) {

Vector<RID> fb;

fb.push_back(atlas->depth_buffer);

atlas->depth_fb = RD::get_singleton()->framebuffer_create(fb);

}

if (rpi->atlas_index == -1) {

return true;

}

bool LightStorage::reflection_probe_instance_postprocess_step(RID p_instance) {

ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance);

ERR_FAIL_COND_V(!rpi, false);

//erase lightmap users

if (lm->light_texture.is_valid()) {

if (t) {

t->lightmap_users.erase(p_lightmap);

}

}

lm->light_texture = p_light;

lm->uses_spherical_harmonics = p_uses_spherical_haromics;

#include "servers/rendering/renderer_rd/cluster_builder_rd.h"

#include "servers/rendering/renderer_rd/environment/sky.h"

#include "servers/rendering/renderer_rd/storage_rd/forward_id_storage.h"

#include "servers/rendering/renderer_rd/storage_rd/texture_storage.h"

#include "servers/rendering/storage/light_storage.h"

#include "servers/rendering/storage/utilities.h"

Vector<Reflection> reflections;

ClusterBuilderRD *cluster_builder = nullptr; // only used if cluster builder is supported by the renderer.

};

virtual bool reflection_probe_instance_needs_redraw(RID p_instance) override;

virtual bool reflection_probe_instance_has_reflection(RID p_instance) override;

virtual bool reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas) override;

virtual bool reflection_probe_instance_postprocess_step(RID p_instance) override;

uint32_t reflection_probe_instance_get_resolution(RID p_instance);

gui[j + 3] = 0; // ignored

}

} else {

gui[0] = v & 1 ? 1 : 0;

gui[1] = v & 2 ? 1 : 0;

}

gui[j + 3] = 0; // ignored

}

} else {

gui[0] = (v & 1) ? 1 : 0;

gui[1] = (v & 2) ? 1 : 0;

gui[2] = (v & 4) ? 1 : 0;

}

}

} else {

gui[0] = (v & 1) ? 1 : 0;

gui[1] = (v & 2) ? 1 : 0;

gui[2] = (v & 4) ? 1 : 0;

switch (type) {

case ShaderLanguage::TYPE_BOOL: {

uint32_t *gui = (uint32_t *)data;

} break;

case ShaderLanguage::TYPE_BVEC2: {

uint32_t *gui = (uint32_t *)data;

}

///////////////////////////////////////////////////////////////////////////

// MaterialStorage::MaterialData

void MaterialStorage::MaterialData::update_uniform_buffer(const HashMap<StringName, ShaderLanguage::ShaderNode::Uniform> &p_uniforms, const uint32_t *p_uniform_offsets, const HashMap<StringName, Variant> &p_parameters, uint8_t *p_buffer, uint32_t p_buffer_size, bool p_use_linear_color) {

roughness_detect_texture = tex;

roughness_channel = RS::TextureDetectRoughnessChannel(p_texture_uniforms[i].hint - ShaderLanguage::ShaderNode::Uniform::HINT_ROUGHNESS_R);

}

#endif

}

if (rd_texture.is_null()) {

if ((uint32_t)texture_cache.size() != tex_uniform_count || p_textures_dirty) {

texture_cache.resize(tex_uniform_count);

p_textures_dirty = true;

//clear previous uniform set

return true;

}

///////////////////////////////////////////////////////////////////////////

// MaterialStorage

for (const PropertyInfo &E : settings) {

if (E.name.begins_with("shader_globals/")) {

StringName name = E.name.get_slice("/", 1);

ERR_CONTINUE(!d.has("type"));

ERR_CONTINUE(!d.has("value"));

global_shader_uniforms.instance_buffer_pos.erase(p_instance);

}

if (!global_shader_uniforms.instance_buffer_pos.has(p_instance)) {

return; //just not allocated, ignore

}

return; //again, not allocated, ignore

}

ERR_FAIL_INDEX(p_index, ShaderLanguage::MAX_INSTANCE_UNIFORM_INDICES);

const ShaderLanguage::DataType datatype_from_value[Variant::COLOR + 1] = {

ShaderLanguage::TYPE_MAX, //nil

ShaderLanguage::TYPE_VEC4 //color

};

pos += p_index;

#ifndef MATERIAL_STORAGE_RD_H

#define MATERIAL_STORAGE_RD_H

#include "core/math/projection.h"

#include "core/templates/local_vector.h"

#include "core/templates/rid_owner.h"

};

struct ShaderData {

virtual bool is_animated() const = 0;

virtual bool casts_shadows() const = 0;

virtual RS::ShaderNativeSourceCode get_native_source_code() const { return RS::ShaderNativeSourceCode(); }

virtual ~ShaderData() {}

};

struct MaterialData {

void update_uniform_buffer(const HashMap<StringName, ShaderLanguage::ShaderNode::Uniform> &p_uniforms, const uint32_t *p_uniform_offsets, const HashMap<StringName, Variant> &p_parameters, uint8_t *p_buffer, uint32_t p_buffer_size, bool p_use_linear_color);

void update_textures(const HashMap<StringName, Variant> &p_parameters, const HashMap<StringName, HashMap<int, RID>> &p_default_textures, const Vector<ShaderCompiler::GeneratedCode::Texture> &p_texture_uniforms, RID *p_textures, bool p_use_linear_color);

virtual void set_render_priority(int p_priority) = 0;

virtual void set_next_pass(RID p_pass) = 0;

virtual ~MaterialData();

//to be used internally by update_parameters, in the most common configuration of material parameters

void free_parameters_uniform_set(RID p_uniform_set);

private:

virtual int32_t global_shader_parameters_instance_allocate(RID p_instance) override;

virtual void global_shader_parameters_instance_free(RID p_instance) override;

RID global_shader_uniforms_get_storage_buffer() const;

}

if (mesh->surface_count == 0) {

mesh->aabb = p_surface.aabb;

} else {

mesh->aabb.merge_with(p_surface.aabb);

}

Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton);

return mesh->aabb;

}

}

}

return aabb;

}

RD::get_singleton()->buffer_update(multimesh->buffer, buffer_offset * sizeof(float) + offset, MIN(region_size, size - offset), &data[region_start_index], RD::BARRIER_MASK_NO_BARRIER);

}

}

}

memcpy(multimesh->previous_data_cache_dirty_regions, multimesh->data_cache_dirty_regions, data_cache_dirty_region_count * sizeof(bool));

Surface **surfaces = nullptr;

uint32_t surface_count = 0;

bool has_bone_weights = false;

AABB aabb;

AABB custom_aabb;

Vector<RID> material_cache;

return s->index_count ? s->index_count : s->vertex_count;

}

Mesh::Surface *s = reinterpret_cast<Mesh::Surface *>(p_surface);

int32_t current_lod = -1;

for (uint32_t i = 0; i < s->lod_count; i++) {

float screen_size = s->lods[i].edge_length * p_model_scale / p_distance_threshold;

if (screen_size > p_mesh_lod_threshold) {

if (current_lod == -1) {

return 0;

} else {

return current_lod + 1;

}

}

virtual void skeleton_allocate_data(RID p_skeleton, int p_bones, bool p_2d_skeleton = false) override;

virtual void skeleton_set_base_transform_2d(RID p_skeleton, const Transform2D &p_base_transform) override;

virtual int skeleton_get_bone_count(RID p_skeleton) const override;

virtual void skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform3D &p_transform) override;

virtual Transform3D skeleton_bone_get_transform(RID p_skeleton, int p_bone) const override;

p_length = MIN(10.0, p_length);

particles->trails_enabled = p_enable;

_particles_free_data(particles);

//2D collision

Transform2D xform = p_particles->sdf_collision_transform; //will use dotproduct manually so invert beforehand

Transform2D revert = xform.affine_inverse();

frame_params.collider_count = 1;

frame_params.colliders[0].transform[0] = xform.columns[0][0];

uniforms.push_back(u);

}

p_particles->collision_textures_uniform_set = RD::get_singleton()->uniform_set_create(uniforms, particles_shader.default_shader_rd, 2);

}

}

if (m->uniform_set.is_valid() && RD::get_singleton()->uniform_set_is_valid(m->uniform_set)) {

RD::get_singleton()->compute_list_bind_uniform_set(compute_list, m->uniform_set, 3);

}

RD::get_singleton()->compute_list_set_push_constant(compute_list, &push_constant, sizeof(ParticlesShader::PushConstant));

RendererCompositorRD::singleton->get_effects()->sort_buffer(particles->particles_sort_uniform_set, particles->amount);

}

RD::ComputeListID compute_list = RD::get_singleton()->compute_list_begin();

uint32_t copy_pipeline = do_sort ? ParticlesShader::COPY_MODE_FILL_INSTANCES_WITH_SORT_BUFFER : ParticlesShader::COPY_MODE_FILL_INSTANCES;

int history_size = 1;

int trail_steps = 1;

if (particles->trails_enabled && particles->trail_bind_poses.size() > 1) {

trail_steps = particles->trail_bind_poses.size();

}

}

bool zero_time_scale = Engine::get_singleton()->get_time_scale() <= 0.0;

if (particles->clear && particles->pre_process_time > 0.0) {

double frame_time;

while (todo >= 0) {

_particles_process(particles, frame_time);

todo -= frame_time;

}

}

}

double todo = particles->frame_remainder + delta;

_particles_process(particles, frame_time);

todo -= decr;

}

particles->frame_remainder = todo;

} else {

if (zero_time_scale) {

_particles_process(particles, 0.0);

} else {

_particles_process(particles, RendererCompositorRD::singleton->get_frame_delta_time());

}

}

//copy particles to instance buffer

//does not need view dependent operation, do copy here

ParticlesShader::CopyPushConstant copy_push_constant;

/* Particles SHADER */

void ParticlesStorage::ParticlesShaderData::set_code(const String &p_code) {

ParticlesStorage *particles_storage = ParticlesStorage::get_singleton();

//compile

valid = true;

}

bool ParticlesStorage::ParticlesShaderData::is_animated() const {

return false;

}

return false;

}

RS::ShaderNativeSourceCode ParticlesStorage::ParticlesShaderData::get_native_source_code() const {

return ParticlesStorage::get_singleton()->particles_shader.shader.version_get_native_source_code(version);

}

float velocity[3];

uint32_t active;

float color[4];

};

struct ParticlesFrameParams {

uint32_t type;

uint32_t texture_index; //texture index for vector field

uint32_t pad[2];

};

float prev_system_phase;

uint32_t cycle;

float time;

float delta;

Collider colliders[MAX_COLLIDERS];

};

struct ParticleEmissionBuffer {

struct Data {

float xform[16];

Dependency dependency;

bool trails_enabled = false;

LocalVector<ParticlesFrameParams> frame_history;

LocalVector<ParticlesFrameParams> trail_params;

RID version;

bool uses_collision = false;

Vector<ShaderCompiler::GeneratedCode::Texture> texture_uniforms;

Vector<uint32_t> ubo_offsets;

uint32_t ubo_size = 0;

String code;

RID pipeline;

uint32_t userdata_count = 0;

virtual void set_code(const String &p_Code);

virtual bool is_animated() const;

virtual bool casts_shadows() const;

virtual RS::ShaderNativeSourceCode get_native_source_code() const;

ParticlesShaderData() {}

bool owns_particles(RID p_rid) { return particles_owner.owns(p_rid); }

virtual RID particles_allocate() override;

virtual void particles_free(RID p_rid) override;

virtual void particles_set_mode(RID p_particles, RS::ParticlesMode p_mode) override;

return particles->mode;

}

_FORCE_INLINE_ uint32_t particles_get_amount(RID p_particles, uint32_t &r_trail_divisor) {

Particles *particles = particles_owner.get_or_null(p_particles);

ERR_FAIL_COND_V(!particles, 0);

_FORCE_INLINE_ RID particles_get_instance_buffer_uniform_set(RID p_particles, RID p_shader, uint32_t p_set) {

Particles *particles = particles_owner.get_or_null(p_particles);

ERR_FAIL_COND_V(!particles, RID());

_particles_update_buffers(particles);

Vector<RD::Uniform> uniforms;

{

virtual void particles_add_collision(RID p_particles, RID p_particles_collision_instance) override;

virtual void particles_remove_collision(RID p_particles, RID p_particles_collision_instance) override;

virtual void update_particles() override;

virtual AABB particles_collision_get_aabb(RID p_particles_collision) const override;

Vector3 particles_collision_get_extents(RID p_particles_collision) const;

virtual bool particles_collision_is_heightfield(RID p_particles_collision) const override;

Dependency *particles_collision_get_dependency(RID p_particles) const;

}

}

void RenderSceneBuffersRD::set_fsr_sharpness(float p_fsr_sharpness) {

fsr_sharpness = p_fsr_sharpness;

}

}

Ref<RenderBufferCustomDataRD> RenderSceneBuffersRD::get_custom_data(const StringName &p_name) const {

ERR_FAIL_COND_V(!data_buffers.has(p_name), Ref<RenderBufferCustomDataRD>());

Ref<RenderBufferCustomDataRD> ret = data_buffers[p_name];

void cleanup();

virtual void configure(RID p_render_target, const Size2i p_internal_size, const Size2i p_target_size, float p_fsr_sharpness, float p_texture_mipmap_bias, RS::ViewportMSAA p_msaa_3d, RenderingServer::ViewportScreenSpaceAA p_screen_space_aa, bool p_use_taa, bool p_use_debanding, uint32_t p_view_count) override;

virtual void set_fsr_sharpness(float p_fsr_sharpness) override;

virtual void set_texture_mipmap_bias(float p_texture_mipmap_bias) override;

virtual void set_use_debanding(bool p_use_debanding) override;

RendererRD::MaterialStorage::store_soft_shadow_kernel(render_scene_render->directional_soft_shadow_kernel_get(), ubo.directional_soft_shadow_kernel);

RendererRD::MaterialStorage::store_soft_shadow_kernel(render_scene_render->penumbra_shadow_kernel_get(), ubo.penumbra_shadow_kernel);

RendererRD::MaterialStorage::store_soft_shadow_kernel(render_scene_render->soft_shadow_kernel_get(), ubo.soft_shadow_kernel);

ubo.viewport_size[0] = p_screen_size.x;

ubo.viewport_size[1] = p_screen_size.y;

Transform3D cam_transform;

Projection cam_projection;

Vector2 taa_jitter;

bool cam_orthogonal = false;

// For stereo rendering

float IBL_exposure_normalization; // Adjusts for baked exposure.

uint32_t pancake_shadows;

uint32_t pad2;

uint32_t pad3;

};

tformat.format = RD::DATA_FORMAT_R8_UINT;

tformat.width = 4;

tformat.height = 4;

tformat.texture_type = RD::TEXTURE_TYPE_2D;

Vector<uint8_t> pv;

pv.resize(4 * 4);

void TextureStorage::canvas_texture_set_texture_repeat(RID p_canvas_texture, RS::CanvasItemTextureRepeat p_repeat) {

CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);

ERR_FAIL_NULL(ct);

ct->texture_repeat = p_repeat;

ct->clear_sets();

}

}

ct = t->canvas_texture;

} else {

ct = canvas_texture_owner.get_or_null(p_texture);

}

} else {

u.append_id(t->rd_texture);

ct->size_cache = Size2i(t->width_2d, t->height_2d);

}

uniforms.push_back(u);

}

} else {

u.append_id(t->rd_texture);

ct->use_normal_cache = true;

}

uniforms.push_back(u);

}

} else {

u.append_id(t->rd_texture);

ct->use_specular_cache = true;

}

uniforms.push_back(u);

}

return texture_2d_get_size(p_proxy);

}

Ref<Image> TextureStorage::_validate_texture_format(const Ref<Image> &p_image, TextureToRDFormat &r_format) {

Ref<Image> image = p_image->duplicate();

r_format.swizzle_b = RD::TEXTURE_SWIZZLE_ZERO;

r_format.swizzle_a = RD::TEXTURE_SWIZZLE_ONE;

} break;

default: {

}

rt->color = RID();

rt->color_multisample = RID();

}

void TextureStorage::_update_render_target(RenderTarget *rt) {

tex->rd_texture = RID();

tex->rd_texture_srgb = RID();

//create shared textures to the color buffer,

//so transparent can be supported

return rt->texture;

}

RenderTarget *rt = render_target_owner.get_or_null(p_render_target);

ERR_FAIL_COND(!rt);

}

RID TextureStorage::render_target_get_override_color(RID p_render_target) const {

return rt->overridden.color;

}

RID TextureStorage::render_target_get_override_depth(RID p_render_target) const {

RenderTarget *rt = render_target_owner.get_or_null(p_render_target);

ERR_FAIL_COND_V(!rt, RID());

}

}

RID TextureStorage::render_target_get_override_velocity(RID p_render_target) const {

RenderTarget *rt = render_target_owner.get_or_null(p_render_target);

ERR_FAIL_COND_V(!rt, RID());

// TODO figure out stereo support here

if (!p_gen_mipmaps) {

return;

//then mipmap blur

RID prev_texture = rt->color; //use color, not backbuffer, as bb has mipmaps.

for (int i = 0; i < rt->backbuffer_mipmaps.size(); i++) {

region.position.x >>= 1;

region.position.y >>= 1;

region.size.x = MAX(1, region.size.x >> 1);

region.size.y = MAX(1, region.size.y >> 1);

RID mipmap = rt->backbuffer_mipmaps[i];

prev_texture = mipmap;

}

RD::get_singleton()->draw_command_end_label();

}

//single texture copy for backbuffer

}

void TextureStorage::render_target_gen_back_buffer_mipmaps(RID p_render_target, const Rect2i &p_region) {

RD::get_singleton()->draw_command_begin_label("Gaussian Blur Mipmaps2");

//then mipmap blur

RID prev_texture = rt->backbuffer_mipmap0;

for (int i = 0; i < rt->backbuffer_mipmaps.size(); i++) {

region.position.x >>= 1;

region.position.y >>= 1;

region.size.x = MAX(1, region.size.x >> 1);

region.size.y = MAX(1, region.size.y >> 1);

RID mipmap = rt->backbuffer_mipmaps[i];

prev_texture = mipmap;

}

RD::get_singleton()->draw_command_end_label();

/* Texture API */

class Texture {

public:

TextureType type;

Vector<BufferSlice3D> buffer_slices_3d;

uint32_t buffer_size_3d = 0;

bool is_render_target;

bool is_proxy;

virtual Size2 texture_size_with_proxy(RID p_proxy) override;

//internal usage

_FORCE_INLINE_ TextureType texture_get_type(RID p_texture) {

RendererRD::TextureStorage::Texture *tex = texture_owner.get_or_null(p_texture);

virtual void render_target_set_vrs_texture(RID p_render_target, RID p_texture) override;

virtual RID render_target_get_vrs_texture(RID p_render_target) const override;

virtual RID render_target_get_override_color(RID p_render_target) const override;

virtual RID render_target_get_override_depth(RID p_render_target) const override;

RID render_target_get_override_depth_slice(RID p_render_target, const uint32_t p_layer) const;

virtual RID render_target_get_override_velocity(RID p_render_target) const override;

RID render_target_get_override_velocity_slice(RID p_render_target, const uint32_t p_layer) const;

if (p_enter) {

if (!vn->enter_callback.is_null()) {

if (p_deferred) {

} else {

Variant r;

Callable::CallError ce;

} else {

if (!vn->exit_callback.is_null()) {

if (p_deferred) {

} else {

Variant r;

Callable::CallError ce;

String Utilities::get_video_adapter_api_version() const {

return RenderingDevice::get_singleton()->get_device_api_version();

}

virtual String get_video_adapter_vendor() const override;

virtual RenderingDevice::DeviceType get_video_adapter_type() const override;

virtual String get_video_adapter_api_version() const override;

};

} // namespace RendererRD