2017-03-05 14:47:28 +00:00
/*************************************************************************/
/* visual_server_scene.cpp */
/*************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
2017-08-27 12:16:55 +00:00
/* https://godotengine.org */
2017-03-05 14:47:28 +00:00
/*************************************************************************/
2020-01-01 10:16:22 +00:00
/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur. */
/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md). */
2017-03-05 14:47:28 +00:00
/* */
/* 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. */
/*************************************************************************/
2018-01-04 23:50:27 +00:00
2016-10-19 14:14:41 +00:00
# include "visual_server_scene.h"
2020-01-21 20:32:27 +00:00
2018-09-11 16:13:45 +00:00
# include "core/os/os.h"
2019-02-12 13:23:35 +00:00
# include "visual_server_globals.h"
2017-04-07 02:36:37 +00:00
# include "visual_server_raster.h"
2020-01-21 20:32:27 +00:00
2019-01-25 11:06:44 +00:00
# include <new>
2020-01-21 20:32:27 +00:00
2016-10-19 14:14:41 +00:00
/* CAMERA API */
RID VisualServerScene : : camera_create ( ) {
2017-03-05 15:44:50 +00:00
Camera * camera = memnew ( Camera ) ;
return camera_owner . make_rid ( camera ) ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : camera_set_perspective ( RID p_camera , float p_fovy_degrees , float p_z_near , float p_z_far ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Camera * camera = camera_owner . getornull ( p_camera ) ;
2016-10-19 14:14:41 +00:00
ERR_FAIL_COND ( ! camera ) ;
2017-03-05 15:44:50 +00:00
camera - > type = Camera : : PERSPECTIVE ;
camera - > fov = p_fovy_degrees ;
camera - > znear = p_z_near ;
camera - > zfar = p_z_far ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : camera_set_orthogonal ( RID p_camera , float p_size , float p_z_near , float p_z_far ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Camera * camera = camera_owner . getornull ( p_camera ) ;
2016-10-19 14:14:41 +00:00
ERR_FAIL_COND ( ! camera ) ;
2017-03-05 15:44:50 +00:00
camera - > type = Camera : : ORTHOGONAL ;
camera - > size = p_size ;
camera - > znear = p_z_near ;
camera - > zfar = p_z_far ;
2016-10-19 14:14:41 +00:00
}
2019-02-19 16:17:02 +00:00
void VisualServerScene : : camera_set_frustum ( RID p_camera , float p_size , Vector2 p_offset , float p_z_near , float p_z_far ) {
2019-06-10 15:38:51 +00:00
Camera * camera = camera_owner . getornull ( p_camera ) ;
2019-02-19 16:17:02 +00:00
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 ;
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : camera_set_transform ( RID p_camera , const Transform & p_transform ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Camera * camera = camera_owner . getornull ( p_camera ) ;
2016-10-19 14:14:41 +00:00
ERR_FAIL_COND ( ! camera ) ;
2017-03-05 15:44:50 +00:00
camera - > transform = p_transform . orthonormalized ( ) ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : camera_set_cull_mask ( RID p_camera , uint32_t p_layers ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Camera * camera = camera_owner . getornull ( p_camera ) ;
2016-10-19 14:14:41 +00:00
ERR_FAIL_COND ( ! camera ) ;
2017-03-05 15:44:50 +00:00
camera - > visible_layers = p_layers ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : camera_set_environment ( RID p_camera , RID p_env ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Camera * camera = camera_owner . getornull ( p_camera ) ;
2016-10-19 14:14:41 +00:00
ERR_FAIL_COND ( ! camera ) ;
2017-03-05 15:44:50 +00:00
camera - > env = p_env ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : camera_set_use_vertical_aspect ( RID p_camera , bool p_enable ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Camera * camera = camera_owner . getornull ( p_camera ) ;
2016-10-19 14:14:41 +00:00
ERR_FAIL_COND ( ! camera ) ;
2017-03-05 15:44:50 +00:00
camera - > vaspect = p_enable ;
2016-10-19 14:14:41 +00:00
}
/* SCENARIO API */
2017-03-05 15:44:50 +00:00
void * VisualServerScene : : _instance_pair ( void * p_self , OctreeElementID , Instance * p_A , int , OctreeElementID , Instance * p_B , int ) {
2016-10-19 14:14:41 +00:00
2017-01-14 11:26:56 +00:00
//VisualServerScene *self = (VisualServerScene*)p_self;
2016-10-19 14:14:41 +00:00
Instance * A = p_A ;
Instance * B = p_B ;
//instance indices are designed so greater always contains lesser
if ( A - > base_type > B - > base_type ) {
2017-03-05 15:44:50 +00:00
SWAP ( A , B ) ; //lesser always first
2016-10-19 14:14:41 +00:00
}
2017-09-07 19:48:50 +00:00
if ( B - > base_type = = VS : : INSTANCE_LIGHT & & ( ( 1 < < A - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
InstanceLightData * light = static_cast < InstanceLightData * > ( B - > base_data ) ;
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( A - > base_data ) ;
2016-10-19 14:14:41 +00:00
InstanceLightData : : PairInfo pinfo ;
2017-03-05 15:44:50 +00:00
pinfo . geometry = A ;
2016-10-19 14:14:41 +00:00
pinfo . L = geom - > lighting . push_back ( B ) ;
List < InstanceLightData : : PairInfo > : : Element * E = light - > geometries . push_back ( pinfo ) ;
2016-11-10 02:55:06 +00:00
if ( geom - > can_cast_shadows ) {
2017-03-05 15:44:50 +00:00
light - > shadow_dirty = true ;
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
geom - > lighting_dirty = true ;
2016-10-19 14:14:41 +00:00
2016-11-19 16:23:37 +00:00
return E ; //this element should make freeing faster
2017-09-07 19:48:50 +00:00
} else if ( B - > base_type = = VS : : INSTANCE_REFLECTION_PROBE & & ( ( 1 < < A - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) ) {
2016-11-19 16:23:37 +00:00
2017-03-05 15:44:50 +00:00
InstanceReflectionProbeData * reflection_probe = static_cast < InstanceReflectionProbeData * > ( B - > base_data ) ;
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( A - > base_data ) ;
2016-11-19 16:23:37 +00:00
InstanceReflectionProbeData : : PairInfo pinfo ;
2017-03-05 15:44:50 +00:00
pinfo . geometry = A ;
2016-11-19 16:23:37 +00:00
pinfo . L = geom - > reflection_probes . push_back ( B ) ;
List < InstanceReflectionProbeData : : PairInfo > : : Element * E = reflection_probe - > geometries . push_back ( pinfo ) ;
2017-03-05 15:44:50 +00:00
geom - > reflection_dirty = true ;
2016-11-19 16:23:37 +00:00
2017-12-14 11:59:46 +00:00
return E ; //this element should make freeing faster
} else if ( B - > base_type = = VS : : INSTANCE_LIGHTMAP_CAPTURE & & ( ( 1 < < A - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) ) {
InstanceLightmapCaptureData * lightmap_capture = static_cast < InstanceLightmapCaptureData * > ( B - > base_data ) ;
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( A - > base_data ) ;
InstanceLightmapCaptureData : : PairInfo pinfo ;
pinfo . geometry = A ;
pinfo . L = geom - > lightmap_captures . push_back ( B ) ;
List < InstanceLightmapCaptureData : : PairInfo > : : Element * E = lightmap_capture - > geometries . push_back ( pinfo ) ;
( ( VisualServerScene * ) p_self ) - > _instance_queue_update ( A , false , false ) ; //need to update capture
2016-10-19 14:14:41 +00:00
return E ; //this element should make freeing faster
2017-09-07 19:48:50 +00:00
} else if ( B - > base_type = = VS : : INSTANCE_GI_PROBE & & ( ( 1 < < A - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) ) {
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
InstanceGIProbeData * gi_probe = static_cast < InstanceGIProbeData * > ( B - > base_data ) ;
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( A - > base_data ) ;
2016-12-20 03:21:07 +00:00
InstanceGIProbeData : : PairInfo pinfo ;
2017-03-05 15:44:50 +00:00
pinfo . geometry = A ;
2016-12-20 03:21:07 +00:00
pinfo . L = geom - > gi_probes . push_back ( B ) ;
2019-10-11 02:14:56 +00:00
List < InstanceGIProbeData : : PairInfo > : : Element * E ;
if ( A - > dynamic_gi ) {
E = gi_probe - > dynamic_geometries . push_back ( pinfo ) ;
} else {
E = gi_probe - > geometries . push_back ( pinfo ) ;
}
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
geom - > gi_probes_dirty = true ;
2016-12-20 03:21:07 +00:00
return E ; //this element should make freeing faster
2017-03-05 15:44:50 +00:00
} else if ( B - > base_type = = VS : : INSTANCE_GI_PROBE & & A - > base_type = = VS : : INSTANCE_LIGHT ) {
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
InstanceGIProbeData * gi_probe = static_cast < InstanceGIProbeData * > ( B - > base_data ) ;
2016-12-20 03:21:07 +00:00
return gi_probe - > lights . insert ( A ) ;
2016-10-19 14:14:41 +00:00
}
return NULL ;
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : _instance_unpair ( void * p_self , OctreeElementID , Instance * p_A , int , OctreeElementID , Instance * p_B , int , void * udata ) {
2016-10-19 14:14:41 +00:00
2017-01-14 11:26:56 +00:00
//VisualServerScene *self = (VisualServerScene*)p_self;
2016-10-19 14:14:41 +00:00
Instance * A = p_A ;
Instance * B = p_B ;
//instance indices are designed so greater always contains lesser
if ( A - > base_type > B - > base_type ) {
2017-03-05 15:44:50 +00:00
SWAP ( A , B ) ; //lesser always first
2016-10-19 14:14:41 +00:00
}
2017-09-07 19:48:50 +00:00
if ( B - > base_type = = VS : : INSTANCE_LIGHT & & ( ( 1 < < A - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
InstanceLightData * light = static_cast < InstanceLightData * > ( B - > base_data ) ;
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( A - > base_data ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
List < InstanceLightData : : PairInfo > : : Element * E = reinterpret_cast < List < InstanceLightData : : PairInfo > : : Element * > ( udata ) ;
2016-10-19 14:14:41 +00:00
geom - > lighting . erase ( E - > get ( ) . L ) ;
light - > geometries . erase ( E ) ;
2016-11-10 02:55:06 +00:00
if ( geom - > can_cast_shadows ) {
2017-03-05 15:44:50 +00:00
light - > shadow_dirty = true ;
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
geom - > lighting_dirty = true ;
2016-10-19 14:14:41 +00:00
2017-09-07 19:48:50 +00:00
} else if ( B - > base_type = = VS : : INSTANCE_REFLECTION_PROBE & & ( ( 1 < < A - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) ) {
2016-11-19 16:23:37 +00:00
2017-03-05 15:44:50 +00:00
InstanceReflectionProbeData * reflection_probe = static_cast < InstanceReflectionProbeData * > ( B - > base_data ) ;
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( A - > base_data ) ;
2016-11-19 16:23:37 +00:00
2017-03-05 15:44:50 +00:00
List < InstanceReflectionProbeData : : PairInfo > : : Element * E = reinterpret_cast < List < InstanceReflectionProbeData : : PairInfo > : : Element * > ( udata ) ;
2016-11-19 16:23:37 +00:00
geom - > reflection_probes . erase ( E - > get ( ) . L ) ;
reflection_probe - > geometries . erase ( E ) ;
2017-03-05 15:44:50 +00:00
geom - > reflection_dirty = true ;
2017-12-14 11:59:46 +00:00
} else if ( B - > base_type = = VS : : INSTANCE_LIGHTMAP_CAPTURE & & ( ( 1 < < A - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) ) {
InstanceLightmapCaptureData * lightmap_capture = static_cast < InstanceLightmapCaptureData * > ( B - > base_data ) ;
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( A - > base_data ) ;
List < InstanceLightmapCaptureData : : PairInfo > : : Element * E = reinterpret_cast < List < InstanceLightmapCaptureData : : PairInfo > : : Element * > ( udata ) ;
geom - > lightmap_captures . erase ( E - > get ( ) . L ) ;
lightmap_capture - > geometries . erase ( E ) ;
( ( VisualServerScene * ) p_self ) - > _instance_queue_update ( A , false , false ) ; //need to update capture
2016-11-19 16:23:37 +00:00
2017-09-07 19:48:50 +00:00
} else if ( B - > base_type = = VS : : INSTANCE_GI_PROBE & & ( ( 1 < < A - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) ) {
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
InstanceGIProbeData * gi_probe = static_cast < InstanceGIProbeData * > ( B - > base_data ) ;
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( A - > base_data ) ;
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
List < InstanceGIProbeData : : PairInfo > : : Element * E = reinterpret_cast < List < InstanceGIProbeData : : PairInfo > : : Element * > ( udata ) ;
2016-12-20 03:21:07 +00:00
geom - > gi_probes . erase ( E - > get ( ) . L ) ;
2019-10-11 02:14:56 +00:00
if ( A - > dynamic_gi ) {
gi_probe - > dynamic_geometries . erase ( E ) ;
} else {
gi_probe - > geometries . erase ( E ) ;
}
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
geom - > gi_probes_dirty = true ;
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
} else if ( B - > base_type = = VS : : INSTANCE_GI_PROBE & & A - > base_type = = VS : : INSTANCE_LIGHT ) {
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
InstanceGIProbeData * gi_probe = static_cast < InstanceGIProbeData * > ( B - > base_data ) ;
Set < Instance * > : : Element * E = reinterpret_cast < Set < Instance * > : : Element * > ( udata ) ;
2016-12-20 03:21:07 +00:00
gi_probe - > lights . erase ( E ) ;
2016-10-19 14:14:41 +00:00
}
}
RID VisualServerScene : : scenario_create ( ) {
2017-03-05 15:44:50 +00:00
Scenario * scenario = memnew ( Scenario ) ;
ERR_FAIL_COND_V ( ! scenario , RID ( ) ) ;
RID scenario_rid = scenario_owner . make_rid ( scenario ) ;
scenario - > self = scenario_rid ;
scenario - > octree . set_pair_callback ( _instance_pair , this ) ;
scenario - > octree . set_unpair_callback ( _instance_unpair , this ) ;
scenario - > reflection_probe_shadow_atlas = VSG : : scene_render - > shadow_atlas_create ( ) ;
VSG : : scene_render - > shadow_atlas_set_size ( scenario - > reflection_probe_shadow_atlas , 1024 ) ; //make enough shadows for close distance, don't bother with rest
VSG : : scene_render - > shadow_atlas_set_quadrant_subdivision ( scenario - > reflection_probe_shadow_atlas , 0 , 4 ) ;
VSG : : scene_render - > shadow_atlas_set_quadrant_subdivision ( scenario - > reflection_probe_shadow_atlas , 1 , 4 ) ;
VSG : : scene_render - > shadow_atlas_set_quadrant_subdivision ( scenario - > reflection_probe_shadow_atlas , 2 , 4 ) ;
VSG : : scene_render - > shadow_atlas_set_quadrant_subdivision ( scenario - > reflection_probe_shadow_atlas , 3 , 8 ) ;
2019-09-09 20:50:51 +00:00
scenario - > reflection_atlas = VSG : : scene_render - > reflection_atlas_create ( ) ;
2016-10-19 14:14:41 +00:00
return scenario_rid ;
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : scenario_set_debug ( RID p_scenario , VS : : ScenarioDebugMode p_debug_mode ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Scenario * scenario = scenario_owner . getornull ( p_scenario ) ;
2016-10-19 14:14:41 +00:00
ERR_FAIL_COND ( ! scenario ) ;
2017-03-05 15:44:50 +00:00
scenario - > debug = p_debug_mode ;
2016-10-19 14:14:41 +00:00
}
void VisualServerScene : : scenario_set_environment ( RID p_scenario , RID p_environment ) {
2019-06-10 15:38:51 +00:00
Scenario * scenario = scenario_owner . getornull ( p_scenario ) ;
2016-10-19 14:14:41 +00:00
ERR_FAIL_COND ( ! scenario ) ;
2017-03-05 15:44:50 +00:00
scenario - > environment = p_environment ;
2016-10-19 14:14:41 +00:00
}
void VisualServerScene : : scenario_set_fallback_environment ( RID p_scenario , RID p_environment ) {
2019-06-10 15:38:51 +00:00
Scenario * scenario = scenario_owner . getornull ( p_scenario ) ;
2016-10-19 14:14:41 +00:00
ERR_FAIL_COND ( ! scenario ) ;
2017-03-05 15:44:50 +00:00
scenario - > fallback_environment = p_environment ;
2016-10-19 14:14:41 +00:00
}
2019-09-09 20:50:51 +00:00
void VisualServerScene : : scenario_set_reflection_atlas_size ( RID p_scenario , int p_reflection_size , int p_reflection_count ) {
Scenario * scenario = scenario_owner . getornull ( p_scenario ) ;
ERR_FAIL_COND ( ! scenario ) ;
VSG : : scene_render - > reflection_atlas_set_size ( scenario - > reflection_atlas , p_reflection_size , p_reflection_count ) ;
}
2016-10-19 14:14:41 +00:00
/* INSTANCING API */
2019-07-21 14:31:30 +00:00
void VisualServerScene : : _instance_queue_update ( Instance * p_instance , bool p_update_aabb , bool p_update_dependencies ) {
2016-10-19 14:14:41 +00:00
if ( p_update_aabb )
2017-03-05 15:44:50 +00:00
p_instance - > update_aabb = true ;
2019-07-21 14:31:30 +00:00
if ( p_update_dependencies )
p_instance - > update_dependencies = true ;
2016-10-19 14:14:41 +00:00
if ( p_instance - > update_item . in_list ( ) )
return ;
_instance_update_list . add ( & p_instance - > update_item ) ;
}
2017-03-05 15:44:50 +00:00
RID VisualServerScene : : instance_create ( ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
Instance * instance = memnew ( Instance ) ;
ERR_FAIL_COND_V ( ! instance , RID ( ) ) ;
2016-10-19 14:14:41 +00:00
RID instance_rid = instance_owner . make_rid ( instance ) ;
2017-03-05 15:44:50 +00:00
instance - > self = instance_rid ;
2016-10-19 14:14:41 +00:00
return instance_rid ;
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_set_base ( RID p_instance , RID p_base ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! instance ) ;
2016-10-19 14:14:41 +00:00
Scenario * scenario = instance - > scenario ;
2017-03-05 15:44:50 +00:00
if ( instance - > base_type ! = VS : : INSTANCE_NONE ) {
2016-10-19 14:14:41 +00:00
//free anything related to that base
if ( scenario & & instance - > octree_id ) {
scenario - > octree . erase ( instance - > octree_id ) ; //make dependencies generated by the octree go away
2017-03-05 15:44:50 +00:00
instance - > octree_id = 0 ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
switch ( instance - > base_type ) {
2016-10-19 14:14:41 +00:00
case VS : : INSTANCE_LIGHT : {
2017-03-05 15:44:50 +00:00
InstanceLightData * light = static_cast < InstanceLightData * > ( instance - > base_data ) ;
2019-10-05 13:27:43 +00:00
# ifdef DEBUG_ENABLED
if ( light - > geometries . size ( ) ) {
ERR_PRINT ( " BUG, indexing did not unpair geometries from light. " ) ;
}
# endif
2016-10-19 14:14:41 +00:00
if ( instance - > scenario & & light - > D ) {
2017-03-05 15:44:50 +00:00
instance - > scenario - > directional_lights . erase ( light - > D ) ;
light - > D = NULL ;
2016-10-19 14:14:41 +00:00
}
VSG : : scene_render - > free ( light - > instance ) ;
2016-10-27 14:50:26 +00:00
} break ;
2016-11-19 16:23:37 +00:00
case VS : : INSTANCE_REFLECTION_PROBE : {
2017-03-05 15:44:50 +00:00
InstanceReflectionProbeData * reflection_probe = static_cast < InstanceReflectionProbeData * > ( instance - > base_data ) ;
2016-11-19 16:23:37 +00:00
VSG : : scene_render - > free ( reflection_probe - > instance ) ;
if ( reflection_probe - > update_list . in_list ( ) ) {
reflection_probe_render_list . remove ( & reflection_probe - > update_list ) ;
}
} break ;
2017-12-14 11:59:46 +00:00
case VS : : INSTANCE_LIGHTMAP_CAPTURE : {
InstanceLightmapCaptureData * lightmap_capture = static_cast < InstanceLightmapCaptureData * > ( instance - > base_data ) ;
//erase dependencies, since no longer a lightmap
while ( lightmap_capture - > users . front ( ) ) {
instance_set_use_lightmap ( lightmap_capture - > users . front ( ) - > get ( ) - > self , RID ( ) , RID ( ) ) ;
}
} break ;
2016-12-20 03:21:07 +00:00
case VS : : INSTANCE_GI_PROBE : {
2017-03-05 15:44:50 +00:00
InstanceGIProbeData * gi_probe = static_cast < InstanceGIProbeData * > ( instance - > base_data ) ;
2019-10-05 13:27:43 +00:00
# ifdef DEBUG_ENABLED
if ( gi_probe - > geometries . size ( ) ) {
ERR_PRINT ( " BUG, indexing did not unpair geometries from GIProbe. " ) ;
}
# endif
# ifdef DEBUG_ENABLED
if ( gi_probe - > lights . size ( ) ) {
ERR_PRINT ( " BUG, indexing did not unpair lights from GIProbe. " ) ;
}
# endif
2016-12-20 03:21:07 +00:00
if ( gi_probe - > update_element . in_list ( ) ) {
gi_probe_update_list . remove ( & gi_probe - > update_element ) ;
}
2017-12-14 11:59:46 +00:00
if ( instance - > lightmap_capture ) {
Instance * capture = ( Instance * ) instance - > lightmap_capture ;
InstanceLightmapCaptureData * lightmap_capture = static_cast < InstanceLightmapCaptureData * > ( capture - > base_data ) ;
lightmap_capture - > users . erase ( instance ) ;
instance - > lightmap_capture = NULL ;
instance - > lightmap = RID ( ) ;
}
2016-12-20 03:21:07 +00:00
VSG : : scene_render - > free ( gi_probe - > probe_instance ) ;
} break ;
2019-04-09 15:08:36 +00:00
default : {
}
2016-10-19 14:14:41 +00:00
}
if ( instance - > base_data ) {
2017-03-05 15:44:50 +00:00
memdelete ( instance - > base_data ) ;
instance - > base_data = NULL ;
2016-10-19 14:14:41 +00:00
}
2017-01-12 11:34:00 +00:00
instance - > blend_values . clear ( ) ;
2016-10-19 14:14:41 +00:00
instance - > materials . clear ( ) ;
}
2017-03-05 15:44:50 +00:00
instance - > base_type = VS : : INSTANCE_NONE ;
instance - > base = RID ( ) ;
2016-10-19 14:14:41 +00:00
if ( p_base . is_valid ( ) ) {
2017-03-05 15:44:50 +00:00
instance - > base_type = VSG : : storage - > get_base_type ( p_base ) ;
ERR_FAIL_COND ( instance - > base_type = = VS : : INSTANCE_NONE ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
switch ( instance - > base_type ) {
2016-10-19 14:14:41 +00:00
case VS : : INSTANCE_LIGHT : {
2017-03-05 15:44:50 +00:00
InstanceLightData * light = memnew ( InstanceLightData ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
if ( scenario & & VSG : : storage - > light_get_type ( p_base ) = = VS : : LIGHT_DIRECTIONAL ) {
2016-10-19 14:14:41 +00:00
light - > D = scenario - > directional_lights . push_back ( instance ) ;
}
light - > instance = VSG : : scene_render - > light_instance_create ( p_base ) ;
2017-03-05 15:44:50 +00:00
instance - > base_data = light ;
2016-10-27 14:50:26 +00:00
} break ;
2016-11-23 10:04:55 +00:00
case VS : : INSTANCE_MESH :
case VS : : INSTANCE_MULTIMESH :
2017-04-07 02:36:37 +00:00
case VS : : INSTANCE_IMMEDIATE :
case VS : : INSTANCE_PARTICLES : {
2016-11-22 04:26:56 +00:00
2017-03-05 15:44:50 +00:00
InstanceGeometryData * geom = memnew ( InstanceGeometryData ) ;
instance - > base_data = geom ;
2019-03-01 19:01:21 +00:00
if ( instance - > base_type = = VS : : INSTANCE_MESH ) {
instance - > blend_values . resize ( VSG : : storage - > mesh_get_blend_shape_count ( p_base ) ) ;
}
2016-11-22 04:26:56 +00:00
} break ;
2016-11-19 16:23:37 +00:00
case VS : : INSTANCE_REFLECTION_PROBE : {
2017-03-05 15:44:50 +00:00
InstanceReflectionProbeData * reflection_probe = memnew ( InstanceReflectionProbeData ) ;
reflection_probe - > owner = instance ;
instance - > base_data = reflection_probe ;
2016-11-19 16:23:37 +00:00
2017-03-05 15:44:50 +00:00
reflection_probe - > instance = VSG : : scene_render - > reflection_probe_instance_create ( p_base ) ;
2016-11-19 16:23:37 +00:00
} break ;
2017-12-14 11:59:46 +00:00
case VS : : INSTANCE_LIGHTMAP_CAPTURE : {
InstanceLightmapCaptureData * lightmap_capture = memnew ( InstanceLightmapCaptureData ) ;
instance - > base_data = lightmap_capture ;
//lightmap_capture->instance = VSG::scene_render->lightmap_capture_instance_create(p_base);
} break ;
2016-12-20 03:21:07 +00:00
case VS : : INSTANCE_GI_PROBE : {
2017-03-05 15:44:50 +00:00
InstanceGIProbeData * gi_probe = memnew ( InstanceGIProbeData ) ;
instance - > base_data = gi_probe ;
gi_probe - > owner = instance ;
2016-12-20 03:21:07 +00:00
if ( scenario & & ! gi_probe - > update_element . in_list ( ) ) {
gi_probe_update_list . add ( & gi_probe - > update_element ) ;
}
2019-10-03 20:39:08 +00:00
gi_probe - > probe_instance = VSG : : scene_render - > gi_probe_instance_create ( p_base ) ;
2016-12-20 03:21:07 +00:00
} break ;
2019-04-09 15:08:36 +00:00
default : {
}
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
instance - > base = p_base ;
2016-10-19 14:14:41 +00:00
2019-07-21 14:31:30 +00:00
//forcefully update the dependency now, so if for some reason it gets removed, we can immediately clear it
VSG : : storage - > base_update_dependency ( p_base , instance ) ;
2016-10-19 14:14:41 +00:00
}
2019-07-21 14:31:30 +00:00
_instance_queue_update ( instance , true , true ) ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_set_scenario ( RID p_instance , RID p_scenario ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! instance ) ;
2016-10-19 14:14:41 +00:00
if ( instance - > scenario ) {
2017-03-05 15:44:50 +00:00
instance - > scenario - > instances . remove ( & instance - > scenario_item ) ;
2016-10-19 14:14:41 +00:00
if ( instance - > octree_id ) {
instance - > scenario - > octree . erase ( instance - > octree_id ) ; //make dependencies generated by the octree go away
2017-03-05 15:44:50 +00:00
instance - > octree_id = 0 ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
switch ( instance - > base_type ) {
2016-10-19 14:14:41 +00:00
case VS : : INSTANCE_LIGHT : {
2017-03-05 15:44:50 +00:00
InstanceLightData * light = static_cast < InstanceLightData * > ( instance - > base_data ) ;
2019-10-05 13:27:43 +00:00
# ifdef DEBUG_ENABLED
if ( light - > geometries . size ( ) ) {
ERR_PRINT ( " BUG, indexing did not unpair geometries from light. " ) ;
}
# endif
2016-10-19 14:14:41 +00:00
if ( light - > D ) {
2017-03-05 15:44:50 +00:00
instance - > scenario - > directional_lights . erase ( light - > D ) ;
light - > D = NULL ;
2016-10-19 14:14:41 +00:00
}
2016-10-27 14:50:26 +00:00
} break ;
2016-11-19 16:23:37 +00:00
case VS : : INSTANCE_REFLECTION_PROBE : {
2019-09-09 20:50:51 +00:00
InstanceReflectionProbeData * reflection_probe = static_cast < InstanceReflectionProbeData * > ( instance - > base_data ) ;
VSG : : scene_render - > reflection_probe_release_atlas_index ( reflection_probe - > instance ) ;
2016-11-19 16:23:37 +00:00
} break ;
2016-12-20 03:21:07 +00:00
case VS : : INSTANCE_GI_PROBE : {
2017-03-05 15:44:50 +00:00
InstanceGIProbeData * gi_probe = static_cast < InstanceGIProbeData * > ( instance - > base_data ) ;
2019-10-05 13:27:43 +00:00
# ifdef DEBUG_ENABLED
if ( gi_probe - > geometries . size ( ) ) {
ERR_PRINT ( " BUG, indexing did not unpair geometries from GIProbe. " ) ;
}
# endif
# ifdef DEBUG_ENABLED
if ( gi_probe - > lights . size ( ) ) {
ERR_PRINT ( " BUG, indexing did not unpair lights from GIProbe. " ) ;
}
# endif
2016-12-20 03:21:07 +00:00
if ( gi_probe - > update_element . in_list ( ) ) {
gi_probe_update_list . remove ( & gi_probe - > update_element ) ;
}
} break ;
2019-04-09 15:08:36 +00:00
default : {
}
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
instance - > scenario = NULL ;
2016-10-19 14:14:41 +00:00
}
if ( p_scenario . is_valid ( ) ) {
2019-06-10 15:38:51 +00:00
Scenario * scenario = scenario_owner . getornull ( p_scenario ) ;
2016-10-19 14:14:41 +00:00
ERR_FAIL_COND ( ! scenario ) ;
2017-03-05 15:44:50 +00:00
instance - > scenario = scenario ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
scenario - > instances . add ( & instance - > scenario_item ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
switch ( instance - > base_type ) {
2016-10-19 14:14:41 +00:00
case VS : : INSTANCE_LIGHT : {
2017-03-05 15:44:50 +00:00
InstanceLightData * light = static_cast < InstanceLightData * > ( instance - > base_data ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
if ( VSG : : storage - > light_get_type ( instance - > base ) = = VS : : LIGHT_DIRECTIONAL ) {
2016-10-19 14:14:41 +00:00
light - > D = scenario - > directional_lights . push_back ( instance ) ;
}
2016-10-27 14:50:26 +00:00
} break ;
2016-12-20 03:21:07 +00:00
case VS : : INSTANCE_GI_PROBE : {
2017-03-05 15:44:50 +00:00
InstanceGIProbeData * gi_probe = static_cast < InstanceGIProbeData * > ( instance - > base_data ) ;
2016-12-20 03:21:07 +00:00
if ( ! gi_probe - > update_element . in_list ( ) ) {
gi_probe_update_list . add ( & gi_probe - > update_element ) ;
}
} break ;
2019-04-09 15:08:36 +00:00
default : {
}
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
_instance_queue_update ( instance , true , true ) ;
2016-10-19 14:14:41 +00:00
}
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_set_layer_mask ( RID p_instance , uint32_t p_mask ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! instance ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
instance - > layer_mask = p_mask ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_set_transform ( RID p_instance , const Transform & p_transform ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! instance ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
if ( instance - > transform = = p_transform )
2016-10-19 14:14:41 +00:00
return ; //must be checked to avoid worst evil
2019-01-26 22:09:48 +00:00
# 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
2017-03-05 15:44:50 +00:00
instance - > transform = p_transform ;
_instance_queue_update ( instance , true ) ;
2016-10-19 14:14:41 +00:00
}
2019-05-09 09:21:49 +00:00
void VisualServerScene : : instance_attach_object_instance_id ( RID p_instance , ObjectID p_id ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! instance ) ;
2016-10-19 14:14:41 +00:00
2019-05-09 09:21:49 +00:00
instance - > object_id = p_id ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_set_blend_shape_weight ( RID p_instance , int p_shape , float p_weight ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! instance ) ;
2016-11-24 23:46:55 +00:00
if ( instance - > update_item . in_list ( ) ) {
_update_dirty_instance ( instance ) ;
}
2017-03-05 15:44:50 +00:00
ERR_FAIL_INDEX ( p_shape , instance - > blend_values . size ( ) ) ;
2018-07-25 01:11:03 +00:00
instance - > blend_values . write [ p_shape ] = p_weight ;
2016-10-19 14:14:41 +00:00
}
2016-11-24 23:46:55 +00:00
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_set_surface_material ( RID p_instance , int p_surface , RID p_material ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! instance ) ;
2016-10-19 14:14:41 +00:00
2018-11-08 18:58:52 +00:00
if ( instance - > base_type = = VS : : INSTANCE_MESH ) {
2019-07-21 14:31:30 +00:00
//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 , VSG : : storage - > mesh_get_surface_count ( instance - > base ) ) ) ;
2016-11-24 23:46:55 +00:00
}
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
ERR_FAIL_INDEX ( p_surface , instance - > materials . size ( ) ) ;
2016-10-19 14:14:41 +00:00
2018-07-25 01:11:03 +00:00
instance - > materials . write [ p_surface ] = p_material ;
2016-11-10 02:55:06 +00:00
2019-07-21 14:31:30 +00:00
_instance_queue_update ( instance , false , true ) ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_set_visible ( RID p_instance , bool p_visible ) {
2017-01-04 04:16:14 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! instance ) ;
2017-01-04 04:16:14 +00:00
2017-03-05 15:44:50 +00:00
if ( instance - > visible = = p_visible )
2017-01-04 04:16:14 +00:00
return ;
2017-03-05 15:44:50 +00:00
instance - > visible = p_visible ;
2017-01-04 04:16:14 +00:00
2017-03-05 15:44:50 +00:00
switch ( instance - > base_type ) {
2017-01-04 04:16:14 +00:00
case VS : : INSTANCE_LIGHT : {
2017-03-05 15:44:50 +00:00
if ( VSG : : storage - > light_get_type ( instance - > base ) ! = VS : : LIGHT_DIRECTIONAL & & instance - > octree_id & & instance - > scenario ) {
instance - > scenario - > octree . set_pairable ( instance - > octree_id , p_visible , 1 < < VS : : INSTANCE_LIGHT , p_visible ? VS : : INSTANCE_GEOMETRY_MASK : 0 ) ;
2017-01-04 04:16:14 +00:00
}
} break ;
case VS : : INSTANCE_REFLECTION_PROBE : {
if ( instance - > octree_id & & instance - > scenario ) {
2017-03-05 15:44:50 +00:00
instance - > scenario - > octree . set_pairable ( instance - > octree_id , p_visible , 1 < < VS : : INSTANCE_REFLECTION_PROBE , p_visible ? VS : : INSTANCE_GEOMETRY_MASK : 0 ) ;
2017-01-04 04:16:14 +00:00
}
2017-12-14 11:59:46 +00:00
} break ;
case VS : : INSTANCE_LIGHTMAP_CAPTURE : {
if ( instance - > octree_id & & instance - > scenario ) {
instance - > scenario - > octree . set_pairable ( instance - > octree_id , p_visible , 1 < < VS : : INSTANCE_LIGHTMAP_CAPTURE , p_visible ? VS : : INSTANCE_GEOMETRY_MASK : 0 ) ;
}
2017-01-04 04:16:14 +00:00
} break ;
case VS : : INSTANCE_GI_PROBE : {
if ( instance - > octree_id & & instance - > scenario ) {
2017-03-05 15:44:50 +00:00
instance - > scenario - > octree . set_pairable ( instance - > octree_id , p_visible , 1 < < VS : : INSTANCE_GI_PROBE , p_visible ? ( VS : : INSTANCE_GEOMETRY_MASK | ( 1 < < VS : : INSTANCE_LIGHT ) ) : 0 ) ;
2017-01-04 04:16:14 +00:00
}
} break ;
2019-04-09 15:08:36 +00:00
default : {
}
2017-01-04 04:16:14 +00:00
}
}
2017-11-20 19:54:26 +00:00
inline bool is_geometry_instance ( VisualServer : : InstanceType p_type ) {
return p_type = = VS : : INSTANCE_MESH | | p_type = = VS : : INSTANCE_MULTIMESH | | p_type = = VS : : INSTANCE_PARTICLES | | p_type = = VS : : INSTANCE_IMMEDIATE ;
}
2017-12-14 11:59:46 +00:00
void VisualServerScene : : instance_set_use_lightmap ( RID p_instance , RID p_lightmap_instance , RID p_lightmap ) {
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-12-14 11:59:46 +00:00
ERR_FAIL_COND ( ! instance ) ;
if ( instance - > lightmap_capture ) {
InstanceLightmapCaptureData * lightmap_capture = static_cast < InstanceLightmapCaptureData * > ( ( ( Instance * ) instance - > lightmap_capture ) - > base_data ) ;
lightmap_capture - > users . erase ( instance ) ;
instance - > lightmap = RID ( ) ;
instance - > lightmap_capture = NULL ;
}
if ( p_lightmap_instance . is_valid ( ) ) {
2019-06-10 15:38:51 +00:00
Instance * lightmap_instance = instance_owner . getornull ( p_lightmap_instance ) ;
2017-12-14 11:59:46 +00:00
ERR_FAIL_COND ( ! lightmap_instance ) ;
ERR_FAIL_COND ( lightmap_instance - > base_type ! = VS : : INSTANCE_LIGHTMAP_CAPTURE ) ;
instance - > lightmap_capture = lightmap_instance ;
InstanceLightmapCaptureData * lightmap_capture = static_cast < InstanceLightmapCaptureData * > ( ( ( Instance * ) instance - > lightmap_capture ) - > base_data ) ;
lightmap_capture - > users . insert ( instance ) ;
instance - > lightmap = p_lightmap ;
}
}
2017-11-20 19:54:26 +00:00
void VisualServerScene : : instance_set_custom_aabb ( RID p_instance , AABB p_aabb ) {
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-11-20 19:54:26 +00:00
ERR_FAIL_COND ( ! instance ) ;
ERR_FAIL_COND ( ! is_geometry_instance ( instance - > base_type ) ) ;
2017-11-25 03:07:54 +00:00
if ( p_aabb ! = AABB ( ) ) {
2017-11-20 19:54:26 +00:00
// Set custom AABB
if ( instance - > custom_aabb = = NULL )
instance - > custom_aabb = memnew ( AABB ) ;
* instance - > custom_aabb = p_aabb ;
} else {
// Clear custom AABB
if ( instance - > custom_aabb ! = NULL ) {
memdelete ( instance - > custom_aabb ) ;
instance - > custom_aabb = NULL ;
}
}
if ( instance - > scenario )
_instance_queue_update ( instance , true , false ) ;
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_attach_skeleton ( RID p_instance , RID p_skeleton ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! instance ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
if ( instance - > skeleton = = p_skeleton )
2016-11-22 04:26:56 +00:00
return ;
2017-03-05 15:44:50 +00:00
instance - > skeleton = p_skeleton ;
2016-10-19 14:14:41 +00:00
2019-07-21 14:31:30 +00:00
if ( p_skeleton . is_valid ( ) ) {
//update the dependency now, so if cleared, we remove it
VSG : : storage - > skeleton_update_dependency ( p_skeleton , instance ) ;
2016-11-22 04:26:56 +00:00
}
2019-07-21 14:31:30 +00:00
_instance_queue_update ( instance , true , true ) ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_set_exterior ( RID p_instance , bool p_enabled ) {
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_set_extra_visibility_margin ( RID p_instance , real_t p_margin ) {
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2018-03-04 13:20:59 +00:00
ERR_FAIL_COND ( ! instance ) ;
instance - > extra_margin = p_margin ;
_instance_queue_update ( instance , true , false ) ;
2016-10-19 14:14:41 +00:00
}
2017-11-17 02:09:00 +00:00
Vector < ObjectID > VisualServerScene : : instances_cull_aabb ( const AABB & p_aabb , RID p_scenario ) const {
2016-10-19 14:14:41 +00:00
2016-10-29 23:48:09 +00:00
Vector < ObjectID > instances ;
2019-06-10 15:38:51 +00:00
Scenario * scenario = scenario_owner . getornull ( p_scenario ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V ( ! scenario , instances ) ;
2016-10-29 23:48:09 +00:00
2017-03-05 15:44:50 +00:00
const_cast < VisualServerScene * > ( this ) - > update_dirty_instances ( ) ; // check dirty instances before culling
2016-10-29 23:48:09 +00:00
2017-03-05 15:44:50 +00:00
int culled = 0 ;
2016-10-29 23:48:09 +00:00
Instance * cull [ 1024 ] ;
2017-08-16 15:00:07 +00:00
culled = scenario - > octree . cull_aabb ( p_aabb , cull , 1024 ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < culled ; i + + ) {
2016-10-29 23:48:09 +00:00
2017-03-05 15:44:50 +00:00
Instance * instance = cull [ i ] ;
2016-10-29 23:48:09 +00:00
ERR_CONTINUE ( ! instance ) ;
2019-05-09 09:21:49 +00:00
if ( instance - > object_id = = 0 )
2016-10-29 23:48:09 +00:00
continue ;
2019-05-09 09:21:49 +00:00
instances . push_back ( instance - > object_id ) ;
2016-10-29 23:48:09 +00:00
}
return instances ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
Vector < ObjectID > VisualServerScene : : instances_cull_ray ( const Vector3 & p_from , const Vector3 & p_to , RID p_scenario ) const {
2016-10-29 23:48:09 +00:00
Vector < ObjectID > instances ;
2019-06-10 15:38:51 +00:00
Scenario * scenario = scenario_owner . getornull ( p_scenario ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V ( ! scenario , instances ) ;
const_cast < VisualServerScene * > ( this ) - > update_dirty_instances ( ) ; // check dirty instances before culling
2016-10-29 23:48:09 +00:00
2017-03-05 15:44:50 +00:00
int culled = 0 ;
2016-10-29 23:48:09 +00:00
Instance * cull [ 1024 ] ;
2017-11-25 20:14:54 +00:00
culled = scenario - > octree . cull_segment ( p_from , p_from + p_to * 10000 , cull , 1024 ) ;
2016-10-29 23:48:09 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < culled ; i + + ) {
Instance * instance = cull [ i ] ;
2016-10-29 23:48:09 +00:00
ERR_CONTINUE ( ! instance ) ;
2019-05-09 09:21:49 +00:00
if ( instance - > object_id = = 0 )
2016-10-29 23:48:09 +00:00
continue ;
2019-05-09 09:21:49 +00:00
instances . push_back ( instance - > object_id ) ;
2016-10-29 23:48:09 +00:00
}
return instances ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
Vector < ObjectID > VisualServerScene : : instances_cull_convex ( const Vector < Plane > & p_convex , RID p_scenario ) const {
2016-10-29 23:48:09 +00:00
Vector < ObjectID > instances ;
2019-06-10 15:38:51 +00:00
Scenario * scenario = scenario_owner . getornull ( p_scenario ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V ( ! scenario , instances ) ;
const_cast < VisualServerScene * > ( this ) - > update_dirty_instances ( ) ; // check dirty instances before culling
2016-10-29 23:48:09 +00:00
2017-03-05 15:44:50 +00:00
int culled = 0 ;
2016-10-29 23:48:09 +00:00
Instance * cull [ 1024 ] ;
2017-03-05 15:44:50 +00:00
culled = scenario - > octree . cull_convex ( p_convex , cull , 1024 ) ;
2016-10-29 23:48:09 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < culled ; i + + ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
Instance * instance = cull [ i ] ;
2016-10-29 23:48:09 +00:00
ERR_CONTINUE ( ! instance ) ;
2019-05-09 09:21:49 +00:00
if ( instance - > object_id = = 0 )
2016-10-29 23:48:09 +00:00
continue ;
2019-05-09 09:21:49 +00:00
instances . push_back ( instance - > object_id ) ;
2016-10-29 23:48:09 +00:00
}
return instances ;
}
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_geometry_set_flag ( RID p_instance , VS : : InstanceFlags p_flags , bool p_enabled ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! instance ) ;
2016-10-27 14:50:26 +00:00
2019-10-31 22:54:21 +00:00
//ERR_FAIL_COND(((1 << instance->base_type) & VS::INSTANCE_GEOMETRY_MASK));
2019-10-11 02:14:56 +00:00
2017-03-05 15:44:50 +00:00
switch ( p_flags ) {
2016-10-27 14:50:26 +00:00
2017-07-16 02:24:37 +00:00
case VS : : INSTANCE_FLAG_USE_BAKED_LIGHT : {
instance - > baked_light = p_enabled ;
2019-10-11 02:14:56 +00:00
} break ;
case VS : : INSTANCE_FLAG_USE_DYNAMIC_GI : {
if ( p_enabled = = instance - > dynamic_gi ) {
//bye, redundant
return ;
}
if ( instance - > octree_id ! = 0 ) {
//remove from octree, it needs to be re-paired
instance - > scenario - > octree . erase ( instance - > octree_id ) ;
instance - > octree_id = 0 ;
_instance_queue_update ( instance , true , true ) ;
}
//once out of octree, can be changed
instance - > dynamic_gi = p_enabled ;
2017-07-16 02:24:37 +00:00
} break ;
2018-07-27 11:58:56 +00:00
case VS : : INSTANCE_FLAG_DRAW_NEXT_FRAME_IF_VISIBLE : {
2018-07-23 15:28:15 +00:00
instance - > redraw_if_visible = p_enabled ;
} break ;
2019-04-09 15:08:36 +00:00
default : {
}
2016-10-27 14:50:26 +00:00
}
2016-10-19 14:14:41 +00:00
}
void VisualServerScene : : instance_geometry_set_cast_shadows_setting ( RID p_instance , VS : : ShadowCastingSetting p_shadow_casting_setting ) {
2017-08-19 23:06:40 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-08-19 23:06:40 +00:00
ERR_FAIL_COND ( ! instance ) ;
instance - > cast_shadows = p_shadow_casting_setting ;
2019-07-21 14:31:30 +00:00
_instance_queue_update ( instance , false , true ) ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_geometry_set_material_override ( RID p_instance , RID p_material ) {
2016-10-19 14:14:41 +00:00
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_instance ) ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( ! instance ) ;
2016-10-27 14:50:26 +00:00
2017-03-05 15:44:50 +00:00
instance - > material_override = p_material ;
2019-07-21 14:31:30 +00:00
_instance_queue_update ( instance , false , true ) ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_geometry_set_draw_range ( RID p_instance , float p_min , float p_max , float p_min_margin , float p_max_margin ) {
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
void VisualServerScene : : instance_geometry_set_as_instance_lod ( RID p_instance , RID p_as_lod_of_instance ) {
2016-10-19 14:14:41 +00:00
}
void VisualServerScene : : _update_instance ( Instance * p_instance ) {
p_instance - > version + + ;
if ( p_instance - > base_type = = VS : : INSTANCE_LIGHT ) {
2017-03-05 15:44:50 +00:00
InstanceLightData * light = static_cast < InstanceLightData * > ( p_instance - > base_data ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
VSG : : scene_render - > light_instance_set_transform ( light - > instance , p_instance - > transform ) ;
light - > shadow_dirty = true ;
2016-10-19 14:14:41 +00:00
}
2016-11-19 16:23:37 +00:00
if ( p_instance - > base_type = = VS : : INSTANCE_REFLECTION_PROBE ) {
2017-03-05 15:44:50 +00:00
InstanceReflectionProbeData * reflection_probe = static_cast < InstanceReflectionProbeData * > ( p_instance - > base_data ) ;
2016-11-19 16:23:37 +00:00
2017-03-05 15:44:50 +00:00
VSG : : scene_render - > reflection_probe_instance_set_transform ( reflection_probe - > instance , p_instance - > transform ) ;
reflection_probe - > reflection_dirty = true ;
2016-11-19 16:23:37 +00:00
}
2019-10-03 20:39:08 +00:00
if ( p_instance - > base_type = = VS : : INSTANCE_GI_PROBE ) {
InstanceGIProbeData * gi_probe = static_cast < InstanceGIProbeData * > ( p_instance - > base_data ) ;
VSG : : scene_render - > gi_probe_instance_set_transform_to_data ( gi_probe - > probe_instance , p_instance - > transform ) ;
}
2017-04-07 02:36:37 +00:00
if ( p_instance - > base_type = = VS : : INSTANCE_PARTICLES ) {
VSG : : storage - > particles_set_emission_transform ( p_instance - > base , p_instance - > transform ) ;
}
2017-08-19 17:54:04 +00:00
if ( p_instance - > aabb . has_no_surface ( ) ) {
2016-10-19 14:14:41 +00:00
return ;
2017-08-18 18:11:16 +00:00
}
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
if ( ( 1 < < p_instance - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( p_instance - > base_data ) ;
2016-11-10 02:55:06 +00:00
//make sure lights are updated if it casts shadow
2016-10-19 14:14:41 +00:00
2016-11-10 02:55:06 +00:00
if ( geom - > can_cast_shadows ) {
2017-03-05 15:44:50 +00:00
for ( List < Instance * > : : Element * E = geom - > lighting . front ( ) ; E ; E = E - > next ( ) ) {
InstanceLightData * light = static_cast < InstanceLightData * > ( E - > get ( ) - > base_data ) ;
light - > shadow_dirty = true ;
2016-11-10 02:55:06 +00:00
}
2016-10-19 14:14:41 +00:00
}
2017-12-14 11:59:46 +00:00
if ( ! p_instance - > lightmap_capture & & geom - > lightmap_captures . size ( ) ) {
//affected by lightmap captures, must update capture info!
_update_instance_lightmap_captures ( p_instance ) ;
} else {
if ( ! p_instance - > lightmap_capture_data . empty ( ) ) {
2018-09-27 10:07:59 +00:00
p_instance - > lightmap_capture_data . resize ( 0 ) ; //not in use, clear capture data
2017-12-14 11:59:46 +00:00
}
}
2016-10-19 14:14:41 +00:00
}
p_instance - > mirror = p_instance - > transform . basis . determinant ( ) < 0.0 ;
2017-11-17 02:09:00 +00:00
AABB new_aabb ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
new_aabb = p_instance - > transform . xform ( p_instance - > aabb ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
p_instance - > transformed_aabb = new_aabb ;
2016-10-19 14:14:41 +00:00
if ( ! p_instance - > scenario ) {
return ;
}
2017-03-05 15:44:50 +00:00
if ( p_instance - > octree_id = = 0 ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
uint32_t base_type = 1 < < p_instance - > base_type ;
uint32_t pairable_mask = 0 ;
bool pairable = false ;
2016-10-19 14:14:41 +00:00
2017-12-14 11:59:46 +00:00
if ( p_instance - > base_type = = VS : : INSTANCE_LIGHT | | p_instance - > base_type = = VS : : INSTANCE_REFLECTION_PROBE | | p_instance - > base_type = = VS : : INSTANCE_LIGHTMAP_CAPTURE ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
pairable_mask = p_instance - > visible ? VS : : INSTANCE_GEOMETRY_MASK : 0 ;
pairable = true ;
2016-10-19 14:14:41 +00:00
}
2016-12-20 03:21:07 +00:00
if ( p_instance - > base_type = = VS : : INSTANCE_GI_PROBE ) {
//lights and geometries
2017-03-05 15:44:50 +00:00
pairable_mask = p_instance - > visible ? VS : : INSTANCE_GEOMETRY_MASK | ( 1 < < VS : : INSTANCE_LIGHT ) : 0 ;
pairable = true ;
2016-12-20 03:21:07 +00:00
}
2016-10-19 14:14:41 +00:00
// not inside octree
2017-03-05 15:44:50 +00:00
p_instance - > octree_id = p_instance - > scenario - > octree . create ( p_instance , new_aabb , 0 , pairable , base_type , pairable_mask ) ;
2016-10-19 14:14:41 +00:00
} else {
2017-01-14 11:26:56 +00:00
/*
if ( new_aabb = = p_instance - > data . transformed_aabb )
return ;
*/
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
p_instance - > scenario - > octree . move ( p_instance - > octree_id , new_aabb ) ;
2016-10-19 14:14:41 +00:00
}
}
void VisualServerScene : : _update_instance_aabb ( Instance * p_instance ) {
2017-11-17 02:09:00 +00:00
AABB new_aabb ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND ( p_instance - > base_type ! = VS : : INSTANCE_NONE & & ! p_instance - > base . is_valid ( ) ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
switch ( p_instance - > base_type ) {
2016-10-19 14:14:41 +00:00
case VisualServer : : INSTANCE_NONE : {
// do nothing
} break ;
case VisualServer : : INSTANCE_MESH : {
2017-11-20 19:54:26 +00:00
if ( p_instance - > custom_aabb )
new_aabb = * p_instance - > custom_aabb ;
else
new_aabb = VSG : : storage - > mesh_get_aabb ( p_instance - > base , p_instance - > skeleton ) ;
2016-10-19 14:14:41 +00:00
} break ;
2016-11-22 04:26:56 +00:00
2016-10-19 14:14:41 +00:00
case VisualServer : : INSTANCE_MULTIMESH : {
2017-11-20 19:54:26 +00:00
if ( p_instance - > custom_aabb )
new_aabb = * p_instance - > custom_aabb ;
else
new_aabb = VSG : : storage - > multimesh_get_aabb ( p_instance - > base ) ;
2016-10-19 14:14:41 +00:00
} break ;
case VisualServer : : INSTANCE_IMMEDIATE : {
2017-11-20 19:54:26 +00:00
if ( p_instance - > custom_aabb )
new_aabb = * p_instance - > custom_aabb ;
else
new_aabb = VSG : : storage - > immediate_get_aabb ( p_instance - > base ) ;
2016-10-19 14:14:41 +00:00
} break ;
2017-04-07 02:36:37 +00:00
case VisualServer : : INSTANCE_PARTICLES : {
2017-11-20 19:54:26 +00:00
if ( p_instance - > custom_aabb )
new_aabb = * p_instance - > custom_aabb ;
else
new_aabb = VSG : : storage - > particles_get_aabb ( p_instance - > base ) ;
2017-04-07 02:36:37 +00:00
} break ;
2016-10-19 14:14:41 +00:00
case VisualServer : : INSTANCE_LIGHT : {
new_aabb = VSG : : storage - > light_get_aabb ( p_instance - > base ) ;
} break ;
2016-11-19 16:23:37 +00:00
case VisualServer : : INSTANCE_REFLECTION_PROBE : {
new_aabb = VSG : : storage - > reflection_probe_get_aabb ( p_instance - > base ) ;
} break ;
2016-12-20 03:21:07 +00:00
case VisualServer : : INSTANCE_GI_PROBE : {
new_aabb = VSG : : storage - > gi_probe_get_bounds ( p_instance - > base ) ;
2017-12-14 11:59:46 +00:00
} break ;
case VisualServer : : INSTANCE_LIGHTMAP_CAPTURE : {
new_aabb = VSG : : storage - > lightmap_capture_get_bounds ( p_instance - > base ) ;
2016-12-20 03:21:07 +00:00
} break ;
2019-04-09 15:08:36 +00:00
default : {
}
2016-10-19 14:14:41 +00:00
}
2017-11-20 19:54:26 +00:00
// <Zylann> This is why I didn't re-use Instance::aabb to implement custom AABBs
2016-10-19 14:14:41 +00:00
if ( p_instance - > extra_margin )
new_aabb . grow_by ( p_instance - > extra_margin ) ;
2017-03-05 15:44:50 +00:00
p_instance - > aabb = new_aabb ;
2016-10-19 14:14:41 +00:00
}
2017-12-14 11:59:46 +00:00
_FORCE_INLINE_ static void _light_capture_sample_octree ( const RasterizerStorage : : LightmapCaptureOctree * p_octree , int p_cell_subdiv , const Vector3 & p_pos , const Vector3 & p_dir , float p_level , Vector3 & r_color , float & r_alpha ) {
static const Vector3 aniso_normal [ 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 )
} ;
int size = 1 < < ( p_cell_subdiv - 1 ) ;
int clamp_v = size - 1 ;
//first of all, clamp
Vector3 pos ;
pos . x = CLAMP ( p_pos . x , 0 , clamp_v ) ;
pos . y = CLAMP ( p_pos . y , 0 , clamp_v ) ;
pos . z = CLAMP ( p_pos . z , 0 , clamp_v ) ;
float level = ( p_cell_subdiv - 1 ) - p_level ;
int target_level ;
float level_filter ;
if ( level < = 0.0 ) {
level_filter = 0 ;
target_level = 0 ;
} else {
target_level = Math : : ceil ( level ) ;
level_filter = target_level - level ;
}
Vector3 color [ 2 ] [ 8 ] ;
float alpha [ 2 ] [ 8 ] ;
zeromem ( alpha , sizeof ( float ) * 2 * 8 ) ;
//find cell at given level first
for ( int c = 0 ; c < 2 ; c + + ) {
int current_level = MAX ( 0 , target_level - c ) ;
int level_cell_size = ( 1 < < ( p_cell_subdiv - 1 ) ) > > current_level ;
for ( int n = 0 ; n < 8 ; n + + ) {
int x = int ( pos . x ) ;
int y = int ( pos . y ) ;
int z = int ( pos . z ) ;
if ( n & 1 )
x + = level_cell_size ;
if ( n & 2 )
y + = level_cell_size ;
if ( n & 4 )
z + = level_cell_size ;
int ofs_x = 0 ;
int ofs_y = 0 ;
int ofs_z = 0 ;
x = CLAMP ( x , 0 , clamp_v ) ;
y = CLAMP ( y , 0 , clamp_v ) ;
z = CLAMP ( z , 0 , clamp_v ) ;
int half = size / 2 ;
uint32_t cell = 0 ;
for ( int i = 0 ; i < current_level ; i + + ) {
const RasterizerStorage : : LightmapCaptureOctree * bc = & p_octree [ cell ] ;
int child = 0 ;
if ( x > = ofs_x + half ) {
child | = 1 ;
ofs_x + = half ;
}
if ( y > = ofs_y + half ) {
child | = 2 ;
ofs_y + = half ;
}
if ( z > = ofs_z + half ) {
child | = 4 ;
ofs_z + = half ;
}
cell = bc - > children [ child ] ;
if ( cell = = RasterizerStorage : : LightmapCaptureOctree : : CHILD_EMPTY )
break ;
half > > = 1 ;
}
if ( cell = = RasterizerStorage : : LightmapCaptureOctree : : CHILD_EMPTY ) {
alpha [ c ] [ n ] = 0 ;
} else {
alpha [ c ] [ n ] = p_octree [ cell ] . alpha ;
for ( int i = 0 ; i < 6 ; i + + ) {
//anisotropic read light
float amount = p_dir . dot ( aniso_normal [ i ] ) ;
if ( amount < 0 )
amount = 0 ;
color [ c ] [ n ] . x + = p_octree [ cell ] . light [ i ] [ 0 ] / 1024.0 * amount ;
color [ c ] [ n ] . y + = p_octree [ cell ] . light [ i ] [ 1 ] / 1024.0 * amount ;
color [ c ] [ n ] . z + = p_octree [ cell ] . light [ i ] [ 2 ] / 1024.0 * amount ;
}
}
//print_line("\tlev " + itos(c) + " - " + itos(n) + " alpha: " + rtos(cells[test_cell].alpha) + " col: " + color[c][n]);
}
}
float target_level_size = size > > target_level ;
Vector3 pos_fract [ 2 ] ;
pos_fract [ 0 ] . x = Math : : fmod ( pos . x , target_level_size ) / target_level_size ;
pos_fract [ 0 ] . y = Math : : fmod ( pos . y , target_level_size ) / target_level_size ;
pos_fract [ 0 ] . z = Math : : fmod ( pos . z , target_level_size ) / target_level_size ;
target_level_size = size > > MAX ( 0 , target_level - 1 ) ;
pos_fract [ 1 ] . x = Math : : fmod ( pos . x , target_level_size ) / target_level_size ;
pos_fract [ 1 ] . y = Math : : fmod ( pos . y , target_level_size ) / target_level_size ;
pos_fract [ 1 ] . z = Math : : fmod ( pos . z , target_level_size ) / target_level_size ;
float alpha_interp [ 2 ] ;
Vector3 color_interp [ 2 ] ;
for ( int i = 0 ; i < 2 ; i + + ) {
Vector3 color_x00 = color [ i ] [ 0 ] . linear_interpolate ( color [ i ] [ 1 ] , pos_fract [ i ] . x ) ;
Vector3 color_xy0 = color [ i ] [ 2 ] . linear_interpolate ( color [ i ] [ 3 ] , pos_fract [ i ] . x ) ;
Vector3 blend_z0 = color_x00 . linear_interpolate ( color_xy0 , pos_fract [ i ] . y ) ;
Vector3 color_x0z = color [ i ] [ 4 ] . linear_interpolate ( color [ i ] [ 5 ] , pos_fract [ i ] . x ) ;
Vector3 color_xyz = color [ i ] [ 6 ] . linear_interpolate ( color [ i ] [ 7 ] , pos_fract [ i ] . x ) ;
Vector3 blend_z1 = color_x0z . linear_interpolate ( color_xyz , pos_fract [ i ] . y ) ;
color_interp [ i ] = blend_z0 . linear_interpolate ( blend_z1 , pos_fract [ i ] . z ) ;
float alpha_x00 = Math : : lerp ( alpha [ i ] [ 0 ] , alpha [ i ] [ 1 ] , pos_fract [ i ] . x ) ;
float alpha_xy0 = Math : : lerp ( alpha [ i ] [ 2 ] , alpha [ i ] [ 3 ] , pos_fract [ i ] . x ) ;
float alpha_z0 = Math : : lerp ( alpha_x00 , alpha_xy0 , pos_fract [ i ] . y ) ;
float alpha_x0z = Math : : lerp ( alpha [ i ] [ 4 ] , alpha [ i ] [ 5 ] , pos_fract [ i ] . x ) ;
float alpha_xyz = Math : : lerp ( alpha [ i ] [ 6 ] , alpha [ i ] [ 7 ] , pos_fract [ i ] . x ) ;
float alpha_z1 = Math : : lerp ( alpha_x0z , alpha_xyz , pos_fract [ i ] . y ) ;
alpha_interp [ i ] = Math : : lerp ( alpha_z0 , alpha_z1 , pos_fract [ i ] . z ) ;
}
r_color = color_interp [ 0 ] . linear_interpolate ( color_interp [ 1 ] , level_filter ) ;
r_alpha = Math : : lerp ( alpha_interp [ 0 ] , alpha_interp [ 1 ] , level_filter ) ;
2018-08-24 07:35:07 +00:00
//print_line("pos: " + p_posf + " level " + rtos(p_level) + " down to " + itos(target_level) + "." + rtos(level_filter) + " color " + r_color + " alpha " + rtos(r_alpha));
2017-12-14 11:59:46 +00:00
}
_FORCE_INLINE_ static Color _light_capture_voxel_cone_trace ( const RasterizerStorage : : LightmapCaptureOctree * p_octree , const Vector3 & p_pos , const Vector3 & p_dir , float p_aperture , int p_cell_subdiv ) {
float bias = 0.0 ; //no need for bias here
float max_distance = ( Vector3 ( 1 , 1 , 1 ) * ( 1 < < ( p_cell_subdiv - 1 ) ) ) . length ( ) ;
float dist = bias ;
float alpha = 0.0 ;
Vector3 color ;
Vector3 scolor ;
float salpha ;
while ( dist < max_distance & & alpha < 0.95 ) {
float diameter = MAX ( 1.0 , 2.0 * p_aperture * dist ) ;
_light_capture_sample_octree ( p_octree , p_cell_subdiv , p_pos + dist * p_dir , p_dir , log2 ( diameter ) , scolor , salpha ) ;
float a = ( 1.0 - alpha ) ;
color + = scolor * a ;
alpha + = a * salpha ;
dist + = diameter * 0.5 ;
}
return Color ( color . x , color . y , color . z , alpha ) ;
}
void VisualServerScene : : _update_instance_lightmap_captures ( Instance * p_instance ) {
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( p_instance - > base_data ) ;
static const Vector3 cone_traces [ 12 ] = {
Vector3 ( 0 , 0 , 1 ) ,
Vector3 ( 0.866025 , 0 , 0.5 ) ,
Vector3 ( 0.267617 , 0.823639 , 0.5 ) ,
Vector3 ( - 0.700629 , 0.509037 , 0.5 ) ,
Vector3 ( - 0.700629 , - 0.509037 , 0.5 ) ,
Vector3 ( 0.267617 , - 0.823639 , 0.5 ) ,
Vector3 ( 0 , 0 , - 1 ) ,
Vector3 ( 0.866025 , 0 , - 0.5 ) ,
Vector3 ( 0.267617 , 0.823639 , - 0.5 ) ,
Vector3 ( - 0.700629 , 0.509037 , - 0.5 ) ,
Vector3 ( - 0.700629 , - 0.509037 , - 0.5 ) ,
Vector3 ( 0.267617 , - 0.823639 , - 0.5 )
} ;
float cone_aperture = 0.577 ; // tan(angle) 60 degrees
if ( p_instance - > lightmap_capture_data . empty ( ) ) {
p_instance - > lightmap_capture_data . resize ( 12 ) ;
}
//print_line("update captures for pos: " + p_instance->transform.origin);
2019-01-25 11:06:44 +00:00
for ( int i = 0 ; i < 12 ; i + + )
new ( & p_instance - > lightmap_capture_data . ptrw ( ) [ i ] ) Color ;
2017-12-14 11:59:46 +00:00
//this could use some sort of blending..
for ( List < Instance * > : : Element * E = geom - > lightmap_captures . front ( ) ; E ; E = E - > next ( ) ) {
const PoolVector < RasterizerStorage : : LightmapCaptureOctree > * octree = VSG : : storage - > lightmap_capture_get_octree_ptr ( E - > get ( ) - > base ) ;
//print_line("octree size: " + itos(octree->size()));
if ( octree - > size ( ) = = 0 )
continue ;
Transform to_cell_xform = VSG : : storage - > lightmap_capture_get_octree_cell_transform ( E - > get ( ) - > base ) ;
int cell_subdiv = VSG : : storage - > lightmap_capture_get_octree_cell_subdiv ( E - > get ( ) - > base ) ;
to_cell_xform = to_cell_xform * E - > get ( ) - > transform . affine_inverse ( ) ;
PoolVector < RasterizerStorage : : LightmapCaptureOctree > : : Read octree_r = octree - > read ( ) ;
Vector3 pos = to_cell_xform . xform ( p_instance - > transform . origin ) ;
for ( int i = 0 ; i < 12 ; i + + ) {
Vector3 dir = to_cell_xform . basis . xform ( cone_traces [ i ] ) . normalized ( ) ;
Color capture = _light_capture_voxel_cone_trace ( octree_r . ptr ( ) , pos , dir , cone_aperture , cell_subdiv ) ;
2018-07-25 01:11:03 +00:00
p_instance - > lightmap_capture_data . write [ i ] + = capture ;
2017-12-14 11:59:46 +00:00
}
}
}
2018-11-14 12:32:39 +00:00
bool VisualServerScene : : _light_instance_update_shadow ( Instance * p_instance , const Transform p_cam_transform , const CameraMatrix & p_cam_projection , bool p_cam_orthogonal , RID p_shadow_atlas , Scenario * p_scenario ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
InstanceLightData * light = static_cast < InstanceLightData * > ( p_instance - > base_data ) ;
2016-10-19 14:14:41 +00:00
2018-07-03 11:34:06 +00:00
Transform light_transform = p_instance - > transform ;
light_transform . orthonormalize ( ) ; //scale does not count on lights
2018-11-14 12:32:39 +00:00
bool animated_material_found = false ;
2017-03-05 15:44:50 +00:00
switch ( VSG : : storage - > light_get_type ( p_instance - > base ) ) {
2016-11-10 02:55:06 +00:00
case VS : : LIGHT_DIRECTIONAL : {
2017-03-05 15:44:50 +00:00
float max_distance = p_cam_projection . get_z_far ( ) ;
float shadow_max = VSG : : storage - > light_get_param ( p_instance - > base , VS : : LIGHT_PARAM_SHADOW_MAX_DISTANCE ) ;
2017-09-07 21:00:47 +00:00
if ( shadow_max > 0 & & ! p_cam_orthogonal ) { //its impractical (and leads to unwanted behaviors) to set max distance in orthogonal camera
2017-03-05 15:44:50 +00:00
max_distance = MIN ( shadow_max , max_distance ) ;
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
max_distance = MAX ( max_distance , p_cam_projection . get_z_near ( ) + 0.001 ) ;
2017-09-07 19:48:50 +00:00
float min_distance = MIN ( p_cam_projection . get_z_near ( ) , max_distance ) ;
2016-11-10 02:55:06 +00:00
2017-09-07 21:00:47 +00:00
VS : : LightDirectionalShadowDepthRangeMode depth_range_mode = VSG : : storage - > light_directional_get_shadow_depth_range_mode ( p_instance - > base ) ;
2017-09-07 19:48:50 +00:00
if ( depth_range_mode = = VS : : LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_OPTIMIZED ) {
2017-09-07 21:00:47 +00:00
//optimize min/max
Vector < Plane > planes = p_cam_projection . get_projection_planes ( p_cam_transform ) ;
int cull_count = p_scenario - > octree . cull_convex ( planes , instance_shadow_cull_result , MAX_INSTANCE_CULL , VS : : INSTANCE_GEOMETRY_MASK ) ;
2017-09-07 19:48:50 +00:00
Plane base ( p_cam_transform . origin , - p_cam_transform . basis . get_axis ( 2 ) ) ;
2017-09-07 21:00:47 +00:00
//check distance max and min
2017-09-07 19:48:50 +00:00
bool found_items = false ;
float z_max = - 1e20 ;
float z_min = 1e20 ;
2017-09-07 21:00:47 +00:00
2017-09-07 19:48:50 +00:00
for ( int i = 0 ; i < cull_count ; i + + ) {
2017-09-07 21:00:47 +00:00
Instance * instance = instance_shadow_cull_result [ i ] ;
if ( ! instance - > visible | | ! ( ( 1 < < instance - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) | | ! static_cast < InstanceGeometryData * > ( instance - > base_data ) - > can_cast_shadows ) {
continue ;
}
2018-11-14 12:32:39 +00:00
if ( static_cast < InstanceGeometryData * > ( instance - > base_data ) - > material_is_animated ) {
animated_material_found = true ;
}
2017-09-07 19:48:50 +00:00
float max , min ;
2017-09-07 21:00:47 +00:00
instance - > transformed_aabb . project_range_in_plane ( base , min , max ) ;
2017-09-07 19:48:50 +00:00
if ( max > z_max ) {
z_max = max ;
2017-09-07 21:00:47 +00:00
}
2017-09-07 19:48:50 +00:00
if ( min < z_min ) {
z_min = min ;
2017-09-07 21:00:47 +00:00
}
2017-09-07 19:48:50 +00:00
found_items = true ;
2017-09-07 21:00:47 +00:00
}
if ( found_items ) {
2017-09-07 19:48:50 +00:00
min_distance = MAX ( min_distance , z_min ) ;
max_distance = MIN ( max_distance , z_max ) ;
2017-09-07 21:00:47 +00:00
}
}
float range = max_distance - min_distance ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
int splits = 0 ;
switch ( VSG : : storage - > light_directional_get_shadow_mode ( p_instance - > base ) ) {
case VS : : LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL : splits = 1 ; break ;
case VS : : LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS : splits = 2 ; break ;
case VS : : LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS : splits = 4 ; break ;
2016-11-10 02:55:06 +00:00
}
float distances [ 5 ] ;
2017-09-07 21:00:47 +00:00
distances [ 0 ] = min_distance ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < splits ; i + + ) {
2017-09-07 21:00:47 +00:00
distances [ i + 1 ] = min_distance + VSG : : storage - > light_get_param ( p_instance - > base , VS : : LightParam ( VS : : LIGHT_PARAM_SHADOW_SPLIT_1_OFFSET + i ) ) * range ;
2016-11-10 02:55:06 +00:00
} ;
2017-03-05 15:44:50 +00:00
distances [ splits ] = max_distance ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
float texture_size = VSG : : scene_render - > get_directional_light_shadow_size ( light - > instance ) ;
2016-11-10 02:55:06 +00:00
2016-11-11 15:27:52 +00:00
bool overlap = VSG : : storage - > light_directional_get_blend_splits ( p_instance - > base ) ;
2016-11-10 02:55:06 +00:00
2017-06-14 19:56:47 +00:00
float first_radius = 0.0 ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < splits ; i + + ) {
2016-11-10 02:55:06 +00:00
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " Culling Directional Light split " + itos ( i ) ) ;
2016-11-10 02:55:06 +00:00
// setup a camera matrix for that range!
CameraMatrix camera_matrix ;
2016-11-19 16:23:37 +00:00
float aspect = p_cam_projection . get_aspect ( ) ;
2016-11-10 02:55:06 +00:00
2016-11-19 16:23:37 +00:00
if ( p_cam_orthogonal ) {
2016-11-10 02:55:06 +00:00
2020-01-21 18:39:16 +00:00
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 ) ;
2016-11-19 16:23:37 +00:00
} else {
2016-11-10 02:55:06 +00:00
2016-11-19 16:23:37 +00:00
float fov = p_cam_projection . get_fov ( ) ;
2017-03-05 15:44:50 +00:00
camera_matrix . set_perspective ( fov , aspect , distances [ ( i = = 0 | | ! overlap ) ? i : i - 1 ] , distances [ i + 1 ] , false ) ;
2016-11-10 02:55:06 +00:00
}
//obtain the frustum endpoints
Vector3 endpoints [ 8 ] ; // frustum plane endpoints
2017-03-05 15:44:50 +00:00
bool res = camera_matrix . get_endpoints ( p_cam_transform , endpoints ) ;
2016-11-10 02:55:06 +00:00
ERR_CONTINUE ( ! res ) ;
// obtain the light frustm ranges (given endpoints)
2018-07-03 11:34:06 +00:00
Transform transform = light_transform ; //discard scale and stabilize light
2017-06-14 19:56:47 +00:00
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 ( ) ;
2016-11-10 02:55:06 +00:00
//z_vec points agsint the camera, like in default opengl
2017-09-01 20:33:39 +00:00
float x_min = 0.f , x_max = 0.f ;
float y_min = 0.f , y_max = 0.f ;
float z_min = 0.f , z_max = 0.f ;
2016-11-10 02:55:06 +00:00
2018-09-27 10:07:59 +00:00
// 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.
2017-09-01 20:33:39 +00:00
float x_min_cam = 0.f , x_max_cam = 0.f ;
float y_min_cam = 0.f , y_max_cam = 0.f ;
2018-09-27 10:07:59 +00:00
float z_min_cam = 0.f ;
//float z_max_cam = 0.f;
2016-11-10 02:55:06 +00:00
2017-06-14 19:56:47 +00:00
float bias_scale = 1.0 ;
2016-11-10 02:55:06 +00:00
//used for culling
2017-06-14 19:56:47 +00:00
2017-03-05 15:44:50 +00:00
for ( int j = 0 ; j < 8 ; j + + ) {
float d_x = x_vec . dot ( endpoints [ j ] ) ;
float d_y = y_vec . dot ( endpoints [ j ] ) ;
float 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 ;
2016-11-10 02:55:06 +00:00
}
{
//camera viewport stuff
Vector3 center ;
2017-03-05 15:44:50 +00:00
for ( int j = 0 ; j < 8 ; j + + ) {
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
center + = endpoints [ j ] ;
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
center / = 8.0 ;
2016-11-10 02:55:06 +00:00
//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;
2017-03-05 15:44:50 +00:00
float radius = 0 ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
for ( int j = 0 ; j < 8 ; j + + ) {
2016-11-10 02:55:06 +00:00
float d = center . distance_to ( endpoints [ j ] ) ;
2017-03-05 15:44:50 +00:00
if ( d > radius )
radius = d ;
2016-11-10 02:55:06 +00:00
}
2017-09-07 21:00:47 +00:00
radius * = texture_size / ( texture_size - 2.0 ) ; //add a texel by each side
2016-11-10 02:55:06 +00:00
2017-06-14 19:56:47 +00:00
if ( i = = 0 ) {
first_radius = radius ;
} else {
bias_scale = radius / first_radius ;
}
2017-03-05 15:44:50 +00:00
x_max_cam = x_vec . dot ( center ) + radius ;
x_min_cam = x_vec . dot ( center ) - radius ;
y_max_cam = y_vec . dot ( center ) + radius ;
y_min_cam = y_vec . dot ( center ) - radius ;
2018-09-27 10:07:59 +00:00
//z_max_cam = z_vec.dot(center) + radius;
2017-03-05 15:44:50 +00:00
z_min_cam = z_vec . dot ( center ) - radius ;
2016-11-10 02:55:06 +00:00
2017-09-07 19:48:50 +00:00
if ( depth_range_mode = = VS : : LIGHT_DIRECTIONAL_SHADOW_DEPTH_RANGE_STABLE ) {
2017-09-07 21:00:47 +00:00
//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
float unit = radius * 2.0 / texture_size ;
x_max_cam = Math : : stepify ( x_max_cam , unit ) ;
x_min_cam = Math : : stepify ( x_min_cam , unit ) ;
y_max_cam = Math : : stepify ( y_max_cam , unit ) ;
y_min_cam = Math : : stepify ( y_min_cam , unit ) ;
}
2016-11-10 02:55:06 +00:00
}
//now that we now all ranges, we can proceed to make the light frustum planes, for culling octree
Vector < Plane > light_frustum_planes ;
light_frustum_planes . resize ( 6 ) ;
//right/left
2018-07-25 01:11:03 +00:00
light_frustum_planes . write [ 0 ] = Plane ( x_vec , x_max ) ;
light_frustum_planes . write [ 1 ] = Plane ( - x_vec , - x_min ) ;
2016-11-10 02:55:06 +00:00
//top/bottom
2018-07-25 01:11:03 +00:00
light_frustum_planes . write [ 2 ] = Plane ( y_vec , y_max ) ;
light_frustum_planes . write [ 3 ] = Plane ( - y_vec , - y_min ) ;
2016-11-10 02:55:06 +00:00
//near/far
2018-07-25 01:11:03 +00:00
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
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
int cull_count = p_scenario - > octree . cull_convex ( light_frustum_planes , instance_shadow_cull_result , MAX_INSTANCE_CULL , VS : : INSTANCE_GEOMETRY_MASK ) ;
2016-11-10 02:55:06 +00:00
// a pre pass will need to be needed to determine the actual z-near to be used
2018-07-03 11:34:06 +00:00
Plane near_plane ( light_transform . origin , - light_transform . basis . get_axis ( 2 ) ) ;
2017-07-15 04:23:10 +00:00
2017-03-05 15:44:50 +00:00
for ( int j = 0 ; j < cull_count ; j + + ) {
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
float min , max ;
2016-11-10 02:55:06 +00:00
Instance * instance = instance_shadow_cull_result [ j ] ;
2017-03-05 15:44:50 +00:00
if ( ! instance - > visible | | ! ( ( 1 < < instance - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) | | ! static_cast < InstanceGeometryData * > ( instance - > base_data ) - > can_cast_shadows ) {
2016-11-10 02:55:06 +00:00
cull_count - - ;
2017-03-05 15:44:50 +00:00
SWAP ( instance_shadow_cull_result [ j ] , instance_shadow_cull_result [ cull_count ] ) ;
2016-11-10 02:55:06 +00:00
j - - ;
2017-02-16 11:55:11 +00:00
continue ;
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
instance - > transformed_aabb . project_range_in_plane ( Plane ( z_vec , 0 ) , min , max ) ;
2017-07-15 04:23:10 +00:00
instance - > depth = near_plane . distance_to ( instance - > transform . origin ) ;
instance - > depth_layer = 0 ;
2017-03-05 15:44:50 +00:00
if ( max > z_max )
z_max = max ;
2016-11-10 02:55:06 +00:00
}
{
2017-09-07 21:00:47 +00:00
2016-11-10 02:55:06 +00:00
CameraMatrix ortho_camera ;
2017-03-05 15:44:50 +00:00
real_t half_x = ( x_max_cam - x_min_cam ) * 0.5 ;
real_t half_y = ( y_max_cam - y_min_cam ) * 0.5 ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
ortho_camera . set_orthogonal ( - half_x , half_x , - half_y , half_y , 0 , ( z_max - z_min_cam ) ) ;
2016-11-10 02:55:06 +00:00
Transform ortho_transform ;
2017-06-14 19:56:47 +00:00
ortho_transform . basis = transform . basis ;
2017-03-05 15:44:50 +00:00
ortho_transform . origin = x_vec * ( x_min_cam + half_x ) + y_vec * ( y_min_cam + half_y ) + z_vec * z_max ;
2016-11-10 02:55:06 +00:00
2017-06-14 19:56:47 +00:00
VSG : : scene_render - > light_instance_set_shadow_transform ( light - > instance , ortho_camera , ortho_transform , 0 , distances [ i + 1 ] , i , bias_scale ) ;
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
VSG : : scene_render - > render_shadow ( light - > instance , p_shadow_atlas , i , ( RasterizerScene : : InstanceBase * * ) instance_shadow_cull_result , cull_count ) ;
2016-11-10 02:55:06 +00:00
}
} break ;
case VS : : LIGHT_OMNI : {
VS : : LightOmniShadowMode shadow_mode = VSG : : storage - > light_omni_get_shadow_mode ( p_instance - > base ) ;
2019-01-22 13:04:25 +00:00
if ( shadow_mode = = VS : : LIGHT_OMNI_SHADOW_DUAL_PARABOLOID | | ! VSG : : scene_render - > light_instances_can_render_shadow_cube ( ) ) {
2016-11-10 02:55:06 +00:00
2019-01-22 13:04:25 +00:00
for ( int i = 0 ; i < 2 ; i + + ) {
2016-11-10 02:55:06 +00:00
2019-01-22 13:04:25 +00:00
//using this one ensures that raster deferred will have it
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " Culling Shadow Paraboloid " + itos ( i ) ) ;
2016-11-10 02:55:06 +00:00
2019-01-22 13:04:25 +00:00
float radius = VSG : : storage - > light_get_param ( p_instance - > base , VS : : LIGHT_PARAM_RANGE ) ;
2016-11-10 02:55:06 +00:00
2019-01-22 13:04:25 +00:00
float z = i = = 0 ? - 1 : 1 ;
Vector < Plane > planes ;
planes . resize ( 5 ) ;
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 ) ) ;
int cull_count = p_scenario - > octree . cull_convex ( planes , instance_shadow_cull_result , MAX_INSTANCE_CULL , VS : : INSTANCE_GEOMETRY_MASK ) ;
Plane near_plane ( light_transform . origin , light_transform . basis . get_axis ( 2 ) * z ) ;
for ( int j = 0 ; j < cull_count ; j + + ) {
Instance * instance = instance_shadow_cull_result [ j ] ;
if ( ! instance - > visible | | ! ( ( 1 < < instance - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) | | ! static_cast < InstanceGeometryData * > ( instance - > base_data ) - > can_cast_shadows ) {
cull_count - - ;
SWAP ( instance_shadow_cull_result [ j ] , instance_shadow_cull_result [ cull_count ] ) ;
j - - ;
} else {
if ( static_cast < InstanceGeometryData * > ( instance - > base_data ) - > material_is_animated ) {
animated_material_found = true ;
}
2016-11-10 02:55:06 +00:00
2019-01-22 13:04:25 +00:00
instance - > depth = near_plane . distance_to ( instance - > transform . origin ) ;
instance - > depth_layer = 0 ;
}
}
2016-11-10 02:55:06 +00:00
2019-01-22 13:04:25 +00:00
VSG : : scene_render - > light_instance_set_shadow_transform ( light - > instance , CameraMatrix ( ) , light_transform , radius , 0 , i ) ;
VSG : : scene_render - > render_shadow ( light - > instance , p_shadow_atlas , i , ( RasterizerScene : : InstanceBase * * ) instance_shadow_cull_result , cull_count ) ;
}
} else { //shadow cube
2016-11-10 02:55:06 +00:00
2019-01-22 13:04:25 +00:00
float radius = VSG : : storage - > light_get_param ( p_instance - > base , VS : : LIGHT_PARAM_RANGE ) ;
CameraMatrix cm ;
cm . set_perspective ( 90 , 1 , 0.01 , radius ) ;
2018-11-14 12:32:39 +00:00
2019-01-22 13:04:25 +00:00
for ( int i = 0 ; i < 6 ; i + + ) {
2016-11-10 02:55:06 +00:00
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " Culling Shadow Cube side " + itos ( i ) ) ;
2019-01-22 13:04:25 +00:00
//using this one ensures that raster deferred will have it
static const Vector3 view_normals [ 6 ] = {
Vector3 ( + 1 , 0 , 0 ) ,
2019-09-07 01:51:27 +00:00
Vector3 ( - 1 , 0 , 0 ) ,
2019-01-22 13:04:25 +00:00
Vector3 ( 0 , - 1 , 0 ) ,
Vector3 ( 0 , + 1 , 0 ) ,
2019-09-07 01:51:27 +00:00
Vector3 ( 0 , 0 , + 1 ) ,
Vector3 ( 0 , 0 , - 1 )
2019-01-22 13:04:25 +00:00
} ;
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 )
} ;
Transform xform = light_transform * Transform ( ) . looking_at ( view_normals [ i ] , view_up [ i ] ) ;
Vector < Plane > planes = cm . get_projection_planes ( xform ) ;
int cull_count = p_scenario - > octree . cull_convex ( planes , instance_shadow_cull_result , MAX_INSTANCE_CULL , VS : : INSTANCE_GEOMETRY_MASK ) ;
Plane near_plane ( xform . origin , - xform . basis . get_axis ( 2 ) ) ;
for ( int j = 0 ; j < cull_count ; j + + ) {
Instance * instance = instance_shadow_cull_result [ j ] ;
if ( ! instance - > visible | | ! ( ( 1 < < instance - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) | | ! static_cast < InstanceGeometryData * > ( instance - > base_data ) - > can_cast_shadows ) {
cull_count - - ;
SWAP ( instance_shadow_cull_result [ j ] , instance_shadow_cull_result [ cull_count ] ) ;
j - - ;
} else {
if ( static_cast < InstanceGeometryData * > ( instance - > base_data ) - > material_is_animated ) {
animated_material_found = true ;
2016-11-10 02:55:06 +00:00
}
2019-01-22 13:04:25 +00:00
instance - > depth = near_plane . distance_to ( instance - > transform . origin ) ;
instance - > depth_layer = 0 ;
2016-11-10 02:55:06 +00:00
}
}
2019-01-22 13:04:25 +00:00
VSG : : scene_render - > light_instance_set_shadow_transform ( light - > instance , cm , xform , radius , 0 , i ) ;
VSG : : scene_render - > render_shadow ( light - > instance , p_shadow_atlas , i , ( RasterizerScene : : InstanceBase * * ) instance_shadow_cull_result , cull_count ) ;
}
2016-11-10 02:55:06 +00:00
2019-01-22 13:04:25 +00:00
//restore the regular DP matrix
VSG : : scene_render - > light_instance_set_shadow_transform ( light - > instance , CameraMatrix ( ) , light_transform , radius , 0 , 0 ) ;
2016-11-10 02:55:06 +00:00
}
} break ;
case VS : : LIGHT_SPOT : {
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " Culling Spot Light " ) ;
2017-03-05 15:44:50 +00:00
float radius = VSG : : storage - > light_get_param ( p_instance - > base , VS : : LIGHT_PARAM_RANGE ) ;
float angle = VSG : : storage - > light_get_param ( p_instance - > base , VS : : LIGHT_PARAM_SPOT_ANGLE ) ;
2016-11-10 02:55:06 +00:00
CameraMatrix cm ;
2017-03-05 15:44:50 +00:00
cm . set_perspective ( angle * 2.0 , 1.0 , 0.01 , radius ) ;
2016-11-10 02:55:06 +00:00
2018-07-03 11:34:06 +00:00
Vector < Plane > planes = cm . get_projection_planes ( light_transform ) ;
2017-03-05 15:44:50 +00:00
int cull_count = p_scenario - > octree . cull_convex ( planes , instance_shadow_cull_result , MAX_INSTANCE_CULL , VS : : INSTANCE_GEOMETRY_MASK ) ;
2016-11-10 02:55:06 +00:00
2018-07-03 11:34:06 +00:00
Plane near_plane ( light_transform . origin , - light_transform . basis . get_axis ( 2 ) ) ;
2017-03-05 15:44:50 +00:00
for ( int j = 0 ; j < cull_count ; j + + ) {
2016-11-10 02:55:06 +00:00
Instance * instance = instance_shadow_cull_result [ j ] ;
2017-03-05 15:44:50 +00:00
if ( ! instance - > visible | | ! ( ( 1 < < instance - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) | | ! static_cast < InstanceGeometryData * > ( instance - > base_data ) - > can_cast_shadows ) {
2016-11-10 02:55:06 +00:00
cull_count - - ;
2017-03-05 15:44:50 +00:00
SWAP ( instance_shadow_cull_result [ j ] , instance_shadow_cull_result [ cull_count ] ) ;
2016-11-10 02:55:06 +00:00
j - - ;
2017-07-15 04:23:10 +00:00
} else {
2018-11-14 12:32:39 +00:00
if ( static_cast < InstanceGeometryData * > ( instance - > base_data ) - > material_is_animated ) {
animated_material_found = true ;
}
2017-07-15 04:23:10 +00:00
instance - > depth = near_plane . distance_to ( instance - > transform . origin ) ;
instance - > depth_layer = 0 ;
2016-11-10 02:55:06 +00:00
}
}
2018-07-03 11:34:06 +00:00
VSG : : scene_render - > light_instance_set_shadow_transform ( light - > instance , cm , light_transform , radius , 0 , 0 ) ;
2017-03-05 15:44:50 +00:00
VSG : : scene_render - > render_shadow ( light - > instance , p_shadow_atlas , 0 , ( RasterizerScene : : InstanceBase * * ) instance_shadow_cull_result , cull_count ) ;
2016-11-10 02:55:06 +00:00
} break ;
}
2018-11-14 12:32:39 +00:00
return animated_material_found ;
2016-11-10 02:55:06 +00:00
}
2019-08-18 22:40:52 +00:00
void VisualServerScene : : render_camera ( RID p_render_buffers , RID p_camera , RID p_scenario , Size2 p_viewport_size , RID p_shadow_atlas ) {
2018-07-21 20:26:14 +00:00
// render to mono camera
# ifndef _3D_DISABLED
2016-11-10 02:55:06 +00:00
2016-10-19 14:14:41 +00:00
Camera * camera = camera_owner . getornull ( p_camera ) ;
ERR_FAIL_COND ( ! camera ) ;
/* STEP 1 - SETUP CAMERA */
CameraMatrix camera_matrix ;
2017-03-05 15:44:50 +00:00
bool ortho = false ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
switch ( camera - > type ) {
2016-10-19 14:14:41 +00:00
case Camera : : ORTHOGONAL : {
camera_matrix . set_orthogonal (
2017-03-05 15:44:50 +00:00
camera - > size ,
p_viewport_size . width / ( float ) p_viewport_size . height ,
camera - > znear ,
camera - > zfar ,
2017-12-06 20:36:34 +00:00
camera - > vaspect ) ;
2017-03-05 15:44:50 +00:00
ortho = true ;
2016-10-19 14:14:41 +00:00
} break ;
case Camera : : PERSPECTIVE : {
camera_matrix . set_perspective (
2017-03-05 15:44:50 +00:00
camera - > fov ,
p_viewport_size . width / ( float ) p_viewport_size . height ,
camera - > znear ,
camera - > zfar ,
2017-12-06 20:36:34 +00:00
camera - > vaspect ) ;
2017-03-05 15:44:50 +00:00
ortho = false ;
2016-10-19 14:14:41 +00:00
} break ;
2019-02-19 16:17:02 +00:00
case Camera : : FRUSTUM : {
camera_matrix . set_frustum (
camera - > size ,
p_viewport_size . width / ( float ) p_viewport_size . height ,
camera - > offset ,
camera - > znear ,
camera - > zfar ,
camera - > vaspect ) ;
ortho = false ;
} break ;
2016-10-19 14:14:41 +00:00
}
2018-06-11 11:51:30 +00:00
_prepare_scene ( camera - > transform , camera_matrix , ortho , camera - > env , camera - > visible_layers , p_scenario , p_shadow_atlas , RID ( ) ) ;
2019-08-18 22:40:52 +00:00
_render_scene ( p_render_buffers , camera - > transform , camera_matrix , ortho , camera - > env , p_scenario , p_shadow_atlas , RID ( ) , - 1 ) ;
2018-07-21 20:26:14 +00:00
# endif
2016-11-19 16:23:37 +00:00
}
2019-08-18 22:40:52 +00:00
void VisualServerScene : : render_camera ( RID p_render_buffers , Ref < ARVRInterface > & p_interface , ARVRInterface : : Eyes p_eye , RID p_camera , RID p_scenario , Size2 p_viewport_size , RID p_shadow_atlas ) {
2017-04-23 12:10:41 +00:00
// render for AR/VR interface
Camera * camera = camera_owner . getornull ( p_camera ) ;
ERR_FAIL_COND ( ! camera ) ;
/* SETUP CAMERA, we are ignoring type and FOV here */
float aspect = p_viewport_size . width / ( float ) p_viewport_size . height ;
CameraMatrix camera_matrix = p_interface - > get_projection_for_eye ( p_eye , aspect , camera - > znear , camera - > zfar ) ;
// We also ignore our camera position, it will have been positioned with a slightly old tracking position.
// Instead we take our origin point and have our ar/vr interface add fresh tracking data! Whoohoo!
Transform world_origin = ARVRServer : : get_singleton ( ) - > get_world_origin ( ) ;
Transform cam_transform = p_interface - > get_transform_for_eye ( p_eye , world_origin ) ;
2018-06-11 11:51:30 +00:00
// For stereo render we only prepare for our left eye and then reuse the outcome for our right eye
if ( p_eye = = ARVRInterface : : EYE_LEFT ) {
///@TODO possibly move responsibility for this into our ARVRServer or ARVRInterface?
// Center our transform, we assume basis is equal.
Transform mono_transform = cam_transform ;
Transform right_transform = p_interface - > get_transform_for_eye ( ARVRInterface : : EYE_RIGHT , world_origin ) ;
mono_transform . origin + = right_transform . origin ;
mono_transform . origin * = 0.5 ;
// We need to combine our projection frustums for culling.
// Ideally we should use our clipping planes for this and combine them,
// however our shadow map logic uses our projection matrix.
// Note: as our left and right frustums should be mirrored, we don't need our right projection matrix.
// - get some base values we need
float eye_dist = ( mono_transform . origin - cam_transform . origin ) . length ( ) ;
float z_near = camera_matrix . get_z_near ( ) ; // get our near plane
float z_far = camera_matrix . get_z_far ( ) ; // get our far plane
float width = ( 2.0 * z_near ) / camera_matrix . matrix [ 0 ] [ 0 ] ;
float x_shift = width * camera_matrix . matrix [ 2 ] [ 0 ] ;
float height = ( 2.0 * z_near ) / camera_matrix . matrix [ 1 ] [ 1 ] ;
2018-06-23 12:22:57 +00:00
float y_shift = height * camera_matrix . matrix [ 2 ] [ 1 ] ;
2018-06-11 11:51:30 +00:00
// printf("Eye_dist = %f, Near = %f, Far = %f, Width = %f, Shift = %f\n", eye_dist, z_near, z_far, width, x_shift);
// - calculate our near plane size (horizontal only, right_near is mirrored)
float left_near = - eye_dist - ( ( width - x_shift ) * 0.5 ) ;
// - calculate our far plane size (horizontal only, right_far is mirrored)
float left_far = - eye_dist - ( z_far * ( width - x_shift ) * 0.5 / z_near ) ;
float left_far_right_eye = eye_dist - ( z_far * ( width + x_shift ) * 0.5 / z_near ) ;
if ( left_far > left_far_right_eye ) {
// on displays smaller then double our iod, the right eye far frustrum can overtake the left eyes.
left_far = left_far_right_eye ;
}
// - figure out required z-shift
float slope = ( left_far - left_near ) / ( z_far - z_near ) ;
float z_shift = ( left_near / slope ) - z_near ;
// - figure out new vertical near plane size (this will be slightly oversized thanks to our z-shift)
2018-06-23 12:22:57 +00:00
float top_near = ( height - y_shift ) * 0.5 ;
top_near + = ( top_near / z_near ) * z_shift ;
float bottom_near = - ( height + y_shift ) * 0.5 ;
bottom_near + = ( bottom_near / z_near ) * z_shift ;
2018-06-11 11:51:30 +00:00
// printf("Left_near = %f, Left_far = %f, Top_near = %f, Bottom_near = %f, Z_shift = %f\n", left_near, left_far, top_near, bottom_near, z_shift);
// - generate our frustum
CameraMatrix combined_matrix ;
combined_matrix . set_frustum ( left_near , - left_near , bottom_near , top_near , z_near + z_shift , z_far + z_shift ) ;
// and finally move our camera back
Transform apply_z_shift ;
apply_z_shift . origin = Vector3 ( 0.0 , 0.0 , z_shift ) ; // z negative is forward so this moves it backwards
mono_transform * = apply_z_shift ;
// now prepare our scene with our adjusted transform projection matrix
_prepare_scene ( mono_transform , combined_matrix , false , camera - > env , camera - > visible_layers , p_scenario , p_shadow_atlas , RID ( ) ) ;
} else if ( p_eye = = ARVRInterface : : EYE_MONO ) {
// For mono render, prepare as per usual
_prepare_scene ( cam_transform , camera_matrix , false , camera - > env , camera - > visible_layers , p_scenario , p_shadow_atlas , RID ( ) ) ;
}
// And render our scene...
2019-08-18 22:40:52 +00:00
_render_scene ( p_render_buffers , cam_transform , camera_matrix , false , camera - > env , p_scenario , p_shadow_atlas , RID ( ) , - 1 ) ;
2017-04-23 12:10:41 +00:00
} ;
2019-09-09 20:50:51 +00:00
void VisualServerScene : : _prepare_scene ( const Transform p_cam_transform , const CameraMatrix & p_cam_projection , bool p_cam_orthogonal , RID p_force_environment , uint32_t p_visible_layers , RID p_scenario , RID p_shadow_atlas , RID p_reflection_probe , bool p_using_shadows ) {
2018-06-11 11:51:30 +00:00
// Note, in stereo rendering:
// - p_cam_transform will be a transform in the middle of our two eyes
// - p_cam_projection is a wider frustrum that encompasses both eyes
2016-11-19 16:23:37 +00:00
Scenario * scenario = scenario_owner . getornull ( p_scenario ) ;
render_pass + + ;
2017-03-05 15:44:50 +00:00
uint32_t camera_layer_mask = p_visible_layers ;
2016-11-19 16:23:37 +00:00
VSG : : scene_render - > set_scene_pass ( render_pass ) ;
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " Frustum Culling " ) ;
2017-01-14 11:26:56 +00:00
//rasterizer->set_camera(camera->transform, camera_matrix,ortho);
2016-10-19 14:14:41 +00:00
2016-11-19 16:23:37 +00:00
Vector < Plane > planes = p_cam_projection . get_projection_planes ( p_cam_transform ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
Plane near_plane ( p_cam_transform . origin , - p_cam_transform . basis . get_axis ( 2 ) . normalized ( ) ) ;
2016-11-19 16:23:37 +00:00
float z_far = p_cam_projection . get_z_far ( ) ;
2016-10-19 14:14:41 +00:00
/* STEP 2 - CULL */
2018-06-11 11:51:30 +00:00
instance_cull_count = scenario - > octree . cull_convex ( planes , instance_cull_result , MAX_INSTANCE_CULL ) ;
2017-03-05 15:44:50 +00:00
light_cull_count = 0 ;
2016-11-19 16:23:37 +00:00
2017-03-05 15:44:50 +00:00
reflection_probe_cull_count = 0 ;
2019-10-03 20:39:08 +00:00
gi_probe_cull_count = 0 ;
2016-11-19 16:23:37 +00:00
2017-08-26 03:40:45 +00:00
//light_samplers_culled=0;
2016-10-19 14:14:41 +00:00
2018-08-24 07:35:07 +00:00
/*
print_line ( " OT: " + rtos ( ( OS : : get_singleton ( ) - > get_ticks_usec ( ) - t ) / 1000.0 ) ) ;
2016-10-19 14:14:41 +00:00
print_line ( " OTO: " + itos ( p_scenario - > octree . get_octant_count ( ) ) ) ;
2018-08-24 07:35:07 +00:00
print_line ( " OTE: " + itos ( p_scenario - > octree . get_elem_count ( ) ) ) ;
2016-10-19 14:14:41 +00:00
print_line ( " OTP: " + itos ( p_scenario - > octree . get_pair_count ( ) ) ) ;
2018-08-24 07:35:07 +00:00
*/
2016-10-19 14:14:41 +00:00
2017-08-26 03:40:45 +00:00
/* STEP 3 - PROCESS PORTALS, VALIDATE ROOMS */
//removed, will replace with culling
2016-10-19 14:14:41 +00:00
/* STEP 4 - REMOVE FURTHER CULLED OBJECTS, ADD LIGHTS */
2018-06-11 11:51:30 +00:00
for ( int i = 0 ; i < instance_cull_count ; i + + ) {
2016-10-19 14:14:41 +00:00
Instance * ins = instance_cull_result [ i ] ;
2017-03-05 15:44:50 +00:00
bool keep = false ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
if ( ( camera_layer_mask & ins - > layer_mask ) = = 0 ) {
2016-10-19 14:14:41 +00:00
//failure
2017-03-05 15:44:50 +00:00
} else if ( ins - > base_type = = VS : : INSTANCE_LIGHT & & ins - > visible ) {
2016-10-27 14:50:26 +00:00
2019-04-08 09:03:37 +00:00
if ( light_cull_count < MAX_LIGHTS_CULLED ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
InstanceLightData * light = static_cast < InstanceLightData * > ( ins - > base_data ) ;
2016-10-19 14:14:41 +00:00
if ( ! light - > geometries . empty ( ) ) {
//do not add this light if no geometry is affected by it..
2017-03-05 15:44:50 +00:00
light_cull_result [ light_cull_count ] = ins ;
light_instance_cull_result [ light_cull_count ] = light - > instance ;
2016-11-10 02:55:06 +00:00
if ( p_shadow_atlas . is_valid ( ) & & VSG : : storage - > light_has_shadow ( ins - > base ) ) {
VSG : : scene_render - > light_instance_mark_visible ( light - > instance ) ; //mark it visible for shadow allocation later
}
2016-10-19 14:14:41 +00:00
light_cull_count + + ;
}
}
2017-03-05 15:44:50 +00:00
} else if ( ins - > base_type = = VS : : INSTANCE_REFLECTION_PROBE & & ins - > visible ) {
2016-11-19 16:23:37 +00:00
2019-04-08 09:03:37 +00:00
if ( reflection_probe_cull_count < MAX_REFLECTION_PROBES_CULLED ) {
2016-11-19 16:23:37 +00:00
2017-03-05 15:44:50 +00:00
InstanceReflectionProbeData * reflection_probe = static_cast < InstanceReflectionProbeData * > ( ins - > base_data ) ;
2016-11-19 16:23:37 +00:00
2017-03-05 15:44:50 +00:00
if ( p_reflection_probe ! = reflection_probe - > instance ) {
2016-11-19 16:23:37 +00:00
//avoid entering The Matrix
if ( ! reflection_probe - > geometries . empty ( ) ) {
//do not add this light if no geometry is affected by it..
if ( reflection_probe - > reflection_dirty | | VSG : : scene_render - > reflection_probe_instance_needs_redraw ( reflection_probe - > instance ) ) {
if ( ! reflection_probe - > update_list . in_list ( ) ) {
2017-03-05 15:44:50 +00:00
reflection_probe - > render_step = 0 ;
2017-07-15 21:40:47 +00:00
reflection_probe_render_list . add_last ( & reflection_probe - > update_list ) ;
2016-11-19 16:23:37 +00:00
}
2017-03-05 15:44:50 +00:00
reflection_probe - > reflection_dirty = false ;
2016-11-19 16:23:37 +00:00
}
2019-09-09 20:50:51 +00:00
if ( VSG : : scene_render - > reflection_probe_instance_has_reflection ( reflection_probe - > instance ) ) {
reflection_probe_instance_cull_result [ reflection_probe_cull_count ] = reflection_probe - > instance ;
reflection_probe_cull_count + + ;
}
2016-11-19 16:23:37 +00:00
}
}
}
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
} else if ( ins - > base_type = = VS : : INSTANCE_GI_PROBE & & ins - > visible ) {
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
InstanceGIProbeData * gi_probe = static_cast < InstanceGIProbeData * > ( ins - > base_data ) ;
2016-12-20 03:21:07 +00:00
if ( ! gi_probe - > update_element . in_list ( ) ) {
gi_probe_update_list . add ( & gi_probe - > update_element ) ;
}
2019-10-03 20:39:08 +00:00
if ( gi_probe_cull_count < MAX_GI_PROBES_CULLED ) {
gi_probe_instance_cull_result [ gi_probe_cull_count ] = gi_probe - > probe_instance ;
gi_probe_cull_count + + ;
}
2017-09-07 19:48:50 +00:00
} else if ( ( ( 1 < < ins - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) & & ins - > visible & & ins - > cast_shadows ! = VS : : SHADOW_CASTING_SETTING_SHADOWS_ONLY ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
keep = true ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( ins - > base_data ) ;
2016-11-19 16:23:37 +00:00
2018-07-23 15:28:15 +00:00
if ( ins - > redraw_if_visible ) {
VisualServerRaster : : redraw_request ( ) ;
}
2017-04-07 02:36:37 +00:00
if ( ins - > base_type = = VS : : INSTANCE_PARTICLES ) {
2018-07-17 14:52:13 +00:00
//particles visible? process them
2018-11-19 23:34:29 +00:00
if ( VSG : : storage - > particles_is_inactive ( ins - > base ) ) {
//but if nothing is going on, don't do it.
keep = false ;
} else {
VSG : : storage - > particles_request_process ( ins - > base ) ;
//particles visible? request redraw
VisualServerRaster : : redraw_request ( ) ;
}
2017-04-07 02:36:37 +00:00
}
2016-10-19 14:14:41 +00:00
if ( geom - > lighting_dirty ) {
2017-03-05 15:44:50 +00:00
int l = 0 ;
2016-10-19 14:14:41 +00:00
//only called when lights AABB enter/exit this geometry
ins - > light_instances . resize ( geom - > lighting . size ( ) ) ;
2017-03-05 15:44:50 +00:00
for ( List < Instance * > : : Element * E = geom - > lighting . front ( ) ; E ; E = E - > next ( ) ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
InstanceLightData * light = static_cast < InstanceLightData * > ( E - > get ( ) - > base_data ) ;
2016-10-19 14:14:41 +00:00
2018-07-25 01:11:03 +00:00
ins - > light_instances . write [ l + + ] = light - > instance ;
2016-10-19 14:14:41 +00:00
}
2017-03-05 15:44:50 +00:00
geom - > lighting_dirty = false ;
2016-10-19 14:14:41 +00:00
}
2016-11-19 16:23:37 +00:00
if ( geom - > reflection_dirty ) {
2017-03-05 15:44:50 +00:00
int l = 0 ;
2016-11-19 16:23:37 +00:00
//only called when reflection probe AABB enter/exit this geometry
ins - > reflection_probe_instances . resize ( geom - > reflection_probes . size ( ) ) ;
2017-03-05 15:44:50 +00:00
for ( List < Instance * > : : Element * E = geom - > reflection_probes . front ( ) ; E ; E = E - > next ( ) ) {
2016-11-19 16:23:37 +00:00
2017-03-05 15:44:50 +00:00
InstanceReflectionProbeData * reflection_probe = static_cast < InstanceReflectionProbeData * > ( E - > get ( ) - > base_data ) ;
2016-11-19 16:23:37 +00:00
2018-07-25 01:11:03 +00:00
ins - > reflection_probe_instances . write [ l + + ] = reflection_probe - > instance ;
2016-11-19 16:23:37 +00:00
}
2017-03-05 15:44:50 +00:00
geom - > reflection_dirty = false ;
2016-11-19 16:23:37 +00:00
}
2016-12-20 03:21:07 +00:00
if ( geom - > gi_probes_dirty ) {
2017-03-05 15:44:50 +00:00
int l = 0 ;
2016-12-20 03:21:07 +00:00
//only called when reflection probe AABB enter/exit this geometry
ins - > gi_probe_instances . resize ( geom - > gi_probes . size ( ) ) ;
2017-03-05 15:44:50 +00:00
for ( List < Instance * > : : Element * E = geom - > gi_probes . front ( ) ; E ; E = E - > next ( ) ) {
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
InstanceGIProbeData * gi_probe = static_cast < InstanceGIProbeData * > ( E - > get ( ) - > base_data ) ;
2016-12-20 03:21:07 +00:00
2018-07-25 01:11:03 +00:00
ins - > gi_probe_instances . write [ l + + ] = gi_probe - > probe_instance ;
2016-12-20 03:21:07 +00:00
}
2017-03-05 15:44:50 +00:00
geom - > gi_probes_dirty = false ;
2016-12-20 03:21:07 +00:00
}
2016-10-27 14:50:26 +00:00
ins - > depth = near_plane . distance_to ( ins - > transform . origin ) ;
2017-09-01 15:56:52 +00:00
ins - > depth_layer = CLAMP ( int ( ins - > depth * 16 / z_far ) , 0 , 15 ) ;
2016-10-19 14:14:41 +00:00
}
if ( ! keep ) {
// remove, no reason to keep
2018-06-11 11:51:30 +00:00
instance_cull_count - - ;
SWAP ( instance_cull_result [ i ] , instance_cull_result [ instance_cull_count ] ) ;
2016-10-19 14:14:41 +00:00
i - - ;
2017-03-05 15:44:50 +00:00
ins - > last_render_pass = 0 ; // make invalid
2016-10-19 14:14:41 +00:00
} else {
2017-03-05 15:44:50 +00:00
ins - > last_render_pass = render_pass ;
2016-10-19 14:14:41 +00:00
}
}
/* STEP 5 - PROCESS LIGHTS */
2017-03-05 15:44:50 +00:00
RID * directional_light_ptr = & light_instance_cull_result [ light_cull_count ] ;
2018-06-11 11:51:30 +00:00
directional_light_count = 0 ;
2016-10-19 14:14:41 +00:00
// directional lights
{
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
Instance * * lights_with_shadow = ( Instance * * ) alloca ( sizeof ( Instance * ) * scenario - > directional_lights . size ( ) ) ;
int directional_shadow_count = 0 ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
for ( List < Instance * > : : Element * E = scenario - > directional_lights . front ( ) ; E ; E = E - > next ( ) ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
if ( light_cull_count + directional_light_count > = MAX_LIGHTS_CULLED ) {
2016-10-19 14:14:41 +00:00
break ;
}
if ( ! E - > get ( ) - > visible )
continue ;
2017-03-05 15:44:50 +00:00
InstanceLightData * light = static_cast < InstanceLightData * > ( E - > get ( ) - > base_data ) ;
2016-10-19 14:14:41 +00:00
//check shadow..
2017-08-29 11:31:27 +00:00
if ( light ) {
2019-09-09 20:50:51 +00:00
if ( p_using_shadows & & p_shadow_atlas . is_valid ( ) & & VSG : : storage - > light_has_shadow ( E - > get ( ) - > base ) ) {
2017-08-29 11:31:27 +00:00
lights_with_shadow [ directional_shadow_count + + ] = E - > get ( ) ;
}
2017-08-25 15:14:33 +00:00
//add to list
directional_light_ptr [ directional_light_count + + ] = light - > instance ;
}
2016-11-10 02:55:06 +00:00
}
VSG : : scene_render - > set_directional_shadow_count ( directional_shadow_count ) ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < directional_shadow_count ; i + + ) {
2016-10-19 14:14:41 +00:00
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " >Rendering Directional Light " + itos ( i ) ) ;
2017-03-05 15:44:50 +00:00
_light_instance_update_shadow ( lights_with_shadow [ i ] , p_cam_transform , p_cam_projection , p_cam_orthogonal , p_shadow_atlas , scenario ) ;
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " <Rendering Directional Light " + itos ( i ) ) ;
2016-10-19 14:14:41 +00:00
}
}
2019-09-09 20:50:51 +00:00
if ( p_using_shadows ) { //setup shadow maps
2016-11-10 02:55:06 +00:00
//SortArray<Instance*,_InstanceLightsort> sorter;
//sorter.sort(light_cull_result,light_cull_count);
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < light_cull_count ; i + + ) {
2016-10-19 14:14:41 +00:00
Instance * ins = light_cull_result [ i ] ;
2016-11-10 02:55:06 +00:00
if ( ! p_shadow_atlas . is_valid ( ) | | ! VSG : : storage - > light_has_shadow ( ins - > base ) )
2016-10-19 14:14:41 +00:00
continue ;
2017-03-05 15:44:50 +00:00
InstanceLightData * light = static_cast < InstanceLightData * > ( ins - > base_data ) ;
2016-11-10 02:55:06 +00:00
2017-09-01 20:33:39 +00:00
float coverage = 0.f ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
{ //compute coverage
2016-11-10 02:55:06 +00:00
2016-11-19 16:23:37 +00:00
Transform cam_xf = p_cam_transform ;
float zn = p_cam_projection . get_z_near ( ) ;
2017-03-05 15:44:50 +00:00
Plane p ( cam_xf . origin + cam_xf . basis . get_axis ( 2 ) * - zn , - cam_xf . basis . get_axis ( 2 ) ) ; //camera near plane
2016-11-10 02:55:06 +00:00
2020-01-21 18:39:16 +00:00
// near plane half width and height
Vector2 vp_half_extents = p_cam_projection . get_viewport_half_extents ( ) ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
switch ( VSG : : storage - > light_get_type ( ins - > base ) ) {
2016-11-10 02:55:06 +00:00
case VS : : LIGHT_OMNI : {
2017-03-05 15:44:50 +00:00
float radius = VSG : : storage - > light_get_param ( ins - > base , VS : : LIGHT_PARAM_RANGE ) ;
2016-11-10 02:55:06 +00:00
//get two points parallel to near plane
2017-03-05 15:44:50 +00:00
Vector3 points [ 2 ] = {
2016-11-10 02:55:06 +00:00
ins - > transform . origin ,
2017-03-05 15:44:50 +00:00
ins - > transform . origin + cam_xf . basis . get_axis ( 0 ) * radius
2016-11-10 02:55:06 +00:00
} ;
2016-11-19 16:23:37 +00:00
if ( ! p_cam_orthogonal ) {
2016-11-10 02:55:06 +00:00
//if using perspetive, map them to near plane
2017-03-05 15:44:50 +00:00
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
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
p . intersects_segment ( cam_xf . origin , points [ j ] , & points [ j ] ) ; //map to plane
2016-11-10 02:55:06 +00:00
}
}
2017-03-05 15:44:50 +00:00
float screen_diameter = points [ 0 ] . distance_to ( points [ 1 ] ) * 2 ;
2020-01-21 18:39:16 +00:00
coverage = screen_diameter / ( vp_half_extents . x + vp_half_extents . y ) ;
2016-11-10 02:55:06 +00:00
} break ;
case VS : : LIGHT_SPOT : {
2017-03-05 15:44:50 +00:00
float radius = VSG : : storage - > light_get_param ( ins - > base , VS : : LIGHT_PARAM_RANGE ) ;
float angle = VSG : : storage - > light_get_param ( ins - > base , VS : : LIGHT_PARAM_SPOT_ANGLE ) ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
float w = radius * Math : : sin ( Math : : deg2rad ( angle ) ) ;
float d = radius * Math : : cos ( Math : : deg2rad ( angle ) ) ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
Vector3 base = ins - > transform . origin - ins - > transform . basis . get_axis ( 2 ) . normalized ( ) * d ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
Vector3 points [ 2 ] = {
2016-11-10 02:55:06 +00:00
base ,
2017-03-05 15:44:50 +00:00
base + cam_xf . basis . get_axis ( 0 ) * w
2016-11-10 02:55:06 +00:00
} ;
2016-11-19 16:23:37 +00:00
if ( ! p_cam_orthogonal ) {
2016-11-10 02:55:06 +00:00
//if using perspetive, map them to near plane
2017-03-05 15:44:50 +00:00
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
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
p . intersects_segment ( cam_xf . origin , points [ j ] , & points [ j ] ) ; //map to plane
2016-11-10 02:55:06 +00:00
}
}
2017-03-05 15:44:50 +00:00
float screen_diameter = points [ 0 ] . distance_to ( points [ 1 ] ) * 2 ;
2020-01-21 18:39:16 +00:00
coverage = screen_diameter / ( vp_half_extents . x + vp_half_extents . y ) ;
2016-11-10 02:55:06 +00:00
} break ;
default : {
ERR_PRINT ( " Invalid Light Type " ) ;
}
}
}
if ( light - > shadow_dirty ) {
light - > last_version + + ;
2017-03-05 15:44:50 +00:00
light - > shadow_dirty = false ;
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
bool redraw = VSG : : scene_render - > shadow_atlas_update_light ( p_shadow_atlas , light - > instance , coverage , light - > last_version ) ;
2016-11-10 02:55:06 +00:00
if ( redraw ) {
//must redraw!
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " >Rendering Light " + itos ( i ) ) ;
2018-11-14 12:32:39 +00:00
light - > shadow_dirty = _light_instance_update_shadow ( ins , p_cam_transform , p_cam_projection , p_cam_orthogonal , p_shadow_atlas , scenario ) ;
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " <Rendering Light " + itos ( i ) ) ;
2016-11-10 02:55:06 +00:00
}
2016-10-19 14:14:41 +00:00
}
}
2018-06-11 11:51:30 +00:00
}
2019-08-18 22:40:52 +00:00
void VisualServerScene : : _render_scene ( RID p_render_buffers , const Transform p_cam_transform , const CameraMatrix & p_cam_projection , bool p_cam_orthogonal , RID p_force_environment , RID p_scenario , RID p_shadow_atlas , RID p_reflection_probe , int p_reflection_probe_pass ) {
2018-06-11 11:51:30 +00:00
Scenario * scenario = scenario_owner . getornull ( p_scenario ) ;
2016-11-10 02:55:06 +00:00
2016-10-19 14:14:41 +00:00
/* ENVIRONMENT */
RID environment ;
2016-11-19 16:23:37 +00:00
if ( p_force_environment . is_valid ( ) ) //camera has more environment priority
2017-03-05 15:44:50 +00:00
environment = p_force_environment ;
2016-10-19 14:14:41 +00:00
else if ( scenario - > environment . is_valid ( ) )
2017-03-05 15:44:50 +00:00
environment = scenario - > environment ;
2016-10-19 14:14:41 +00:00
else
2017-03-05 15:44:50 +00:00
environment = scenario - > fallback_environment ;
2016-10-19 14:14:41 +00:00
2018-06-11 11:51:30 +00:00
/* PROCESS GEOMETRY AND DRAW SCENE */
2016-10-19 14:14:41 +00:00
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " Render Scene " ) ;
2019-10-03 20:39:08 +00:00
VSG : : scene_render - > render_scene ( p_render_buffers , p_cam_transform , p_cam_projection , p_cam_orthogonal , ( RasterizerScene : : InstanceBase * * ) instance_cull_result , instance_cull_count , light_instance_cull_result , light_cull_count + directional_light_count , reflection_probe_instance_cull_result , reflection_probe_cull_count , gi_probe_instance_cull_result , gi_probe_cull_count , environment , p_shadow_atlas , p_reflection_probe . is_valid ( ) ? RID ( ) : scenario - > reflection_atlas , p_reflection_probe , p_reflection_probe_pass ) ;
2016-11-19 16:23:37 +00:00
}
2016-10-19 14:14:41 +00:00
2019-08-18 22:40:52 +00:00
void VisualServerScene : : render_empty_scene ( RID p_render_buffers , RID p_scenario , RID p_shadow_atlas ) {
2017-06-24 11:58:27 +00:00
2018-07-21 20:26:14 +00:00
# ifndef _3D_DISABLED
2017-06-24 11:58:27 +00:00
Scenario * scenario = scenario_owner . getornull ( p_scenario ) ;
RID environment ;
if ( scenario - > environment . is_valid ( ) )
environment = scenario - > environment ;
else
environment = scenario - > fallback_environment ;
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " Render Empty Scene " ) ;
2019-10-03 20:39:08 +00:00
VSG : : scene_render - > render_scene ( p_render_buffers , Transform ( ) , CameraMatrix ( ) , true , NULL , 0 , NULL , 0 , NULL , 0 , NULL , 0 , environment , p_shadow_atlas , scenario - > reflection_atlas , RID ( ) , 0 ) ;
2018-07-21 20:26:14 +00:00
# endif
2017-06-24 11:58:27 +00:00
}
2017-03-05 15:44:50 +00:00
bool VisualServerScene : : _render_reflection_probe_step ( Instance * p_instance , int p_step ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
InstanceReflectionProbeData * reflection_probe = static_cast < InstanceReflectionProbeData * > ( p_instance - > base_data ) ;
2016-11-19 16:23:37 +00:00
Scenario * scenario = p_instance - > scenario ;
2017-03-05 15:44:50 +00:00
ERR_FAIL_COND_V ( ! scenario , true ) ;
2016-10-19 14:14:41 +00:00
2018-09-28 19:40:20 +00:00
VisualServerRaster : : redraw_request ( ) ; //update, so it updates in editor
2017-03-05 15:44:50 +00:00
if ( p_step = = 0 ) {
2016-11-19 16:23:37 +00:00
2019-09-09 20:50:51 +00:00
if ( ! VSG : : scene_render - > reflection_probe_instance_begin_render ( reflection_probe - > instance , scenario - > reflection_atlas ) ) {
return true ; //all full
}
2016-11-19 16:23:37 +00:00
}
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
if ( p_step > = 0 & & p_step < 6 ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
static const Vector3 view_normals [ 6 ] = {
2016-11-19 16:23:37 +00:00
Vector3 ( + 1 , 0 , 0 ) ,
2019-09-09 20:50:51 +00:00
Vector3 ( - 1 , 0 , 0 ) ,
2017-03-05 15:44:50 +00:00
Vector3 ( 0 , + 1 , 0 ) ,
2019-09-09 20:50:51 +00:00
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 ) ,
2017-03-05 15:44:50 +00:00
Vector3 ( 0 , 0 , - 1 ) ,
2019-09-09 20:50:51 +00:00
Vector3 ( 0 , - 1 , 0 ) ,
Vector3 ( 0 , - 1 , 0 )
2016-11-19 16:23:37 +00:00
} ;
Vector3 extents = VSG : : storage - > reflection_probe_get_extents ( p_instance - > base ) ;
Vector3 origin_offset = VSG : : storage - > reflection_probe_get_origin_offset ( p_instance - > base ) ;
float max_distance = VSG : : storage - > reflection_probe_get_origin_max_distance ( p_instance - > base ) ;
2017-03-05 15:44:50 +00:00
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
2016-11-19 16:23:37 +00:00
2017-03-05 15:44:50 +00:00
max_distance = MAX ( max_distance , distance ) ;
2016-11-19 16:23:37 +00:00
//render cubemap side
CameraMatrix cm ;
2017-03-05 15:44:50 +00:00
cm . set_perspective ( 90 , 1 , 0.01 , max_distance ) ;
2016-11-19 16:23:37 +00:00
Transform local_view ;
2017-03-05 15:44:50 +00:00
local_view . set_look_at ( origin_offset , origin_offset + view_normals [ p_step ] , view_up [ p_step ] ) ;
2016-11-19 16:23:37 +00:00
Transform xform = p_instance - > transform * local_view ;
RID shadow_atlas ;
2019-09-09 20:50:51 +00:00
bool use_shadows = VSG : : storage - > reflection_probe_renders_shadows ( p_instance - > base ) ;
if ( use_shadows ) {
2016-11-19 16:23:37 +00:00
2017-03-05 15:44:50 +00:00
shadow_atlas = scenario - > reflection_probe_shadow_atlas ;
2016-10-19 14:14:41 +00:00
}
2016-11-19 16:23:37 +00:00
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " Render Reflection Probe, Step " + itos ( p_step ) ) ;
2019-09-09 20:50:51 +00:00
_prepare_scene ( xform , cm , false , RID ( ) , VSG : : storage - > reflection_probe_get_cull_mask ( p_instance - > base ) , p_instance - > scenario - > self , shadow_atlas , reflection_probe - > instance , use_shadows ) ;
2019-08-18 22:40:52 +00:00
_render_scene ( RID ( ) , xform , cm , false , RID ( ) , p_instance - > scenario - > self , shadow_atlas , reflection_probe - > instance , p_step ) ;
2016-11-19 16:23:37 +00:00
} else {
2018-01-18 20:37:17 +00:00
//do roughness postprocess step until it believes it's done
2019-09-20 20:58:06 +00:00
RENDER_TIMESTAMP ( " Post-Process Reflection Probe, Step " + itos ( p_step ) ) ;
2016-11-19 16:23:37 +00:00
return VSG : : scene_render - > reflection_probe_instance_postprocess_step ( reflection_probe - > instance ) ;
2016-10-19 14:14:41 +00:00
}
2016-11-19 16:23:37 +00:00
return false ;
}
2016-10-19 14:14:41 +00:00
2016-11-19 16:23:37 +00:00
void VisualServerScene : : render_probes ( ) {
2016-11-10 02:55:06 +00:00
2016-12-20 03:21:07 +00:00
/* REFLECTION PROBES */
2016-10-19 14:14:41 +00:00
2016-12-20 03:21:07 +00:00
SelfList < InstanceReflectionProbeData > * ref_probe = reflection_probe_render_list . first ( ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
bool busy = false ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
while ( ref_probe ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
SelfList < InstanceReflectionProbeData > * next = ref_probe - > next ( ) ;
2016-12-20 03:21:07 +00:00
RID base = ref_probe - > self ( ) - > owner - > base ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
switch ( VSG : : storage - > reflection_probe_get_update_mode ( base ) ) {
2016-11-19 16:23:37 +00:00
case VS : : REFLECTION_PROBE_UPDATE_ONCE : {
if ( busy ) //already rendering something
break ;
2017-03-05 15:44:50 +00:00
bool done = _render_reflection_probe_step ( ref_probe - > self ( ) - > owner , ref_probe - > self ( ) - > render_step ) ;
2016-11-19 16:23:37 +00:00
if ( done ) {
2016-12-20 03:21:07 +00:00
reflection_probe_render_list . remove ( ref_probe ) ;
2016-11-19 16:23:37 +00:00
} else {
2016-12-20 03:21:07 +00:00
ref_probe - > self ( ) - > render_step + + ;
2016-11-19 16:23:37 +00:00
}
2017-03-05 15:44:50 +00:00
busy = true ; //do not render another one of this kind
2016-11-19 16:23:37 +00:00
} break ;
case VS : : REFLECTION_PROBE_UPDATE_ALWAYS : {
2017-03-05 15:44:50 +00:00
int step = 0 ;
bool done = false ;
while ( ! done ) {
done = _render_reflection_probe_step ( ref_probe - > self ( ) - > owner , step ) ;
2016-11-19 16:23:37 +00:00
step + + ;
}
2016-12-20 03:21:07 +00:00
reflection_probe_render_list . remove ( ref_probe ) ;
2016-11-19 16:23:37 +00:00
} break ;
}
2017-03-05 15:44:50 +00:00
ref_probe = next ;
2016-11-19 16:23:37 +00:00
}
2016-12-20 03:21:07 +00:00
/* GI PROBES */
SelfList < InstanceGIProbeData > * gi_probe = gi_probe_update_list . first ( ) ;
2019-10-03 20:39:08 +00:00
if ( gi_probe ) {
RENDER_TIMESTAMP ( " Render GI Probes " ) ;
}
2017-03-05 15:44:50 +00:00
while ( gi_probe ) {
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
SelfList < InstanceGIProbeData > * next = gi_probe - > next ( ) ;
2016-12-20 03:21:07 +00:00
InstanceGIProbeData * probe = gi_probe - > self ( ) ;
2019-10-03 20:39:08 +00:00
//Instance *instance_probe = probe->owner;
2016-12-20 03:21:07 +00:00
//check if probe must be setup, but don't do if on the lighting thread
2019-10-03 20:39:08 +00:00
bool cache_dirty = false ;
int cache_count = 0 ;
{
2016-12-20 03:21:07 +00:00
2019-10-03 20:39:08 +00:00
int light_cache_size = probe - > light_cache . size ( ) ;
const InstanceGIProbeData : : LightCache * caches = probe - > light_cache . ptr ( ) ;
const RID * instance_caches = probe - > light_instances . ptr ( ) ;
2016-12-20 03:21:07 +00:00
2019-10-03 20:39:08 +00:00
int idx = 0 ; //must count visible lights
for ( Set < Instance * > : : 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 {
2016-12-20 03:21:07 +00:00
2019-10-03 20:39:08 +00:00
const InstanceGIProbeData : : LightCache * cache = & caches [ idx ] ;
if (
instance_caches [ idx ] ! = instance_light - > instance | |
cache - > has_shadow ! = VSG : : storage - > light_has_shadow ( instance - > base ) | |
cache - > type ! = VSG : : storage - > light_get_type ( instance - > base ) | |
cache - > transform ! = instance - > transform | |
cache - > color ! = VSG : : storage - > light_get_color ( instance - > base ) | |
cache - > energy ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_ENERGY ) | |
cache - > bake_energy ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_INDIRECT_ENERGY ) | |
cache - > radius ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_RANGE ) | |
cache - > attenuation ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_ATTENUATION ) | |
cache - > spot_angle ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_SPOT_ANGLE ) | |
cache - > spot_attenuation ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_SPOT_ATTENUATION ) ) {
cache_dirty = true ;
}
}
2017-02-06 08:12:15 +00:00
2019-10-03 20:39:08 +00:00
idx + + ;
}
2017-02-06 08:12:15 +00:00
2019-10-03 20:39:08 +00:00
for ( List < Instance * > : : Element * E = probe - > owner - > scenario - > directional_lights . front ( ) ; E ; E = E - > next ( ) ) {
2017-02-06 08:12:15 +00:00
2019-10-03 20:39:08 +00:00
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 {
2016-12-20 03:21:07 +00:00
2019-10-03 20:39:08 +00:00
const InstanceGIProbeData : : LightCache * cache = & caches [ idx ] ;
if (
instance_caches [ idx ] ! = instance_light - > instance | |
cache - > has_shadow ! = VSG : : storage - > light_has_shadow ( instance - > base ) | |
cache - > type ! = VSG : : storage - > light_get_type ( instance - > base ) | |
cache - > transform ! = instance - > transform | |
cache - > color ! = VSG : : storage - > light_get_color ( instance - > base ) | |
cache - > energy ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_ENERGY ) | |
cache - > bake_energy ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_INDIRECT_ENERGY ) | |
cache - > radius ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_RANGE ) | |
cache - > attenuation ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_ATTENUATION ) | |
cache - > spot_angle ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_SPOT_ANGLE ) | |
cache - > spot_attenuation ! = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_SPOT_ATTENUATION ) ) {
cache_dirty = true ;
}
}
2016-12-20 03:21:07 +00:00
2019-10-03 20:39:08 +00:00
idx + + ;
}
2016-12-20 03:21:07 +00:00
2019-10-03 20:39:08 +00:00
if ( idx ! = light_cache_size ) {
cache_dirty = true ;
}
2016-12-20 03:21:07 +00:00
2019-10-03 20:39:08 +00:00
cache_count = idx ;
}
2016-12-20 03:21:07 +00:00
2019-10-11 02:14:56 +00:00
bool update_lights = VSG : : scene_render - > gi_probe_needs_update ( probe - > probe_instance ) ;
2016-12-20 03:21:07 +00:00
2019-10-03 20:39:08 +00:00
if ( cache_dirty ) {
probe - > light_cache . resize ( cache_count ) ;
probe - > light_instances . resize ( cache_count ) ;
2016-12-20 03:21:07 +00:00
2019-10-03 20:39:08 +00:00
if ( cache_count ) {
InstanceGIProbeData : : LightCache * caches = probe - > light_cache . ptrw ( ) ;
RID * instance_caches = probe - > light_instances . ptrw ( ) ;
2016-12-20 03:21:07 +00:00
2019-10-03 20:39:08 +00:00
int idx = 0 ; //must count visible lights
for ( Set < Instance * > : : Element * E = probe - > lights . front ( ) ; E ; E = E - > next ( ) ) {
Instance * instance = E - > get ( ) ;
InstanceLightData * instance_light = ( InstanceLightData * ) instance - > base_data ;
if ( ! instance - > visible ) {
continue ;
2016-12-20 03:21:07 +00:00
}
2019-10-03 20:39:08 +00:00
InstanceGIProbeData : : LightCache * cache = & caches [ idx ] ;
instance_caches [ idx ] = instance_light - > instance ;
cache - > has_shadow = VSG : : storage - > light_has_shadow ( instance - > base ) ;
cache - > type = VSG : : storage - > light_get_type ( instance - > base ) ;
cache - > transform = instance - > transform ;
cache - > color = VSG : : storage - > light_get_color ( instance - > base ) ;
cache - > energy = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_ENERGY ) ;
cache - > bake_energy = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_INDIRECT_ENERGY ) ;
cache - > radius = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_RANGE ) ;
cache - > attenuation = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_ATTENUATION ) ;
cache - > spot_angle = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_SPOT_ANGLE ) ;
cache - > spot_attenuation = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_SPOT_ATTENUATION ) ;
idx + + ;
}
for ( List < Instance * > : : Element * E = probe - > owner - > scenario - > directional_lights . front ( ) ; E ; E = E - > next ( ) ) {
Instance * instance = E - > get ( ) ;
InstanceLightData * instance_light = ( InstanceLightData * ) instance - > base_data ;
if ( ! instance - > visible ) {
continue ;
}
2016-12-20 03:21:07 +00:00
2019-10-03 20:39:08 +00:00
InstanceGIProbeData : : LightCache * cache = & caches [ idx ] ;
instance_caches [ idx ] = instance_light - > instance ;
cache - > has_shadow = VSG : : storage - > light_has_shadow ( instance - > base ) ;
cache - > type = VSG : : storage - > light_get_type ( instance - > base ) ;
cache - > transform = instance - > transform ;
cache - > color = VSG : : storage - > light_get_color ( instance - > base ) ;
cache - > energy = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_ENERGY ) ;
cache - > bake_energy = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_INDIRECT_ENERGY ) ;
cache - > radius = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_RANGE ) ;
cache - > attenuation = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_ATTENUATION ) ;
cache - > spot_angle = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_SPOT_ANGLE ) ;
cache - > spot_attenuation = VSG : : storage - > light_get_param ( instance - > base , VS : : LIGHT_PARAM_SPOT_ATTENUATION ) ;
idx + + ;
}
2016-12-20 03:21:07 +00:00
}
2019-10-03 20:39:08 +00:00
2019-10-11 02:14:56 +00:00
update_lights = true ;
2019-10-03 20:39:08 +00:00
}
2019-10-11 02:14:56 +00:00
instance_cull_count = 0 ;
for ( List < InstanceGIProbeData : : PairInfo > : : Element * E = probe - > dynamic_geometries . front ( ) ; E ; E = E - > next ( ) ) {
if ( instance_cull_count < MAX_INSTANCE_CULL ) {
Instance * ins = E - > get ( ) . geometry ;
2019-10-31 22:54:21 +00:00
if ( ! ins - > visible ) {
continue ;
}
2019-10-11 02:14:56 +00:00
InstanceGeometryData * geom = ( InstanceGeometryData * ) ins - > base_data ;
if ( geom - > gi_probes_dirty ) {
//giprobes may be dirty, so update
int l = 0 ;
//only called when reflection probe AABB enter/exit this geometry
ins - > gi_probe_instances . resize ( geom - > gi_probes . size ( ) ) ;
for ( List < Instance * > : : Element * F = geom - > gi_probes . front ( ) ; F ; F = F - > next ( ) ) {
InstanceGIProbeData * gi_probe2 = static_cast < InstanceGIProbeData * > ( F - > get ( ) - > base_data ) ;
ins - > gi_probe_instances . write [ l + + ] = gi_probe2 - > probe_instance ;
}
geom - > gi_probes_dirty = false ;
}
instance_cull_result [ instance_cull_count + + ] = E - > get ( ) . geometry ;
}
2016-12-20 03:21:07 +00:00
}
2019-10-03 20:39:08 +00:00
2019-10-11 02:14:56 +00:00
VSG : : scene_render - > gi_probe_update ( probe - > probe_instance , update_lights , probe - > light_instances , instance_cull_count , ( RasterizerScene : : InstanceBase * * ) instance_cull_result ) ;
2019-10-03 20:39:08 +00:00
gi_probe_update_list . remove ( gi_probe ) ;
2016-12-20 03:21:07 +00:00
2017-03-05 15:44:50 +00:00
gi_probe = next ;
2016-12-20 03:21:07 +00:00
}
2016-11-19 16:23:37 +00:00
}
void VisualServerScene : : _update_dirty_instance ( Instance * p_instance ) {
2016-10-19 14:14:41 +00:00
2017-08-18 18:11:16 +00:00
if ( p_instance - > update_aabb ) {
2016-10-19 14:14:41 +00:00
_update_instance_aabb ( p_instance ) ;
2017-08-18 18:11:16 +00:00
}
2016-10-19 14:14:41 +00:00
2019-07-21 14:31:30 +00:00
if ( p_instance - > update_dependencies ) {
p_instance - > instance_increase_version ( ) ;
if ( p_instance - > base . is_valid ( ) ) {
VSG : : storage - > base_update_dependency ( p_instance - > base , p_instance ) ;
}
if ( p_instance - > material_override . is_valid ( ) ) {
VSG : : storage - > material_update_dependency ( p_instance - > material_override , p_instance ) ;
}
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
if ( p_instance - > base_type = = VS : : INSTANCE_MESH ) {
2016-11-10 02:55:06 +00:00
//remove materials no longer used and un-own them
int new_mat_count = VSG : : storage - > mesh_get_surface_count ( p_instance - > base ) ;
p_instance - > materials . resize ( new_mat_count ) ;
2016-11-24 23:46:55 +00:00
2017-01-12 11:34:00 +00:00
int new_blend_shape_count = VSG : : storage - > mesh_get_blend_shape_count ( p_instance - > base ) ;
2017-03-05 15:44:50 +00:00
if ( new_blend_shape_count ! = p_instance - > blend_values . size ( ) ) {
2017-01-12 11:34:00 +00:00
p_instance - > blend_values . resize ( new_blend_shape_count ) ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < new_blend_shape_count ; i + + ) {
2018-07-25 01:11:03 +00:00
p_instance - > blend_values . write [ i ] = 0 ;
2016-11-24 23:46:55 +00:00
}
}
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
if ( ( 1 < < p_instance - > base_type ) & VS : : INSTANCE_GEOMETRY_MASK ) {
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
InstanceGeometryData * geom = static_cast < InstanceGeometryData * > ( p_instance - > base_data ) ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
bool can_cast_shadows = true ;
2018-11-14 12:32:39 +00:00
bool is_animated = false ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
if ( p_instance - > cast_shadows = = VS : : SHADOW_CASTING_SETTING_OFF ) {
can_cast_shadows = false ;
2016-11-10 02:55:06 +00:00
} else if ( p_instance - > material_override . is_valid ( ) ) {
2017-03-05 15:44:50 +00:00
can_cast_shadows = VSG : : storage - > material_casts_shadows ( p_instance - > material_override ) ;
2018-11-14 12:32:39 +00:00
is_animated = VSG : : storage - > material_is_animated ( p_instance - > material_override ) ;
2016-11-10 02:55:06 +00:00
} else {
2017-03-05 15:44:50 +00:00
if ( p_instance - > base_type = = VS : : INSTANCE_MESH ) {
RID mesh = p_instance - > base ;
2016-11-10 02:55:06 +00:00
2016-11-22 04:26:56 +00:00
if ( mesh . is_valid ( ) ) {
2017-03-05 15:44:50 +00:00
bool cast_shadows = false ;
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < p_instance - > materials . size ( ) ; i + + ) {
2016-11-10 02:55:06 +00:00
2017-03-05 15:44:50 +00:00
RID mat = p_instance - > materials [ i ] . is_valid ( ) ? p_instance - > materials [ i ] : VSG : : storage - > mesh_surface_get_material ( mesh , i ) ;
2016-11-10 02:55:06 +00:00
2016-11-22 04:26:56 +00:00
if ( ! mat . is_valid ( ) ) {
2017-03-05 15:44:50 +00:00
cast_shadows = true ;
2018-11-14 12:32:39 +00:00
} else {
2016-11-10 02:55:06 +00:00
2018-11-14 12:32:39 +00:00
if ( VSG : : storage - > material_casts_shadows ( mat ) ) {
cast_shadows = true ;
}
if ( VSG : : storage - > material_is_animated ( mat ) ) {
is_animated = true ;
}
2019-07-21 14:31:30 +00:00
VSG : : storage - > material_update_dependency ( mat , p_instance ) ;
2016-11-22 04:26:56 +00:00
}
2016-11-10 02:55:06 +00:00
}
2016-11-22 04:26:56 +00:00
if ( ! cast_shadows ) {
2017-03-05 15:44:50 +00:00
can_cast_shadows = false ;
2016-11-10 02:55:06 +00:00
}
}
2017-03-05 15:44:50 +00:00
} else if ( p_instance - > base_type = = VS : : INSTANCE_MULTIMESH ) {
2016-11-22 04:26:56 +00:00
RID mesh = VSG : : storage - > multimesh_get_mesh ( p_instance - > base ) ;
if ( mesh . is_valid ( ) ) {
2017-02-16 11:55:11 +00:00
2017-03-05 15:44:50 +00:00
bool cast_shadows = false ;
2016-11-22 04:26:56 +00:00
int sc = VSG : : storage - > mesh_get_surface_count ( mesh ) ;
2017-03-05 15:44:50 +00:00
for ( int i = 0 ; i < sc ; i + + ) {
2016-11-22 04:26:56 +00:00
2017-03-05 15:44:50 +00:00
RID mat = VSG : : storage - > mesh_surface_get_material ( mesh , i ) ;
2016-11-22 04:26:56 +00:00
if ( ! mat . is_valid ( ) ) {
2017-03-05 15:44:50 +00:00
cast_shadows = true ;
2016-11-22 04:26:56 +00:00
2018-11-14 12:32:39 +00:00
} else {
if ( VSG : : storage - > material_casts_shadows ( mat ) ) {
cast_shadows = true ;
}
if ( VSG : : storage - > material_is_animated ( mat ) ) {
is_animated = true ;
}
2019-07-21 14:31:30 +00:00
VSG : : storage - > material_update_dependency ( mat , p_instance ) ;
2016-11-22 04:26:56 +00:00
}
}
if ( ! cast_shadows ) {
2017-03-05 15:44:50 +00:00
can_cast_shadows = false ;
2016-11-22 04:26:56 +00:00
}
2019-08-18 22:40:52 +00:00
VSG : : storage - > base_update_dependency ( mesh , p_instance ) ;
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
} else if ( p_instance - > base_type = = VS : : INSTANCE_IMMEDIATE ) {
2016-11-23 10:04:55 +00:00
RID mat = VSG : : storage - > immediate_get_material ( p_instance - > base ) ;
2019-06-26 13:08:25 +00:00
can_cast_shadows = ! mat . is_valid ( ) | | VSG : : storage - > material_casts_shadows ( mat ) ;
2018-11-14 12:32:39 +00:00
if ( mat . is_valid ( ) & & VSG : : storage - > material_is_animated ( mat ) ) {
is_animated = true ;
}
2019-07-21 14:31:30 +00:00
if ( mat . is_valid ( ) ) {
VSG : : storage - > material_update_dependency ( mat , p_instance ) ;
}
2017-06-17 10:32:49 +00:00
} else if ( p_instance - > base_type = = VS : : INSTANCE_PARTICLES ) {
bool cast_shadows = false ;
int dp = VSG : : storage - > particles_get_draw_passes ( p_instance - > base ) ;
for ( int i = 0 ; i < dp ; i + + ) {
RID mesh = VSG : : storage - > particles_get_draw_pass_mesh ( p_instance - > base , i ) ;
2017-07-15 04:23:10 +00:00
if ( ! mesh . is_valid ( ) )
continue ;
2017-06-17 10:32:49 +00:00
int sc = VSG : : storage - > mesh_get_surface_count ( mesh ) ;
for ( int j = 0 ; j < sc ; j + + ) {
RID mat = VSG : : storage - > mesh_surface_get_material ( mesh , j ) ;
if ( ! mat . is_valid ( ) ) {
cast_shadows = true ;
2018-11-14 12:32:39 +00:00
} else {
2017-06-17 10:32:49 +00:00
2018-11-14 12:32:39 +00:00
if ( VSG : : storage - > material_casts_shadows ( mat ) ) {
cast_shadows = true ;
}
if ( VSG : : storage - > material_is_animated ( mat ) ) {
is_animated = true ;
}
2019-07-21 14:31:30 +00:00
VSG : : storage - > material_update_dependency ( mat , p_instance ) ;
2017-06-17 10:32:49 +00:00
}
}
}
if ( ! cast_shadows ) {
can_cast_shadows = false ;
}
2016-11-10 02:55:06 +00:00
}
}
2017-03-05 15:44:50 +00:00
if ( can_cast_shadows ! = geom - > can_cast_shadows ) {
2016-11-10 02:55:06 +00:00
//ability to cast shadows change, let lights now
2017-03-05 15:44:50 +00:00
for ( List < Instance * > : : Element * E = geom - > lighting . front ( ) ; E ; E = E - > next ( ) ) {
InstanceLightData * light = static_cast < InstanceLightData * > ( E - > get ( ) - > base_data ) ;
light - > shadow_dirty = true ;
2016-11-10 02:55:06 +00:00
}
2017-03-05 15:44:50 +00:00
geom - > can_cast_shadows = can_cast_shadows ;
2016-11-10 02:55:06 +00:00
}
2018-11-14 12:32:39 +00:00
geom - > material_is_animated = is_animated ;
2016-10-19 14:14:41 +00:00
}
2019-07-21 14:31:30 +00:00
if ( p_instance - > skeleton . is_valid ( ) ) {
VSG : : storage - > skeleton_update_dependency ( p_instance - > skeleton , p_instance ) ;
}
p_instance - > clean_up_dependencies ( ) ;
2016-10-19 14:14:41 +00:00
}
2017-12-14 11:59:46 +00:00
_instance_update_list . remove ( & p_instance - > update_item ) ;
2016-10-19 14:14:41 +00:00
_update_instance ( p_instance ) ;
2017-03-05 15:44:50 +00:00
p_instance - > update_aabb = false ;
2019-07-21 14:31:30 +00:00
p_instance - > update_dependencies = false ;
2016-10-19 14:14:41 +00:00
}
void VisualServerScene : : update_dirty_instances ( ) {
2017-02-16 11:55:11 +00:00
VSG : : storage - > update_dirty_resources ( ) ;
2017-03-05 15:44:50 +00:00
while ( _instance_update_list . first ( ) ) {
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
_update_dirty_instance ( _instance_update_list . first ( ) - > self ( ) ) ;
2016-10-19 14:14:41 +00:00
}
}
bool VisualServerScene : : free ( RID p_rid ) {
if ( camera_owner . owns ( p_rid ) ) {
2019-06-10 15:38:51 +00:00
Camera * camera = camera_owner . getornull ( p_rid ) ;
2016-10-19 14:14:41 +00:00
camera_owner . free ( p_rid ) ;
memdelete ( camera ) ;
} else if ( scenario_owner . owns ( p_rid ) ) {
2019-06-10 15:38:51 +00:00
Scenario * scenario = scenario_owner . getornull ( p_rid ) ;
2016-10-19 14:14:41 +00:00
2017-03-05 15:44:50 +00:00
while ( scenario - > instances . first ( ) ) {
instance_set_scenario ( scenario - > instances . first ( ) - > self ( ) - > self , RID ( ) ) ;
2016-10-19 14:14:41 +00:00
}
2016-11-19 16:23:37 +00:00
VSG : : scene_render - > free ( scenario - > reflection_probe_shadow_atlas ) ;
2019-09-09 20:50:51 +00:00
VSG : : scene_render - > free ( scenario - > reflection_atlas ) ;
2016-10-19 14:14:41 +00:00
scenario_owner . free ( p_rid ) ;
memdelete ( scenario ) ;
} else if ( instance_owner . owns ( p_rid ) ) {
// delete the instance
update_dirty_instances ( ) ;
2019-06-10 15:38:51 +00:00
Instance * instance = instance_owner . getornull ( p_rid ) ;
2016-10-19 14:14:41 +00:00
2018-01-06 22:05:34 +00:00
instance_set_use_lightmap ( p_rid , RID ( ) , RID ( ) ) ;
2017-03-05 15:44:50 +00:00
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 ( ) ) ;
2016-10-19 14:14:41 +00:00
2016-11-22 04:26:56 +00:00
update_dirty_instances ( ) ; //in case something changed this
2016-10-19 14:14:41 +00:00
instance_owner . free ( p_rid ) ;
memdelete ( instance ) ;
} else {
return false ;
}
return true ;
}
2017-03-05 15:44:50 +00:00
VisualServerScene * VisualServerScene : : singleton = NULL ;
2016-12-20 03:21:07 +00:00
2016-10-19 14:14:41 +00:00
VisualServerScene : : VisualServerScene ( ) {
2017-03-05 15:44:50 +00:00
render_pass = 1 ;
singleton = this ;
2016-10-19 14:14:41 +00:00
}
2016-12-20 03:21:07 +00:00
VisualServerScene : : ~ VisualServerScene ( ) {
}