virtual Color _multimesh_instance_get_color(RID p_multimesh, int p_index) const override { return Color(); }

virtual Color _multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const override { return Color(); }

virtual void _multimesh_set_buffer(RID p_multimesh, const Vector<float> &p_buffer) override;

virtual Vector<float> _multimesh_get_buffer(RID p_multimesh) const override;

virtual void _multimesh_set_visible_instances(RID p_multimesh, int p_visible) override {}

ci->children_order_dirty = false;

}

Rect2 rect = ci->get_rect();

if (ci->visibility_notifier) {

}

global_rect.position += p_clip_rect.position;

int child_item_count = ci->child_items.size();

Item **child_items = ci->child_items.ptrw();

}

}

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

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

// make sure we support our view count

SkyMaterialData *material = nullptr;

RID sky_material;

SkyShaderData *shader_data = nullptr;

if (sky) {

if (sky_material.is_valid()) {

material = static_cast<SkyMaterialData *>(material_storage->material_get_data(sky_material, RendererRD::MaterialStorage::SHADER_TYPE_SKY));

update_dirty_skys();

}

sky->reflection.dirty = true;

RenderingServerDefault::redraw_request();

}

sky->reflection.dirty = true;

}

sky->reflection.dirty = true;

}

}

sky_scene_state.ubo.directional_light_count = 0;

if (shader_data->uses_light) {

// Run through the list of lights in the scene and pick out the Directional Lights.

// This can't be done in RenderSceneRenderRD::_setup lights because that needs to be called

// after the depth prepass, but this runs before the depth prepass.

continue;

}

ERR_CONTINUE(base.is_null());

RS::LightType type = light_storage->light_get_type(base);

if (type == RS::LIGHT_DIRECTIONAL && light_storage->light_directional_get_sky_mode(base) != RS::LIGHT_DIRECTIONAL_SKY_MODE_LIGHT_ONLY) {

SkyDirectionalLightData &sky_light_data = sky_scene_state.directional_lights[sky_scene_state.ubo.directional_light_count];

Vector3 world_direction = light_transform.basis.xform(Vector3(0, 0, 1)).normalized();

sky_light_data.direction[0] = world_direction.x;

float sign = light_storage->light_is_negative(base) ? -1 : 1;

sky_light_data.energy = sign * light_storage->light_get_param(base, RS::LIGHT_PARAM_ENERGY);

sky_light_data.energy *= light_storage->light_get_param(base, RS::LIGHT_PARAM_INTENSITY);

}

}

Color linear_col = light_storage->light_get_color(base).srgb_to_linear();

// Setup fog variables.

sky_scene_state.ubo.volumetric_fog_enabled = false;

}

}

Projection correction;

// Our info in our UBO is only used if we're rendering stereo.

// Reprojection is used when we need to have things in combined space.

} else {

// This is unused so just reset to identity.

Projection ident;

}

RendererRD::MaterialStorage::store_camera(view_inv_projection, sky_scene_state.ubo.view_inv_projections[i]);

sky_scene_state.ubo.view_eye_offsets[i][3] = 0.0;

}

sky_scene_state.ubo.fog_light_color[0] = fog_color.r * fog_energy;

sky_scene_state.ubo.fog_light_color[1] = fog_color.g * fog_energy;

sky_scene_state.ubo.fog_light_color[2] = fog_color.b * fog_energy;

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

}

Projection cm;

cm.set_perspective(90, 1, 0.01, 10.0);

Projection correction;

cm = correction * cm;

// Note, we ignore environment_get_sky_orientation here as this is applied when we do our lookup in our scene shader.

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

#include "servers/rendering/renderer_rd/shaders/environment/sky.glsl.gen.h"

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

#include "servers/rendering/renderer_scene_render.h"

#include "servers/rendering/rendering_device.h"

#include "servers/rendering/shader_compiler.h"

void set_texture_format(RD::DataFormat p_texture_format);

~SkyRD();

void update_radiance_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, const Vector3 &p_global_pos, double p_time, float p_luminance_multiplier = 1.0);

void update_res_buffers(Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, double p_time, float p_luminance_multiplier = 1.0);

void draw_sky(RD::DrawListID p_draw_list, Ref<RenderSceneBuffersRD> p_render_buffers, RID p_env, RID p_fb, double p_time, float p_luminance_multiplier = 1.0);

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

// Setup our sky render information for this frame/viewport

sky_energy_multiplier *= bg_energy_multiplier;

_FORCE_INLINE_ bool uses_shared_shadow_material() const {

bool backface_culling = cull_mode == CULL_BACK;

}

virtual void set_code(const String &p_Code);

RENDER_TIMESTAMP("Setup Sky");

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

sky_energy_multiplier *= bg_energy_multiplier;

surf = surf->next;

}

}

}

void RenderForwardMobile::_setup_environment(const RenderDataRD *p_render_data, bool p_no_fog, const Size2i &p_screen_size, const Color &p_default_bg_color, bool p_opaque_render_buffers, bool p_pancake_shadows, int p_index) {

}

_FORCE_INLINE_ bool uses_shared_shadow_material() const {

}

virtual void set_code(const String &p_Code);

RD::get_singleton()->buffer_update(state.lights_uniform_buffer, 0, sizeof(LightUniform) * light_count, &state.light_uniforms[0]);

}

{

//update canvas state uniform buffer

State::Buffer state_buffer;

normal_transform.columns[2] = Vector2();

_update_transform_2d_to_mat4(normal_transform, state_buffer.canvas_normal_transform);

Color modulate = p_modulate;

if (use_linear_colors) {

modulate = p_modulate.srgb_to_linear();

//print_line("w: " + itos(ssize.width) + " s: " + rtos(canvas_scale));

state_buffer.tex_to_sdf = 1.0 / ((canvas_scale.x + canvas_scale.y) * 0.5);

RD::get_singleton()->buffer_update(state.canvas_state_buffer, 0, sizeof(State::Buffer), &state_buffer);

}

RenderTarget to_render_target;

to_render_target.render_target = p_to_render_target;

while (ci) {

if (ci->copy_back_buffer && canvas_group_owner == nullptr) {

instance_data->world[i] = p_world[i];

}

instance_data->color_texture_pixel_size[0] = p_info->texpixel_size.width;

instance_data->color_texture_pixel_size[1] = p_info->texpixel_size.height;

_update_transform_2d_to_mat2x3(base_transform, world);

Color base_color = p_item->final_modulate;

bool reclip = false;

uint32_t lights[4] = { 0, 0, 0, 0 };

uint16_t light_count = 0;

{

Light *light = p_lights;

uint32_t light_index = light->render_index_cache;

lights[light_count >> 2] |= light_index << ((light_count & 3) * 8);

light_count++;

if (light_count == MAX_LIGHTS_PER_ITEM - 1) {

light = light->next_ptr;

}

}

bool use_lighting = (light_count > 0 || using_directional_lights);

// default variant

r_current_batch->shader_variant = SHADER_VARIANT_QUAD;

r_current_batch->render_primitive = RD::RENDER_PRIMITIVE_TRIANGLES;

}

RenderingServer::CanvasItemTextureRepeat rect_repeat = texture_repeat;

if (rect->flags & CANVAS_RECT_FLIP_H) {

src_rect.size.x *= -1;

}

if (rect->flags & CANVAS_RECT_FLIP_V) {

src_rect.size.y *= -1;

}

if (rect->flags & CANVAS_RECT_TRANSPOSE) {

}

if (rect->flags & CANVAS_RECT_CLIP_UV) {

}

} else {

}

if (has_msdf) {

instance_data->msdf[0] = rect->px_range; // Pixel range.

instance_data->msdf[1] = rect->outline; // Outline size.

instance_data->msdf[2] = 0.f; // Reserved.

instance_data->msdf[3] = 0.f; // Reserved.

} else if (rect->flags & CANVAS_RECT_LCD) {

}

instance_data->modulation[0] = modulated.r;

r_current_batch->has_blend = false;

r_current_batch->shader_variant = SHADER_VARIANT_NINEPATCH;

r_current_batch->render_primitive = RD::RENDER_PRIMITIVE_TRIANGLES;

}

TextureState tex_state(np->texture, texture_filter, texture_repeat, false, use_linear_colors);

instance_data->dst_rect[2] = dst_rect.size.width;

instance_data->dst_rect[3] = dst_rect.size.height;

if (np->draw_center) {

}

instance_data->ninepatch_margins[0] = np->margin[SIDE_LEFT];

r_current_batch->command_type = Item::Command::TYPE_POLYGON;

r_current_batch->has_blend = false;

r_current_batch->command = c;

TextureState tex_state(polygon->texture, texture_filter, texture_repeat, false, use_linear_colors);

TextureInfo *tex_info = texture_info_map.getptr(tex_state);

r_current_batch->has_blend = false;

r_current_batch->command = c;

r_current_batch->primitive_points = primitive->point_count;

ERR_CONTINUE(primitive->point_count == 0 || primitive->point_count > 4);

r_current_batch->command = c;

r_current_batch->command_type = c->type;

r_current_batch->has_blend = false;

InstanceData *instance_data = nullptr;

r_current_batch->tex_info = tex_info;

instance_data = new_instance_data(world, lights, base_flags, r_index, tex_info);

if (mesh_storage->multimesh_uses_colors(mm->multimesh)) {

}

if (mesh_storage->multimesh_uses_custom_data(mm->multimesh)) {

}

} else if (c->type == Item::Command::TYPE_PARTICLES) {

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

uint32_t divisor = 1;

r_current_batch->mesh_instance_count = particles_storage->particles_get_amount(pt->particles, divisor);

r_current_batch->mesh_instance_count /= divisor;

RID particles = pt->particles;

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

// Pass collision information.

// default variant

r_current_batch->shader_variant = SHADER_VARIANT_QUAD;

r_current_batch->render_primitive = RD::RENDER_PRIMITIVE_TRIANGLES;

}

// 2: If the current batch has lighting, start a new batch.

PushConstant push_constant;

push_constant.base_instance_index = p_batch->start;

push_constant.specular_shininess = p_batch->tex_info->specular_shininess;

RID pipeline;

PipelineKey pipeline_key;

// cache values to be copied to instance data

if (info.specular_color.a < 0.999) {

}

if (info.use_normal) {

}

uint8_t a = uint8_t(CLAMP(info.specular_color.a * 255.0, 0.0, 255.0));

};

enum {

};

enum {

uint32_t base_instance_index;

ShaderSpecialization shader_specialization;

uint32_t specular_shininess;

};

// TextureState is used to determine when a new batch is required due to a change of texture state.

uint32_t mesh_instance_count;

};

bool has_blend = false;

};

HashMap<TextureState, TextureInfo, HashableHasher<TextureState>> texture_info_map;

uint32_t directional_light_count;

float tex_to_sdf;

uint32_t pad2;

};

struct RenderTarget {

// Current render target for the canvas.

RID render_target;

};

inline RID _get_pipeline_specialization_or_ubershader(CanvasShaderData *p_shader_data, PipelineKey &r_pipeline_key, PushConstant &r_push_constant, RID p_mesh_instance = RID(), void *p_surface = nullptr, uint32_t p_surface_index = 0, RID *r_vertex_array = nullptr);

vec2 vertex = vertex_attrib;

vec4 color = color_attrib;

color.rgb = srgb_to_linear(color.rgb);

}

color *= draw_data.modulation;

vec2 vertex_base_arr[4] = vec2[](vec2(0.0, 0.0), vec2(0.0, 1.0), vec2(1.0, 1.0), vec2(1.0, 0.0));

vec2 vertex_base = vertex_base_arr[gl_VertexIndex];

vec4 color = draw_data.modulation;

vec2 vertex = draw_data.dst_rect.xy + abs(draw_data.dst_rect.zw) * mix(vertex_base, vec2(1.0, 1.0) - vertex_base, lessThan(draw_data.src_rect.zw, vec2(0.0, 0.0)));

uvec4 bones = uvec4(0, 0, 0, 0);

#ifdef USE_ATTRIBUTES

if (instancing > 1) {

// trails

vertex = new_vertex;

color *= pcolor;

} else if (instancing == 1) {

uint offset = stride * gl_InstanceIndex;

mat4 matrix = mat4(transforms.data[offset + 0], transforms.data[offset + 1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0));

offset += 2;

color *= transforms.data[offset];

offset += 1;

}

instance_custom = transforms.data[offset];

}

} else if (pixel >= draw_size - margin_end) {

return (tex_size - (draw_size - pixel)) * tex_pixel_size;

} else {

// np_repeat is passed as uniform using NinePatchRect::AxisStretchMode enum.

if (np_repeat == 0) { // Stretch.

int draw_center = 2;

uv = vec2(

if (draw_center == 0) {

color.a = 0.0;

uv = uv * draw_data.src_rect.zw + draw_data.src_rect.xy; //apply region if needed

#endif

vec2 half_texpixel = draw_data.color_texture_pixel_size * 0.5;

uv = clamp(uv, draw_data.src_rect.xy + half_texpixel, draw_data.src_rect.xy + abs(draw_data.src_rect.zw) - half_texpixel);

}

#endif

#ifndef USE_PRIMITIVE

float px_range = draw_data.ninepatch_margins.x;

float outline_thickness = draw_data.ninepatch_margins.y;

//float reserved1 = draw_data.ninepatch_margins.z;

float a = clamp(d * px_size + 0.5, 0.0, 1.0);

color.a = a * color.a;

}

vec4 lcd_sample = texture(sampler2D(color_texture, texture_sampler), uv);

if (lcd_sample.a == 1.0) {

color.rgb = lcd_sample.rgb * color.a;

color *= texture(sampler2D(color_texture, texture_sampler), uv);

}

bool using_light = (light_count + canvas_data.directional_light_count) > 0;

vec3 normal;

bool normal_used = false;

#endif

normal.xy = texture(sampler2D(normal_texture, texture_sampler), uv).xy * vec2(2.0, -2.0) - vec2(1.0, -1.0);

normal.xy = normal.yx;

}

normal.z = sqrt(max(0.0, 1.0 - dot(normal.xy, normal.xy)));

normal_used = true;

} else {

bool specular_shininess_used = false;

#endif

specular_shininess = texture(sampler2D(specular_texture, texture_sampler), uv);

specular_shininess *= unpackUnorm4x8(params.specular_shininess);

specular_shininess_used = true;

}

#endif

vec2 shadow_pos = (vec4(shadow_vertex, 0.0, 1.0) * mat4(light_array.data[light_base].shadow_matrix[0], light_array.data[light_base].shadow_matrix[1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy; //multiply inverse given its transposed. Optimizer removes useless operations.

vec4 shadow_uv = vec4(shadow_pos.x, light_array.data[light_base].shadow_y_ofs, shadow_pos.y * light_array.data[light_base].shadow_zfar_inv, 1.0);

}

#endif

vec2 shadow_pos = (vec4(shadow_vertex, 0.0, 1.0) * mat4(light_array.data[light_base].shadow_matrix[0], light_array.data[light_base].shadow_matrix[1], vec4(0.0, 0.0, 1.0, 0.0), vec4(0.0, 0.0, 0.0, 1.0))).xy; //multiply inverse given its transposed. Optimizer removes useless operations.

vec2 pos_norm = normalize(shadow_pos);

#define MAX_LIGHTS_PER_ITEM 16

#define M_PI 3.14159265359

#define SDF_MAX_LENGTH 16384.0

struct InstanceData {

vec2 world_x;

uint lights[4];

};

layout(push_constant, std430) uniform Params {

uint base_instance_index; // base index to instance data

uint sc_packed_0;

uint specular_shininess;

}

params;

/* SET0: Globals */

// The values passed per draw primitives are cached within it

layout(set = 0, binding = 1, std140) uniform CanvasData {

uint directional_light_count;

float tex_to_sdf;

uint pad2;

}

canvas_data;

struct DecalData {

highp mat4 xform; //to decal transform

highp vec3 inv_extents;

layout(push_constant, std430) uniform PushConstant {

ivec2 source_size;

ivec2 dest_size;

float depth_scale;

if (params.orthogonal) {

depth_scale = params.unit_size; //remember depth is negative by default in OpenGL

} else {

depth_scale = params.unit_size / depth; //remember depth is negative by default in OpenGL

}

vec3 cube_normal;

#ifdef USE_MULTIVIEW

// In multiview our projection matrices will contain positional and rotational offsets that we need to properly unproject.

vec4 unprojected = sky_scene_data.view_inv_projections[ViewIndex] * unproject;

cube_normal = unprojected.xyz / unprojected.w;

#else

cube_normal.z = -1.0;

cube_normal.x = (cube_normal.z * (-uv_interp.x - params.projection.x)) / params.projection.y;

#endif

cube_normal = mat3(params.orientation) * cube_normal;

cube_normal = normalize(cube_normal);

#else

directional_lights.data[i].color * directional_lights.data[i].energy * tint,

#endif

#ifdef LIGHT_BACKLIGHT_USED

backlight,

#endif

shadow = blur_shadow(shadow);

#ifdef LIGHT_BACKLIGHT_USED

backlight,

#endif

shadow = blur_shadow(shadow);

#ifdef LIGHT_BACKLIGHT_USED

backlight,

#endif

light_compute(normal, directional_lights.data[i].direction, view, size_A,

directional_lights.data[i].color * directional_lights.data[i].energy * tint,

#ifdef LIGHT_BACKLIGHT_USED

backlight,

#endif

shadow = blur_shadow(shadow);

// Fragment lighting

#ifdef LIGHT_BACKLIGHT_USED

backlight,

#endif

shadow = blur_shadow(shadow);

#ifdef LIGHT_BACKLIGHT_USED

backlight,

#endif

return mix(vec3(dielectric), albedo, vec3(metallic));

}

#ifdef LIGHT_BACKLIGHT_USED

vec3 backlight,

#endif

return 1.0;

}

#ifdef LIGHT_BACKLIGHT_USED

vec3 backlight,

#endif

light_attenuation *= shadow;

#ifdef LIGHT_BACKLIGHT_USED

backlight,

#endif

return panorama_coords;

}

#ifdef LIGHT_BACKLIGHT_USED

vec3 backlight,

#endif

}

light_attenuation *= shadow;

#ifdef LIGHT_BACKLIGHT_USED

backlight,

#endif

}

}

Vector<float> MeshStorage::_multimesh_get_buffer(RID p_multimesh) const {

MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh);

ERR_FAIL_NULL_V(multimesh, Vector<float>());

virtual Color _multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const override;

virtual void _multimesh_set_buffer(RID p_multimesh, const Vector<float> &p_buffer) override;

virtual Vector<float> _multimesh_get_buffer(RID p_multimesh) const override;

virtual void _multimesh_set_visible_instances(RID p_multimesh, int p_visible) override;

cull_data.cull->lock.lock();

RSG::particles_storage->particles_request_process(idata.base_rid);

cull_data.cull->lock.unlock();

//particles visible? request redraw

RenderingServerDefault::redraw_request();

}

}

}

void RendererSceneCull::_render_scene(const RendererSceneRender::CameraData *p_camera_data, const Ref<RenderSceneBuffers> &p_render_buffers, RID p_environment, RID p_force_camera_attributes, RID p_compositor, uint32_t p_visible_layers, RID p_scenario, RID p_viewport, RID p_shadow_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_mesh_lod_threshold, bool p_using_shadows, RenderingMethod::RenderInfo *r_render_info) {

Instance *render_reflection_probe = instance_owner.get_or_null(p_reflection_probe); //if null, not rendering to it

void _scene_cull_threaded(uint32_t p_thread, CullData *cull_data);

void _scene_cull(CullData &cull_data, InstanceCullResult &cull_result, uint64_t p_from, uint64_t p_to);

_FORCE_INLINE_ bool _visibility_parent_check(const CullData &p_cull_data, const InstanceData &p_instance_data);

bool _render_reflection_probe_step(Instance *p_instance, int p_step);

void _render_scene(const RendererSceneRender::CameraData *p_camera_data, const Ref<RenderSceneBuffers> &p_render_buffers, RID p_environment, RID p_force_camera_attributes, RID p_compositor, uint32_t p_visible_layers, RID p_scenario, RID p_viewport, RID p_shadow_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_mesh_lod_threshold, bool p_using_shadows = true, RenderInfo *r_render_info = nullptr);

void render_empty_scene(const Ref<RenderSceneBuffers> &p_render_buffers, RID p_scenario, RID p_shadow_atlas);

RDG::ResourceTracker *tracker = RDG::resource_tracker_create();

tracker->texture_driver_id = texture.shared_fallback->texture;

tracker->texture_subresources = texture.barrier_range();

tracker->texture_usage = alias_format.usage_bits;

tracker->reference_count = 1;

RDG::ResourceTracker *tracker = RDG::resource_tracker_create();

tracker->texture_driver_id = texture.shared_fallback->texture;

tracker->texture_subresources = slice_range;

tracker->texture_usage = slice_format.usage_bits;

tracker->reference_count = 1;

draw_tracker = RDG::resource_tracker_create();

draw_tracker->parent = owner_texture->draw_tracker;

draw_tracker->texture_driver_id = p_texture->driver_id;

draw_tracker->texture_subresources = p_texture->barrier_range();

draw_tracker->texture_usage = p_texture->usage_flags;

draw_tracker->texture_slice_or_dirty_rect = p_texture->slice_rect;

// Regular texture.

p_texture->draw_tracker = RDG::resource_tracker_create();

p_texture->draw_tracker->texture_driver_id = p_texture->driver_id;

p_texture->draw_tracker->texture_subresources = p_texture->barrier_range();

p_texture->draw_tracker->texture_usage = p_texture->usage_flags;

p_texture->draw_tracker->reference_count = 1;

#endif

}

if (p_resource_tracker->usage != RESOURCE_USAGE_ATTACHMENT_COLOR_READ_WRITE && p_resource_tracker->usage != RESOURCE_USAGE_ATTACHMENT_DEPTH_STENCIL_READ_WRITE) {

// We don't check possible intersections for usages that aren't consecutive color or depth writes.

return true;

return true;

}

// We check if the region used by both draw lists have an intersection.

return previous_draw_list_command.region.intersects(current_draw_list_command.region);

}

int32_t RenderingDeviceGraph::_add_to_command_list(int32_t p_command_index, int32_t p_list_index) {

DEV_ASSERT(p_command_index < int32_t(command_count));

DEV_ASSERT(p_list_index < int32_t(command_list_nodes.size()));

return next_index;

}

DEV_ASSERT(p_command_index < int32_t(command_count));

DEV_ASSERT(p_list_index < int32_t(write_slice_list_nodes.size()));

new_node.command_index = p_command_index;

new_node.next_list_index = p_list_index;

new_node.subresources = p_subresources;

return next_index;

}

resource_tracker->usage = new_resource_usage;

}

if (search_tracker->write_command_or_list_index >= 0) {

if (search_tracker->write_command_list_enabled) {

// Make this command adjacent to any commands that wrote to this resource and intersect with the slice if it applies.

if (!resource_has_parent || search_tracker_rect.intersects(write_list_node.subresources)) {

if (write_list_node.command_index == p_command_index) {

ERR_FAIL_COND_MSG(!resource_has_parent, "Command can't have itself as a dependency.");

// Command is dependent on this command. Add this command to the adjacency list of the write command.

_add_adjacent_command(write_list_node.command_index, p_command_index, r_command);

// Eliminate redundant writes from the list.

if (previous_write_list_index >= 0) {

RecordedSliceListNode &previous_list_node = write_slice_list_nodes[previous_write_list_index];

// The index is just the latest command index that wrote to the resource.

if (search_tracker->write_command_or_list_index == p_command_index) {

ERR_FAIL_MSG("Command can't have itself as a dependency.");

_add_adjacent_command(search_tracker->write_command_or_list_index, p_command_index, r_command);

}

}

}

if (write_usage) {

if (!search_tracker->write_command_list_enabled && search_tracker->write_command_or_list_index >= 0) {

// Write command list was not being used but there was a write command recorded. Add a new node with the entire parent resource's subresources and the recorded command index to the list.

const RDD::TextureSubresourceRange &tracker_subresources = search_tracker->texture_subresources;

Rect2i tracker_rect(tracker_subresources.base_mipmap, tracker_subresources.base_layer, tracker_subresources.mipmap_count, tracker_subresources.layer_count);

}

search_tracker->write_command_list_enabled = true;

} else {

search_tracker->write_command_or_list_index = p_command_index;

read_full_command_list_index = read_full_next_index;

}

// Clear the full list if this resource is not a slice.

search_tracker->read_full_command_list_index = -1;

}

int32_t read_slice_command_list_index = search_tracker->read_slice_command_list_index;

while (read_slice_command_list_index >= 0) {

const RecordedSliceListNode &read_list_node = read_slice_list_nodes[read_slice_command_list_index];

if (previous_slice_command_list_index >= 0) {

// Erase this element and connect the previous one to the next element.

read_slice_list_nodes[previous_slice_command_list_index].next_list_index = read_list_node.next_list_index;

RDD::BufferID buffer_driver_id;

RDD::TextureID texture_driver_id;

RDD::TextureSubresourceRange texture_subresources;

uint32_t texture_usage = 0;

int32_t texture_slice_command_index = -1;

ResourceTracker *parent = nullptr;

int32_t command_index = -1;

int32_t next_list_index = -1;

Rect2i subresources;

};

struct RecordedBufferClearCommand : RecordedCommand {

static bool _is_write_usage(ResourceUsage p_usage);

static RDD::TextureLayout _usage_to_image_layout(ResourceUsage p_usage);

static RDD::BarrierAccessBits _usage_to_access_bits(ResourceUsage p_usage);

int32_t _add_to_command_list(int32_t p_command_index, int32_t p_list_index);

void _add_adjacent_command(int32_t p_previous_command_index, int32_t p_command_index, RecordedCommand *r_command);

int32_t _add_to_slice_read_list(int32_t p_command_index, Rect2i p_subresources, int32_t p_list_index);

RecordedCommand *_allocate_command(uint32_t p_command_size, int32_t &r_command_index);

DrawListInstruction *_allocate_draw_list_instruction(uint32_t p_instruction_size);

ComputeListInstruction *_allocate_compute_list_instruction(uint32_t p_instruction_size);

FUNC2RC(Color, multimesh_instance_get_custom_data, RID, int)

FUNC2(multimesh_set_buffer, RID, const Vector<float> &)

FUNC1RC(Vector<float>, multimesh_get_buffer, RID)

FUNC3(multimesh_set_buffer_interpolated, RID, const Vector<float> &, const Vector<float> &)

shader_modes[RS::SHADER_SPATIAL].functions["light"].built_ins["DIFFUSE_LIGHT"] = ShaderLanguage::TYPE_VEC3;

shader_modes[RS::SHADER_SPATIAL].functions["light"].built_ins["SPECULAR_LIGHT"] = ShaderLanguage::TYPE_VEC3;

shader_modes[RS::SHADER_SPATIAL].functions["light"].built_ins["ALPHA"] = ShaderLanguage::TYPE_FLOAT;

shader_modes[RS::SHADER_SPATIAL].functions["light"].can_discard = true;

shader_modes[RS::SHADER_SPATIAL].functions["light"].main_function = true;

_multimesh_set_buffer(p_multimesh, p_buffer);

}

Vector<float> RendererMeshStorage::multimesh_get_buffer(RID p_multimesh) const {

return _multimesh_get_buffer(p_multimesh);

}

virtual Color multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const;

virtual void multimesh_set_buffer(RID p_multimesh, const Vector<float> &p_buffer);

virtual Vector<float> multimesh_get_buffer(RID p_multimesh) const;

virtual void multimesh_set_buffer_interpolated(RID p_multimesh, const Vector<float> &p_buffer, const Vector<float> &p_buffer_prev);

virtual Color _multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const = 0;

virtual void _multimesh_set_buffer(RID p_multimesh, const Vector<float> &p_buffer) = 0;

virtual Vector<float> _multimesh_get_buffer(RID p_multimesh) const = 0;

virtual void _multimesh_set_visible_instances(RID p_multimesh, int p_visible) = 0;

ClassDB::bind_method(D_METHOD("multimesh_set_visible_instances", "multimesh", "visible"), &RenderingServer::multimesh_set_visible_instances);

ClassDB::bind_method(D_METHOD("multimesh_get_visible_instances", "multimesh"), &RenderingServer::multimesh_get_visible_instances);

ClassDB::bind_method(D_METHOD("multimesh_set_buffer", "multimesh", "buffer"), &RenderingServer::multimesh_set_buffer);

ClassDB::bind_method(D_METHOD("multimesh_get_buffer", "multimesh"), &RenderingServer::multimesh_get_buffer);

ClassDB::bind_method(D_METHOD("multimesh_set_buffer_interpolated", "multimesh", "buffer", "buffer_previous"), &RenderingServer::multimesh_set_buffer_interpolated);

virtual Color multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const = 0;

virtual void multimesh_set_buffer(RID p_multimesh, const Vector<float> &p_buffer) = 0;

virtual Vector<float> multimesh_get_buffer(RID p_multimesh) const = 0;

// Interpolation.