/*************************************************************************/ /* renderer_scene_cull.cpp */ /*************************************************************************/ /* This file is part of: */ /* GODOT ENGINE */ /* https://godotengine.org */ /*************************************************************************/ /* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur. */ /* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md). */ /* */ /* Permission is hereby granted, free of charge, to any person obtaining */ /* a copy of this software and associated documentation files (the */ /* "Software"), to deal in the Software without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of the Software, and to */ /* permit persons to whom the Software is furnished to do so, subject to */ /* the following conditions: */ /* */ /* The above copyright notice and this permission notice shall be */ /* included in all copies or substantial portions of the Software. */ /* */ /* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, */ /* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF */ /* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/ /* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY */ /* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, */ /* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE */ /* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. */ /*************************************************************************/ #include "renderer_scene_cull.h" #include "core/config/project_settings.h" #include "core/os/os.h" #include "rendering_server_default.h" #include "rendering_server_globals.h" #include /* CAMERA API */ RID RendererSceneCull::camera_allocate() { return camera_owner.allocate_rid(); } void RendererSceneCull::camera_initialize(RID p_rid) { camera_owner.initialize_rid(p_rid); } void RendererSceneCull::camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far) { Camera *camera = camera_owner.get_or_null(p_camera); ERR_FAIL_COND(!camera); camera->type = Camera::PERSPECTIVE; camera->fov = p_fovy_degrees; camera->znear = p_z_near; camera->zfar = p_z_far; } void RendererSceneCull::camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far) { Camera *camera = camera_owner.get_or_null(p_camera); ERR_FAIL_COND(!camera); camera->type = Camera::ORTHOGONAL; camera->size = p_size; camera->znear = p_z_near; camera->zfar = p_z_far; } void RendererSceneCull::camera_set_frustum(RID p_camera, float p_size, Vector2 p_offset, float p_z_near, float p_z_far) { Camera *camera = camera_owner.get_or_null(p_camera); ERR_FAIL_COND(!camera); camera->type = Camera::FRUSTUM; camera->size = p_size; camera->offset = p_offset; camera->znear = p_z_near; camera->zfar = p_z_far; } void RendererSceneCull::camera_set_transform(RID p_camera, const Transform3D &p_transform) { Camera *camera = camera_owner.get_or_null(p_camera); ERR_FAIL_COND(!camera); camera->transform = p_transform.orthonormalized(); } void RendererSceneCull::camera_set_cull_mask(RID p_camera, uint32_t p_layers) { Camera *camera = camera_owner.get_or_null(p_camera); ERR_FAIL_COND(!camera); camera->visible_layers = p_layers; } void RendererSceneCull::camera_set_environment(RID p_camera, RID p_env) { Camera *camera = camera_owner.get_or_null(p_camera); ERR_FAIL_COND(!camera); camera->env = p_env; } void RendererSceneCull::camera_set_camera_effects(RID p_camera, RID p_fx) { Camera *camera = camera_owner.get_or_null(p_camera); ERR_FAIL_COND(!camera); camera->effects = p_fx; } void RendererSceneCull::camera_set_use_vertical_aspect(RID p_camera, bool p_enable) { Camera *camera = camera_owner.get_or_null(p_camera); ERR_FAIL_COND(!camera); camera->vaspect = p_enable; } bool RendererSceneCull::is_camera(RID p_camera) const { return camera_owner.owns(p_camera); } /* OCCLUDER API */ RID RendererSceneCull::occluder_allocate() { return RendererSceneOcclusionCull::get_singleton()->occluder_allocate(); } void RendererSceneCull::occluder_initialize(RID p_rid) { RendererSceneOcclusionCull::get_singleton()->occluder_initialize(p_rid); } void RendererSceneCull::occluder_set_mesh(RID p_occluder, const PackedVector3Array &p_vertices, const PackedInt32Array &p_indices) { RendererSceneOcclusionCull::get_singleton()->occluder_set_mesh(p_occluder, p_vertices, p_indices); } /* SCENARIO API */ void RendererSceneCull::_instance_pair(Instance *p_A, Instance *p_B) { RendererSceneCull *self = (RendererSceneCull *)singleton; Instance *A = p_A; Instance *B = p_B; //instance indices are designed so greater always contains lesser if (A->base_type > B->base_type) { SWAP(A, B); //lesser always first } if (B->base_type == RS::INSTANCE_LIGHT && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) { InstanceLightData *light = static_cast(B->base_data); InstanceGeometryData *geom = static_cast(A->base_data); geom->lights.insert(B); light->geometries.insert(A); if (geom->can_cast_shadows) { light->shadow_dirty = true; } if (A->scenario && A->array_index >= 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_LIGHTING_DIRTY; } if (light->uses_projector) { geom->projector_count++; if (geom->projector_count == 1) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_PROJECTOR_SOFTSHADOW_DIRTY; } } if (light->uses_softshadow) { geom->softshadow_count++; if (geom->softshadow_count == 1) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_PROJECTOR_SOFTSHADOW_DIRTY; } } } else if (self->geometry_instance_pair_mask & (1 << RS::INSTANCE_REFLECTION_PROBE) && B->base_type == RS::INSTANCE_REFLECTION_PROBE && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) { InstanceReflectionProbeData *reflection_probe = static_cast(B->base_data); InstanceGeometryData *geom = static_cast(A->base_data); geom->reflection_probes.insert(B); reflection_probe->geometries.insert(A); if (A->scenario && A->array_index >= 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_REFLECTION_DIRTY; } } else if (self->geometry_instance_pair_mask & (1 << RS::INSTANCE_DECAL) && B->base_type == RS::INSTANCE_DECAL && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) { InstanceDecalData *decal = static_cast(B->base_data); InstanceGeometryData *geom = static_cast(A->base_data); geom->decals.insert(B); decal->geometries.insert(A); if (A->scenario && A->array_index >= 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_DECAL_DIRTY; } } else if (B->base_type == RS::INSTANCE_LIGHTMAP && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) { InstanceLightmapData *lightmap_data = static_cast(B->base_data); InstanceGeometryData *geom = static_cast(A->base_data); if (A->dynamic_gi) { geom->lightmap_captures.insert(A); lightmap_data->geometries.insert(B); if (A->scenario && A->array_index >= 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_LIGHTMAP_CAPTURE; } ((RendererSceneCull *)self)->_instance_queue_update(A, false, false); //need to update capture } } else if (self->geometry_instance_pair_mask & (1 << RS::INSTANCE_VOXEL_GI) && B->base_type == RS::INSTANCE_VOXEL_GI && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) { InstanceVoxelGIData *voxel_gi = static_cast(B->base_data); InstanceGeometryData *geom = static_cast(A->base_data); geom->voxel_gi_instances.insert(B); if (A->dynamic_gi) { voxel_gi->dynamic_geometries.insert(A); } else { voxel_gi->geometries.insert(A); } if (A->scenario && A->array_index >= 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_VOXEL_GI_DIRTY; } } else if (B->base_type == RS::INSTANCE_VOXEL_GI && A->base_type == RS::INSTANCE_LIGHT) { InstanceVoxelGIData *voxel_gi = static_cast(B->base_data); voxel_gi->lights.insert(A); } else if (B->base_type == RS::INSTANCE_PARTICLES_COLLISION && A->base_type == RS::INSTANCE_PARTICLES) { InstanceParticlesCollisionData *collision = static_cast(B->base_data); RSG::storage->particles_add_collision(A->base, collision->instance); } } void RendererSceneCull::_instance_unpair(Instance *p_A, Instance *p_B) { RendererSceneCull *self = (RendererSceneCull *)singleton; Instance *A = p_A; Instance *B = p_B; //instance indices are designed so greater always contains lesser if (A->base_type > B->base_type) { SWAP(A, B); //lesser always first } if (B->base_type == RS::INSTANCE_LIGHT && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) { InstanceLightData *light = static_cast(B->base_data); InstanceGeometryData *geom = static_cast(A->base_data); geom->lights.erase(B); light->geometries.erase(A); if (geom->can_cast_shadows) { light->shadow_dirty = true; } if (A->scenario && A->array_index >= 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_LIGHTING_DIRTY; } if (light->uses_projector) { #ifdef DEBUG_ENABLED if (geom->projector_count == 0) { ERR_PRINT("geom->projector_count==0 - BUG!"); } #endif geom->projector_count--; if (geom->projector_count == 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_PROJECTOR_SOFTSHADOW_DIRTY; } } if (light->uses_softshadow) { #ifdef DEBUG_ENABLED if (geom->softshadow_count == 0) { ERR_PRINT("geom->softshadow_count==0 - BUG!"); } #endif geom->softshadow_count--; if (geom->softshadow_count == 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_PROJECTOR_SOFTSHADOW_DIRTY; } } } else if (self->geometry_instance_pair_mask & (1 << RS::INSTANCE_REFLECTION_PROBE) && B->base_type == RS::INSTANCE_REFLECTION_PROBE && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) { InstanceReflectionProbeData *reflection_probe = static_cast(B->base_data); InstanceGeometryData *geom = static_cast(A->base_data); geom->reflection_probes.erase(B); reflection_probe->geometries.erase(A); if (A->scenario && A->array_index >= 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_REFLECTION_DIRTY; } } else if (self->geometry_instance_pair_mask & (1 << RS::INSTANCE_DECAL) && B->base_type == RS::INSTANCE_DECAL && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) { InstanceDecalData *decal = static_cast(B->base_data); InstanceGeometryData *geom = static_cast(A->base_data); geom->decals.erase(B); decal->geometries.erase(A); if (A->scenario && A->array_index >= 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_DECAL_DIRTY; } } else if (B->base_type == RS::INSTANCE_LIGHTMAP && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) { InstanceLightmapData *lightmap_data = static_cast(B->base_data); InstanceGeometryData *geom = static_cast(A->base_data); if (A->dynamic_gi) { geom->lightmap_captures.erase(B); if (geom->lightmap_captures.is_empty() && A->scenario && A->array_index >= 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags &= ~uint32_t(InstanceData::FLAG_LIGHTMAP_CAPTURE); } lightmap_data->geometries.erase(A); ((RendererSceneCull *)self)->_instance_queue_update(A, false, false); //need to update capture } } else if (self->geometry_instance_pair_mask & (1 << RS::INSTANCE_VOXEL_GI) && B->base_type == RS::INSTANCE_VOXEL_GI && ((1 << A->base_type) & RS::INSTANCE_GEOMETRY_MASK)) { InstanceVoxelGIData *voxel_gi = static_cast(B->base_data); InstanceGeometryData *geom = static_cast(A->base_data); geom->voxel_gi_instances.erase(B); if (A->dynamic_gi) { voxel_gi->dynamic_geometries.erase(A); } else { voxel_gi->geometries.erase(A); } if (A->scenario && A->array_index >= 0) { InstanceData &idata = A->scenario->instance_data[A->array_index]; idata.flags |= InstanceData::FLAG_GEOM_VOXEL_GI_DIRTY; } } else if (B->base_type == RS::INSTANCE_VOXEL_GI && A->base_type == RS::INSTANCE_LIGHT) { InstanceVoxelGIData *voxel_gi = static_cast(B->base_data); voxel_gi->lights.erase(A); } else if (B->base_type == RS::INSTANCE_PARTICLES_COLLISION && A->base_type == RS::INSTANCE_PARTICLES) { InstanceParticlesCollisionData *collision = static_cast(B->base_data); RSG::storage->particles_remove_collision(A->base, collision->instance); } } RID RendererSceneCull::scenario_allocate() { return scenario_owner.allocate_rid(); } void RendererSceneCull::scenario_initialize(RID p_rid) { scenario_owner.initialize_rid(p_rid); Scenario *scenario = scenario_owner.get_or_null(p_rid); scenario->self = p_rid; scenario->reflection_probe_shadow_atlas = scene_render->shadow_atlas_create(); scene_render->shadow_atlas_set_size(scenario->reflection_probe_shadow_atlas, 1024); //make enough shadows for close distance, don't bother with rest scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 0, 4); scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 1, 4); scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 2, 4); scene_render->shadow_atlas_set_quadrant_subdivision(scenario->reflection_probe_shadow_atlas, 3, 8); scenario->reflection_atlas = scene_render->reflection_atlas_create(); scenario->instance_aabbs.set_page_pool(&instance_aabb_page_pool); scenario->instance_data.set_page_pool(&instance_data_page_pool); scenario->instance_visibility.set_page_pool(&instance_visibility_data_page_pool); RendererSceneOcclusionCull::get_singleton()->add_scenario(p_rid); } void RendererSceneCull::scenario_set_environment(RID p_scenario, RID p_environment) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); ERR_FAIL_COND(!scenario); scenario->environment = p_environment; } void RendererSceneCull::scenario_set_camera_effects(RID p_scenario, RID p_camera_effects) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); ERR_FAIL_COND(!scenario); scenario->camera_effects = p_camera_effects; } void RendererSceneCull::scenario_set_fallback_environment(RID p_scenario, RID p_environment) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); ERR_FAIL_COND(!scenario); scenario->fallback_environment = p_environment; } void RendererSceneCull::scenario_set_reflection_atlas_size(RID p_scenario, int p_reflection_size, int p_reflection_count) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); ERR_FAIL_COND(!scenario); scene_render->reflection_atlas_set_size(scenario->reflection_atlas, p_reflection_size, p_reflection_count); } bool RendererSceneCull::is_scenario(RID p_scenario) const { return scenario_owner.owns(p_scenario); } RID RendererSceneCull::scenario_get_environment(RID p_scenario) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); ERR_FAIL_COND_V(!scenario, RID()); return scenario->environment; } void RendererSceneCull::scenario_remove_viewport_visibility_mask(RID p_scenario, RID p_viewport) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); ERR_FAIL_COND(!scenario); if (!scenario->viewport_visibility_masks.has(p_viewport)) { return; } uint64_t mask = scenario->viewport_visibility_masks[p_viewport]; scenario->used_viewport_visibility_bits &= ~mask; scenario->viewport_visibility_masks.erase(p_viewport); } void RendererSceneCull::scenario_add_viewport_visibility_mask(RID p_scenario, RID p_viewport) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); ERR_FAIL_COND(!scenario); ERR_FAIL_COND(scenario->viewport_visibility_masks.has(p_viewport)); uint64_t new_mask = 1; while (new_mask & scenario->used_viewport_visibility_bits) { new_mask <<= 1; } if (new_mask == 0) { ERR_PRINT("Only 64 viewports per scenario allowed when using visibility ranges."); new_mask = ((uint64_t)1) << 63; } scenario->viewport_visibility_masks[p_viewport] = new_mask; scenario->used_viewport_visibility_bits |= new_mask; } /* INSTANCING API */ void RendererSceneCull::_instance_queue_update(Instance *p_instance, bool p_update_aabb, bool p_update_dependencies) { if (p_update_aabb) { p_instance->update_aabb = true; } if (p_update_dependencies) { p_instance->update_dependencies = true; } if (p_instance->update_item.in_list()) { return; } _instance_update_list.add(&p_instance->update_item); } RID RendererSceneCull::instance_allocate() { return instance_owner.allocate_rid(); } void RendererSceneCull::instance_initialize(RID p_rid) { instance_owner.initialize_rid(p_rid); Instance *instance = instance_owner.get_or_null(p_rid); instance->self = p_rid; } void RendererSceneCull::_instance_update_mesh_instance(Instance *p_instance) { bool needs_instance = RSG::storage->mesh_needs_instance(p_instance->base, p_instance->skeleton.is_valid()); if (needs_instance != p_instance->mesh_instance.is_valid()) { if (needs_instance) { p_instance->mesh_instance = RSG::storage->mesh_instance_create(p_instance->base); } else { RSG::storage->free(p_instance->mesh_instance); p_instance->mesh_instance = RID(); } InstanceGeometryData *geom = static_cast(p_instance->base_data); scene_render->geometry_instance_set_mesh_instance(geom->geometry_instance, p_instance->mesh_instance); if (p_instance->scenario && p_instance->array_index >= 0) { InstanceData &idata = p_instance->scenario->instance_data[p_instance->array_index]; if (p_instance->mesh_instance.is_valid()) { idata.flags |= InstanceData::FLAG_USES_MESH_INSTANCE; } else { idata.flags &= ~uint32_t(InstanceData::FLAG_USES_MESH_INSTANCE); } } } if (p_instance->mesh_instance.is_valid()) { RSG::storage->mesh_instance_set_skeleton(p_instance->mesh_instance, p_instance->skeleton); } } void RendererSceneCull::instance_set_base(RID p_instance, RID p_base) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); Scenario *scenario = instance->scenario; if (instance->base_type != RS::INSTANCE_NONE) { //free anything related to that base if (scenario && instance->indexer_id.is_valid()) { _unpair_instance(instance); } if (instance->mesh_instance.is_valid()) { RSG::storage->free(instance->mesh_instance); instance->mesh_instance = RID(); // no need to set instance data flag here, as it was freed above } switch (instance->base_type) { case RS::INSTANCE_MESH: case RS::INSTANCE_MULTIMESH: case RS::INSTANCE_PARTICLES: { InstanceGeometryData *geom = static_cast(instance->base_data); scene_render->geometry_instance_free(geom->geometry_instance); } break; case RS::INSTANCE_LIGHT: { InstanceLightData *light = static_cast(instance->base_data); if (scenario && instance->visible && RSG::storage->light_get_type(instance->base) != RS::LIGHT_DIRECTIONAL && light->bake_mode == RS::LIGHT_BAKE_DYNAMIC) { scenario->dynamic_lights.erase(light->instance); } #ifdef DEBUG_ENABLED if (light->geometries.size()) { ERR_PRINT("BUG, indexing did not unpair geometries from light."); } #endif if (scenario && light->D) { scenario->directional_lights.erase(light->D); light->D = nullptr; } scene_render->free(light->instance); } break; case RS::INSTANCE_PARTICLES_COLLISION: { InstanceParticlesCollisionData *collision = static_cast(instance->base_data); RSG::storage->free(collision->instance); } break; case RS::INSTANCE_FOG_VOLUME: { InstanceFogVolumeData *volume = static_cast(instance->base_data); scene_render->free(volume->instance); } break; case RS::INSTANCE_VISIBLITY_NOTIFIER: { //none } break; case RS::INSTANCE_REFLECTION_PROBE: { InstanceReflectionProbeData *reflection_probe = static_cast(instance->base_data); scene_render->free(reflection_probe->instance); if (reflection_probe->update_list.in_list()) { reflection_probe_render_list.remove(&reflection_probe->update_list); } } break; case RS::INSTANCE_DECAL: { InstanceDecalData *decal = static_cast(instance->base_data); scene_render->free(decal->instance); } break; case RS::INSTANCE_LIGHTMAP: { InstanceLightmapData *lightmap_data = static_cast(instance->base_data); //erase dependencies, since no longer a lightmap while (lightmap_data->users.front()) { instance_geometry_set_lightmap(lightmap_data->users.front()->get()->self, RID(), Rect2(), 0); } scene_render->free(lightmap_data->instance); } break; case RS::INSTANCE_VOXEL_GI: { InstanceVoxelGIData *voxel_gi = static_cast(instance->base_data); #ifdef DEBUG_ENABLED if (voxel_gi->geometries.size()) { ERR_PRINT("BUG, indexing did not unpair geometries from VoxelGI."); } #endif #ifdef DEBUG_ENABLED if (voxel_gi->lights.size()) { ERR_PRINT("BUG, indexing did not unpair lights from VoxelGI."); } #endif if (voxel_gi->update_element.in_list()) { voxel_gi_update_list.remove(&voxel_gi->update_element); } scene_render->free(voxel_gi->probe_instance); } break; case RS::INSTANCE_OCCLUDER: { if (scenario && instance->visible) { RendererSceneOcclusionCull::get_singleton()->scenario_remove_instance(instance->scenario->self, p_instance); } } break; default: { } } if (instance->base_data) { memdelete(instance->base_data); instance->base_data = nullptr; } instance->materials.clear(); } instance->base_type = RS::INSTANCE_NONE; instance->base = RID(); if (p_base.is_valid()) { instance->base_type = RSG::storage->get_base_type(p_base); if (instance->base_type == RS::INSTANCE_NONE && RendererSceneOcclusionCull::get_singleton()->is_occluder(p_base)) { instance->base_type = RS::INSTANCE_OCCLUDER; } ERR_FAIL_COND(instance->base_type == RS::INSTANCE_NONE); switch (instance->base_type) { case RS::INSTANCE_LIGHT: { InstanceLightData *light = memnew(InstanceLightData); if (scenario && RSG::storage->light_get_type(p_base) == RS::LIGHT_DIRECTIONAL) { light->D = scenario->directional_lights.push_back(instance); } light->instance = scene_render->light_instance_create(p_base); instance->base_data = light; } break; case RS::INSTANCE_MESH: case RS::INSTANCE_MULTIMESH: case RS::INSTANCE_PARTICLES: { InstanceGeometryData *geom = memnew(InstanceGeometryData); instance->base_data = geom; geom->geometry_instance = scene_render->geometry_instance_create(p_base); scene_render->geometry_instance_set_skeleton(geom->geometry_instance, instance->skeleton); scene_render->geometry_instance_set_material_override(geom->geometry_instance, instance->material_override); scene_render->geometry_instance_set_surface_materials(geom->geometry_instance, instance->materials); scene_render->geometry_instance_set_transform(geom->geometry_instance, instance->transform, instance->aabb, instance->transformed_aabb); scene_render->geometry_instance_set_layer_mask(geom->geometry_instance, instance->layer_mask); scene_render->geometry_instance_set_lod_bias(geom->geometry_instance, instance->lod_bias); scene_render->geometry_instance_set_use_baked_light(geom->geometry_instance, instance->baked_light); scene_render->geometry_instance_set_use_dynamic_gi(geom->geometry_instance, instance->dynamic_gi); scene_render->geometry_instance_set_cast_double_sided_shadows(geom->geometry_instance, instance->cast_shadows == RS::SHADOW_CASTING_SETTING_DOUBLE_SIDED); scene_render->geometry_instance_set_use_lightmap(geom->geometry_instance, RID(), instance->lightmap_uv_scale, instance->lightmap_slice_index); if (instance->lightmap_sh.size() == 9) { scene_render->geometry_instance_set_lightmap_capture(geom->geometry_instance, instance->lightmap_sh.ptr()); } for (Set::Element *E = instance->visibility_dependencies.front(); E; E = E->next()) { Instance *dep_instance = E->get(); ERR_CONTINUE(dep_instance->array_index == -1); ERR_CONTINUE(dep_instance->scenario->instance_data[dep_instance->array_index].parent_array_index != -1); dep_instance->scenario->instance_data[dep_instance->array_index].parent_array_index = instance->array_index; } } break; case RS::INSTANCE_PARTICLES_COLLISION: { InstanceParticlesCollisionData *collision = memnew(InstanceParticlesCollisionData); collision->instance = RSG::storage->particles_collision_instance_create(p_base); RSG::storage->particles_collision_instance_set_active(collision->instance, instance->visible); instance->base_data = collision; } break; case RS::INSTANCE_FOG_VOLUME: { InstanceFogVolumeData *volume = memnew(InstanceFogVolumeData); volume->instance = scene_render->fog_volume_instance_create(p_base); scene_render->fog_volume_instance_set_active(volume->instance, instance->visible); instance->base_data = volume; } break; case RS::INSTANCE_VISIBLITY_NOTIFIER: { InstanceVisibilityNotifierData *vnd = memnew(InstanceVisibilityNotifierData); vnd->base = p_base; instance->base_data = vnd; } break; case RS::INSTANCE_REFLECTION_PROBE: { InstanceReflectionProbeData *reflection_probe = memnew(InstanceReflectionProbeData); reflection_probe->owner = instance; instance->base_data = reflection_probe; reflection_probe->instance = scene_render->reflection_probe_instance_create(p_base); } break; case RS::INSTANCE_DECAL: { InstanceDecalData *decal = memnew(InstanceDecalData); decal->owner = instance; instance->base_data = decal; decal->instance = scene_render->decal_instance_create(p_base); } break; case RS::INSTANCE_LIGHTMAP: { InstanceLightmapData *lightmap_data = memnew(InstanceLightmapData); instance->base_data = lightmap_data; lightmap_data->instance = scene_render->lightmap_instance_create(p_base); } break; case RS::INSTANCE_VOXEL_GI: { InstanceVoxelGIData *voxel_gi = memnew(InstanceVoxelGIData); instance->base_data = voxel_gi; voxel_gi->owner = instance; if (scenario && !voxel_gi->update_element.in_list()) { voxel_gi_update_list.add(&voxel_gi->update_element); } voxel_gi->probe_instance = scene_render->voxel_gi_instance_create(p_base); } break; case RS::INSTANCE_OCCLUDER: { if (scenario) { RendererSceneOcclusionCull::get_singleton()->scenario_set_instance(scenario->self, p_instance, p_base, instance->transform, instance->visible); } } break; default: { } } instance->base = p_base; if (instance->base_type == RS::INSTANCE_MESH) { _instance_update_mesh_instance(instance); } //forcefully update the dependency now, so if for some reason it gets removed, we can immediately clear it RSG::storage->base_update_dependency(p_base, &instance->dependency_tracker); } _instance_queue_update(instance, true, true); } void RendererSceneCull::instance_set_scenario(RID p_instance, RID p_scenario) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); if (instance->scenario) { instance->scenario->instances.remove(&instance->scenario_item); if (instance->indexer_id.is_valid()) { _unpair_instance(instance); } switch (instance->base_type) { case RS::INSTANCE_LIGHT: { InstanceLightData *light = static_cast(instance->base_data); #ifdef DEBUG_ENABLED if (light->geometries.size()) { ERR_PRINT("BUG, indexing did not unpair geometries from light."); } #endif if (light->D) { instance->scenario->directional_lights.erase(light->D); light->D = nullptr; } } break; case RS::INSTANCE_REFLECTION_PROBE: { InstanceReflectionProbeData *reflection_probe = static_cast(instance->base_data); scene_render->reflection_probe_release_atlas_index(reflection_probe->instance); } break; case RS::INSTANCE_PARTICLES_COLLISION: { heightfield_particle_colliders_update_list.erase(instance); } break; case RS::INSTANCE_VOXEL_GI: { InstanceVoxelGIData *voxel_gi = static_cast(instance->base_data); #ifdef DEBUG_ENABLED if (voxel_gi->geometries.size()) { ERR_PRINT("BUG, indexing did not unpair geometries from VoxelGI."); } #endif #ifdef DEBUG_ENABLED if (voxel_gi->lights.size()) { ERR_PRINT("BUG, indexing did not unpair lights from VoxelGI."); } #endif if (voxel_gi->update_element.in_list()) { voxel_gi_update_list.remove(&voxel_gi->update_element); } } break; case RS::INSTANCE_OCCLUDER: { if (instance->visible) { RendererSceneOcclusionCull::get_singleton()->scenario_remove_instance(instance->scenario->self, p_instance); } } break; default: { } } instance->scenario = nullptr; } if (p_scenario.is_valid()) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); ERR_FAIL_COND(!scenario); instance->scenario = scenario; scenario->instances.add(&instance->scenario_item); switch (instance->base_type) { case RS::INSTANCE_LIGHT: { InstanceLightData *light = static_cast(instance->base_data); if (RSG::storage->light_get_type(instance->base) == RS::LIGHT_DIRECTIONAL) { light->D = scenario->directional_lights.push_back(instance); } } break; case RS::INSTANCE_VOXEL_GI: { InstanceVoxelGIData *voxel_gi = static_cast(instance->base_data); if (!voxel_gi->update_element.in_list()) { voxel_gi_update_list.add(&voxel_gi->update_element); } } break; case RS::INSTANCE_OCCLUDER: { RendererSceneOcclusionCull::get_singleton()->scenario_set_instance(scenario->self, p_instance, instance->base, instance->transform, instance->visible); } break; default: { } } _instance_queue_update(instance, true, true); } } void RendererSceneCull::instance_set_layer_mask(RID p_instance, uint32_t p_mask) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); instance->layer_mask = p_mask; if (instance->scenario && instance->array_index >= 0) { instance->scenario->instance_data[instance->array_index].layer_mask = p_mask; } if ((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK && instance->base_data) { InstanceGeometryData *geom = static_cast(instance->base_data); scene_render->geometry_instance_set_layer_mask(geom->geometry_instance, p_mask); } } void RendererSceneCull::instance_geometry_set_transparency(RID p_instance, float p_transparency) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); if ((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK && instance->base_data) { InstanceGeometryData *geom = static_cast(instance->base_data); scene_render->geometry_instance_set_transparency(geom->geometry_instance, p_transparency); } } void RendererSceneCull::instance_set_transform(RID p_instance, const Transform3D &p_transform) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); if (instance->transform == p_transform) { return; //must be checked to avoid worst evil } #ifdef DEBUG_ENABLED for (int i = 0; i < 4; i++) { const Vector3 &v = i < 3 ? p_transform.basis.elements[i] : p_transform.origin; ERR_FAIL_COND(Math::is_inf(v.x)); ERR_FAIL_COND(Math::is_nan(v.x)); ERR_FAIL_COND(Math::is_inf(v.y)); ERR_FAIL_COND(Math::is_nan(v.y)); ERR_FAIL_COND(Math::is_inf(v.z)); ERR_FAIL_COND(Math::is_nan(v.z)); } #endif instance->transform = p_transform; _instance_queue_update(instance, true); } void RendererSceneCull::instance_attach_object_instance_id(RID p_instance, ObjectID p_id) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); instance->object_id = p_id; } void RendererSceneCull::instance_set_blend_shape_weight(RID p_instance, int p_shape, float p_weight) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); if (instance->update_item.in_list()) { _update_dirty_instance(instance); } if (instance->mesh_instance.is_valid()) { RSG::storage->mesh_instance_set_blend_shape_weight(instance->mesh_instance, p_shape, p_weight); } } void RendererSceneCull::instance_set_surface_override_material(RID p_instance, int p_surface, RID p_material) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); if (instance->base_type == RS::INSTANCE_MESH) { //may not have been updated yet, may also have not been set yet. When updated will be correcte, worst case instance->materials.resize(MAX(p_surface + 1, RSG::storage->mesh_get_surface_count(instance->base))); } ERR_FAIL_INDEX(p_surface, instance->materials.size()); instance->materials.write[p_surface] = p_material; _instance_queue_update(instance, false, true); } void RendererSceneCull::instance_set_visible(RID p_instance, bool p_visible) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); if (instance->visible == p_visible) { return; } instance->visible = p_visible; if (p_visible) { if (instance->scenario != nullptr) { _instance_queue_update(instance, true, false); } } else if (instance->indexer_id.is_valid()) { _unpair_instance(instance); } if (instance->base_type == RS::INSTANCE_LIGHT) { InstanceLightData *light = static_cast(instance->base_data); if (instance->scenario && RSG::storage->light_get_type(instance->base) != RS::LIGHT_DIRECTIONAL && light->bake_mode == RS::LIGHT_BAKE_DYNAMIC) { if (p_visible) { instance->scenario->dynamic_lights.push_back(light->instance); } else { instance->scenario->dynamic_lights.erase(light->instance); } } } if (instance->base_type == RS::INSTANCE_PARTICLES_COLLISION) { InstanceParticlesCollisionData *collision = static_cast(instance->base_data); RSG::storage->particles_collision_instance_set_active(collision->instance, p_visible); } if (instance->base_type == RS::INSTANCE_FOG_VOLUME) { InstanceFogVolumeData *volume = static_cast(instance->base_data); scene_render->fog_volume_instance_set_active(volume->instance, p_visible); } if (instance->base_type == RS::INSTANCE_OCCLUDER) { if (instance->scenario) { RendererSceneOcclusionCull::get_singleton()->scenario_set_instance(instance->scenario->self, p_instance, instance->base, instance->transform, p_visible); } } } inline bool is_geometry_instance(RenderingServer::InstanceType p_type) { return p_type == RS::INSTANCE_MESH || p_type == RS::INSTANCE_MULTIMESH || p_type == RS::INSTANCE_PARTICLES; } void RendererSceneCull::instance_set_custom_aabb(RID p_instance, AABB p_aabb) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); ERR_FAIL_COND(!is_geometry_instance(instance->base_type)); if (p_aabb != AABB()) { // Set custom AABB if (instance->custom_aabb == nullptr) { instance->custom_aabb = memnew(AABB); } *instance->custom_aabb = p_aabb; } else { // Clear custom AABB if (instance->custom_aabb != nullptr) { memdelete(instance->custom_aabb); instance->custom_aabb = nullptr; } } if (instance->scenario) { _instance_queue_update(instance, true, false); } } void RendererSceneCull::instance_attach_skeleton(RID p_instance, RID p_skeleton) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); if (instance->skeleton == p_skeleton) { return; } instance->skeleton = p_skeleton; if (p_skeleton.is_valid()) { //update the dependency now, so if cleared, we remove it RSG::storage->skeleton_update_dependency(p_skeleton, &instance->dependency_tracker); } _instance_queue_update(instance, true, true); if ((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK && instance->base_data) { _instance_update_mesh_instance(instance); InstanceGeometryData *geom = static_cast(instance->base_data); scene_render->geometry_instance_set_skeleton(geom->geometry_instance, p_skeleton); } } void RendererSceneCull::instance_set_extra_visibility_margin(RID p_instance, real_t p_margin) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); instance->extra_margin = p_margin; _instance_queue_update(instance, true, false); } void RendererSceneCull::instance_set_ignore_culling(RID p_instance, bool p_enabled) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); instance->ignore_all_culling = p_enabled; if (instance->scenario && instance->array_index >= 0) { InstanceData &idata = instance->scenario->instance_data[instance->array_index]; if (instance->ignore_all_culling) { idata.flags |= InstanceData::FLAG_IGNORE_ALL_CULLING; } else { idata.flags &= ~uint32_t(InstanceData::FLAG_IGNORE_ALL_CULLING); } } } Vector RendererSceneCull::instances_cull_aabb(const AABB &p_aabb, RID p_scenario) const { Vector instances; Scenario *scenario = scenario_owner.get_or_null(p_scenario); ERR_FAIL_COND_V(!scenario, instances); const_cast(this)->update_dirty_instances(); // check dirty instances before culling struct CullAABB { Vector instances; _FORCE_INLINE_ bool operator()(void *p_data) { Instance *p_instance = (Instance *)p_data; if (!p_instance->object_id.is_null()) { instances.push_back(p_instance->object_id); } return false; } }; CullAABB cull_aabb; scenario->indexers[Scenario::INDEXER_GEOMETRY].aabb_query(p_aabb, cull_aabb); scenario->indexers[Scenario::INDEXER_VOLUMES].aabb_query(p_aabb, cull_aabb); return cull_aabb.instances; } Vector RendererSceneCull::instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario) const { Vector instances; Scenario *scenario = scenario_owner.get_or_null(p_scenario); ERR_FAIL_COND_V(!scenario, instances); const_cast(this)->update_dirty_instances(); // check dirty instances before culling struct CullRay { Vector instances; _FORCE_INLINE_ bool operator()(void *p_data) { Instance *p_instance = (Instance *)p_data; if (!p_instance->object_id.is_null()) { instances.push_back(p_instance->object_id); } return false; } }; CullRay cull_ray; scenario->indexers[Scenario::INDEXER_GEOMETRY].ray_query(p_from, p_to, cull_ray); scenario->indexers[Scenario::INDEXER_VOLUMES].ray_query(p_from, p_to, cull_ray); return cull_ray.instances; } Vector RendererSceneCull::instances_cull_convex(const Vector &p_convex, RID p_scenario) const { Vector instances; Scenario *scenario = scenario_owner.get_or_null(p_scenario); ERR_FAIL_COND_V(!scenario, instances); const_cast(this)->update_dirty_instances(); // check dirty instances before culling Vector points = Geometry3D::compute_convex_mesh_points(&p_convex[0], p_convex.size()); struct CullConvex { Vector instances; _FORCE_INLINE_ bool operator()(void *p_data) { Instance *p_instance = (Instance *)p_data; if (!p_instance->object_id.is_null()) { instances.push_back(p_instance->object_id); } return false; } }; CullConvex cull_convex; scenario->indexers[Scenario::INDEXER_GEOMETRY].convex_query(p_convex.ptr(), p_convex.size(), points.ptr(), points.size(), cull_convex); scenario->indexers[Scenario::INDEXER_VOLUMES].convex_query(p_convex.ptr(), p_convex.size(), points.ptr(), points.size(), cull_convex); return cull_convex.instances; } void RendererSceneCull::instance_geometry_set_flag(RID p_instance, RS::InstanceFlags p_flags, bool p_enabled) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); //ERR_FAIL_COND(((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK)); switch (p_flags) { case RS::INSTANCE_FLAG_USE_BAKED_LIGHT: { instance->baked_light = p_enabled; if (instance->scenario && instance->array_index >= 0) { InstanceData &idata = instance->scenario->instance_data[instance->array_index]; if (instance->baked_light) { idata.flags |= InstanceData::FLAG_USES_BAKED_LIGHT; } else { idata.flags &= ~uint32_t(InstanceData::FLAG_USES_BAKED_LIGHT); } } if ((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK && instance->base_data) { InstanceGeometryData *geom = static_cast(instance->base_data); scene_render->geometry_instance_set_use_baked_light(geom->geometry_instance, p_enabled); } } break; case RS::INSTANCE_FLAG_USE_DYNAMIC_GI: { if (p_enabled == instance->dynamic_gi) { //bye, redundant return; } if (instance->indexer_id.is_valid()) { _unpair_instance(instance); _instance_queue_update(instance, true, true); } //once out of octree, can be changed instance->dynamic_gi = p_enabled; if ((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK && instance->base_data) { InstanceGeometryData *geom = static_cast(instance->base_data); scene_render->geometry_instance_set_use_dynamic_gi(geom->geometry_instance, p_enabled); } } break; case RS::INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE: { instance->redraw_if_visible = p_enabled; if (instance->scenario && instance->array_index >= 0) { InstanceData &idata = instance->scenario->instance_data[instance->array_index]; if (instance->redraw_if_visible) { idata.flags |= InstanceData::FLAG_REDRAW_IF_VISIBLE; } else { idata.flags &= ~uint32_t(InstanceData::FLAG_REDRAW_IF_VISIBLE); } } } break; case RS::INSTANCE_FLAG_IGNORE_OCCLUSION_CULLING: { instance->ignore_occlusion_culling = p_enabled; if (instance->scenario && instance->array_index >= 0) { InstanceData &idata = instance->scenario->instance_data[instance->array_index]; if (instance->ignore_occlusion_culling) { idata.flags |= InstanceData::FLAG_IGNORE_OCCLUSION_CULLING; } else { idata.flags &= ~uint32_t(InstanceData::FLAG_IGNORE_OCCLUSION_CULLING); } } } break; default: { } } } void RendererSceneCull::instance_geometry_set_cast_shadows_setting(RID p_instance, RS::ShadowCastingSetting p_shadow_casting_setting) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); instance->cast_shadows = p_shadow_casting_setting; if (instance->scenario && instance->array_index >= 0) { InstanceData &idata = instance->scenario->instance_data[instance->array_index]; if (instance->cast_shadows != RS::SHADOW_CASTING_SETTING_OFF) { idata.flags |= InstanceData::FLAG_CAST_SHADOWS; } else { idata.flags &= ~uint32_t(InstanceData::FLAG_CAST_SHADOWS); } if (instance->cast_shadows == RS::SHADOW_CASTING_SETTING_SHADOWS_ONLY) { idata.flags |= InstanceData::FLAG_CAST_SHADOWS_ONLY; } else { idata.flags &= ~uint32_t(InstanceData::FLAG_CAST_SHADOWS_ONLY); } } if ((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK && instance->base_data) { InstanceGeometryData *geom = static_cast(instance->base_data); scene_render->geometry_instance_set_cast_double_sided_shadows(geom->geometry_instance, instance->cast_shadows == RS::SHADOW_CASTING_SETTING_DOUBLE_SIDED); } _instance_queue_update(instance, false, true); } void RendererSceneCull::instance_geometry_set_material_override(RID p_instance, RID p_material) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); instance->material_override = p_material; _instance_queue_update(instance, false, true); if ((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK && instance->base_data) { InstanceGeometryData *geom = static_cast(instance->base_data); scene_render->geometry_instance_set_material_override(geom->geometry_instance, p_material); } } void RendererSceneCull::instance_geometry_set_visibility_range(RID p_instance, float p_min, float p_max, float p_min_margin, float p_max_margin, RS::VisibilityRangeFadeMode p_fade_mode) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); instance->visibility_range_begin = p_min; instance->visibility_range_end = p_max; instance->visibility_range_begin_margin = p_min_margin; instance->visibility_range_end_margin = p_max_margin; instance->visibility_range_fade_mode = p_fade_mode; _update_instance_visibility_dependencies(instance); if (instance->scenario && instance->visibility_index != -1) { InstanceVisibilityData &vd = instance->scenario->instance_visibility[instance->visibility_index]; vd.range_begin = instance->visibility_range_begin; vd.range_end = instance->visibility_range_end; vd.range_begin_margin = instance->visibility_range_begin_margin; vd.range_end_margin = instance->visibility_range_end_margin; vd.fade_mode = p_fade_mode; } } void RendererSceneCull::instance_set_visibility_parent(RID p_instance, RID p_parent_instance) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); Instance *old_parent = instance->visibility_parent; if (old_parent) { old_parent->visibility_dependencies.erase(instance); instance->visibility_parent = nullptr; _update_instance_visibility_depth(old_parent); } Instance *parent = instance_owner.get_or_null(p_parent_instance); ERR_FAIL_COND(p_parent_instance.is_valid() && !parent); if (parent) { parent->visibility_dependencies.insert(instance); instance->visibility_parent = parent; bool cycle_detected = _update_instance_visibility_depth(parent); if (cycle_detected) { ERR_PRINT("Cycle detected in the visibility dependencies tree. The latest change to visibility_parent will have no effect."); parent->visibility_dependencies.erase(instance); instance->visibility_parent = nullptr; } } _update_instance_visibility_dependencies(instance); } bool RendererSceneCull::_update_instance_visibility_depth(Instance *p_instance) { bool cycle_detected = false; Set traversed_nodes; { Instance *instance = p_instance; while (instance) { if (!instance->visibility_dependencies.is_empty()) { uint32_t depth = 0; for (Set::Element *E = instance->visibility_dependencies.front(); E; E = E->next()) { depth = MAX(depth, E->get()->visibility_dependencies_depth); } instance->visibility_dependencies_depth = depth + 1; } else { instance->visibility_dependencies_depth = 0; } if (instance->scenario && instance->visibility_index != -1) { instance->scenario->instance_visibility.move(instance->visibility_index, instance->visibility_dependencies_depth); } traversed_nodes.insert(instance); instance = instance->visibility_parent; if (traversed_nodes.has(instance)) { cycle_detected = true; break; } } } return cycle_detected; } void RendererSceneCull::_update_instance_visibility_dependencies(Instance *p_instance) { bool is_geometry_instance = ((1 << p_instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) && p_instance->base_data; bool has_visibility_range = p_instance->visibility_range_begin > 0.0 || p_instance->visibility_range_end > 0.0; bool needs_visibility_cull = has_visibility_range && is_geometry_instance && p_instance->array_index != -1; if (!needs_visibility_cull && p_instance->visibility_index != -1) { p_instance->scenario->instance_visibility.remove(p_instance->visibility_index); p_instance->visibility_index = -1; } else if (needs_visibility_cull && p_instance->visibility_index == -1) { InstanceVisibilityData vd; vd.instance = p_instance; vd.range_begin = p_instance->visibility_range_begin; vd.range_end = p_instance->visibility_range_end; vd.range_begin_margin = p_instance->visibility_range_begin_margin; vd.range_end_margin = p_instance->visibility_range_end_margin; vd.position = p_instance->transformed_aabb.get_center(); vd.array_index = p_instance->array_index; vd.fade_mode = p_instance->visibility_range_fade_mode; p_instance->scenario->instance_visibility.insert(vd, p_instance->visibility_dependencies_depth); } if (p_instance->scenario && p_instance->array_index != -1) { InstanceData &idata = p_instance->scenario->instance_data[p_instance->array_index]; idata.visibility_index = p_instance->visibility_index; if (is_geometry_instance) { if (has_visibility_range && p_instance->visibility_range_fade_mode == RS::VISIBILITY_RANGE_FADE_SELF) { bool begin_enabled = p_instance->visibility_range_begin > 0.0f; float begin_min = p_instance->visibility_range_begin - p_instance->visibility_range_begin_margin; float begin_max = p_instance->visibility_range_begin + p_instance->visibility_range_begin_margin; bool end_enabled = p_instance->visibility_range_end > 0.0f; float end_min = p_instance->visibility_range_end - p_instance->visibility_range_end_margin; float end_max = p_instance->visibility_range_end + p_instance->visibility_range_end_margin; scene_render->geometry_instance_set_fade_range(idata.instance_geometry, begin_enabled, begin_min, begin_max, end_enabled, end_min, end_max); } else { scene_render->geometry_instance_set_fade_range(idata.instance_geometry, false, 0.0f, 0.0f, false, 0.0f, 0.0f); } } if ((has_visibility_range || p_instance->visibility_parent) && (p_instance->visibility_index == -1 || p_instance->visibility_dependencies_depth == 0)) { idata.flags |= InstanceData::FLAG_VISIBILITY_DEPENDENCY_NEEDS_CHECK; } else { idata.flags &= ~InstanceData::FLAG_VISIBILITY_DEPENDENCY_NEEDS_CHECK; } if (p_instance->visibility_parent) { idata.parent_array_index = p_instance->visibility_parent->array_index; } else { idata.parent_array_index = -1; if (is_geometry_instance) { scene_render->geometry_instance_set_parent_fade_alpha(idata.instance_geometry, 1.0f); } } } } void RendererSceneCull::instance_geometry_set_lightmap(RID p_instance, RID p_lightmap, const Rect2 &p_lightmap_uv_scale, int p_slice_index) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); if (instance->lightmap) { InstanceLightmapData *lightmap_data = static_cast(((Instance *)instance->lightmap)->base_data); lightmap_data->users.erase(instance); instance->lightmap = nullptr; } Instance *lightmap_instance = instance_owner.get_or_null(p_lightmap); instance->lightmap = lightmap_instance; instance->lightmap_uv_scale = p_lightmap_uv_scale; instance->lightmap_slice_index = p_slice_index; RID lightmap_instance_rid; if (lightmap_instance) { InstanceLightmapData *lightmap_data = static_cast(lightmap_instance->base_data); lightmap_data->users.insert(instance); lightmap_instance_rid = lightmap_data->instance; } if ((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK && instance->base_data) { InstanceGeometryData *geom = static_cast(instance->base_data); scene_render->geometry_instance_set_use_lightmap(geom->geometry_instance, lightmap_instance_rid, p_lightmap_uv_scale, p_slice_index); } } void RendererSceneCull::instance_geometry_set_lod_bias(RID p_instance, float p_lod_bias) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); instance->lod_bias = p_lod_bias; if ((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK && instance->base_data) { InstanceGeometryData *geom = static_cast(instance->base_data); scene_render->geometry_instance_set_lod_bias(geom->geometry_instance, p_lod_bias); } } void RendererSceneCull::instance_geometry_set_shader_parameter(RID p_instance, const StringName &p_parameter, const Variant &p_value) { Instance *instance = instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); ERR_FAIL_COND(p_value.get_type() == Variant::OBJECT); Map::Element *E = instance->instance_shader_parameters.find(p_parameter); if (!E) { Instance::InstanceShaderParameter isp; isp.index = -1; isp.info = PropertyInfo(); isp.value = p_value; instance->instance_shader_parameters[p_parameter] = isp; } else { E->get().value = p_value; if (E->get().index >= 0 && instance->instance_allocated_shader_parameters) { //update directly RSG::storage->global_variables_instance_update(p_instance, E->get().index, p_value); } } } Variant RendererSceneCull::instance_geometry_get_shader_parameter(RID p_instance, const StringName &p_parameter) const { const Instance *instance = const_cast(this)->instance_owner.get_or_null(p_instance); ERR_FAIL_COND_V(!instance, Variant()); if (instance->instance_shader_parameters.has(p_parameter)) { return instance->instance_shader_parameters[p_parameter].value; } return Variant(); } Variant RendererSceneCull::instance_geometry_get_shader_parameter_default_value(RID p_instance, const StringName &p_parameter) const { const Instance *instance = const_cast(this)->instance_owner.get_or_null(p_instance); ERR_FAIL_COND_V(!instance, Variant()); if (instance->instance_shader_parameters.has(p_parameter)) { return instance->instance_shader_parameters[p_parameter].default_value; } return Variant(); } void RendererSceneCull::instance_geometry_get_shader_parameter_list(RID p_instance, List *p_parameters) const { const Instance *instance = const_cast(this)->instance_owner.get_or_null(p_instance); ERR_FAIL_COND(!instance); const_cast(this)->update_dirty_instances(); Vector names; for (const KeyValue &E : instance->instance_shader_parameters) { names.push_back(E.key); } names.sort_custom(); for (int i = 0; i < names.size(); i++) { PropertyInfo pinfo = instance->instance_shader_parameters[names[i]].info; p_parameters->push_back(pinfo); } } void RendererSceneCull::_update_instance(Instance *p_instance) { p_instance->version++; if (p_instance->base_type == RS::INSTANCE_LIGHT) { InstanceLightData *light = static_cast(p_instance->base_data); scene_render->light_instance_set_transform(light->instance, p_instance->transform); scene_render->light_instance_set_aabb(light->instance, p_instance->transform.xform(p_instance->aabb)); light->shadow_dirty = true; RS::LightBakeMode bake_mode = RSG::storage->light_get_bake_mode(p_instance->base); if (RSG::storage->light_get_type(p_instance->base) != RS::LIGHT_DIRECTIONAL && bake_mode != light->bake_mode) { if (p_instance->visible && p_instance->scenario && light->bake_mode == RS::LIGHT_BAKE_DYNAMIC) { p_instance->scenario->dynamic_lights.erase(light->instance); } light->bake_mode = bake_mode; if (p_instance->visible && p_instance->scenario && light->bake_mode == RS::LIGHT_BAKE_DYNAMIC) { p_instance->scenario->dynamic_lights.push_back(light->instance); } } uint32_t max_sdfgi_cascade = RSG::storage->light_get_max_sdfgi_cascade(p_instance->base); if (light->max_sdfgi_cascade != max_sdfgi_cascade) { light->max_sdfgi_cascade = max_sdfgi_cascade; //should most likely make sdfgi dirty in scenario } } else if (p_instance->base_type == RS::INSTANCE_REFLECTION_PROBE) { InstanceReflectionProbeData *reflection_probe = static_cast(p_instance->base_data); scene_render->reflection_probe_instance_set_transform(reflection_probe->instance, p_instance->transform); if (p_instance->scenario && p_instance->array_index >= 0) { InstanceData &idata = p_instance->scenario->instance_data[p_instance->array_index]; idata.flags |= InstanceData::FLAG_REFLECTION_PROBE_DIRTY; } } else if (p_instance->base_type == RS::INSTANCE_DECAL) { InstanceDecalData *decal = static_cast(p_instance->base_data); scene_render->decal_instance_set_transform(decal->instance, p_instance->transform); } else if (p_instance->base_type == RS::INSTANCE_LIGHTMAP) { InstanceLightmapData *lightmap = static_cast(p_instance->base_data); scene_render->lightmap_instance_set_transform(lightmap->instance, p_instance->transform); } else if (p_instance->base_type == RS::INSTANCE_VOXEL_GI) { InstanceVoxelGIData *voxel_gi = static_cast(p_instance->base_data); scene_render->voxel_gi_instance_set_transform_to_data(voxel_gi->probe_instance, p_instance->transform); } else if (p_instance->base_type == RS::INSTANCE_PARTICLES) { RSG::storage->particles_set_emission_transform(p_instance->base, p_instance->transform); } else if (p_instance->base_type == RS::INSTANCE_PARTICLES_COLLISION) { InstanceParticlesCollisionData *collision = static_cast(p_instance->base_data); //remove materials no longer used and un-own them if (RSG::storage->particles_collision_is_heightfield(p_instance->base)) { heightfield_particle_colliders_update_list.insert(p_instance); } RSG::storage->particles_collision_instance_set_transform(collision->instance, p_instance->transform); } else if (p_instance->base_type == RS::INSTANCE_FOG_VOLUME) { InstanceFogVolumeData *volume = static_cast(p_instance->base_data); scene_render->fog_volume_instance_set_transform(volume->instance, p_instance->transform); } else if (p_instance->base_type == RS::INSTANCE_OCCLUDER) { if (p_instance->scenario) { RendererSceneOcclusionCull::get_singleton()->scenario_set_instance(p_instance->scenario->self, p_instance->self, p_instance->base, p_instance->transform, p_instance->visible); } } if (p_instance->aabb.has_no_surface()) { return; } if (p_instance->base_type == RS::INSTANCE_LIGHTMAP) { //if this moved, update the captured objects InstanceLightmapData *lightmap_data = static_cast(p_instance->base_data); //erase dependencies, since no longer a lightmap for (Set::Element *E = lightmap_data->geometries.front(); E; E = E->next()) { Instance *geom = E->get(); _instance_queue_update(geom, true, false); } } AABB new_aabb; new_aabb = p_instance->transform.xform(p_instance->aabb); p_instance->transformed_aabb = new_aabb; if ((1 << p_instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) { InstanceGeometryData *geom = static_cast(p_instance->base_data); //make sure lights are updated if it casts shadow if (geom->can_cast_shadows) { for (Set::Element *E = geom->lights.front(); E; E = E->next()) { InstanceLightData *light = static_cast(E->get()->base_data); light->shadow_dirty = true; } } if (!p_instance->lightmap && geom->lightmap_captures.size()) { //affected by lightmap captures, must update capture info! _update_instance_lightmap_captures(p_instance); } else { if (!p_instance->lightmap_sh.is_empty()) { p_instance->lightmap_sh.clear(); //don't need SH p_instance->lightmap_target_sh.clear(); //don't need SH scene_render->geometry_instance_set_lightmap_capture(geom->geometry_instance, nullptr); } } scene_render->geometry_instance_set_transform(geom->geometry_instance, p_instance->transform, p_instance->aabb, p_instance->transformed_aabb); } // note: we had to remove is equal approx check here, it meant that det == 0.000004 won't work, which is the case for some of our scenes. if (p_instance->scenario == nullptr || !p_instance->visible || p_instance->transform.basis.determinant() == 0) { p_instance->prev_transformed_aabb = p_instance->transformed_aabb; return; } //quantize to improve moving object performance AABB bvh_aabb = p_instance->transformed_aabb; if (p_instance->indexer_id.is_valid() && bvh_aabb != p_instance->prev_transformed_aabb) { //assume motion, see if bounds need to be quantized AABB motion_aabb = bvh_aabb.merge(p_instance->prev_transformed_aabb); float motion_longest_axis = motion_aabb.get_longest_axis_size(); float longest_axis = p_instance->transformed_aabb.get_longest_axis_size(); if (motion_longest_axis < longest_axis * 2) { //moved but not a lot, use motion aabb quantizing float quantize_size = Math::pow(2.0, Math::ceil(Math::log(motion_longest_axis) / Math::log(2.0))) * 0.5; //one fifth bvh_aabb.quantize(quantize_size); } } if (!p_instance->indexer_id.is_valid()) { if ((1 << p_instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) { p_instance->indexer_id = p_instance->scenario->indexers[Scenario::INDEXER_GEOMETRY].insert(bvh_aabb, p_instance); } else { p_instance->indexer_id = p_instance->scenario->indexers[Scenario::INDEXER_VOLUMES].insert(bvh_aabb, p_instance); } p_instance->array_index = p_instance->scenario->instance_data.size(); InstanceData idata; idata.instance = p_instance; idata.layer_mask = p_instance->layer_mask; idata.flags = p_instance->base_type; //changing it means de-indexing, so this never needs to be changed later idata.base_rid = p_instance->base; idata.parent_array_index = p_instance->visibility_parent ? p_instance->visibility_parent->array_index : -1; idata.visibility_index = p_instance->visibility_index; for (Set::Element *E = p_instance->visibility_dependencies.front(); E; E = E->next()) { Instance *dep_instance = E->get(); if (dep_instance->array_index != -1) { dep_instance->scenario->instance_data[dep_instance->array_index].parent_array_index = p_instance->array_index; } } switch (p_instance->base_type) { case RS::INSTANCE_MESH: case RS::INSTANCE_MULTIMESH: case RS::INSTANCE_PARTICLES: { InstanceGeometryData *geom = static_cast(p_instance->base_data); idata.instance_geometry = geom->geometry_instance; } break; case RS::INSTANCE_LIGHT: { InstanceLightData *light_data = static_cast(p_instance->base_data); idata.instance_data_rid = light_data->instance.get_id(); light_data->uses_projector = RSG::storage->light_has_projector(p_instance->base); light_data->uses_softshadow = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_SIZE) > CMP_EPSILON; } break; case RS::INSTANCE_REFLECTION_PROBE: { idata.instance_data_rid = static_cast(p_instance->base_data)->instance.get_id(); } break; case RS::INSTANCE_DECAL: { idata.instance_data_rid = static_cast(p_instance->base_data)->instance.get_id(); } break; case RS::INSTANCE_LIGHTMAP: { idata.instance_data_rid = static_cast(p_instance->base_data)->instance.get_id(); } break; case RS::INSTANCE_VOXEL_GI: { idata.instance_data_rid = static_cast(p_instance->base_data)->probe_instance.get_id(); } break; case RS::INSTANCE_FOG_VOLUME: { idata.instance_data_rid = static_cast(p_instance->base_data)->instance.get_id(); } break; case RS::INSTANCE_VISIBLITY_NOTIFIER: { idata.visibility_notifier = static_cast(p_instance->base_data); } break; default: { } } if (p_instance->base_type == RS::INSTANCE_REFLECTION_PROBE) { //always dirty when added idata.flags |= InstanceData::FLAG_REFLECTION_PROBE_DIRTY; } if (p_instance->cast_shadows != RS::SHADOW_CASTING_SETTING_OFF) { idata.flags |= InstanceData::FLAG_CAST_SHADOWS; } if (p_instance->cast_shadows == RS::SHADOW_CASTING_SETTING_SHADOWS_ONLY) { idata.flags |= InstanceData::FLAG_CAST_SHADOWS_ONLY; } if (p_instance->redraw_if_visible) { idata.flags |= InstanceData::FLAG_REDRAW_IF_VISIBLE; } // dirty flags should not be set here, since no pairing has happened if (p_instance->baked_light) { idata.flags |= InstanceData::FLAG_USES_BAKED_LIGHT; } if (p_instance->mesh_instance.is_valid()) { idata.flags |= InstanceData::FLAG_USES_MESH_INSTANCE; } if (p_instance->ignore_occlusion_culling) { idata.flags |= InstanceData::FLAG_IGNORE_OCCLUSION_CULLING; } if (p_instance->ignore_all_culling) { idata.flags |= InstanceData::FLAG_IGNORE_ALL_CULLING; } p_instance->scenario->instance_data.push_back(idata); p_instance->scenario->instance_aabbs.push_back(InstanceBounds(p_instance->transformed_aabb)); _update_instance_visibility_dependencies(p_instance); } else { if ((1 << p_instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) { p_instance->scenario->indexers[Scenario::INDEXER_GEOMETRY].update(p_instance->indexer_id, bvh_aabb); } else { p_instance->scenario->indexers[Scenario::INDEXER_VOLUMES].update(p_instance->indexer_id, bvh_aabb); } p_instance->scenario->instance_aabbs[p_instance->array_index] = InstanceBounds(p_instance->transformed_aabb); } if (p_instance->visibility_index != -1) { p_instance->scenario->instance_visibility[p_instance->visibility_index].position = p_instance->transformed_aabb.get_center(); } //move instance and repair pair_pass++; PairInstances pair; pair.instance = p_instance; pair.pair_allocator = &pair_allocator; pair.pair_pass = pair_pass; pair.pair_mask = 0; if ((1 << p_instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) { pair.pair_mask |= 1 << RS::INSTANCE_LIGHT; pair.pair_mask |= 1 << RS::INSTANCE_VOXEL_GI; pair.pair_mask |= 1 << RS::INSTANCE_LIGHTMAP; if (p_instance->base_type == RS::INSTANCE_PARTICLES) { pair.pair_mask |= 1 << RS::INSTANCE_PARTICLES_COLLISION; } pair.pair_mask |= geometry_instance_pair_mask; pair.bvh2 = &p_instance->scenario->indexers[Scenario::INDEXER_VOLUMES]; } else if (p_instance->base_type == RS::INSTANCE_LIGHT) { pair.pair_mask |= RS::INSTANCE_GEOMETRY_MASK; pair.bvh = &p_instance->scenario->indexers[Scenario::INDEXER_GEOMETRY]; if (RSG::storage->light_get_bake_mode(p_instance->base) == RS::LIGHT_BAKE_DYNAMIC) { pair.pair_mask |= (1 << RS::INSTANCE_VOXEL_GI); pair.bvh2 = &p_instance->scenario->indexers[Scenario::INDEXER_VOLUMES]; } } else if (geometry_instance_pair_mask & (1 << RS::INSTANCE_REFLECTION_PROBE) && (p_instance->base_type == RS::INSTANCE_REFLECTION_PROBE)) { pair.pair_mask = RS::INSTANCE_GEOMETRY_MASK; pair.bvh = &p_instance->scenario->indexers[Scenario::INDEXER_GEOMETRY]; } else if (geometry_instance_pair_mask & (1 << RS::INSTANCE_DECAL) && (p_instance->base_type == RS::INSTANCE_DECAL)) { pair.pair_mask = RS::INSTANCE_GEOMETRY_MASK; pair.bvh = &p_instance->scenario->indexers[Scenario::INDEXER_GEOMETRY]; } else if (p_instance->base_type == RS::INSTANCE_PARTICLES_COLLISION) { pair.pair_mask = (1 << RS::INSTANCE_PARTICLES); pair.bvh = &p_instance->scenario->indexers[Scenario::INDEXER_GEOMETRY]; } else if (p_instance->base_type == RS::INSTANCE_VOXEL_GI) { //lights and geometries pair.pair_mask = RS::INSTANCE_GEOMETRY_MASK | (1 << RS::INSTANCE_LIGHT); pair.bvh = &p_instance->scenario->indexers[Scenario::INDEXER_GEOMETRY]; pair.bvh2 = &p_instance->scenario->indexers[Scenario::INDEXER_VOLUMES]; } pair.pair(); p_instance->prev_transformed_aabb = p_instance->transformed_aabb; } void RendererSceneCull::_unpair_instance(Instance *p_instance) { if (!p_instance->indexer_id.is_valid()) { return; //nothing to do } while (p_instance->pairs.first()) { InstancePair *pair = p_instance->pairs.first()->self(); Instance *other_instance = p_instance == pair->a ? pair->b : pair->a; _instance_unpair(p_instance, other_instance); pair_allocator.free(pair); } if ((1 << p_instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) { p_instance->scenario->indexers[Scenario::INDEXER_GEOMETRY].remove(p_instance->indexer_id); } else { p_instance->scenario->indexers[Scenario::INDEXER_VOLUMES].remove(p_instance->indexer_id); } p_instance->indexer_id = DynamicBVH::ID(); //replace this by last int32_t swap_with_index = p_instance->scenario->instance_data.size() - 1; if (swap_with_index != p_instance->array_index) { Instance *swapped_instance = p_instance->scenario->instance_data[swap_with_index].instance; swapped_instance->array_index = p_instance->array_index; //swap p_instance->scenario->instance_data[p_instance->array_index] = p_instance->scenario->instance_data[swap_with_index]; p_instance->scenario->instance_aabbs[p_instance->array_index] = p_instance->scenario->instance_aabbs[swap_with_index]; if (swapped_instance->visibility_index != -1) { swapped_instance->scenario->instance_visibility[swapped_instance->visibility_index].array_index = swapped_instance->array_index; } for (Set::Element *E = swapped_instance->visibility_dependencies.front(); E; E = E->next()) { Instance *dep_instance = E->get(); if (dep_instance != p_instance && dep_instance->array_index != -1) { dep_instance->scenario->instance_data[dep_instance->array_index].parent_array_index = swapped_instance->array_index; } } } // pop last p_instance->scenario->instance_data.pop_back(); p_instance->scenario->instance_aabbs.pop_back(); //uninitialize p_instance->array_index = -1; if ((1 << p_instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) { // Clear these now because the InstanceData containing the dirty flags is gone InstanceGeometryData *geom = static_cast(p_instance->base_data); scene_render->geometry_instance_pair_light_instances(geom->geometry_instance, nullptr, 0); scene_render->geometry_instance_pair_reflection_probe_instances(geom->geometry_instance, nullptr, 0); scene_render->geometry_instance_pair_decal_instances(geom->geometry_instance, nullptr, 0); scene_render->geometry_instance_pair_voxel_gi_instances(geom->geometry_instance, nullptr, 0); } for (Set::Element *E = p_instance->visibility_dependencies.front(); E; E = E->next()) { Instance *dep_instance = E->get(); if (dep_instance->array_index != -1) { dep_instance->scenario->instance_data[dep_instance->array_index].parent_array_index = -1; if ((1 << dep_instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) { scene_render->geometry_instance_set_parent_fade_alpha(dep_instance->scenario->instance_data[dep_instance->array_index].instance_geometry, 1.0f); } } } _update_instance_visibility_dependencies(p_instance); } void RendererSceneCull::_update_instance_aabb(Instance *p_instance) { AABB new_aabb; ERR_FAIL_COND(p_instance->base_type != RS::INSTANCE_NONE && !p_instance->base.is_valid()); switch (p_instance->base_type) { case RenderingServer::INSTANCE_NONE: { // do nothing } break; case RenderingServer::INSTANCE_MESH: { if (p_instance->custom_aabb) { new_aabb = *p_instance->custom_aabb; } else { new_aabb = RSG::storage->mesh_get_aabb(p_instance->base, p_instance->skeleton); } } break; case RenderingServer::INSTANCE_MULTIMESH: { if (p_instance->custom_aabb) { new_aabb = *p_instance->custom_aabb; } else { new_aabb = RSG::storage->multimesh_get_aabb(p_instance->base); } } break; case RenderingServer::INSTANCE_PARTICLES: { if (p_instance->custom_aabb) { new_aabb = *p_instance->custom_aabb; } else { new_aabb = RSG::storage->particles_get_aabb(p_instance->base); } } break; case RenderingServer::INSTANCE_PARTICLES_COLLISION: { new_aabb = RSG::storage->particles_collision_get_aabb(p_instance->base); } break; case RenderingServer::INSTANCE_FOG_VOLUME: { new_aabb = RSG::storage->fog_volume_get_aabb(p_instance->base); } break; case RenderingServer::INSTANCE_VISIBLITY_NOTIFIER: { new_aabb = RSG::storage->visibility_notifier_get_aabb(p_instance->base); } break; case RenderingServer::INSTANCE_LIGHT: { new_aabb = RSG::storage->light_get_aabb(p_instance->base); } break; case RenderingServer::INSTANCE_REFLECTION_PROBE: { new_aabb = RSG::storage->reflection_probe_get_aabb(p_instance->base); } break; case RenderingServer::INSTANCE_DECAL: { new_aabb = RSG::storage->decal_get_aabb(p_instance->base); } break; case RenderingServer::INSTANCE_VOXEL_GI: { new_aabb = RSG::storage->voxel_gi_get_bounds(p_instance->base); } break; case RenderingServer::INSTANCE_LIGHTMAP: { new_aabb = RSG::storage->lightmap_get_aabb(p_instance->base); } break; default: { } } // This is why I didn't re-use Instance::aabb to implement custom AABBs if (p_instance->extra_margin) { new_aabb.grow_by(p_instance->extra_margin); } p_instance->aabb = new_aabb; } void RendererSceneCull::_update_instance_lightmap_captures(Instance *p_instance) { bool first_set = p_instance->lightmap_sh.size() == 0; p_instance->lightmap_sh.resize(9); //using SH p_instance->lightmap_target_sh.resize(9); //using SH Color *instance_sh = p_instance->lightmap_target_sh.ptrw(); bool inside = false; Color accum_sh[9]; float accum_blend = 0.0; InstanceGeometryData *geom = static_cast(p_instance->base_data); for (Set::Element *E = geom->lightmap_captures.front(); E; E = E->next()) { Instance *lightmap = E->get(); bool interior = RSG::storage->lightmap_is_interior(lightmap->base); if (inside && !interior) { continue; //we are inside, ignore exteriors } Transform3D to_bounds = lightmap->transform.affine_inverse(); Vector3 center = p_instance->transform.xform(p_instance->aabb.get_center()); //use aabb center Vector3 lm_pos = to_bounds.xform(center); AABB bounds = RSG::storage->lightmap_get_aabb(lightmap->base); if (!bounds.has_point(lm_pos)) { continue; //not in this lightmap } Color sh[9]; RSG::storage->lightmap_tap_sh_light(lightmap->base, lm_pos, sh); //rotate it Basis rot = lightmap->transform.basis.orthonormalized(); for (int i = 0; i < 3; i++) { real_t csh[9]; for (int j = 0; j < 9; j++) { csh[j] = sh[j][i]; } rot.rotate_sh(csh); for (int j = 0; j < 9; j++) { sh[j][i] = csh[j]; } } Vector3 inner_pos = ((lm_pos - bounds.position) / bounds.size) * 2.0 - Vector3(1.0, 1.0, 1.0); real_t blend = MAX(inner_pos.x, MAX(inner_pos.y, inner_pos.z)); //make blend more rounded blend = Math::lerp(inner_pos.length(), blend, blend); blend *= blend; blend = MAX(0.0, 1.0 - blend); if (interior && !inside) { //do not blend, just replace for (int j = 0; j < 9; j++) { accum_sh[j] = sh[j] * blend; } accum_blend = blend; inside = true; } else { for (int j = 0; j < 9; j++) { accum_sh[j] += sh[j] * blend; } accum_blend += blend; } } if (accum_blend > 0.0) { for (int j = 0; j < 9; j++) { instance_sh[j] = accum_sh[j] / accum_blend; if (first_set) { p_instance->lightmap_sh.write[j] = instance_sh[j]; } } } scene_render->geometry_instance_set_lightmap_capture(geom->geometry_instance, p_instance->lightmap_sh.ptr()); } void RendererSceneCull::_light_instance_setup_directional_shadow(int p_shadow_index, Instance *p_instance, const Transform3D p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, bool p_cam_vaspect) { InstanceLightData *light = static_cast(p_instance->base_data); Transform3D light_transform = p_instance->transform; light_transform.orthonormalize(); //scale does not count on lights real_t max_distance = p_cam_projection.get_z_far(); real_t shadow_max = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_SHADOW_MAX_DISTANCE); if (shadow_max > 0 && !p_cam_orthogonal) { //its impractical (and leads to unwanted behaviors) to set max distance in orthogonal camera max_distance = MIN(shadow_max, max_distance); } max_distance = MAX(max_distance, p_cam_projection.get_z_near() + 0.001); real_t min_distance = MIN(p_cam_projection.get_z_near(), max_distance); real_t pancake_size = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_SHADOW_PANCAKE_SIZE); real_t range = max_distance - min_distance; int splits = 0; switch (RSG::storage->light_directional_get_shadow_mode(p_instance->base)) { case RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: splits = 1; break; case RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS: splits = 2; break; case RS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS: splits = 4; break; } real_t distances[5]; distances[0] = min_distance; for (int i = 0; i < splits; i++) { distances[i + 1] = min_distance + RSG::storage->light_get_param(p_instance->base, RS::LightParam(RS::LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET + i)) * range; }; distances[splits] = max_distance; real_t texture_size = scene_render->get_directional_light_shadow_size(light->instance); bool overlap = RSG::storage->light_directional_get_blend_splits(p_instance->base); cull.shadow_count = p_shadow_index + 1; cull.shadows[p_shadow_index].cascade_count = splits; cull.shadows[p_shadow_index].light_instance = light->instance; for (int i = 0; i < splits; i++) { RENDER_TIMESTAMP("Culling Directional Light split" + itos(i)); // setup a camera matrix for that range! CameraMatrix camera_matrix; real_t aspect = p_cam_projection.get_aspect(); if (p_cam_orthogonal) { Vector2 vp_he = p_cam_projection.get_viewport_half_extents(); camera_matrix.set_orthogonal(vp_he.y * 2.0, aspect, distances[(i == 0 || !overlap) ? i : i - 1], distances[i + 1], false); } else { real_t fov = p_cam_projection.get_fov(); //this is actually yfov, because set aspect tries to keep it camera_matrix.set_perspective(fov, aspect, distances[(i == 0 || !overlap) ? i : i - 1], distances[i + 1], true); } //obtain the frustum endpoints Vector3 endpoints[8]; // frustum plane endpoints bool res = camera_matrix.get_endpoints(p_cam_transform, endpoints); ERR_CONTINUE(!res); // obtain the light frustum ranges (given endpoints) Transform3D transform = light_transform; //discard scale and stabilize light Vector3 x_vec = transform.basis.get_axis(Vector3::AXIS_X).normalized(); Vector3 y_vec = transform.basis.get_axis(Vector3::AXIS_Y).normalized(); Vector3 z_vec = transform.basis.get_axis(Vector3::AXIS_Z).normalized(); //z_vec points against the camera, like in default opengl real_t x_min = 0.f, x_max = 0.f; real_t y_min = 0.f, y_max = 0.f; real_t z_min = 0.f, z_max = 0.f; // FIXME: z_max_cam is defined, computed, but not used below when setting up // ortho_camera. Commented out for now to fix warnings but should be investigated. real_t x_min_cam = 0.f, x_max_cam = 0.f; real_t y_min_cam = 0.f, y_max_cam = 0.f; real_t z_min_cam = 0.f; //real_t z_max_cam = 0.f; //real_t bias_scale = 1.0; //real_t aspect_bias_scale = 1.0; //used for culling for (int j = 0; j < 8; j++) { real_t d_x = x_vec.dot(endpoints[j]); real_t d_y = y_vec.dot(endpoints[j]); real_t d_z = z_vec.dot(endpoints[j]); if (j == 0 || d_x < x_min) { x_min = d_x; } if (j == 0 || d_x > x_max) { x_max = d_x; } if (j == 0 || d_y < y_min) { y_min = d_y; } if (j == 0 || d_y > y_max) { y_max = d_y; } if (j == 0 || d_z < z_min) { z_min = d_z; } if (j == 0 || d_z > z_max) { z_max = d_z; } } real_t radius = 0; real_t soft_shadow_expand = 0; Vector3 center; { //camera viewport stuff for (int j = 0; j < 8; j++) { center += endpoints[j]; } center /= 8.0; //center=x_vec*(x_max-x_min)*0.5 + y_vec*(y_max-y_min)*0.5 + z_vec*(z_max-z_min)*0.5; for (int j = 0; j < 8; j++) { real_t d = center.distance_to(endpoints[j]); if (d > radius) { radius = d; } } radius *= texture_size / (texture_size - 2.0); //add a texel by each side z_min_cam = z_vec.dot(center) - radius; { float soft_shadow_angle = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_SIZE); if (soft_shadow_angle > 0.0) { float z_range = (z_vec.dot(center) + radius + pancake_size) - z_min_cam; soft_shadow_expand = Math::tan(Math::deg2rad(soft_shadow_angle)) * z_range; x_max += soft_shadow_expand; y_max += soft_shadow_expand; x_min -= soft_shadow_expand; y_min -= soft_shadow_expand; } } // This trick here is what stabilizes the shadow (make potential jaggies to not move) // at the cost of some wasted resolution. Still, the quality increase is very well worth it. const real_t unit = (radius + soft_shadow_expand) * 2.0 / texture_size; x_max_cam = Math::snapped(x_vec.dot(center) + radius + soft_shadow_expand, unit); x_min_cam = Math::snapped(x_vec.dot(center) - radius - soft_shadow_expand, unit); y_max_cam = Math::snapped(y_vec.dot(center) + radius + soft_shadow_expand, unit); y_min_cam = Math::snapped(y_vec.dot(center) - radius - soft_shadow_expand, unit); } //now that we know all ranges, we can proceed to make the light frustum planes, for culling octree Vector light_frustum_planes; light_frustum_planes.resize(6); //right/left light_frustum_planes.write[0] = Plane(x_vec, x_max); light_frustum_planes.write[1] = Plane(-x_vec, -x_min); //top/bottom light_frustum_planes.write[2] = Plane(y_vec, y_max); light_frustum_planes.write[3] = Plane(-y_vec, -y_min); //near/far light_frustum_planes.write[4] = Plane(z_vec, z_max + 1e6); light_frustum_planes.write[5] = Plane(-z_vec, -z_min); // z_min is ok, since casters further than far-light plane are not needed // a pre pass will need to be needed to determine the actual z-near to be used z_max = z_vec.dot(center) + radius + pancake_size; { CameraMatrix ortho_camera; real_t half_x = (x_max_cam - x_min_cam) * 0.5; real_t half_y = (y_max_cam - y_min_cam) * 0.5; ortho_camera.set_orthogonal(-half_x, half_x, -half_y, half_y, 0, (z_max - z_min_cam)); Vector2 uv_scale(1.0 / (x_max_cam - x_min_cam), 1.0 / (y_max_cam - y_min_cam)); Transform3D ortho_transform; ortho_transform.basis = transform.basis; ortho_transform.origin = x_vec * (x_min_cam + half_x) + y_vec * (y_min_cam + half_y) + z_vec * z_max; cull.shadows[p_shadow_index].cascades[i].frustum = Frustum(light_frustum_planes); cull.shadows[p_shadow_index].cascades[i].projection = ortho_camera; cull.shadows[p_shadow_index].cascades[i].transform = ortho_transform; cull.shadows[p_shadow_index].cascades[i].zfar = z_max - z_min_cam; cull.shadows[p_shadow_index].cascades[i].split = distances[i + 1]; cull.shadows[p_shadow_index].cascades[i].shadow_texel_size = radius * 2.0 / texture_size; cull.shadows[p_shadow_index].cascades[i].bias_scale = (z_max - z_min_cam); cull.shadows[p_shadow_index].cascades[i].range_begin = z_max; cull.shadows[p_shadow_index].cascades[i].uv_scale = uv_scale; } } } bool RendererSceneCull::_light_instance_update_shadow(Instance *p_instance, const Transform3D p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, bool p_cam_vaspect, RID p_shadow_atlas, Scenario *p_scenario, float p_screen_lod_threshold) { InstanceLightData *light = static_cast(p_instance->base_data); Transform3D light_transform = p_instance->transform; light_transform.orthonormalize(); //scale does not count on lights bool animated_material_found = false; switch (RSG::storage->light_get_type(p_instance->base)) { case RS::LIGHT_DIRECTIONAL: { } break; case RS::LIGHT_OMNI: { RS::LightOmniShadowMode shadow_mode = RSG::storage->light_omni_get_shadow_mode(p_instance->base); if (shadow_mode == RS::LIGHT_OMNI_SHADOW_DUAL_PARABOLOID || !scene_render->light_instances_can_render_shadow_cube()) { if (max_shadows_used + 2 > MAX_UPDATE_SHADOWS) { return true; } for (int i = 0; i < 2; i++) { //using this one ensures that raster deferred will have it RENDER_TIMESTAMP("Culling Shadow Paraboloid" + itos(i)); real_t radius = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_RANGE); real_t z = i == 0 ? -1 : 1; Vector planes; planes.resize(6); planes.write[0] = light_transform.xform(Plane(Vector3(0, 0, z), radius)); planes.write[1] = light_transform.xform(Plane(Vector3(1, 0, z).normalized(), radius)); planes.write[2] = light_transform.xform(Plane(Vector3(-1, 0, z).normalized(), radius)); planes.write[3] = light_transform.xform(Plane(Vector3(0, 1, z).normalized(), radius)); planes.write[4] = light_transform.xform(Plane(Vector3(0, -1, z).normalized(), radius)); planes.write[5] = light_transform.xform(Plane(Vector3(0, 0, -z), 0)); instance_shadow_cull_result.clear(); Vector points = Geometry3D::compute_convex_mesh_points(&planes[0], planes.size()); struct CullConvex { PagedArray *result; _FORCE_INLINE_ bool operator()(void *p_data) { Instance *p_instance = (Instance *)p_data; result->push_back(p_instance); return false; } }; CullConvex cull_convex; cull_convex.result = &instance_shadow_cull_result; p_scenario->indexers[Scenario::INDEXER_GEOMETRY].convex_query(planes.ptr(), planes.size(), points.ptr(), points.size(), cull_convex); RendererSceneRender::RenderShadowData &shadow_data = render_shadow_data[max_shadows_used++]; for (int j = 0; j < (int)instance_shadow_cull_result.size(); j++) { Instance *instance = instance_shadow_cull_result[j]; if (!instance->visible || !((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) || !static_cast(instance->base_data)->can_cast_shadows) { continue; } else { if (static_cast(instance->base_data)->material_is_animated) { animated_material_found = true; } if (instance->mesh_instance.is_valid()) { RSG::storage->mesh_instance_check_for_update(instance->mesh_instance); } } shadow_data.instances.push_back(static_cast(instance->base_data)->geometry_instance); } RSG::storage->update_mesh_instances(); scene_render->light_instance_set_shadow_transform(light->instance, CameraMatrix(), light_transform, radius, 0, i, 0); shadow_data.light = light->instance; shadow_data.pass = i; } } else { //shadow cube if (max_shadows_used + 6 > MAX_UPDATE_SHADOWS) { return true; } real_t radius = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_RANGE); CameraMatrix cm; cm.set_perspective(90, 1, radius * 0.005f, radius); for (int i = 0; i < 6; i++) { RENDER_TIMESTAMP("Culling Shadow Cube side" + itos(i)); //using this one ensures that raster deferred will have it static const Vector3 view_normals[6] = { Vector3(+1, 0, 0), Vector3(-1, 0, 0), Vector3(0, -1, 0), Vector3(0, +1, 0), Vector3(0, 0, +1), Vector3(0, 0, -1) }; static const Vector3 view_up[6] = { Vector3(0, -1, 0), Vector3(0, -1, 0), Vector3(0, 0, -1), Vector3(0, 0, +1), Vector3(0, -1, 0), Vector3(0, -1, 0) }; Transform3D xform = light_transform * Transform3D().looking_at(view_normals[i], view_up[i]); Vector planes = cm.get_projection_planes(xform); instance_shadow_cull_result.clear(); Vector points = Geometry3D::compute_convex_mesh_points(&planes[0], planes.size()); struct CullConvex { PagedArray *result; _FORCE_INLINE_ bool operator()(void *p_data) { Instance *p_instance = (Instance *)p_data; result->push_back(p_instance); return false; } }; CullConvex cull_convex; cull_convex.result = &instance_shadow_cull_result; p_scenario->indexers[Scenario::INDEXER_GEOMETRY].convex_query(planes.ptr(), planes.size(), points.ptr(), points.size(), cull_convex); RendererSceneRender::RenderShadowData &shadow_data = render_shadow_data[max_shadows_used++]; for (int j = 0; j < (int)instance_shadow_cull_result.size(); j++) { Instance *instance = instance_shadow_cull_result[j]; if (!instance->visible || !((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) || !static_cast(instance->base_data)->can_cast_shadows) { continue; } else { if (static_cast(instance->base_data)->material_is_animated) { animated_material_found = true; } if (instance->mesh_instance.is_valid()) { RSG::storage->mesh_instance_check_for_update(instance->mesh_instance); } } shadow_data.instances.push_back(static_cast(instance->base_data)->geometry_instance); } RSG::storage->update_mesh_instances(); scene_render->light_instance_set_shadow_transform(light->instance, cm, xform, radius, 0, i, 0); shadow_data.light = light->instance; shadow_data.pass = i; } //restore the regular DP matrix //scene_render->light_instance_set_shadow_transform(light->instance, CameraMatrix(), light_transform, radius, 0, 0, 0); } } break; case RS::LIGHT_SPOT: { RENDER_TIMESTAMP("Culling Spot Light"); if (max_shadows_used + 1 > MAX_UPDATE_SHADOWS) { return true; } real_t radius = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_RANGE); real_t angle = RSG::storage->light_get_param(p_instance->base, RS::LIGHT_PARAM_SPOT_ANGLE); CameraMatrix cm; cm.set_perspective(angle * 2.0, 1.0, 0.005f * radius, radius); Vector planes = cm.get_projection_planes(light_transform); instance_shadow_cull_result.clear(); Vector points = Geometry3D::compute_convex_mesh_points(&planes[0], planes.size()); struct CullConvex { PagedArray *result; _FORCE_INLINE_ bool operator()(void *p_data) { Instance *p_instance = (Instance *)p_data; result->push_back(p_instance); return false; } }; CullConvex cull_convex; cull_convex.result = &instance_shadow_cull_result; p_scenario->indexers[Scenario::INDEXER_GEOMETRY].convex_query(planes.ptr(), planes.size(), points.ptr(), points.size(), cull_convex); RendererSceneRender::RenderShadowData &shadow_data = render_shadow_data[max_shadows_used++]; for (int j = 0; j < (int)instance_shadow_cull_result.size(); j++) { Instance *instance = instance_shadow_cull_result[j]; if (!instance->visible || !((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) || !static_cast(instance->base_data)->can_cast_shadows) { continue; } else { if (static_cast(instance->base_data)->material_is_animated) { animated_material_found = true; } if (instance->mesh_instance.is_valid()) { RSG::storage->mesh_instance_check_for_update(instance->mesh_instance); } } shadow_data.instances.push_back(static_cast(instance->base_data)->geometry_instance); } RSG::storage->update_mesh_instances(); scene_render->light_instance_set_shadow_transform(light->instance, cm, light_transform, radius, 0, 0, 0); shadow_data.light = light->instance; shadow_data.pass = 0; } break; } return animated_material_found; } void RendererSceneCull::render_camera(RID p_render_buffers, RID p_camera, RID p_scenario, RID p_viewport, Size2 p_viewport_size, float p_screen_lod_threshold, RID p_shadow_atlas, Ref &p_xr_interface, RenderInfo *r_render_info) { #ifndef _3D_DISABLED Camera *camera = camera_owner.get_or_null(p_camera); ERR_FAIL_COND(!camera); RendererSceneRender::CameraData camera_data; // Setup Camera(s) if (p_xr_interface.is_null()) { // Normal camera Transform3D transform = camera->transform; CameraMatrix projection; bool vaspect = camera->vaspect; bool is_ortogonal = false; switch (camera->type) { case Camera::ORTHOGONAL: { projection.set_orthogonal( camera->size, p_viewport_size.width / (float)p_viewport_size.height, camera->znear, camera->zfar, camera->vaspect); is_ortogonal = true; } break; case Camera::PERSPECTIVE: { projection.set_perspective( camera->fov, p_viewport_size.width / (float)p_viewport_size.height, camera->znear, camera->zfar, camera->vaspect); } break; case Camera::FRUSTUM: { projection.set_frustum( camera->size, p_viewport_size.width / (float)p_viewport_size.height, camera->offset, camera->znear, camera->zfar, camera->vaspect); } break; } camera_data.set_camera(transform, projection, is_ortogonal, vaspect); } else { // Setup our camera for our XR interface. // We can support multiple views here each with their own camera Transform3D transforms[RendererSceneRender::MAX_RENDER_VIEWS]; CameraMatrix projections[RendererSceneRender::MAX_RENDER_VIEWS]; uint32_t view_count = p_xr_interface->get_view_count(); ERR_FAIL_COND_MSG(view_count > RendererSceneRender::MAX_RENDER_VIEWS, "Requested view count is not supported"); float aspect = p_viewport_size.width / (float)p_viewport_size.height; Transform3D world_origin = XRServer::get_singleton()->get_world_origin(); // We ignore our camera position, it will have been positioned with a slightly old tracking position. // Instead we take our origin point and have our XR interface add fresh tracking data! Whoohoo! for (uint32_t v = 0; v < view_count; v++) { transforms[v] = p_xr_interface->get_transform_for_view(v, world_origin); projections[v] = p_xr_interface->get_projection_for_view(v, aspect, camera->znear, camera->zfar); } if (view_count == 1) { camera_data.set_camera(transforms[0], projections[0], false, camera->vaspect); } else if (view_count == 2) { camera_data.set_multiview_camera(view_count, transforms, projections, false, camera->vaspect); } else { // this won't be called (see fail check above) but keeping this comment to indicate we may support more then 2 views in the future... } } RID environment = _render_get_environment(p_camera, p_scenario); RENDER_TIMESTAMP("Update occlusion buffer") // For now just cull on the first camera RendererSceneOcclusionCull::get_singleton()->buffer_update(p_viewport, camera_data.main_transform, camera_data.main_projection, camera_data.is_ortogonal, RendererThreadPool::singleton->thread_work_pool); _render_scene(&camera_data, p_render_buffers, environment, camera->effects, camera->visible_layers, p_scenario, p_viewport, p_shadow_atlas, RID(), -1, p_screen_lod_threshold, true, r_render_info); #endif } void RendererSceneCull::_visibility_cull_threaded(uint32_t p_thread, VisibilityCullData *cull_data) { uint32_t total_threads = RendererThreadPool::singleton->thread_work_pool.get_thread_count(); uint32_t bin_from = p_thread * cull_data->cull_count / total_threads; uint32_t bin_to = (p_thread + 1 == total_threads) ? cull_data->cull_count : ((p_thread + 1) * cull_data->cull_count / total_threads); _visibility_cull(*cull_data, cull_data->cull_offset + bin_from, cull_data->cull_offset + bin_to); } void RendererSceneCull::_visibility_cull(const VisibilityCullData &cull_data, uint64_t p_from, uint64_t p_to) { Scenario *scenario = cull_data.scenario; for (unsigned int i = p_from; i < p_to; i++) { InstanceVisibilityData &vd = scenario->instance_visibility[i]; InstanceData &idata = scenario->instance_data[vd.array_index]; if (idata.parent_array_index >= 0) { uint32_t parent_flags = scenario->instance_data[idata.parent_array_index].flags; if ((parent_flags & InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN) || !(parent_flags & (InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN_CLOSE_RANGE | InstanceData::FLAG_VISIBILITY_DEPENDENCY_FADE_CHILDREN))) { idata.flags |= InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN; idata.flags &= ~InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN_CLOSE_RANGE; idata.flags &= ~InstanceData::FLAG_VISIBILITY_DEPENDENCY_FADE_CHILDREN; continue; } } int range_check = _visibility_range_check(vd, cull_data.camera_position, cull_data.viewport_mask); if (range_check == -1) { idata.flags |= InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN; idata.flags &= ~InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN_CLOSE_RANGE; idata.flags &= ~InstanceData::FLAG_VISIBILITY_DEPENDENCY_FADE_CHILDREN; } else if (range_check == 1) { idata.flags &= ~InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN; idata.flags |= InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN_CLOSE_RANGE; idata.flags &= ~InstanceData::FLAG_VISIBILITY_DEPENDENCY_FADE_CHILDREN; } else { idata.flags &= ~InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN; idata.flags &= ~InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN_CLOSE_RANGE; if (range_check == 2) { idata.flags |= InstanceData::FLAG_VISIBILITY_DEPENDENCY_FADE_CHILDREN; } else { idata.flags &= ~InstanceData::FLAG_VISIBILITY_DEPENDENCY_FADE_CHILDREN; } } } } template int RendererSceneCull::_visibility_range_check(InstanceVisibilityData &r_vis_data, const Vector3 &p_camera_pos, uint64_t p_viewport_mask) { float dist = p_camera_pos.distance_to(r_vis_data.position); const RS::VisibilityRangeFadeMode &fade_mode = r_vis_data.fade_mode; float begin_offset = -r_vis_data.range_begin_margin; float end_offset = r_vis_data.range_end_margin; if (fade_mode == RS::VISIBILITY_RANGE_FADE_DISABLED && !(p_viewport_mask & r_vis_data.viewport_state)) { begin_offset = -begin_offset; end_offset = -end_offset; } if (r_vis_data.range_end > 0.0f && dist > r_vis_data.range_end + end_offset) { r_vis_data.viewport_state &= ~p_viewport_mask; return -1; } else if (r_vis_data.range_begin > 0.0f && dist < r_vis_data.range_begin + begin_offset) { r_vis_data.viewport_state &= ~p_viewport_mask; return 1; } else { r_vis_data.viewport_state |= p_viewport_mask; if (p_fade_check) { if (fade_mode != RS::VISIBILITY_RANGE_FADE_DISABLED) { r_vis_data.children_fade_alpha = 1.0f; if (r_vis_data.range_end > 0.0f && dist > r_vis_data.range_end - end_offset) { if (fade_mode == RS::VISIBILITY_RANGE_FADE_DEPENDENCIES) { r_vis_data.children_fade_alpha = MIN(1.0f, (dist - (r_vis_data.range_end - end_offset)) / (2.0f * r_vis_data.range_end_margin)); } return 2; } else if (r_vis_data.range_begin > 0.0f && dist < r_vis_data.range_begin - begin_offset) { if (fade_mode == RS::VISIBILITY_RANGE_FADE_DEPENDENCIES) { r_vis_data.children_fade_alpha = MIN(1.0f, 1.0 - (dist - (r_vis_data.range_begin + begin_offset)) / (2.0f * r_vis_data.range_begin_margin)); } return 2; } } } return 0; } } bool RendererSceneCull::_visibility_parent_check(const CullData &p_cull_data, const InstanceData &p_instance_data) { if (p_instance_data.parent_array_index == -1) { return true; } const uint32_t &parent_flags = p_cull_data.scenario->instance_data[p_instance_data.parent_array_index].flags; return ((parent_flags & InstanceData::FLAG_VISIBILITY_DEPENDENCY_NEEDS_CHECK) == InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN_CLOSE_RANGE) || (parent_flags & InstanceData::FLAG_VISIBILITY_DEPENDENCY_FADE_CHILDREN); } void RendererSceneCull::_scene_cull_threaded(uint32_t p_thread, CullData *cull_data) { uint32_t cull_total = cull_data->scenario->instance_data.size(); uint32_t total_threads = RendererThreadPool::singleton->thread_work_pool.get_thread_count(); uint32_t cull_from = p_thread * cull_total / total_threads; uint32_t cull_to = (p_thread + 1 == total_threads) ? cull_total : ((p_thread + 1) * cull_total / total_threads); _scene_cull(*cull_data, scene_cull_result_threads[p_thread], cull_from, cull_to); } void RendererSceneCull::_scene_cull(CullData &cull_data, InstanceCullResult &cull_result, uint64_t p_from, uint64_t p_to) { uint64_t frame_number = RSG::rasterizer->get_frame_number(); float lightmap_probe_update_speed = RSG::storage->lightmap_get_probe_capture_update_speed() * RSG::rasterizer->get_frame_delta_time(); uint32_t sdfgi_last_light_index = 0xFFFFFFFF; uint32_t sdfgi_last_light_cascade = 0xFFFFFFFF; RID instance_pair_buffer[MAX_INSTANCE_PAIRS]; Transform3D inv_cam_transform = cull_data.cam_transform.inverse(); float z_near = cull_data.camera_matrix->get_z_near(); for (uint64_t i = p_from; i < p_to; i++) { bool mesh_visible = false; InstanceData &idata = cull_data.scenario->instance_data[i]; uint32_t visibility_flags = idata.flags & (InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN_CLOSE_RANGE | InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN | InstanceData::FLAG_VISIBILITY_DEPENDENCY_FADE_CHILDREN); int32_t visibility_check = -1; #define HIDDEN_BY_VISIBILITY_CHECKS (visibility_flags == InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN_CLOSE_RANGE || visibility_flags == InstanceData::FLAG_VISIBILITY_DEPENDENCY_HIDDEN) #define LAYER_CHECK (cull_data.visible_layers & idata.layer_mask) #define IN_FRUSTUM(f) (cull_data.scenario->instance_aabbs[i].in_frustum(f)) #define VIS_RANGE_CHECK ((idata.visibility_index == -1) || _visibility_range_check(cull_data.scenario->instance_visibility[idata.visibility_index], cull_data.cam_transform.origin, cull_data.visibility_viewport_mask) == 0) #define VIS_PARENT_CHECK (_visibility_parent_check(cull_data, idata)) #define VIS_CHECK (visibility_check < 0 ? (visibility_check = (visibility_flags != InstanceData::FLAG_VISIBILITY_DEPENDENCY_NEEDS_CHECK || (VIS_RANGE_CHECK && VIS_PARENT_CHECK))) : visibility_check) #define OCCLUSION_CULLED (cull_data.occlusion_buffer != nullptr && (cull_data.scenario->instance_data[i].flags & InstanceData::FLAG_IGNORE_OCCLUSION_CULLING) == 0 && cull_data.occlusion_buffer->is_occluded(cull_data.scenario->instance_aabbs[i].bounds, cull_data.cam_transform.origin, inv_cam_transform, *cull_data.camera_matrix, z_near)) if (!HIDDEN_BY_VISIBILITY_CHECKS) { if ((LAYER_CHECK && IN_FRUSTUM(cull_data.cull->frustum) && VIS_CHECK && !OCCLUSION_CULLED) || (cull_data.scenario->instance_data[i].flags & InstanceData::FLAG_IGNORE_ALL_CULLING)) { uint32_t base_type = idata.flags & InstanceData::FLAG_BASE_TYPE_MASK; if (base_type == RS::INSTANCE_LIGHT) { cull_result.lights.push_back(idata.instance); cull_result.light_instances.push_back(RID::from_uint64(idata.instance_data_rid)); if (cull_data.shadow_atlas.is_valid() && RSG::storage->light_has_shadow(idata.base_rid)) { scene_render->light_instance_mark_visible(RID::from_uint64(idata.instance_data_rid)); //mark it visible for shadow allocation later } } else if (base_type == RS::INSTANCE_REFLECTION_PROBE) { if (cull_data.render_reflection_probe != idata.instance) { //avoid entering The Matrix if ((idata.flags & InstanceData::FLAG_REFLECTION_PROBE_DIRTY) || scene_render->reflection_probe_instance_needs_redraw(RID::from_uint64(idata.instance_data_rid))) { InstanceReflectionProbeData *reflection_probe = static_cast(idata.instance->base_data); cull_data.cull->lock.lock(); if (!reflection_probe->update_list.in_list()) { reflection_probe->render_step = 0; reflection_probe_render_list.add_last(&reflection_probe->update_list); } cull_data.cull->lock.unlock(); idata.flags &= ~uint32_t(InstanceData::FLAG_REFLECTION_PROBE_DIRTY); } if (scene_render->reflection_probe_instance_has_reflection(RID::from_uint64(idata.instance_data_rid))) { cull_result.reflections.push_back(RID::from_uint64(idata.instance_data_rid)); } } } else if (base_type == RS::INSTANCE_DECAL) { cull_result.decals.push_back(RID::from_uint64(idata.instance_data_rid)); } else if (base_type == RS::INSTANCE_VOXEL_GI) { InstanceVoxelGIData *voxel_gi = static_cast(idata.instance->base_data); cull_data.cull->lock.lock(); if (!voxel_gi->update_element.in_list()) { voxel_gi_update_list.add(&voxel_gi->update_element); } cull_data.cull->lock.unlock(); cull_result.voxel_gi_instances.push_back(RID::from_uint64(idata.instance_data_rid)); } else if (base_type == RS::INSTANCE_LIGHTMAP) { cull_result.lightmaps.push_back(RID::from_uint64(idata.instance_data_rid)); } else if (base_type == RS::INSTANCE_FOG_VOLUME) { cull_result.fog_volumes.push_back(RID::from_uint64(idata.instance_data_rid)); } else if (base_type == RS::INSTANCE_VISIBLITY_NOTIFIER) { InstanceVisibilityNotifierData *vnd = idata.visibility_notifier; if (!vnd->list_element.in_list()) { visible_notifier_list_lock.lock(); visible_notifier_list.add(&vnd->list_element); visible_notifier_list_lock.unlock(); vnd->just_visible = true; } vnd->visible_in_frame = RSG::rasterizer->get_frame_number(); } else if (((1 << base_type) & RS::INSTANCE_GEOMETRY_MASK) && !(idata.flags & InstanceData::FLAG_CAST_SHADOWS_ONLY)) { bool keep = true; if (idata.flags & InstanceData::FLAG_REDRAW_IF_VISIBLE) { RenderingServerDefault::redraw_request(); } if (base_type == RS::INSTANCE_MESH) { mesh_visible = true; } else if (base_type == RS::INSTANCE_PARTICLES) { //particles visible? process them if (RSG::storage->particles_is_inactive(idata.base_rid)) { //but if nothing is going on, don't do it. keep = false; } else { cull_data.cull->lock.lock(); RSG::storage->particles_request_process(idata.base_rid); cull_data.cull->lock.unlock(); RSG::storage->particles_set_view_axis(idata.base_rid, -cull_data.cam_transform.basis.get_axis(2).normalized(), cull_data.cam_transform.basis.get_axis(1).normalized()); //particles visible? request redraw RenderingServerDefault::redraw_request(); } } if (idata.parent_array_index != -1) { float fade = 1.0f; const uint32_t &parent_flags = cull_data.scenario->instance_data[idata.parent_array_index].flags; if (parent_flags & InstanceData::FLAG_VISIBILITY_DEPENDENCY_FADE_CHILDREN) { const int32_t &parent_idx = cull_data.scenario->instance_data[idata.parent_array_index].visibility_index; fade = cull_data.scenario->instance_visibility[parent_idx].children_fade_alpha; } scene_render->geometry_instance_set_parent_fade_alpha(idata.instance_geometry, fade); } if (geometry_instance_pair_mask & (1 << RS::INSTANCE_LIGHT) && (idata.flags & InstanceData::FLAG_GEOM_LIGHTING_DIRTY)) { InstanceGeometryData *geom = static_cast(idata.instance->base_data); uint32_t idx = 0; for (Set::Element *E = geom->lights.front(); E; E = E->next()) { InstanceLightData *light = static_cast(E->get()->base_data); instance_pair_buffer[idx++] = light->instance; if (idx == MAX_INSTANCE_PAIRS) { break; } } scene_render->geometry_instance_pair_light_instances(geom->geometry_instance, instance_pair_buffer, idx); idata.flags &= ~uint32_t(InstanceData::FLAG_GEOM_LIGHTING_DIRTY); } if (idata.flags & InstanceData::FLAG_GEOM_PROJECTOR_SOFTSHADOW_DIRTY) { InstanceGeometryData *geom = static_cast(idata.instance->base_data); scene_render->geometry_instance_set_softshadow_projector_pairing(geom->geometry_instance, geom->softshadow_count > 0, geom->projector_count > 0); idata.flags &= ~uint32_t(InstanceData::FLAG_GEOM_PROJECTOR_SOFTSHADOW_DIRTY); } if (geometry_instance_pair_mask & (1 << RS::INSTANCE_REFLECTION_PROBE) && (idata.flags & InstanceData::FLAG_GEOM_REFLECTION_DIRTY)) { InstanceGeometryData *geom = static_cast(idata.instance->base_data); uint32_t idx = 0; for (Set::Element *E = geom->reflection_probes.front(); E; E = E->next()) { InstanceReflectionProbeData *reflection_probe = static_cast(E->get()->base_data); instance_pair_buffer[idx++] = reflection_probe->instance; if (idx == MAX_INSTANCE_PAIRS) { break; } } scene_render->geometry_instance_pair_reflection_probe_instances(geom->geometry_instance, instance_pair_buffer, idx); idata.flags &= ~uint32_t(InstanceData::FLAG_GEOM_REFLECTION_DIRTY); } if (geometry_instance_pair_mask & (1 << RS::INSTANCE_DECAL) && (idata.flags & InstanceData::FLAG_GEOM_DECAL_DIRTY)) { InstanceGeometryData *geom = static_cast(idata.instance->base_data); uint32_t idx = 0; for (Set::Element *E = geom->decals.front(); E; E = E->next()) { InstanceDecalData *decal = static_cast(E->get()->base_data); instance_pair_buffer[idx++] = decal->instance; if (idx == MAX_INSTANCE_PAIRS) { break; } } scene_render->geometry_instance_pair_decal_instances(geom->geometry_instance, instance_pair_buffer, idx); idata.flags &= ~uint32_t(InstanceData::FLAG_GEOM_DECAL_DIRTY); } if (idata.flags & InstanceData::FLAG_GEOM_VOXEL_GI_DIRTY) { InstanceGeometryData *geom = static_cast(idata.instance->base_data); uint32_t idx = 0; for (Set::Element *E = geom->voxel_gi_instances.front(); E; E = E->next()) { InstanceVoxelGIData *voxel_gi = static_cast(E->get()->base_data); instance_pair_buffer[idx++] = voxel_gi->probe_instance; if (idx == MAX_INSTANCE_PAIRS) { break; } } scene_render->geometry_instance_pair_voxel_gi_instances(geom->geometry_instance, instance_pair_buffer, idx); idata.flags &= ~uint32_t(InstanceData::FLAG_GEOM_VOXEL_GI_DIRTY); } if ((idata.flags & InstanceData::FLAG_LIGHTMAP_CAPTURE) && idata.instance->last_frame_pass != frame_number && !idata.instance->lightmap_target_sh.is_empty() && !idata.instance->lightmap_sh.is_empty()) { InstanceGeometryData *geom = static_cast(idata.instance->base_data); Color *sh = idata.instance->lightmap_sh.ptrw(); const Color *target_sh = idata.instance->lightmap_target_sh.ptr(); for (uint32_t j = 0; j < 9; j++) { sh[j] = sh[j].lerp(target_sh[j], MIN(1.0, lightmap_probe_update_speed)); } scene_render->geometry_instance_set_lightmap_capture(geom->geometry_instance, sh); idata.instance->last_frame_pass = frame_number; } if (keep) { cull_result.geometry_instances.push_back(idata.instance_geometry); } } } for (uint32_t j = 0; j < cull_data.cull->shadow_count; j++) { for (uint32_t k = 0; k < cull_data.cull->shadows[j].cascade_count; k++) { if (IN_FRUSTUM(cull_data.cull->shadows[j].cascades[k].frustum) && VIS_CHECK) { uint32_t base_type = idata.flags & InstanceData::FLAG_BASE_TYPE_MASK; if (((1 << base_type) & RS::INSTANCE_GEOMETRY_MASK) && idata.flags & InstanceData::FLAG_CAST_SHADOWS) { cull_result.directional_shadows[j].cascade_geometry_instances[k].push_back(idata.instance_geometry); mesh_visible = true; } } } } } #undef HIDDEN_BY_VISIBILITY_CHECKS #undef LAYER_CHECK #undef IN_FRUSTUM #undef VIS_RANGE_CHECK #undef VIS_PARENT_CHECK #undef VIS_CHECK #undef OCCLUSION_CULLED for (uint32_t j = 0; j < cull_data.cull->sdfgi.region_count; j++) { if (cull_data.scenario->instance_aabbs[i].in_aabb(cull_data.cull->sdfgi.region_aabb[j])) { uint32_t base_type = idata.flags & InstanceData::FLAG_BASE_TYPE_MASK; if (base_type == RS::INSTANCE_LIGHT) { InstanceLightData *instance_light = (InstanceLightData *)idata.instance->base_data; if (instance_light->bake_mode == RS::LIGHT_BAKE_STATIC && cull_data.cull->sdfgi.region_cascade[j] <= instance_light->max_sdfgi_cascade) { if (sdfgi_last_light_index != i || sdfgi_last_light_cascade != cull_data.cull->sdfgi.region_cascade[j]) { sdfgi_last_light_index = i; sdfgi_last_light_cascade = cull_data.cull->sdfgi.region_cascade[j]; cull_result.sdfgi_cascade_lights[sdfgi_last_light_cascade].push_back(instance_light->instance); } } } else if ((1 << base_type) & RS::INSTANCE_GEOMETRY_MASK) { if (idata.flags & InstanceData::FLAG_USES_BAKED_LIGHT) { cull_result.sdfgi_region_geometry_instances[j].push_back(idata.instance_geometry); mesh_visible = true; } } } } if (mesh_visible && cull_data.scenario->instance_data[i].flags & InstanceData::FLAG_USES_MESH_INSTANCE) { cull_result.mesh_instances.push_back(cull_data.scenario->instance_data[i].instance->mesh_instance); } } } void RendererSceneCull::_render_scene(const RendererSceneRender::CameraData *p_camera_data, RID p_render_buffers, RID p_environment, RID p_force_camera_effects, 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_lod_threshold, bool p_using_shadows, RendererScene::RenderInfo *r_render_info) { Instance *render_reflection_probe = instance_owner.get_or_null(p_reflection_probe); //if null, not rendering to it Scenario *scenario = scenario_owner.get_or_null(p_scenario); render_pass++; scene_render->set_scene_pass(render_pass); if (p_render_buffers.is_valid()) { //no rendering code here, this is only to set up what needs to be done, request regions, etc. scene_render->sdfgi_update(p_render_buffers, p_environment, p_camera_data->main_transform.origin); //update conditions for SDFGI (whether its used or not) } RENDER_TIMESTAMP("Visibility Dependencies"); if (scenario->instance_visibility.get_bin_count() > 0) { if (!scenario->viewport_visibility_masks.has(p_viewport)) { scenario_add_viewport_visibility_mask(scenario->self, p_viewport); } VisibilityCullData visibility_cull_data; visibility_cull_data.scenario = scenario; visibility_cull_data.viewport_mask = scenario->viewport_visibility_masks[p_viewport]; visibility_cull_data.camera_position = p_camera_data->main_transform.origin; for (int i = scenario->instance_visibility.get_bin_count() - 1; i > 0; i--) { // We skip bin 0 visibility_cull_data.cull_offset = scenario->instance_visibility.get_bin_start(i); visibility_cull_data.cull_count = scenario->instance_visibility.get_bin_size(i); if (visibility_cull_data.cull_count == 0) { continue; } if (visibility_cull_data.cull_count > thread_cull_threshold) { RendererThreadPool::singleton->thread_work_pool.do_work(RendererThreadPool::singleton->thread_work_pool.get_thread_count(), this, &RendererSceneCull::_visibility_cull_threaded, &visibility_cull_data); } else { _visibility_cull(visibility_cull_data, visibility_cull_data.cull_offset, visibility_cull_data.cull_offset + visibility_cull_data.cull_count); } } } RENDER_TIMESTAMP("Culling"); //rasterizer->set_camera(p_camera_data->main_transform, p_camera_data.main_projection, p_camera_data.is_ortogonal); /* STEP 2 - CULL */ Vector planes = p_camera_data->main_projection.get_projection_planes(p_camera_data->main_transform); cull.frustum = Frustum(planes); Vector directional_lights; // directional lights { cull.shadow_count = 0; Vector lights_with_shadow; for (Instance *E : scenario->directional_lights) { if (!E->visible) { continue; } if (directional_lights.size() > RendererSceneRender::MAX_DIRECTIONAL_LIGHTS) { break; } InstanceLightData *light = static_cast(E->base_data); //check shadow.. if (light) { if (p_using_shadows && p_shadow_atlas.is_valid() && RSG::storage->light_has_shadow(E->base) && !(RSG::storage->light_get_type(E->base) == RS::LIGHT_DIRECTIONAL && RSG::storage->light_directional_is_sky_only(E->base))) { lights_with_shadow.push_back(E); } //add to list directional_lights.push_back(light->instance); } } scene_render->set_directional_shadow_count(lights_with_shadow.size()); for (int i = 0; i < lights_with_shadow.size(); i++) { _light_instance_setup_directional_shadow(i, lights_with_shadow[i], p_camera_data->main_transform, p_camera_data->main_projection, p_camera_data->is_ortogonal, p_camera_data->vaspect); } } { //sdfgi cull.sdfgi.region_count = 0; if (p_render_buffers.is_valid()) { cull.sdfgi.cascade_light_count = 0; uint32_t prev_cascade = 0xFFFFFFFF; uint32_t pending_region_count = scene_render->sdfgi_get_pending_region_count(p_render_buffers); for (uint32_t i = 0; i < pending_region_count; i++) { cull.sdfgi.region_aabb[i] = scene_render->sdfgi_get_pending_region_bounds(p_render_buffers, i); uint32_t region_cascade = scene_render->sdfgi_get_pending_region_cascade(p_render_buffers, i); cull.sdfgi.region_cascade[i] = region_cascade; if (region_cascade != prev_cascade) { cull.sdfgi.cascade_light_index[cull.sdfgi.cascade_light_count] = region_cascade; cull.sdfgi.cascade_light_count++; prev_cascade = region_cascade; } } cull.sdfgi.region_count = pending_region_count; } } scene_cull_result.clear(); { uint64_t cull_from = 0; uint64_t cull_to = scenario->instance_data.size(); CullData cull_data; //prepare for eventual thread usage cull_data.cull = &cull; cull_data.scenario = scenario; cull_data.shadow_atlas = p_shadow_atlas; cull_data.cam_transform = p_camera_data->main_transform; cull_data.visible_layers = p_visible_layers; cull_data.render_reflection_probe = render_reflection_probe; cull_data.occlusion_buffer = RendererSceneOcclusionCull::get_singleton()->buffer_get_ptr(p_viewport); cull_data.camera_matrix = &p_camera_data->main_projection; cull_data.visibility_viewport_mask = scenario->viewport_visibility_masks.has(p_viewport) ? scenario->viewport_visibility_masks[p_viewport] : 0; //#define DEBUG_CULL_TIME #ifdef DEBUG_CULL_TIME uint64_t time_from = OS::get_singleton()->get_ticks_usec(); #endif if (cull_to > thread_cull_threshold) { //multiple threads for (uint32_t i = 0; i < scene_cull_result_threads.size(); i++) { scene_cull_result_threads[i].clear(); } RendererThreadPool::singleton->thread_work_pool.do_work(scene_cull_result_threads.size(), this, &RendererSceneCull::_scene_cull_threaded, &cull_data); for (uint32_t i = 0; i < scene_cull_result_threads.size(); i++) { scene_cull_result.append_from(scene_cull_result_threads[i]); } } else { //single threaded _scene_cull(cull_data, scene_cull_result, cull_from, cull_to); } #ifdef DEBUG_CULL_TIME static float time_avg = 0; static uint32_t time_count = 0; time_avg += double(OS::get_singleton()->get_ticks_usec() - time_from) / 1000.0; time_count++; print_line("time taken: " + rtos(time_avg / time_count)); #endif if (scene_cull_result.mesh_instances.size()) { for (uint64_t i = 0; i < scene_cull_result.mesh_instances.size(); i++) { RSG::storage->mesh_instance_check_for_update(scene_cull_result.mesh_instances[i]); } RSG::storage->update_mesh_instances(); } } //render shadows max_shadows_used = 0; if (p_using_shadows) { //setup shadow maps // Directional Shadows for (uint32_t i = 0; i < cull.shadow_count; i++) { for (uint32_t j = 0; j < cull.shadows[i].cascade_count; j++) { const Cull::Shadow::Cascade &c = cull.shadows[i].cascades[j]; // print_line("shadow " + itos(i) + " cascade " + itos(j) + " elements: " + itos(c.cull_result.size())); scene_render->light_instance_set_shadow_transform(cull.shadows[i].light_instance, c.projection, c.transform, c.zfar, c.split, j, c.shadow_texel_size, c.bias_scale, c.range_begin, c.uv_scale); if (max_shadows_used == MAX_UPDATE_SHADOWS) { continue; } render_shadow_data[max_shadows_used].light = cull.shadows[i].light_instance; render_shadow_data[max_shadows_used].pass = j; render_shadow_data[max_shadows_used].instances.merge_unordered(scene_cull_result.directional_shadows[i].cascade_geometry_instances[j]); max_shadows_used++; } } // Positional Shadowss for (uint32_t i = 0; i < (uint32_t)scene_cull_result.lights.size(); i++) { Instance *ins = scene_cull_result.lights[i]; if (!p_shadow_atlas.is_valid() || !RSG::storage->light_has_shadow(ins->base)) { continue; } InstanceLightData *light = static_cast(ins->base_data); float coverage = 0.f; { //compute coverage Transform3D cam_xf = p_camera_data->main_transform; float zn = p_camera_data->main_projection.get_z_near(); Plane p(-cam_xf.basis.get_axis(2), cam_xf.origin + cam_xf.basis.get_axis(2) * -zn); //camera near plane // near plane half width and height Vector2 vp_half_extents = p_camera_data->main_projection.get_viewport_half_extents(); switch (RSG::storage->light_get_type(ins->base)) { case RS::LIGHT_OMNI: { float radius = RSG::storage->light_get_param(ins->base, RS::LIGHT_PARAM_RANGE); //get two points parallel to near plane Vector3 points[2] = { ins->transform.origin, ins->transform.origin + cam_xf.basis.get_axis(0) * radius }; if (!p_camera_data->is_ortogonal) { //if using perspetive, map them to near plane for (int j = 0; j < 2; j++) { if (p.distance_to(points[j]) < 0) { points[j].z = -zn; //small hack to keep size constant when hitting the screen } p.intersects_segment(cam_xf.origin, points[j], &points[j]); //map to plane } } float screen_diameter = points[0].distance_to(points[1]) * 2; coverage = screen_diameter / (vp_half_extents.x + vp_half_extents.y); } break; case RS::LIGHT_SPOT: { float radius = RSG::storage->light_get_param(ins->base, RS::LIGHT_PARAM_RANGE); float angle = RSG::storage->light_get_param(ins->base, RS::LIGHT_PARAM_SPOT_ANGLE); float w = radius * Math::sin(Math::deg2rad(angle)); float d = radius * Math::cos(Math::deg2rad(angle)); Vector3 base = ins->transform.origin - ins->transform.basis.get_axis(2).normalized() * d; Vector3 points[2] = { base, base + cam_xf.basis.get_axis(0) * w }; if (!p_camera_data->is_ortogonal) { //if using perspetive, map them to near plane for (int j = 0; j < 2; j++) { if (p.distance_to(points[j]) < 0) { points[j].z = -zn; //small hack to keep size constant when hitting the screen } p.intersects_segment(cam_xf.origin, points[j], &points[j]); //map to plane } } float screen_diameter = points[0].distance_to(points[1]) * 2; coverage = screen_diameter / (vp_half_extents.x + vp_half_extents.y); } break; default: { ERR_PRINT("Invalid Light Type"); } } } if (light->shadow_dirty) { light->last_version++; light->shadow_dirty = false; } bool redraw = scene_render->shadow_atlas_update_light(p_shadow_atlas, light->instance, coverage, light->last_version); if (redraw && max_shadows_used < MAX_UPDATE_SHADOWS) { //must redraw! RENDER_TIMESTAMP(">Rendering Light " + itos(i)); light->shadow_dirty = _light_instance_update_shadow(ins, p_camera_data->main_transform, p_camera_data->main_projection, p_camera_data->is_ortogonal, p_camera_data->vaspect, p_shadow_atlas, scenario, p_screen_lod_threshold); RENDER_TIMESTAMP("shadow_dirty = redraw; } } } //render SDFGI { sdfgi_update_data.update_static = false; if (cull.sdfgi.region_count > 0) { //update regions for (uint32_t i = 0; i < cull.sdfgi.region_count; i++) { render_sdfgi_data[i].instances.merge_unordered(scene_cull_result.sdfgi_region_geometry_instances[i]); render_sdfgi_data[i].region = i; } //check if static lights were culled bool static_lights_culled = false; for (uint32_t i = 0; i < cull.sdfgi.cascade_light_count; i++) { if (scene_cull_result.sdfgi_cascade_lights[i].size()) { static_lights_culled = true; break; } } if (static_lights_culled) { sdfgi_update_data.static_cascade_count = cull.sdfgi.cascade_light_count; sdfgi_update_data.static_cascade_indices = cull.sdfgi.cascade_light_index; sdfgi_update_data.static_positional_lights = scene_cull_result.sdfgi_cascade_lights; sdfgi_update_data.update_static = true; } } if (p_render_buffers.is_valid()) { sdfgi_update_data.directional_lights = &directional_lights; sdfgi_update_data.positional_light_instances = scenario->dynamic_lights.ptr(); sdfgi_update_data.positional_light_count = scenario->dynamic_lights.size(); } } //append the directional lights to the lights culled for (int i = 0; i < directional_lights.size(); i++) { scene_cull_result.light_instances.push_back(directional_lights[i]); } RID camera_effects; if (p_force_camera_effects.is_valid()) { camera_effects = p_force_camera_effects; } else { camera_effects = scenario->camera_effects; } /* PROCESS GEOMETRY AND DRAW SCENE */ RID occluders_tex; if (p_viewport.is_valid()) { occluders_tex = RSG::viewport->viewport_get_occluder_debug_texture(p_viewport); } RENDER_TIMESTAMP("Render Scene "); scene_render->render_scene(p_render_buffers, p_camera_data, scene_cull_result.geometry_instances, scene_cull_result.light_instances, scene_cull_result.reflections, scene_cull_result.voxel_gi_instances, scene_cull_result.decals, scene_cull_result.lightmaps, scene_cull_result.fog_volumes, p_environment, camera_effects, p_shadow_atlas, occluders_tex, p_reflection_probe.is_valid() ? RID() : scenario->reflection_atlas, p_reflection_probe, p_reflection_probe_pass, p_screen_lod_threshold, render_shadow_data, max_shadows_used, render_sdfgi_data, cull.sdfgi.region_count, &sdfgi_update_data, r_render_info); for (uint32_t i = 0; i < max_shadows_used; i++) { render_shadow_data[i].instances.clear(); } max_shadows_used = 0; for (uint32_t i = 0; i < cull.sdfgi.region_count; i++) { render_sdfgi_data[i].instances.clear(); } // virtual void render_scene(RID p_render_buffers, const Transform3D &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, const PagedArray &p_instances, const PagedArray &p_lights, const PagedArray &p_reflection_probes, const PagedArray &p_voxel_gi_instances, const PagedArray &p_decals, const PagedArray &p_lightmaps, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_lod_threshold,const RenderShadowData *p_render_shadows,int p_render_shadow_count,const RenderSDFGIData *p_render_sdfgi_regions,int p_render_sdfgi_region_count,const RenderSDFGIStaticLightData *p_render_sdfgi_static_lights=nullptr) = 0; } RID RendererSceneCull::_render_get_environment(RID p_camera, RID p_scenario) { Camera *camera = camera_owner.get_or_null(p_camera); if (camera && scene_render->is_environment(camera->env)) { return camera->env; } Scenario *scenario = scenario_owner.get_or_null(p_scenario); if (!scenario) { return RID(); } if (scene_render->is_environment(scenario->environment)) { return scenario->environment; } if (scene_render->is_environment(scenario->fallback_environment)) { return scenario->fallback_environment; } return RID(); } void RendererSceneCull::render_empty_scene(RID p_render_buffers, RID p_scenario, RID p_shadow_atlas) { #ifndef _3D_DISABLED Scenario *scenario = scenario_owner.get_or_null(p_scenario); RID environment; if (scenario->environment.is_valid()) { environment = scenario->environment; } else { environment = scenario->fallback_environment; } RENDER_TIMESTAMP("Render Empty Scene "); RendererSceneRender::CameraData camera_data; camera_data.set_camera(Transform3D(), CameraMatrix(), true, false); scene_render->render_scene(p_render_buffers, &camera_data, PagedArray(), PagedArray(), PagedArray(), PagedArray(), PagedArray(), PagedArray(), PagedArray(), RID(), RID(), p_shadow_atlas, RID(), scenario->reflection_atlas, RID(), 0, 0, nullptr, 0, nullptr, 0, nullptr); #endif } bool RendererSceneCull::_render_reflection_probe_step(Instance *p_instance, int p_step) { InstanceReflectionProbeData *reflection_probe = static_cast(p_instance->base_data); Scenario *scenario = p_instance->scenario; ERR_FAIL_COND_V(!scenario, true); RenderingServerDefault::redraw_request(); //update, so it updates in editor if (p_step == 0) { if (!scene_render->reflection_probe_instance_begin_render(reflection_probe->instance, scenario->reflection_atlas)) { return true; //all full } } if (p_step >= 0 && p_step < 6) { static const Vector3 view_normals[6] = { Vector3(+1, 0, 0), Vector3(-1, 0, 0), Vector3(0, +1, 0), Vector3(0, -1, 0), Vector3(0, 0, +1), Vector3(0, 0, -1) }; static const Vector3 view_up[6] = { Vector3(0, -1, 0), Vector3(0, -1, 0), Vector3(0, 0, +1), Vector3(0, 0, -1), Vector3(0, -1, 0), Vector3(0, -1, 0) }; Vector3 extents = RSG::storage->reflection_probe_get_extents(p_instance->base); Vector3 origin_offset = RSG::storage->reflection_probe_get_origin_offset(p_instance->base); float max_distance = RSG::storage->reflection_probe_get_origin_max_distance(p_instance->base); float size = scene_render->reflection_atlas_get_size(scenario->reflection_atlas); float lod_threshold = RSG::storage->reflection_probe_get_lod_threshold(p_instance->base) / size; Vector3 edge = view_normals[p_step] * extents; float distance = ABS(view_normals[p_step].dot(edge) - view_normals[p_step].dot(origin_offset)); //distance from origin offset to actual view distance limit max_distance = MAX(max_distance, distance); //render cubemap side CameraMatrix cm; cm.set_perspective(90, 1, 0.01, max_distance); Transform3D local_view; local_view.set_look_at(origin_offset, origin_offset + view_normals[p_step], view_up[p_step]); Transform3D xform = p_instance->transform * local_view; RID shadow_atlas; bool use_shadows = RSG::storage->reflection_probe_renders_shadows(p_instance->base); if (use_shadows) { shadow_atlas = scenario->reflection_probe_shadow_atlas; } RID environment; if (scenario->environment.is_valid()) { environment = scenario->environment; } else { environment = scenario->fallback_environment; } RENDER_TIMESTAMP("Render Reflection Probe, Step " + itos(p_step)); RendererSceneRender::CameraData camera_data; camera_data.set_camera(xform, cm, false, false); _render_scene(&camera_data, RID(), environment, RID(), RSG::storage->reflection_probe_get_cull_mask(p_instance->base), p_instance->scenario->self, RID(), shadow_atlas, reflection_probe->instance, p_step, lod_threshold, use_shadows); } else { //do roughness postprocess step until it believes it's done RENDER_TIMESTAMP("Post-Process Reflection Probe, Step " + itos(p_step)); return scene_render->reflection_probe_instance_postprocess_step(reflection_probe->instance); } return false; } void RendererSceneCull::render_probes() { /* REFLECTION PROBES */ SelfList *ref_probe = reflection_probe_render_list.first(); bool busy = false; while (ref_probe) { SelfList *next = ref_probe->next(); RID base = ref_probe->self()->owner->base; switch (RSG::storage->reflection_probe_get_update_mode(base)) { case RS::REFLECTION_PROBE_UPDATE_ONCE: { if (busy) { //already rendering something break; } bool done = _render_reflection_probe_step(ref_probe->self()->owner, ref_probe->self()->render_step); if (done) { reflection_probe_render_list.remove(ref_probe); } else { ref_probe->self()->render_step++; } busy = true; //do not render another one of this kind } break; case RS::REFLECTION_PROBE_UPDATE_ALWAYS: { int step = 0; bool done = false; while (!done) { done = _render_reflection_probe_step(ref_probe->self()->owner, step); step++; } reflection_probe_render_list.remove(ref_probe); } break; } ref_probe = next; } /* VOXEL GIS */ SelfList *voxel_gi = voxel_gi_update_list.first(); if (voxel_gi) { RENDER_TIMESTAMP("Render GI Probes"); } while (voxel_gi) { SelfList *next = voxel_gi->next(); InstanceVoxelGIData *probe = voxel_gi->self(); //Instance *instance_probe = probe->owner; //check if probe must be setup, but don't do if on the lighting thread bool cache_dirty = false; int cache_count = 0; { int light_cache_size = probe->light_cache.size(); const InstanceVoxelGIData::LightCache *caches = probe->light_cache.ptr(); const RID *instance_caches = probe->light_instances.ptr(); int idx = 0; //must count visible lights for (Set::Element *E = probe->lights.front(); E; E = E->next()) { Instance *instance = E->get(); InstanceLightData *instance_light = (InstanceLightData *)instance->base_data; if (!instance->visible) { continue; } if (cache_dirty) { //do nothing, since idx must count all visible lights anyway } else if (idx >= light_cache_size) { cache_dirty = true; } else { const InstanceVoxelGIData::LightCache *cache = &caches[idx]; if ( instance_caches[idx] != instance_light->instance || cache->has_shadow != RSG::storage->light_has_shadow(instance->base) || cache->type != RSG::storage->light_get_type(instance->base) || cache->transform != instance->transform || cache->color != RSG::storage->light_get_color(instance->base) || cache->energy != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ENERGY) || cache->bake_energy != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_INDIRECT_ENERGY) || cache->radius != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_RANGE) || cache->attenuation != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ATTENUATION) || cache->spot_angle != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ANGLE) || cache->spot_attenuation != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ATTENUATION)) { cache_dirty = true; } } idx++; } for (const Instance *instance : probe->owner->scenario->directional_lights) { InstanceLightData *instance_light = (InstanceLightData *)instance->base_data; if (!instance->visible) { continue; } if (cache_dirty) { //do nothing, since idx must count all visible lights anyway } else if (idx >= light_cache_size) { cache_dirty = true; } else { const InstanceVoxelGIData::LightCache *cache = &caches[idx]; if ( instance_caches[idx] != instance_light->instance || cache->has_shadow != RSG::storage->light_has_shadow(instance->base) || cache->type != RSG::storage->light_get_type(instance->base) || cache->transform != instance->transform || cache->color != RSG::storage->light_get_color(instance->base) || cache->energy != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ENERGY) || cache->bake_energy != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_INDIRECT_ENERGY) || cache->radius != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_RANGE) || cache->attenuation != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ATTENUATION) || cache->spot_angle != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ANGLE) || cache->spot_attenuation != RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ATTENUATION) || cache->sky_only != RSG::storage->light_directional_is_sky_only(instance->base)) { cache_dirty = true; } } idx++; } if (idx != light_cache_size) { cache_dirty = true; } cache_count = idx; } bool update_lights = scene_render->voxel_gi_needs_update(probe->probe_instance); if (cache_dirty) { probe->light_cache.resize(cache_count); probe->light_instances.resize(cache_count); if (cache_count) { InstanceVoxelGIData::LightCache *caches = probe->light_cache.ptrw(); RID *instance_caches = probe->light_instances.ptrw(); int idx = 0; //must count visible lights for (Set::Element *E = probe->lights.front(); E; E = E->next()) { Instance *instance = E->get(); InstanceLightData *instance_light = (InstanceLightData *)instance->base_data; if (!instance->visible) { continue; } InstanceVoxelGIData::LightCache *cache = &caches[idx]; instance_caches[idx] = instance_light->instance; cache->has_shadow = RSG::storage->light_has_shadow(instance->base); cache->type = RSG::storage->light_get_type(instance->base); cache->transform = instance->transform; cache->color = RSG::storage->light_get_color(instance->base); cache->energy = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ENERGY); cache->bake_energy = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_INDIRECT_ENERGY); cache->radius = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_RANGE); cache->attenuation = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ATTENUATION); cache->spot_angle = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ANGLE); cache->spot_attenuation = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ATTENUATION); idx++; } for (const Instance *instance : probe->owner->scenario->directional_lights) { InstanceLightData *instance_light = (InstanceLightData *)instance->base_data; if (!instance->visible) { continue; } InstanceVoxelGIData::LightCache *cache = &caches[idx]; instance_caches[idx] = instance_light->instance; cache->has_shadow = RSG::storage->light_has_shadow(instance->base); cache->type = RSG::storage->light_get_type(instance->base); cache->transform = instance->transform; cache->color = RSG::storage->light_get_color(instance->base); cache->energy = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ENERGY); cache->bake_energy = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_INDIRECT_ENERGY); cache->radius = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_RANGE); cache->attenuation = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_ATTENUATION); cache->spot_angle = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ANGLE); cache->spot_attenuation = RSG::storage->light_get_param(instance->base, RS::LIGHT_PARAM_SPOT_ATTENUATION); cache->sky_only = RSG::storage->light_directional_is_sky_only(instance->base); idx++; } } update_lights = true; } scene_cull_result.geometry_instances.clear(); RID instance_pair_buffer[MAX_INSTANCE_PAIRS]; for (Set::Element *E = probe->dynamic_geometries.front(); E; E = E->next()) { Instance *ins = E->get(); if (!ins->visible) { continue; } InstanceGeometryData *geom = (InstanceGeometryData *)ins->base_data; if (ins->scenario && ins->array_index >= 0 && (ins->scenario->instance_data[ins->array_index].flags & InstanceData::FLAG_GEOM_VOXEL_GI_DIRTY)) { uint32_t idx = 0; for (Set::Element *F = geom->voxel_gi_instances.front(); F; F = F->next()) { InstanceVoxelGIData *voxel_gi2 = static_cast(F->get()->base_data); instance_pair_buffer[idx++] = voxel_gi2->probe_instance; if (idx == MAX_INSTANCE_PAIRS) { break; } } scene_render->geometry_instance_pair_voxel_gi_instances(geom->geometry_instance, instance_pair_buffer, idx); ins->scenario->instance_data[ins->array_index].flags &= ~uint32_t(InstanceData::FLAG_GEOM_VOXEL_GI_DIRTY); } scene_cull_result.geometry_instances.push_back(geom->geometry_instance); } scene_render->voxel_gi_update(probe->probe_instance, update_lights, probe->light_instances, scene_cull_result.geometry_instances); voxel_gi_update_list.remove(voxel_gi); voxel_gi = next; } } void RendererSceneCull::render_particle_colliders() { while (heightfield_particle_colliders_update_list.front()) { Instance *hfpc = heightfield_particle_colliders_update_list.front()->get(); if (hfpc->scenario && hfpc->base_type == RS::INSTANCE_PARTICLES_COLLISION && RSG::storage->particles_collision_is_heightfield(hfpc->base)) { //update heightfield instance_cull_result.clear(); scene_cull_result.geometry_instances.clear(); struct CullAABB { PagedArray *result; _FORCE_INLINE_ bool operator()(void *p_data) { Instance *p_instance = (Instance *)p_data; result->push_back(p_instance); return false; } }; CullAABB cull_aabb; cull_aabb.result = &instance_cull_result; hfpc->scenario->indexers[Scenario::INDEXER_GEOMETRY].aabb_query(hfpc->transformed_aabb, cull_aabb); hfpc->scenario->indexers[Scenario::INDEXER_VOLUMES].aabb_query(hfpc->transformed_aabb, cull_aabb); for (int i = 0; i < (int)instance_cull_result.size(); i++) { Instance *instance = instance_cull_result[i]; if (!instance || !((1 << instance->base_type) & (RS::INSTANCE_GEOMETRY_MASK & (~(1 << RS::INSTANCE_PARTICLES))))) { //all but particles to avoid self collision continue; } InstanceGeometryData *geom = static_cast(instance->base_data); scene_cull_result.geometry_instances.push_back(geom->geometry_instance); } scene_render->render_particle_collider_heightfield(hfpc->base, hfpc->transform, scene_cull_result.geometry_instances); } heightfield_particle_colliders_update_list.erase(heightfield_particle_colliders_update_list.front()); } } void RendererSceneCull::_update_instance_shader_parameters_from_material(Map &isparams, const Map &existing_isparams, RID p_material) { List plist; RSG::storage->material_get_instance_shader_parameters(p_material, &plist); for (const RendererStorage::InstanceShaderParam &E : plist) { StringName name = E.info.name; if (isparams.has(name)) { if (isparams[name].info.type != E.info.type) { WARN_PRINT("More than one material in instance export the same instance shader uniform '" + E.info.name + "', but they do it with different data types. Only the first one (in order) will display correctly."); } if (isparams[name].index != E.index) { WARN_PRINT("More than one material in instance export the same instance shader uniform '" + E.info.name + "', but they do it with different indices. Only the first one (in order) will display correctly."); } continue; //first one found always has priority } Instance::InstanceShaderParameter isp; isp.index = E.index; isp.info = E.info; isp.default_value = E.default_value; if (existing_isparams.has(name)) { isp.value = existing_isparams[name].value; } else { isp.value = E.default_value; } isparams[name] = isp; } } void RendererSceneCull::_update_dirty_instance(Instance *p_instance) { if (p_instance->update_aabb) { _update_instance_aabb(p_instance); } if (p_instance->update_dependencies) { p_instance->dependency_tracker.update_begin(); if (p_instance->base.is_valid()) { RSG::storage->base_update_dependency(p_instance->base, &p_instance->dependency_tracker); } if (p_instance->material_override.is_valid()) { RSG::storage->material_update_dependency(p_instance->material_override, &p_instance->dependency_tracker); } if (p_instance->base_type == RS::INSTANCE_MESH) { //remove materials no longer used and un-own them int new_mat_count = RSG::storage->mesh_get_surface_count(p_instance->base); p_instance->materials.resize(new_mat_count); _instance_update_mesh_instance(p_instance); } if ((1 << p_instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) { InstanceGeometryData *geom = static_cast(p_instance->base_data); bool can_cast_shadows = true; bool is_animated = false; Map isparams; if (p_instance->cast_shadows == RS::SHADOW_CASTING_SETTING_OFF) { can_cast_shadows = false; } if (p_instance->material_override.is_valid()) { if (!RSG::storage->material_casts_shadows(p_instance->material_override)) { can_cast_shadows = false; } is_animated = RSG::storage->material_is_animated(p_instance->material_override); _update_instance_shader_parameters_from_material(isparams, p_instance->instance_shader_parameters, p_instance->material_override); } else { if (p_instance->base_type == RS::INSTANCE_MESH) { RID mesh = p_instance->base; if (mesh.is_valid()) { bool cast_shadows = false; for (int i = 0; i < p_instance->materials.size(); i++) { RID mat = p_instance->materials[i].is_valid() ? p_instance->materials[i] : RSG::storage->mesh_surface_get_material(mesh, i); if (!mat.is_valid()) { cast_shadows = true; } else { if (RSG::storage->material_casts_shadows(mat)) { cast_shadows = true; } if (RSG::storage->material_is_animated(mat)) { is_animated = true; } _update_instance_shader_parameters_from_material(isparams, p_instance->instance_shader_parameters, mat); RSG::storage->material_update_dependency(mat, &p_instance->dependency_tracker); } } if (!cast_shadows) { can_cast_shadows = false; } } } else if (p_instance->base_type == RS::INSTANCE_MULTIMESH) { RID mesh = RSG::storage->multimesh_get_mesh(p_instance->base); if (mesh.is_valid()) { bool cast_shadows = false; int sc = RSG::storage->mesh_get_surface_count(mesh); for (int i = 0; i < sc; i++) { RID mat = RSG::storage->mesh_surface_get_material(mesh, i); if (!mat.is_valid()) { cast_shadows = true; } else { if (RSG::storage->material_casts_shadows(mat)) { cast_shadows = true; } if (RSG::storage->material_is_animated(mat)) { is_animated = true; } _update_instance_shader_parameters_from_material(isparams, p_instance->instance_shader_parameters, mat); RSG::storage->material_update_dependency(mat, &p_instance->dependency_tracker); } } if (!cast_shadows) { can_cast_shadows = false; } RSG::storage->base_update_dependency(mesh, &p_instance->dependency_tracker); } } else if (p_instance->base_type == RS::INSTANCE_PARTICLES) { bool cast_shadows = false; int dp = RSG::storage->particles_get_draw_passes(p_instance->base); for (int i = 0; i < dp; i++) { RID mesh = RSG::storage->particles_get_draw_pass_mesh(p_instance->base, i); if (!mesh.is_valid()) { continue; } int sc = RSG::storage->mesh_get_surface_count(mesh); for (int j = 0; j < sc; j++) { RID mat = RSG::storage->mesh_surface_get_material(mesh, j); if (!mat.is_valid()) { cast_shadows = true; } else { if (RSG::storage->material_casts_shadows(mat)) { cast_shadows = true; } if (RSG::storage->material_is_animated(mat)) { is_animated = true; } _update_instance_shader_parameters_from_material(isparams, p_instance->instance_shader_parameters, mat); RSG::storage->material_update_dependency(mat, &p_instance->dependency_tracker); } } } if (!cast_shadows) { can_cast_shadows = false; } } } if (can_cast_shadows != geom->can_cast_shadows) { //ability to cast shadows change, let lights now for (Set::Element *E = geom->lights.front(); E; E = E->next()) { InstanceLightData *light = static_cast(E->get()->base_data); light->shadow_dirty = true; } geom->can_cast_shadows = can_cast_shadows; } geom->material_is_animated = is_animated; p_instance->instance_shader_parameters = isparams; if (p_instance->instance_allocated_shader_parameters != (p_instance->instance_shader_parameters.size() > 0)) { p_instance->instance_allocated_shader_parameters = (p_instance->instance_shader_parameters.size() > 0); if (p_instance->instance_allocated_shader_parameters) { p_instance->instance_allocated_shader_parameters_offset = RSG::storage->global_variables_instance_allocate(p_instance->self); scene_render->geometry_instance_set_instance_shader_parameters_offset(geom->geometry_instance, p_instance->instance_allocated_shader_parameters_offset); for (const KeyValue &E : p_instance->instance_shader_parameters) { if (E.value.value.get_type() != Variant::NIL) { RSG::storage->global_variables_instance_update(p_instance->self, E.value.index, E.value.value); } } } else { RSG::storage->global_variables_instance_free(p_instance->self); p_instance->instance_allocated_shader_parameters_offset = -1; scene_render->geometry_instance_set_instance_shader_parameters_offset(geom->geometry_instance, -1); } } } if (p_instance->skeleton.is_valid()) { RSG::storage->skeleton_update_dependency(p_instance->skeleton, &p_instance->dependency_tracker); } p_instance->dependency_tracker.update_end(); if ((1 << p_instance->base_type) & RS::INSTANCE_GEOMETRY_MASK) { InstanceGeometryData *geom = static_cast(p_instance->base_data); scene_render->geometry_instance_set_surface_materials(geom->geometry_instance, p_instance->materials); } } _instance_update_list.remove(&p_instance->update_item); _update_instance(p_instance); p_instance->update_aabb = false; p_instance->update_dependencies = false; } void RendererSceneCull::update_dirty_instances() { RSG::storage->update_dirty_resources(); while (_instance_update_list.first()) { _update_dirty_instance(_instance_update_list.first()->self()); } } void RendererSceneCull::update() { //optimize bvhs for (uint32_t i = 0; i < scenario_owner.get_rid_count(); i++) { Scenario *s = scenario_owner.get_ptr_by_index(i); s->indexers[Scenario::INDEXER_GEOMETRY].optimize_incremental(indexer_update_iterations); s->indexers[Scenario::INDEXER_VOLUMES].optimize_incremental(indexer_update_iterations); } scene_render->update(); update_dirty_instances(); render_particle_colliders(); } bool RendererSceneCull::free(RID p_rid) { if (p_rid.is_null()) { return true; } if (scene_render->free(p_rid)) { return true; } if (camera_owner.owns(p_rid)) { camera_owner.free(p_rid); } else if (scenario_owner.owns(p_rid)) { Scenario *scenario = scenario_owner.get_or_null(p_rid); while (scenario->instances.first()) { instance_set_scenario(scenario->instances.first()->self()->self, RID()); } scenario->instance_aabbs.reset(); scenario->instance_data.reset(); scenario->instance_visibility.reset(); scene_render->free(scenario->reflection_probe_shadow_atlas); scene_render->free(scenario->reflection_atlas); scenario_owner.free(p_rid); RendererSceneOcclusionCull::get_singleton()->remove_scenario(p_rid); } else if (RendererSceneOcclusionCull::get_singleton()->is_occluder(p_rid)) { RendererSceneOcclusionCull::get_singleton()->free_occluder(p_rid); } else if (instance_owner.owns(p_rid)) { // delete the instance update_dirty_instances(); Instance *instance = instance_owner.get_or_null(p_rid); instance_geometry_set_lightmap(p_rid, RID(), Rect2(), 0); instance_set_scenario(p_rid, RID()); instance_set_base(p_rid, RID()); instance_geometry_set_material_override(p_rid, RID()); instance_attach_skeleton(p_rid, RID()); if (instance->instance_allocated_shader_parameters) { //free the used shader parameters RSG::storage->global_variables_instance_free(instance->self); } update_dirty_instances(); //in case something changed this instance_owner.free(p_rid); } else { return false; } return true; } TypedArray RendererSceneCull::bake_render_uv2(RID p_base, const Vector &p_material_overrides, const Size2i &p_image_size) { return scene_render->bake_render_uv2(p_base, p_material_overrides, p_image_size); } void RendererSceneCull::update_visibility_notifiers() { SelfList *E = visible_notifier_list.first(); while (E) { SelfList *N = E->next(); InstanceVisibilityNotifierData *visibility_notifier = E->self(); if (visibility_notifier->just_visible) { visibility_notifier->just_visible = false; RSG::storage->visibility_notifier_call(visibility_notifier->base, true, RSG::threaded); } else { if (visibility_notifier->visible_in_frame != RSG::rasterizer->get_frame_number()) { visible_notifier_list.remove(E); RSG::storage->visibility_notifier_call(visibility_notifier->base, false, RSG::threaded); } } E = N; } } /*******************************/ /* Passthrough to Scene Render */ /*******************************/ /* ENVIRONMENT API */ RendererSceneCull *RendererSceneCull::singleton = nullptr; void RendererSceneCull::set_scene_render(RendererSceneRender *p_scene_render) { scene_render = p_scene_render; geometry_instance_pair_mask = scene_render->geometry_instance_get_pair_mask(); } RendererSceneCull::RendererSceneCull() { render_pass = 1; singleton = this; instance_cull_result.set_page_pool(&instance_cull_page_pool); instance_shadow_cull_result.set_page_pool(&instance_cull_page_pool); for (uint32_t i = 0; i < MAX_UPDATE_SHADOWS; i++) { render_shadow_data[i].instances.set_page_pool(&geometry_instance_cull_page_pool); } for (uint32_t i = 0; i < SDFGI_MAX_CASCADES * SDFGI_MAX_REGIONS_PER_CASCADE; i++) { render_sdfgi_data[i].instances.set_page_pool(&geometry_instance_cull_page_pool); } scene_cull_result.init(&rid_cull_page_pool, &geometry_instance_cull_page_pool, &instance_cull_page_pool); scene_cull_result_threads.resize(RendererThreadPool::singleton->thread_work_pool.get_thread_count()); for (uint32_t i = 0; i < scene_cull_result_threads.size(); i++) { scene_cull_result_threads[i].init(&rid_cull_page_pool, &geometry_instance_cull_page_pool, &instance_cull_page_pool); } indexer_update_iterations = GLOBAL_GET("rendering/limits/spatial_indexer/update_iterations_per_frame"); thread_cull_threshold = GLOBAL_GET("rendering/limits/spatial_indexer/threaded_cull_minimum_instances"); thread_cull_threshold = MAX(thread_cull_threshold, (uint32_t)RendererThreadPool::singleton->thread_work_pool.get_thread_count()); //make sure there is at least one thread per CPU dummy_occlusion_culling = memnew(RendererSceneOcclusionCull); } RendererSceneCull::~RendererSceneCull() { instance_cull_result.reset(); instance_shadow_cull_result.reset(); for (uint32_t i = 0; i < MAX_UPDATE_SHADOWS; i++) { render_shadow_data[i].instances.reset(); } for (uint32_t i = 0; i < SDFGI_MAX_CASCADES * SDFGI_MAX_REGIONS_PER_CASCADE; i++) { render_sdfgi_data[i].instances.reset(); } scene_cull_result.reset(); for (uint32_t i = 0; i < scene_cull_result_threads.size(); i++) { scene_cull_result_threads[i].reset(); } scene_cull_result_threads.clear(); if (dummy_occlusion_culling) { memdelete(dummy_occlusion_culling); } }