diff --git a/editor/plugins/gradient_editor_plugin.cpp b/editor/plugins/gradient_editor_plugin.cpp index 128b52e7ec6..f2404633611 100644 --- a/editor/plugins/gradient_editor_plugin.cpp +++ b/editor/plugins/gradient_editor_plugin.cpp @@ -659,7 +659,7 @@ bool EditorInspectorPluginGradient::can_handle(Object *p_object) { void EditorInspectorPluginGradient::parse_begin(Object *p_object) { Gradient *gradient = Object::cast_to(p_object); - ERR_FAIL_COND(!gradient); + ERR_FAIL_NULL(gradient); Ref g(gradient); GradientEditor *editor = memnew(GradientEditor); diff --git a/servers/audio_server.cpp b/servers/audio_server.cpp index ce7f6ee6f07..511a8b3122f 100644 --- a/servers/audio_server.cpp +++ b/servers/audio_server.cpp @@ -389,7 +389,7 @@ void AudioServer::_mix_step() { } AudioStreamPlaybackBusDetails *ptr = playback->bus_details.load(); - ERR_FAIL_COND(ptr == nullptr); + ERR_FAIL_NULL(ptr); // By putting null into the bus details pointers, we're taking ownership of their memory for the duration of this mix. AudioStreamPlaybackBusDetails bus_details = *ptr; @@ -620,8 +620,8 @@ void AudioServer::_mix_step_for_channel(AudioFrame *p_out_buf, AudioFrame *p_sou filter.set_stages(1); filter.set_gain(p_highshelf_gain); - ERR_FAIL_COND(p_processor_l == nullptr); - ERR_FAIL_COND(p_processor_r == nullptr); + ERR_FAIL_NULL(p_processor_l); + ERR_FAIL_NULL(p_processor_r); bool is_just_started = p_vol_start.l == 0 && p_vol_start.r == 0; p_processor_l->set_filter(&filter, /* clear_history= */ is_just_started); diff --git a/servers/debugger/servers_debugger.cpp b/servers/debugger/servers_debugger.cpp index e1bdba0595e..9161c5c8b78 100644 --- a/servers/debugger/servers_debugger.cpp +++ b/servers/debugger/servers_debugger.cpp @@ -396,7 +396,7 @@ void ServersDebugger::deinitialize() { } Error ServersDebugger::_capture(void *p_user, const String &p_cmd, const Array &p_data, bool &r_captured) { - ERR_FAIL_COND_V(!singleton, ERR_BUG); + ERR_FAIL_NULL_V(singleton, ERR_BUG); r_captured = true; if (p_cmd == "memory") { singleton->_send_resource_usage(); diff --git a/servers/physics_2d/godot_body_2d.cpp b/servers/physics_2d/godot_body_2d.cpp index bc31721ae71..c2236a7a0bf 100644 --- a/servers/physics_2d/godot_body_2d.cpp +++ b/servers/physics_2d/godot_body_2d.cpp @@ -510,7 +510,7 @@ void GodotBody2D::integrate_forces(real_t p_step) { // Add default gravity and damping from space area. if (!stopped) { GodotArea2D *default_area = get_space()->get_default_area(); - ERR_FAIL_COND(!default_area); + ERR_FAIL_NULL(default_area); if (!gravity_done) { Vector2 default_gravity; diff --git a/servers/physics_2d/godot_broad_phase_2d_bvh.cpp b/servers/physics_2d/godot_broad_phase_2d_bvh.cpp index eaf50d53d95..59623a26673 100644 --- a/servers/physics_2d/godot_broad_phase_2d_bvh.cpp +++ b/servers/physics_2d/godot_broad_phase_2d_bvh.cpp @@ -58,7 +58,7 @@ void GodotBroadPhase2DBVH::remove(ID p_id) { GodotCollisionObject2D *GodotBroadPhase2DBVH::get_object(ID p_id) const { ERR_FAIL_COND_V(!p_id, nullptr); GodotCollisionObject2D *it = bvh.get(p_id - 1); - ERR_FAIL_COND_V(!it, nullptr); + ERR_FAIL_NULL_V(it, nullptr); return it; } diff --git a/servers/physics_2d/godot_collision_solver_2d_sat.cpp b/servers/physics_2d/godot_collision_solver_2d_sat.cpp index e64a3629e26..c85fdc592a7 100644 --- a/servers/physics_2d/godot_collision_solver_2d_sat.cpp +++ b/servers/physics_2d/godot_collision_solver_2d_sat.cpp @@ -167,7 +167,7 @@ static void _generate_contacts_from_supports(const Vector2 *p_points_A, int p_po int version_B = (pointcount_B > 2 ? 2 : pointcount_B) - 1; GenerateContactsFunc contacts_func = generate_contacts_func_table[version_A][version_B]; - ERR_FAIL_COND(!contacts_func); + ERR_FAIL_NULL(contacts_func); contacts_func(points_A, pointcount_A, points_B, pointcount_B, p_collector); } @@ -1396,7 +1396,7 @@ bool sat_2d_calculate_penetration(const GodotShape2D *p_shape_A, const Transform } } - ERR_FAIL_COND_V(!collision_func, false); + ERR_FAIL_NULL_V(collision_func, false); collision_func(A, *transform_A, B, *transform_B, &callback, *motion_A, *motion_B, margin_A, margin_B); diff --git a/servers/physics_2d/godot_joints_2d.cpp b/servers/physics_2d/godot_joints_2d.cpp index c7cdd271ca0..204661926af 100644 --- a/servers/physics_2d/godot_joints_2d.cpp +++ b/servers/physics_2d/godot_joints_2d.cpp @@ -105,7 +105,7 @@ bool GodotPinJoint2D::setup(real_t p_step) { } GodotSpace2D *space = A->get_space(); - ERR_FAIL_COND_V(!space, false); + ERR_FAIL_NULL_V(space, false); rA = A->get_transform().basis_xform(anchor_A); rB = B ? B->get_transform().basis_xform(anchor_B) : anchor_B; @@ -286,7 +286,7 @@ bool GodotGrooveJoint2D::setup(real_t p_step) { } GodotSpace2D *space = A->get_space(); - ERR_FAIL_COND_V(!space, false); + ERR_FAIL_NULL_V(space, false); // calculate endpoints in worldspace Vector2 ta = A->get_transform().xform(A_groove_1); diff --git a/servers/physics_2d/godot_physics_server_2d.cpp b/servers/physics_2d/godot_physics_server_2d.cpp index 30600e0e573..d4d3ff2dab8 100644 --- a/servers/physics_2d/godot_physics_server_2d.cpp +++ b/servers/physics_2d/godot_physics_server_2d.cpp @@ -114,32 +114,32 @@ RID GodotPhysicsServer2D::concave_polygon_shape_create() { void GodotPhysicsServer2D::shape_set_data(RID p_shape, const Variant &p_data) { GodotShape2D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); shape->set_data(p_data); }; void GodotPhysicsServer2D::shape_set_custom_solver_bias(RID p_shape, real_t p_bias) { GodotShape2D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); shape->set_custom_bias(p_bias); } PhysicsServer2D::ShapeType GodotPhysicsServer2D::shape_get_type(RID p_shape) const { const GodotShape2D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND_V(!shape, SHAPE_CUSTOM); + ERR_FAIL_NULL_V(shape, SHAPE_CUSTOM); return shape->get_type(); }; Variant GodotPhysicsServer2D::shape_get_data(RID p_shape) const { const GodotShape2D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND_V(!shape, Variant()); + ERR_FAIL_NULL_V(shape, Variant()); ERR_FAIL_COND_V(!shape->is_configured(), Variant()); return shape->get_data(); }; real_t GodotPhysicsServer2D::shape_get_custom_solver_bias(RID p_shape) const { const GodotShape2D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND_V(!shape, 0); + ERR_FAIL_NULL_V(shape, 0); return shape->get_custom_bias(); } @@ -195,9 +195,9 @@ void GodotPhysicsServer2D::_shape_col_cbk(const Vector2 &p_point_A, const Vector bool GodotPhysicsServer2D::shape_collide(RID p_shape_A, const Transform2D &p_xform_A, const Vector2 &p_motion_A, RID p_shape_B, const Transform2D &p_xform_B, const Vector2 &p_motion_B, Vector2 *r_results, int p_result_max, int &r_result_count) { GodotShape2D *shape_A = shape_owner.get_or_null(p_shape_A); - ERR_FAIL_COND_V(!shape_A, false); + ERR_FAIL_NULL_V(shape_A, false); GodotShape2D *shape_B = shape_owner.get_or_null(p_shape_B); - ERR_FAIL_COND_V(!shape_B, false); + ERR_FAIL_NULL_V(shape_B, false); if (p_result_max == 0) { return GodotCollisionSolver2D::solve(shape_A, p_xform_A, p_motion_A, shape_B, p_xform_B, p_motion_B, nullptr, nullptr); @@ -220,7 +220,7 @@ RID GodotPhysicsServer2D::space_create() { space->set_self(id); RID area_id = area_create(); GodotArea2D *area = area_owner.get_or_null(area_id); - ERR_FAIL_COND_V(!area, RID()); + ERR_FAIL_NULL_V(area, RID()); space->set_default_area(area); area->set_space(space); area->set_priority(-1); @@ -230,7 +230,7 @@ RID GodotPhysicsServer2D::space_create() { void GodotPhysicsServer2D::space_set_active(RID p_space, bool p_active) { GodotSpace2D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND(!space); + ERR_FAIL_NULL(space); if (p_active) { active_spaces.insert(space); } else { @@ -240,45 +240,45 @@ void GodotPhysicsServer2D::space_set_active(RID p_space, bool p_active) { bool GodotPhysicsServer2D::space_is_active(RID p_space) const { const GodotSpace2D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND_V(!space, false); + ERR_FAIL_NULL_V(space, false); return active_spaces.has(space); } void GodotPhysicsServer2D::space_set_param(RID p_space, SpaceParameter p_param, real_t p_value) { GodotSpace2D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND(!space); + ERR_FAIL_NULL(space); space->set_param(p_param, p_value); } real_t GodotPhysicsServer2D::space_get_param(RID p_space, SpaceParameter p_param) const { const GodotSpace2D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND_V(!space, 0); + ERR_FAIL_NULL_V(space, 0); return space->get_param(p_param); } void GodotPhysicsServer2D::space_set_debug_contacts(RID p_space, int p_max_contacts) { GodotSpace2D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND(!space); + ERR_FAIL_NULL(space); space->set_debug_contacts(p_max_contacts); } Vector GodotPhysicsServer2D::space_get_contacts(RID p_space) const { GodotSpace2D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND_V(!space, Vector()); + ERR_FAIL_NULL_V(space, Vector()); return space->get_debug_contacts(); } int GodotPhysicsServer2D::space_get_contact_count(RID p_space) const { GodotSpace2D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND_V(!space, 0); + ERR_FAIL_NULL_V(space, 0); return space->get_debug_contact_count(); } PhysicsDirectSpaceState2D *GodotPhysicsServer2D::space_get_direct_state(RID p_space) { GodotSpace2D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND_V(!space, nullptr); + ERR_FAIL_NULL_V(space, nullptr); ERR_FAIL_COND_V_MSG((using_threads && !doing_sync) || space->is_locked(), nullptr, "Space state is inaccessible right now, wait for iteration or physics process notification."); return space->get_direct_state(); @@ -293,12 +293,12 @@ RID GodotPhysicsServer2D::area_create() { void GodotPhysicsServer2D::area_set_space(RID p_area, RID p_space) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); GodotSpace2D *space = nullptr; if (p_space.is_valid()) { space = space_owner.get_or_null(p_space); - ERR_FAIL_COND(!space); + ERR_FAIL_NULL(space); } if (area->get_space() == space) { @@ -311,7 +311,7 @@ void GodotPhysicsServer2D::area_set_space(RID p_area, RID p_space) { RID GodotPhysicsServer2D::area_get_space(RID p_area) const { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, RID()); + ERR_FAIL_NULL_V(area, RID()); GodotSpace2D *space = area->get_space(); if (!space) { @@ -322,20 +322,20 @@ RID GodotPhysicsServer2D::area_get_space(RID p_area) const { void GodotPhysicsServer2D::area_add_shape(RID p_area, RID p_shape, const Transform2D &p_transform, bool p_disabled) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); GodotShape2D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); area->add_shape(shape, p_transform, p_disabled); } void GodotPhysicsServer2D::area_set_shape(RID p_area, int p_shape_idx, RID p_shape) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); GodotShape2D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); ERR_FAIL_COND(!shape->is_configured()); area->set_shape(p_shape_idx, shape); @@ -343,14 +343,14 @@ void GodotPhysicsServer2D::area_set_shape(RID p_area, int p_shape_idx, RID p_sha void GodotPhysicsServer2D::area_set_shape_transform(RID p_area, int p_shape_idx, const Transform2D &p_transform) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_shape_transform(p_shape_idx, p_transform); } void GodotPhysicsServer2D::area_set_shape_disabled(RID p_area, int p_shape, bool p_disabled) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); ERR_FAIL_INDEX(p_shape, area->get_shape_count()); FLUSH_QUERY_CHECK(area); @@ -359,38 +359,38 @@ void GodotPhysicsServer2D::area_set_shape_disabled(RID p_area, int p_shape, bool int GodotPhysicsServer2D::area_get_shape_count(RID p_area) const { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, -1); + ERR_FAIL_NULL_V(area, -1); return area->get_shape_count(); } RID GodotPhysicsServer2D::area_get_shape(RID p_area, int p_shape_idx) const { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, RID()); + ERR_FAIL_NULL_V(area, RID()); GodotShape2D *shape = area->get_shape(p_shape_idx); - ERR_FAIL_COND_V(!shape, RID()); + ERR_FAIL_NULL_V(shape, RID()); return shape->get_self(); } Transform2D GodotPhysicsServer2D::area_get_shape_transform(RID p_area, int p_shape_idx) const { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, Transform2D()); + ERR_FAIL_NULL_V(area, Transform2D()); return area->get_shape_transform(p_shape_idx); } void GodotPhysicsServer2D::area_remove_shape(RID p_area, int p_shape_idx) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->remove_shape(p_shape_idx); } void GodotPhysicsServer2D::area_clear_shapes(RID p_area) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); while (area->get_shape_count()) { area->remove_shape(0); @@ -403,7 +403,7 @@ void GodotPhysicsServer2D::area_attach_object_instance_id(RID p_area, ObjectID p p_area = space->get_default_area()->get_self(); } GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_instance_id(p_id); } @@ -413,7 +413,7 @@ ObjectID GodotPhysicsServer2D::area_get_object_instance_id(RID p_area) const { p_area = space->get_default_area()->get_self(); } GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, ObjectID()); + ERR_FAIL_NULL_V(area, ObjectID()); return area->get_instance_id(); } @@ -423,7 +423,7 @@ void GodotPhysicsServer2D::area_attach_canvas_instance_id(RID p_area, ObjectID p p_area = space->get_default_area()->get_self(); } GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_canvas_instance_id(p_id); } @@ -433,7 +433,7 @@ ObjectID GodotPhysicsServer2D::area_get_canvas_instance_id(RID p_area) const { p_area = space->get_default_area()->get_self(); } GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, ObjectID()); + ERR_FAIL_NULL_V(area, ObjectID()); return area->get_canvas_instance_id(); } @@ -443,13 +443,13 @@ void GodotPhysicsServer2D::area_set_param(RID p_area, AreaParameter p_param, con p_area = space->get_default_area()->get_self(); } GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_param(p_param, p_value); }; void GodotPhysicsServer2D::area_set_transform(RID p_area, const Transform2D &p_transform) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_transform(p_transform); }; @@ -459,27 +459,27 @@ Variant GodotPhysicsServer2D::area_get_param(RID p_area, AreaParameter p_param) p_area = space->get_default_area()->get_self(); } GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, Variant()); + ERR_FAIL_NULL_V(area, Variant()); return area->get_param(p_param); }; Transform2D GodotPhysicsServer2D::area_get_transform(RID p_area) const { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, Transform2D()); + ERR_FAIL_NULL_V(area, Transform2D()); return area->get_transform(); }; void GodotPhysicsServer2D::area_set_pickable(RID p_area, bool p_pickable) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_pickable(p_pickable); } void GodotPhysicsServer2D::area_set_monitorable(RID p_area, bool p_monitorable) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); FLUSH_QUERY_CHECK(area); area->set_monitorable(p_monitorable); @@ -487,42 +487,42 @@ void GodotPhysicsServer2D::area_set_monitorable(RID p_area, bool p_monitorable) void GodotPhysicsServer2D::area_set_collision_layer(RID p_area, uint32_t p_layer) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_collision_layer(p_layer); } uint32_t GodotPhysicsServer2D::area_get_collision_layer(RID p_area) const { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, 0); + ERR_FAIL_NULL_V(area, 0); return area->get_collision_layer(); } void GodotPhysicsServer2D::area_set_collision_mask(RID p_area, uint32_t p_mask) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_collision_mask(p_mask); } uint32_t GodotPhysicsServer2D::area_get_collision_mask(RID p_area) const { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, 0); + ERR_FAIL_NULL_V(area, 0); return area->get_collision_mask(); } void GodotPhysicsServer2D::area_set_monitor_callback(RID p_area, const Callable &p_callback) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_monitor_callback(p_callback.is_valid() ? p_callback : Callable()); } void GodotPhysicsServer2D::area_set_area_monitor_callback(RID p_area, const Callable &p_callback) { GodotArea2D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_area_monitor_callback(p_callback.is_valid() ? p_callback : Callable()); } @@ -538,11 +538,11 @@ RID GodotPhysicsServer2D::body_create() { void GodotPhysicsServer2D::body_set_space(RID p_body, RID p_space) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); GodotSpace2D *space = nullptr; if (p_space.is_valid()) { space = space_owner.get_or_null(p_space); - ERR_FAIL_COND(!space); + ERR_FAIL_NULL(space); } if (body->get_space() == space) { @@ -555,7 +555,7 @@ void GodotPhysicsServer2D::body_set_space(RID p_body, RID p_space) { RID GodotPhysicsServer2D::body_get_space(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, RID()); + ERR_FAIL_NULL_V(body, RID()); GodotSpace2D *space = body->get_space(); if (!space) { @@ -566,7 +566,7 @@ RID GodotPhysicsServer2D::body_get_space(RID p_body) const { void GodotPhysicsServer2D::body_set_mode(RID p_body, BodyMode p_mode) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); FLUSH_QUERY_CHECK(body); body->set_mode(p_mode); @@ -574,27 +574,27 @@ void GodotPhysicsServer2D::body_set_mode(RID p_body, BodyMode p_mode) { PhysicsServer2D::BodyMode GodotPhysicsServer2D::body_get_mode(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, BODY_MODE_STATIC); + ERR_FAIL_NULL_V(body, BODY_MODE_STATIC); return body->get_mode(); }; void GodotPhysicsServer2D::body_add_shape(RID p_body, RID p_shape, const Transform2D &p_transform, bool p_disabled) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); GodotShape2D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); body->add_shape(shape, p_transform, p_disabled); } void GodotPhysicsServer2D::body_set_shape(RID p_body, int p_shape_idx, RID p_shape) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); GodotShape2D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); ERR_FAIL_COND(!shape->is_configured()); body->set_shape(p_shape_idx, shape); @@ -602,45 +602,45 @@ void GodotPhysicsServer2D::body_set_shape(RID p_body, int p_shape_idx, RID p_sha void GodotPhysicsServer2D::body_set_shape_transform(RID p_body, int p_shape_idx, const Transform2D &p_transform) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_shape_transform(p_shape_idx, p_transform); } int GodotPhysicsServer2D::body_get_shape_count(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, -1); + ERR_FAIL_NULL_V(body, -1); return body->get_shape_count(); } RID GodotPhysicsServer2D::body_get_shape(RID p_body, int p_shape_idx) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, RID()); + ERR_FAIL_NULL_V(body, RID()); GodotShape2D *shape = body->get_shape(p_shape_idx); - ERR_FAIL_COND_V(!shape, RID()); + ERR_FAIL_NULL_V(shape, RID()); return shape->get_self(); } Transform2D GodotPhysicsServer2D::body_get_shape_transform(RID p_body, int p_shape_idx) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, Transform2D()); + ERR_FAIL_NULL_V(body, Transform2D()); return body->get_shape_transform(p_shape_idx); } void GodotPhysicsServer2D::body_remove_shape(RID p_body, int p_shape_idx) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->remove_shape(p_shape_idx); } void GodotPhysicsServer2D::body_clear_shapes(RID p_body) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); while (body->get_shape_count()) { body->remove_shape(0); @@ -649,7 +649,7 @@ void GodotPhysicsServer2D::body_clear_shapes(RID p_body) { void GodotPhysicsServer2D::body_set_shape_disabled(RID p_body, int p_shape_idx, bool p_disabled) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); ERR_FAIL_INDEX(p_shape_idx, body->get_shape_count()); FLUSH_QUERY_CHECK(body); @@ -658,7 +658,7 @@ void GodotPhysicsServer2D::body_set_shape_disabled(RID p_body, int p_shape_idx, void GodotPhysicsServer2D::body_set_shape_as_one_way_collision(RID p_body, int p_shape_idx, bool p_enable, real_t p_margin) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); ERR_FAIL_INDEX(p_shape_idx, body->get_shape_count()); FLUSH_QUERY_CHECK(body); @@ -667,123 +667,123 @@ void GodotPhysicsServer2D::body_set_shape_as_one_way_collision(RID p_body, int p void GodotPhysicsServer2D::body_set_continuous_collision_detection_mode(RID p_body, CCDMode p_mode) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_continuous_collision_detection_mode(p_mode); } GodotPhysicsServer2D::CCDMode GodotPhysicsServer2D::body_get_continuous_collision_detection_mode(RID p_body) const { const GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, CCD_MODE_DISABLED); + ERR_FAIL_NULL_V(body, CCD_MODE_DISABLED); return body->get_continuous_collision_detection_mode(); } void GodotPhysicsServer2D::body_attach_object_instance_id(RID p_body, ObjectID p_id) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_instance_id(p_id); } ObjectID GodotPhysicsServer2D::body_get_object_instance_id(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, ObjectID()); + ERR_FAIL_NULL_V(body, ObjectID()); return body->get_instance_id(); } void GodotPhysicsServer2D::body_attach_canvas_instance_id(RID p_body, ObjectID p_id) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_canvas_instance_id(p_id); } ObjectID GodotPhysicsServer2D::body_get_canvas_instance_id(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, ObjectID()); + ERR_FAIL_NULL_V(body, ObjectID()); return body->get_canvas_instance_id(); } void GodotPhysicsServer2D::body_set_collision_layer(RID p_body, uint32_t p_layer) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_collision_layer(p_layer); } uint32_t GodotPhysicsServer2D::body_get_collision_layer(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return body->get_collision_layer(); } void GodotPhysicsServer2D::body_set_collision_mask(RID p_body, uint32_t p_mask) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_collision_mask(p_mask); } uint32_t GodotPhysicsServer2D::body_get_collision_mask(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return body->get_collision_mask(); } void GodotPhysicsServer2D::body_set_collision_priority(RID p_body, real_t p_priority) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_collision_priority(p_priority); } real_t GodotPhysicsServer2D::body_get_collision_priority(RID p_body) const { const GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return body->get_collision_priority(); } void GodotPhysicsServer2D::body_set_param(RID p_body, BodyParameter p_param, const Variant &p_value) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_param(p_param, p_value); } Variant GodotPhysicsServer2D::body_get_param(RID p_body, BodyParameter p_param) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return body->get_param(p_param); } void GodotPhysicsServer2D::body_reset_mass_properties(RID p_body) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); return body->reset_mass_properties(); } void GodotPhysicsServer2D::body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_state(p_state, p_variant); } Variant GodotPhysicsServer2D::body_get_state(RID p_body, BodyState p_state) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, Variant()); + ERR_FAIL_NULL_V(body, Variant()); return body->get_state(p_state); } void GodotPhysicsServer2D::body_apply_central_impulse(RID p_body, const Vector2 &p_impulse) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->apply_central_impulse(p_impulse); body->wakeup(); @@ -791,7 +791,7 @@ void GodotPhysicsServer2D::body_apply_central_impulse(RID p_body, const Vector2 void GodotPhysicsServer2D::body_apply_torque_impulse(RID p_body, real_t p_torque) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); _update_shapes(); @@ -801,7 +801,7 @@ void GodotPhysicsServer2D::body_apply_torque_impulse(RID p_body, real_t p_torque void GodotPhysicsServer2D::body_apply_impulse(RID p_body, const Vector2 &p_impulse, const Vector2 &p_position) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); _update_shapes(); @@ -811,7 +811,7 @@ void GodotPhysicsServer2D::body_apply_impulse(RID p_body, const Vector2 &p_impul void GodotPhysicsServer2D::body_apply_central_force(RID p_body, const Vector2 &p_force) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->apply_central_force(p_force); body->wakeup(); @@ -819,7 +819,7 @@ void GodotPhysicsServer2D::body_apply_central_force(RID p_body, const Vector2 &p void GodotPhysicsServer2D::body_apply_force(RID p_body, const Vector2 &p_force, const Vector2 &p_position) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->apply_force(p_force, p_position); body->wakeup(); @@ -827,7 +827,7 @@ void GodotPhysicsServer2D::body_apply_force(RID p_body, const Vector2 &p_force, void GodotPhysicsServer2D::body_apply_torque(RID p_body, real_t p_torque) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->apply_torque(p_torque); body->wakeup(); @@ -835,7 +835,7 @@ void GodotPhysicsServer2D::body_apply_torque(RID p_body, real_t p_torque) { void GodotPhysicsServer2D::body_add_constant_central_force(RID p_body, const Vector2 &p_force) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->add_constant_central_force(p_force); body->wakeup(); @@ -843,7 +843,7 @@ void GodotPhysicsServer2D::body_add_constant_central_force(RID p_body, const Vec void GodotPhysicsServer2D::body_add_constant_force(RID p_body, const Vector2 &p_force, const Vector2 &p_position) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->add_constant_force(p_force, p_position); body->wakeup(); @@ -851,7 +851,7 @@ void GodotPhysicsServer2D::body_add_constant_force(RID p_body, const Vector2 &p_ void GodotPhysicsServer2D::body_add_constant_torque(RID p_body, real_t p_torque) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->add_constant_torque(p_torque); body->wakeup(); @@ -859,7 +859,7 @@ void GodotPhysicsServer2D::body_add_constant_torque(RID p_body, real_t p_torque) void GodotPhysicsServer2D::body_set_constant_force(RID p_body, const Vector2 &p_force) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_constant_force(p_force); if (!p_force.is_zero_approx()) { @@ -869,13 +869,13 @@ void GodotPhysicsServer2D::body_set_constant_force(RID p_body, const Vector2 &p_ Vector2 GodotPhysicsServer2D::body_get_constant_force(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, Vector2()); + ERR_FAIL_NULL_V(body, Vector2()); return body->get_constant_force(); } void GodotPhysicsServer2D::body_set_constant_torque(RID p_body, real_t p_torque) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_constant_torque(p_torque); if (!Math::is_zero_approx(p_torque)) { @@ -885,14 +885,14 @@ void GodotPhysicsServer2D::body_set_constant_torque(RID p_body, real_t p_torque) real_t GodotPhysicsServer2D::body_get_constant_torque(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return body->get_constant_torque(); } void GodotPhysicsServer2D::body_set_axis_velocity(RID p_body, const Vector2 &p_axis_velocity) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); _update_shapes(); @@ -906,7 +906,7 @@ void GodotPhysicsServer2D::body_set_axis_velocity(RID p_body, const Vector2 &p_a void GodotPhysicsServer2D::body_add_collision_exception(RID p_body, RID p_body_b) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->add_exception(p_body_b); body->wakeup(); @@ -914,7 +914,7 @@ void GodotPhysicsServer2D::body_add_collision_exception(RID p_body, RID p_body_b void GodotPhysicsServer2D::body_remove_collision_exception(RID p_body, RID p_body_b) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->remove_exception(p_body_b); body->wakeup(); @@ -922,7 +922,7 @@ void GodotPhysicsServer2D::body_remove_collision_exception(RID p_body, RID p_bod void GodotPhysicsServer2D::body_get_collision_exceptions(RID p_body, List *p_exceptions) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); for (int i = 0; i < body->get_exceptions().size(); i++) { p_exceptions->push_back(body->get_exceptions()[i]); @@ -931,55 +931,55 @@ void GodotPhysicsServer2D::body_get_collision_exceptions(RID p_body, List * void GodotPhysicsServer2D::body_set_contacts_reported_depth_threshold(RID p_body, real_t p_threshold) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); }; real_t GodotPhysicsServer2D::body_get_contacts_reported_depth_threshold(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return 0; }; void GodotPhysicsServer2D::body_set_omit_force_integration(RID p_body, bool p_omit) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_omit_force_integration(p_omit); }; bool GodotPhysicsServer2D::body_is_omitting_force_integration(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, false); + ERR_FAIL_NULL_V(body, false); return body->get_omit_force_integration(); }; void GodotPhysicsServer2D::body_set_max_contacts_reported(RID p_body, int p_contacts) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_max_contacts_reported(p_contacts); } int GodotPhysicsServer2D::body_get_max_contacts_reported(RID p_body) const { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, -1); + ERR_FAIL_NULL_V(body, -1); return body->get_max_contacts_reported(); } void GodotPhysicsServer2D::body_set_state_sync_callback(RID p_body, const Callable &p_callable) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_state_sync_callback(p_callable); } void GodotPhysicsServer2D::body_set_force_integration_callback(RID p_body, const Callable &p_callable, const Variant &p_udata) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_force_integration_callback(p_callable, p_udata); } bool GodotPhysicsServer2D::body_collide_shape(RID p_body, int p_body_shape, RID p_shape, const Transform2D &p_shape_xform, const Vector2 &p_motion, Vector2 *r_results, int p_result_max, int &r_result_count) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, false); + ERR_FAIL_NULL_V(body, false); ERR_FAIL_INDEX_V(p_body_shape, body->get_shape_count(), false); return shape_collide(body->get_shape(p_body_shape)->get_self(), body->get_transform() * body->get_shape_transform(p_body_shape), Vector2(), p_shape, p_shape_xform, p_motion, r_results, p_result_max, r_result_count); @@ -987,13 +987,13 @@ bool GodotPhysicsServer2D::body_collide_shape(RID p_body, int p_body_shape, RID void GodotPhysicsServer2D::body_set_pickable(RID p_body, bool p_pickable) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_pickable(p_pickable); } bool GodotPhysicsServer2D::body_test_motion(RID p_body, const MotionParameters &p_parameters, MotionResult *r_result) { GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, false); + ERR_FAIL_NULL_V(body, false); ERR_FAIL_COND_V(!body->get_space(), false); ERR_FAIL_COND_V(body->get_space()->is_locked(), false); @@ -1010,7 +1010,7 @@ PhysicsDirectBodyState2D *GodotPhysicsServer2D::body_get_direct_state(RID p_body } GodotBody2D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, nullptr); + ERR_FAIL_NULL_V(body, nullptr); if (!body->get_space()) { return nullptr; @@ -1044,7 +1044,7 @@ void GodotPhysicsServer2D::joint_clear(RID p_joint) { void GodotPhysicsServer2D::joint_set_param(RID p_joint, JointParam p_param, real_t p_value) { GodotJoint2D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); switch (p_param) { case JOINT_PARAM_BIAS: @@ -1061,7 +1061,7 @@ void GodotPhysicsServer2D::joint_set_param(RID p_joint, JointParam p_param, real real_t GodotPhysicsServer2D::joint_get_param(RID p_joint, JointParam p_param) const { const GodotJoint2D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, -1); + ERR_FAIL_NULL_V(joint, -1); switch (p_param) { case JOINT_PARAM_BIAS: @@ -1080,7 +1080,7 @@ real_t GodotPhysicsServer2D::joint_get_param(RID p_joint, JointParam p_param) co void GodotPhysicsServer2D::joint_disable_collisions_between_bodies(RID p_joint, const bool p_disable) { GodotJoint2D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); joint->disable_collisions_between_bodies(p_disable); @@ -1100,22 +1100,22 @@ void GodotPhysicsServer2D::joint_disable_collisions_between_bodies(RID p_joint, bool GodotPhysicsServer2D::joint_is_disabled_collisions_between_bodies(RID p_joint) const { const GodotJoint2D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, true); + ERR_FAIL_NULL_V(joint, true); return joint->is_disabled_collisions_between_bodies(); } void GodotPhysicsServer2D::joint_make_pin(RID p_joint, const Vector2 &p_pos, RID p_body_a, RID p_body_b) { GodotBody2D *A = body_owner.get_or_null(p_body_a); - ERR_FAIL_COND(!A); + ERR_FAIL_NULL(A); GodotBody2D *B = nullptr; if (body_owner.owns(p_body_b)) { B = body_owner.get_or_null(p_body_b); - ERR_FAIL_COND(!B); + ERR_FAIL_NULL(B); } GodotJoint2D *prev_joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(prev_joint == nullptr); + ERR_FAIL_NULL(prev_joint); GodotJoint2D *joint = memnew(GodotPinJoint2D(p_pos, A, B)); @@ -1126,13 +1126,13 @@ void GodotPhysicsServer2D::joint_make_pin(RID p_joint, const Vector2 &p_pos, RID void GodotPhysicsServer2D::joint_make_groove(RID p_joint, const Vector2 &p_a_groove1, const Vector2 &p_a_groove2, const Vector2 &p_b_anchor, RID p_body_a, RID p_body_b) { GodotBody2D *A = body_owner.get_or_null(p_body_a); - ERR_FAIL_COND(!A); + ERR_FAIL_NULL(A); GodotBody2D *B = body_owner.get_or_null(p_body_b); - ERR_FAIL_COND(!B); + ERR_FAIL_NULL(B); GodotJoint2D *prev_joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(prev_joint == nullptr); + ERR_FAIL_NULL(prev_joint); GodotJoint2D *joint = memnew(GodotGrooveJoint2D(p_a_groove1, p_a_groove2, p_b_anchor, A, B)); @@ -1143,13 +1143,13 @@ void GodotPhysicsServer2D::joint_make_groove(RID p_joint, const Vector2 &p_a_gro void GodotPhysicsServer2D::joint_make_damped_spring(RID p_joint, const Vector2 &p_anchor_a, const Vector2 &p_anchor_b, RID p_body_a, RID p_body_b) { GodotBody2D *A = body_owner.get_or_null(p_body_a); - ERR_FAIL_COND(!A); + ERR_FAIL_NULL(A); GodotBody2D *B = body_owner.get_or_null(p_body_b); - ERR_FAIL_COND(!B); + ERR_FAIL_NULL(B); GodotJoint2D *prev_joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(prev_joint == nullptr); + ERR_FAIL_NULL(prev_joint); GodotJoint2D *joint = memnew(GodotDampedSpringJoint2D(p_anchor_a, p_anchor_b, A, B)); @@ -1196,7 +1196,7 @@ real_t GodotPhysicsServer2D::damped_spring_joint_get_param(RID p_joint, DampedSp PhysicsServer2D::JointType GodotPhysicsServer2D::joint_get_type(RID p_joint) const { GodotJoint2D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, JOINT_TYPE_PIN); + ERR_FAIL_NULL_V(joint, JOINT_TYPE_PIN); return joint->get_type(); } diff --git a/servers/physics_2d/godot_space_2d.cpp b/servers/physics_2d/godot_space_2d.cpp index 1beb5336f76..2966818bebb 100644 --- a/servers/physics_2d/godot_space_2d.cpp +++ b/servers/physics_2d/godot_space_2d.cpp @@ -210,7 +210,7 @@ int GodotPhysicsDirectSpaceState2D::intersect_shape(const ShapeParameters &p_par } GodotShape2D *shape = GodotPhysicsServer2D::godot_singleton->shape_owner.get_or_null(p_parameters.shape_rid); - ERR_FAIL_COND_V(!shape, 0); + ERR_FAIL_NULL_V(shape, 0); Rect2 aabb = p_parameters.transform.xform(shape->get_aabb()); aabb = aabb.merge(Rect2(aabb.position + p_parameters.motion, aabb.size)); //motion @@ -255,7 +255,7 @@ int GodotPhysicsDirectSpaceState2D::intersect_shape(const ShapeParameters &p_par bool GodotPhysicsDirectSpaceState2D::cast_motion(const ShapeParameters &p_parameters, real_t &p_closest_safe, real_t &p_closest_unsafe) { GodotShape2D *shape = GodotPhysicsServer2D::godot_singleton->shape_owner.get_or_null(p_parameters.shape_rid); - ERR_FAIL_COND_V(!shape, false); + ERR_FAIL_NULL_V(shape, false); Rect2 aabb = p_parameters.transform.xform(shape->get_aabb()); aabb = aabb.merge(Rect2(aabb.position + p_parameters.motion, aabb.size)); //motion @@ -342,7 +342,7 @@ bool GodotPhysicsDirectSpaceState2D::collide_shape(const ShapeParameters &p_para } GodotShape2D *shape = GodotPhysicsServer2D::godot_singleton->shape_owner.get_or_null(p_parameters.shape_rid); - ERR_FAIL_COND_V(!shape, 0); + ERR_FAIL_NULL_V(shape, 0); Rect2 aabb = p_parameters.transform.xform(shape->get_aabb()); aabb = aabb.merge(Rect2(aabb.position + p_parameters.motion, aabb.size)); //motion @@ -439,7 +439,7 @@ static void _rest_cbk_result(const Vector2 &p_point_A, const Vector2 &p_point_B, bool GodotPhysicsDirectSpaceState2D::rest_info(const ShapeParameters &p_parameters, ShapeRestInfo *r_info) { GodotShape2D *shape = GodotPhysicsServer2D::godot_singleton->shape_owner.get_or_null(p_parameters.shape_rid); - ERR_FAIL_COND_V(!shape, 0); + ERR_FAIL_NULL_V(shape, 0); real_t margin = MAX(p_parameters.margin, TEST_MOTION_MARGIN_MIN_VALUE); diff --git a/servers/physics_3d/godot_body_3d.cpp b/servers/physics_3d/godot_body_3d.cpp index 3c93fee4f83..7bacbd476c2 100644 --- a/servers/physics_3d/godot_body_3d.cpp +++ b/servers/physics_3d/godot_body_3d.cpp @@ -565,7 +565,7 @@ void GodotBody3D::integrate_forces(real_t p_step) { // Add default gravity and damping from space area. if (!stopped) { GodotArea3D *default_area = get_space()->get_default_area(); - ERR_FAIL_COND(!default_area); + ERR_FAIL_NULL(default_area); if (!gravity_done) { Vector3 default_gravity; diff --git a/servers/physics_3d/godot_broad_phase_3d_bvh.cpp b/servers/physics_3d/godot_broad_phase_3d_bvh.cpp index 118b136ce56..0faa56b52ef 100644 --- a/servers/physics_3d/godot_broad_phase_3d_bvh.cpp +++ b/servers/physics_3d/godot_broad_phase_3d_bvh.cpp @@ -59,7 +59,7 @@ void GodotBroadPhase3DBVH::remove(ID p_id) { GodotCollisionObject3D *GodotBroadPhase3DBVH::get_object(ID p_id) const { ERR_FAIL_COND_V(!p_id, nullptr); GodotCollisionObject3D *it = bvh.get(p_id - 1); - ERR_FAIL_COND_V(!it, nullptr); + ERR_FAIL_NULL_V(it, nullptr); return it; } diff --git a/servers/physics_3d/godot_collision_solver_3d_sat.cpp b/servers/physics_3d/godot_collision_solver_3d_sat.cpp index 92a4d47cd3e..3aa2f256c18 100644 --- a/servers/physics_3d/godot_collision_solver_3d_sat.cpp +++ b/servers/physics_3d/godot_collision_solver_3d_sat.cpp @@ -608,7 +608,7 @@ static void _generate_contacts_from_supports(const Vector3 *p_points_A, int p_po } GenerateContactsFunc contacts_func = generate_contacts_func_table[version_A][version_B]; - ERR_FAIL_COND(!contacts_func); + ERR_FAIL_NULL(contacts_func); contacts_func(points_A, pointcount_A, points_B, pointcount_B, p_callback); } @@ -2409,7 +2409,7 @@ bool sat_calculate_penetration(const GodotShape3D *p_shape_A, const Transform3D } else { collision_func = collision_table[type_A - 2][type_B - 2]; } - ERR_FAIL_COND_V(!collision_func, false); + ERR_FAIL_NULL_V(collision_func, false); collision_func(A, *transform_A, B, *transform_B, &callback, margin_A, margin_B); diff --git a/servers/physics_3d/godot_physics_server_3d.cpp b/servers/physics_3d/godot_physics_server_3d.cpp index b6d8acfbf3b..02e22775e8b 100644 --- a/servers/physics_3d/godot_physics_server_3d.cpp +++ b/servers/physics_3d/godot_physics_server_3d.cpp @@ -104,25 +104,25 @@ RID GodotPhysicsServer3D::custom_shape_create() { void GodotPhysicsServer3D::shape_set_data(RID p_shape, const Variant &p_data) { GodotShape3D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); shape->set_data(p_data); }; void GodotPhysicsServer3D::shape_set_custom_solver_bias(RID p_shape, real_t p_bias) { GodotShape3D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); shape->set_custom_bias(p_bias); } PhysicsServer3D::ShapeType GodotPhysicsServer3D::shape_get_type(RID p_shape) const { const GodotShape3D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND_V(!shape, SHAPE_CUSTOM); + ERR_FAIL_NULL_V(shape, SHAPE_CUSTOM); return shape->get_type(); }; Variant GodotPhysicsServer3D::shape_get_data(RID p_shape) const { const GodotShape3D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND_V(!shape, Variant()); + ERR_FAIL_NULL_V(shape, Variant()); ERR_FAIL_COND_V(!shape->is_configured(), Variant()); return shape->get_data(); }; @@ -136,7 +136,7 @@ real_t GodotPhysicsServer3D::shape_get_margin(RID p_shape) const { real_t GodotPhysicsServer3D::shape_get_custom_solver_bias(RID p_shape) const { const GodotShape3D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND_V(!shape, 0); + ERR_FAIL_NULL_V(shape, 0); return shape->get_custom_bias(); } @@ -146,7 +146,7 @@ RID GodotPhysicsServer3D::space_create() { space->set_self(id); RID area_id = area_create(); GodotArea3D *area = area_owner.get_or_null(area_id); - ERR_FAIL_COND_V(!area, RID()); + ERR_FAIL_NULL_V(area, RID()); space->set_default_area(area); area->set_space(space); area->set_priority(-1); @@ -160,7 +160,7 @@ RID GodotPhysicsServer3D::space_create() { void GodotPhysicsServer3D::space_set_active(RID p_space, bool p_active) { GodotSpace3D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND(!space); + ERR_FAIL_NULL(space); if (p_active) { active_spaces.insert(space); } else { @@ -170,27 +170,27 @@ void GodotPhysicsServer3D::space_set_active(RID p_space, bool p_active) { bool GodotPhysicsServer3D::space_is_active(RID p_space) const { const GodotSpace3D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND_V(!space, false); + ERR_FAIL_NULL_V(space, false); return active_spaces.has(space); } void GodotPhysicsServer3D::space_set_param(RID p_space, SpaceParameter p_param, real_t p_value) { GodotSpace3D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND(!space); + ERR_FAIL_NULL(space); space->set_param(p_param, p_value); } real_t GodotPhysicsServer3D::space_get_param(RID p_space, SpaceParameter p_param) const { const GodotSpace3D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND_V(!space, 0); + ERR_FAIL_NULL_V(space, 0); return space->get_param(p_param); } PhysicsDirectSpaceState3D *GodotPhysicsServer3D::space_get_direct_state(RID p_space) { GodotSpace3D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND_V(!space, nullptr); + ERR_FAIL_NULL_V(space, nullptr); ERR_FAIL_COND_V_MSG((using_threads && !doing_sync) || space->is_locked(), nullptr, "Space state is inaccessible right now, wait for iteration or physics process notification."); return space->get_direct_state(); @@ -198,19 +198,19 @@ PhysicsDirectSpaceState3D *GodotPhysicsServer3D::space_get_direct_state(RID p_sp void GodotPhysicsServer3D::space_set_debug_contacts(RID p_space, int p_max_contacts) { GodotSpace3D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND(!space); + ERR_FAIL_NULL(space); space->set_debug_contacts(p_max_contacts); } Vector GodotPhysicsServer3D::space_get_contacts(RID p_space) const { GodotSpace3D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND_V(!space, Vector()); + ERR_FAIL_NULL_V(space, Vector()); return space->get_debug_contacts(); } int GodotPhysicsServer3D::space_get_contact_count(RID p_space) const { GodotSpace3D *space = space_owner.get_or_null(p_space); - ERR_FAIL_COND_V(!space, 0); + ERR_FAIL_NULL_V(space, 0); return space->get_debug_contact_count(); } @@ -223,12 +223,12 @@ RID GodotPhysicsServer3D::area_create() { void GodotPhysicsServer3D::area_set_space(RID p_area, RID p_space) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); GodotSpace3D *space = nullptr; if (p_space.is_valid()) { space = space_owner.get_or_null(p_space); - ERR_FAIL_COND(!space); + ERR_FAIL_NULL(space); } if (area->get_space() == space) { @@ -241,7 +241,7 @@ void GodotPhysicsServer3D::area_set_space(RID p_area, RID p_space) { RID GodotPhysicsServer3D::area_get_space(RID p_area) const { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, RID()); + ERR_FAIL_NULL_V(area, RID()); GodotSpace3D *space = area->get_space(); if (!space) { @@ -252,20 +252,20 @@ RID GodotPhysicsServer3D::area_get_space(RID p_area) const { void GodotPhysicsServer3D::area_add_shape(RID p_area, RID p_shape, const Transform3D &p_transform, bool p_disabled) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); GodotShape3D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); area->add_shape(shape, p_transform, p_disabled); } void GodotPhysicsServer3D::area_set_shape(RID p_area, int p_shape_idx, RID p_shape) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); GodotShape3D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); ERR_FAIL_COND(!shape->is_configured()); area->set_shape(p_shape_idx, shape); @@ -273,45 +273,45 @@ void GodotPhysicsServer3D::area_set_shape(RID p_area, int p_shape_idx, RID p_sha void GodotPhysicsServer3D::area_set_shape_transform(RID p_area, int p_shape_idx, const Transform3D &p_transform) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_shape_transform(p_shape_idx, p_transform); } int GodotPhysicsServer3D::area_get_shape_count(RID p_area) const { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, -1); + ERR_FAIL_NULL_V(area, -1); return area->get_shape_count(); } RID GodotPhysicsServer3D::area_get_shape(RID p_area, int p_shape_idx) const { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, RID()); + ERR_FAIL_NULL_V(area, RID()); GodotShape3D *shape = area->get_shape(p_shape_idx); - ERR_FAIL_COND_V(!shape, RID()); + ERR_FAIL_NULL_V(shape, RID()); return shape->get_self(); } Transform3D GodotPhysicsServer3D::area_get_shape_transform(RID p_area, int p_shape_idx) const { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, Transform3D()); + ERR_FAIL_NULL_V(area, Transform3D()); return area->get_shape_transform(p_shape_idx); } void GodotPhysicsServer3D::area_remove_shape(RID p_area, int p_shape_idx) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->remove_shape(p_shape_idx); } void GodotPhysicsServer3D::area_clear_shapes(RID p_area) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); while (area->get_shape_count()) { area->remove_shape(0); @@ -320,7 +320,7 @@ void GodotPhysicsServer3D::area_clear_shapes(RID p_area) { void GodotPhysicsServer3D::area_set_shape_disabled(RID p_area, int p_shape_idx, bool p_disabled) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); ERR_FAIL_INDEX(p_shape_idx, area->get_shape_count()); FLUSH_QUERY_CHECK(area); area->set_shape_disabled(p_shape_idx, p_disabled); @@ -332,7 +332,7 @@ void GodotPhysicsServer3D::area_attach_object_instance_id(RID p_area, ObjectID p p_area = space->get_default_area()->get_self(); } GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_instance_id(p_id); } @@ -342,7 +342,7 @@ ObjectID GodotPhysicsServer3D::area_get_object_instance_id(RID p_area) const { p_area = space->get_default_area()->get_self(); } GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, ObjectID()); + ERR_FAIL_NULL_V(area, ObjectID()); return area->get_instance_id(); } @@ -352,13 +352,13 @@ void GodotPhysicsServer3D::area_set_param(RID p_area, AreaParameter p_param, con p_area = space->get_default_area()->get_self(); } GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_param(p_param, p_value); }; void GodotPhysicsServer3D::area_set_transform(RID p_area, const Transform3D &p_transform) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_transform(p_transform); }; @@ -368,49 +368,49 @@ Variant GodotPhysicsServer3D::area_get_param(RID p_area, AreaParameter p_param) p_area = space->get_default_area()->get_self(); } GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, Variant()); + ERR_FAIL_NULL_V(area, Variant()); return area->get_param(p_param); }; Transform3D GodotPhysicsServer3D::area_get_transform(RID p_area) const { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, Transform3D()); + ERR_FAIL_NULL_V(area, Transform3D()); return area->get_transform(); }; void GodotPhysicsServer3D::area_set_collision_layer(RID p_area, uint32_t p_layer) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_collision_layer(p_layer); } uint32_t GodotPhysicsServer3D::area_get_collision_layer(RID p_area) const { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, 0); + ERR_FAIL_NULL_V(area, 0); return area->get_collision_layer(); } void GodotPhysicsServer3D::area_set_collision_mask(RID p_area, uint32_t p_mask) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_collision_mask(p_mask); } uint32_t GodotPhysicsServer3D::area_get_collision_mask(RID p_area) const { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND_V(!area, 0); + ERR_FAIL_NULL_V(area, 0); return area->get_collision_mask(); } void GodotPhysicsServer3D::area_set_monitorable(RID p_area, bool p_monitorable) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); FLUSH_QUERY_CHECK(area); area->set_monitorable(p_monitorable); @@ -418,21 +418,21 @@ void GodotPhysicsServer3D::area_set_monitorable(RID p_area, bool p_monitorable) void GodotPhysicsServer3D::area_set_monitor_callback(RID p_area, const Callable &p_callback) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_monitor_callback(p_callback.is_valid() ? p_callback : Callable()); } void GodotPhysicsServer3D::area_set_ray_pickable(RID p_area, bool p_enable) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_ray_pickable(p_enable); } void GodotPhysicsServer3D::area_set_area_monitor_callback(RID p_area, const Callable &p_callback) { GodotArea3D *area = area_owner.get_or_null(p_area); - ERR_FAIL_COND(!area); + ERR_FAIL_NULL(area); area->set_area_monitor_callback(p_callback.is_valid() ? p_callback : Callable()); } @@ -448,12 +448,12 @@ RID GodotPhysicsServer3D::body_create() { void GodotPhysicsServer3D::body_set_space(RID p_body, RID p_space) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); GodotSpace3D *space = nullptr; if (p_space.is_valid()) { space = space_owner.get_or_null(p_space); - ERR_FAIL_COND(!space); + ERR_FAIL_NULL(space); } if (body->get_space() == space) { @@ -466,7 +466,7 @@ void GodotPhysicsServer3D::body_set_space(RID p_body, RID p_space) { RID GodotPhysicsServer3D::body_get_space(RID p_body) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, RID()); + ERR_FAIL_NULL_V(body, RID()); GodotSpace3D *space = body->get_space(); if (!space) { @@ -477,65 +477,65 @@ RID GodotPhysicsServer3D::body_get_space(RID p_body) const { void GodotPhysicsServer3D::body_set_mode(RID p_body, BodyMode p_mode) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_mode(p_mode); }; PhysicsServer3D::BodyMode GodotPhysicsServer3D::body_get_mode(RID p_body) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, BODY_MODE_STATIC); + ERR_FAIL_NULL_V(body, BODY_MODE_STATIC); return body->get_mode(); }; void GodotPhysicsServer3D::body_add_shape(RID p_body, RID p_shape, const Transform3D &p_transform, bool p_disabled) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); GodotShape3D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); body->add_shape(shape, p_transform, p_disabled); } void GodotPhysicsServer3D::body_set_shape(RID p_body, int p_shape_idx, RID p_shape) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); GodotShape3D *shape = shape_owner.get_or_null(p_shape); - ERR_FAIL_COND(!shape); + ERR_FAIL_NULL(shape); ERR_FAIL_COND(!shape->is_configured()); body->set_shape(p_shape_idx, shape); } void GodotPhysicsServer3D::body_set_shape_transform(RID p_body, int p_shape_idx, const Transform3D &p_transform) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_shape_transform(p_shape_idx, p_transform); } int GodotPhysicsServer3D::body_get_shape_count(RID p_body) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, -1); + ERR_FAIL_NULL_V(body, -1); return body->get_shape_count(); } RID GodotPhysicsServer3D::body_get_shape(RID p_body, int p_shape_idx) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, RID()); + ERR_FAIL_NULL_V(body, RID()); GodotShape3D *shape = body->get_shape(p_shape_idx); - ERR_FAIL_COND_V(!shape, RID()); + ERR_FAIL_NULL_V(shape, RID()); return shape->get_self(); } void GodotPhysicsServer3D::body_set_shape_disabled(RID p_body, int p_shape_idx, bool p_disabled) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); ERR_FAIL_INDEX(p_shape_idx, body->get_shape_count()); FLUSH_QUERY_CHECK(body); @@ -544,21 +544,21 @@ void GodotPhysicsServer3D::body_set_shape_disabled(RID p_body, int p_shape_idx, Transform3D GodotPhysicsServer3D::body_get_shape_transform(RID p_body, int p_shape_idx) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, Transform3D()); + ERR_FAIL_NULL_V(body, Transform3D()); return body->get_shape_transform(p_shape_idx); } void GodotPhysicsServer3D::body_remove_shape(RID p_body, int p_shape_idx) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->remove_shape(p_shape_idx); } void GodotPhysicsServer3D::body_clear_shapes(RID p_body) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); while (body->get_shape_count()) { body->remove_shape(0); @@ -567,56 +567,56 @@ void GodotPhysicsServer3D::body_clear_shapes(RID p_body) { void GodotPhysicsServer3D::body_set_enable_continuous_collision_detection(RID p_body, bool p_enable) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_continuous_collision_detection(p_enable); } bool GodotPhysicsServer3D::body_is_continuous_collision_detection_enabled(RID p_body) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, false); + ERR_FAIL_NULL_V(body, false); return body->is_continuous_collision_detection_enabled(); } void GodotPhysicsServer3D::body_set_collision_layer(RID p_body, uint32_t p_layer) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_collision_layer(p_layer); } uint32_t GodotPhysicsServer3D::body_get_collision_layer(RID p_body) const { const GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return body->get_collision_layer(); } void GodotPhysicsServer3D::body_set_collision_mask(RID p_body, uint32_t p_mask) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_collision_mask(p_mask); } uint32_t GodotPhysicsServer3D::body_get_collision_mask(RID p_body) const { const GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return body->get_collision_mask(); } void GodotPhysicsServer3D::body_set_collision_priority(RID p_body, real_t p_priority) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_collision_priority(p_priority); } real_t GodotPhysicsServer3D::body_get_collision_priority(RID p_body) const { const GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return body->get_collision_priority(); } @@ -639,61 +639,61 @@ void GodotPhysicsServer3D::body_attach_object_instance_id(RID p_body, ObjectID p ObjectID GodotPhysicsServer3D::body_get_object_instance_id(RID p_body) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, ObjectID()); + ERR_FAIL_NULL_V(body, ObjectID()); return body->get_instance_id(); } void GodotPhysicsServer3D::body_set_user_flags(RID p_body, uint32_t p_flags) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); } uint32_t GodotPhysicsServer3D::body_get_user_flags(RID p_body) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return 0; } void GodotPhysicsServer3D::body_set_param(RID p_body, BodyParameter p_param, const Variant &p_value) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_param(p_param, p_value); } Variant GodotPhysicsServer3D::body_get_param(RID p_body, BodyParameter p_param) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return body->get_param(p_param); } void GodotPhysicsServer3D::body_reset_mass_properties(RID p_body) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); return body->reset_mass_properties(); } void GodotPhysicsServer3D::body_set_state(RID p_body, BodyState p_state, const Variant &p_variant) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_state(p_state, p_variant); } Variant GodotPhysicsServer3D::body_get_state(RID p_body, BodyState p_state) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, Variant()); + ERR_FAIL_NULL_V(body, Variant()); return body->get_state(p_state); } void GodotPhysicsServer3D::body_apply_central_impulse(RID p_body, const Vector3 &p_impulse) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); _update_shapes(); @@ -703,7 +703,7 @@ void GodotPhysicsServer3D::body_apply_central_impulse(RID p_body, const Vector3 void GodotPhysicsServer3D::body_apply_impulse(RID p_body, const Vector3 &p_impulse, const Vector3 &p_position) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); _update_shapes(); @@ -713,7 +713,7 @@ void GodotPhysicsServer3D::body_apply_impulse(RID p_body, const Vector3 &p_impul void GodotPhysicsServer3D::body_apply_torque_impulse(RID p_body, const Vector3 &p_impulse) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); _update_shapes(); @@ -723,7 +723,7 @@ void GodotPhysicsServer3D::body_apply_torque_impulse(RID p_body, const Vector3 & void GodotPhysicsServer3D::body_apply_central_force(RID p_body, const Vector3 &p_force) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->apply_central_force(p_force); body->wakeup(); @@ -731,7 +731,7 @@ void GodotPhysicsServer3D::body_apply_central_force(RID p_body, const Vector3 &p void GodotPhysicsServer3D::body_apply_force(RID p_body, const Vector3 &p_force, const Vector3 &p_position) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->apply_force(p_force, p_position); body->wakeup(); @@ -739,7 +739,7 @@ void GodotPhysicsServer3D::body_apply_force(RID p_body, const Vector3 &p_force, void GodotPhysicsServer3D::body_apply_torque(RID p_body, const Vector3 &p_torque) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->apply_torque(p_torque); body->wakeup(); @@ -747,7 +747,7 @@ void GodotPhysicsServer3D::body_apply_torque(RID p_body, const Vector3 &p_torque void GodotPhysicsServer3D::body_add_constant_central_force(RID p_body, const Vector3 &p_force) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->add_constant_central_force(p_force); body->wakeup(); @@ -755,7 +755,7 @@ void GodotPhysicsServer3D::body_add_constant_central_force(RID p_body, const Vec void GodotPhysicsServer3D::body_add_constant_force(RID p_body, const Vector3 &p_force, const Vector3 &p_position) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->add_constant_force(p_force, p_position); body->wakeup(); @@ -763,7 +763,7 @@ void GodotPhysicsServer3D::body_add_constant_force(RID p_body, const Vector3 &p_ void GodotPhysicsServer3D::body_add_constant_torque(RID p_body, const Vector3 &p_torque) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->add_constant_torque(p_torque); body->wakeup(); @@ -771,7 +771,7 @@ void GodotPhysicsServer3D::body_add_constant_torque(RID p_body, const Vector3 &p void GodotPhysicsServer3D::body_set_constant_force(RID p_body, const Vector3 &p_force) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_constant_force(p_force); if (!p_force.is_zero_approx()) { @@ -781,13 +781,13 @@ void GodotPhysicsServer3D::body_set_constant_force(RID p_body, const Vector3 &p_ Vector3 GodotPhysicsServer3D::body_get_constant_force(RID p_body) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, Vector3()); + ERR_FAIL_NULL_V(body, Vector3()); return body->get_constant_force(); } void GodotPhysicsServer3D::body_set_constant_torque(RID p_body, const Vector3 &p_torque) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_constant_torque(p_torque); if (!p_torque.is_zero_approx()) { @@ -797,14 +797,14 @@ void GodotPhysicsServer3D::body_set_constant_torque(RID p_body, const Vector3 &p Vector3 GodotPhysicsServer3D::body_get_constant_torque(RID p_body) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, Vector3()); + ERR_FAIL_NULL_V(body, Vector3()); return body->get_constant_torque(); } void GodotPhysicsServer3D::body_set_axis_velocity(RID p_body, const Vector3 &p_axis_velocity) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); _update_shapes(); @@ -818,7 +818,7 @@ void GodotPhysicsServer3D::body_set_axis_velocity(RID p_body, const Vector3 &p_a void GodotPhysicsServer3D::body_set_axis_lock(RID p_body, BodyAxis p_axis, bool p_lock) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_axis_lock(p_axis, p_lock); body->wakeup(); @@ -826,13 +826,13 @@ void GodotPhysicsServer3D::body_set_axis_lock(RID p_body, BodyAxis p_axis, bool bool GodotPhysicsServer3D::body_is_axis_locked(RID p_body, BodyAxis p_axis) const { const GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return body->is_axis_locked(p_axis); } void GodotPhysicsServer3D::body_add_collision_exception(RID p_body, RID p_body_b) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->add_exception(p_body_b); body->wakeup(); @@ -840,7 +840,7 @@ void GodotPhysicsServer3D::body_add_collision_exception(RID p_body, RID p_body_b void GodotPhysicsServer3D::body_remove_collision_exception(RID p_body, RID p_body_b) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->remove_exception(p_body_b); body->wakeup(); @@ -848,7 +848,7 @@ void GodotPhysicsServer3D::body_remove_collision_exception(RID p_body, RID p_bod void GodotPhysicsServer3D::body_get_collision_exceptions(RID p_body, List *p_exceptions) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); for (int i = 0; i < body->get_exceptions().size(); i++) { p_exceptions->push_back(body->get_exceptions()[i]); @@ -857,61 +857,61 @@ void GodotPhysicsServer3D::body_get_collision_exceptions(RID p_body, List * void GodotPhysicsServer3D::body_set_contacts_reported_depth_threshold(RID p_body, real_t p_threshold) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); }; real_t GodotPhysicsServer3D::body_get_contacts_reported_depth_threshold(RID p_body) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, 0); + ERR_FAIL_NULL_V(body, 0); return 0; }; void GodotPhysicsServer3D::body_set_omit_force_integration(RID p_body, bool p_omit) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_omit_force_integration(p_omit); }; bool GodotPhysicsServer3D::body_is_omitting_force_integration(RID p_body) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, false); + ERR_FAIL_NULL_V(body, false); return body->get_omit_force_integration(); }; void GodotPhysicsServer3D::body_set_max_contacts_reported(RID p_body, int p_contacts) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_max_contacts_reported(p_contacts); } int GodotPhysicsServer3D::body_get_max_contacts_reported(RID p_body) const { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, -1); + ERR_FAIL_NULL_V(body, -1); return body->get_max_contacts_reported(); } void GodotPhysicsServer3D::body_set_state_sync_callback(RID p_body, const Callable &p_callable) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_state_sync_callback(p_callable); } void GodotPhysicsServer3D::body_set_force_integration_callback(RID p_body, const Callable &p_callable, const Variant &p_udata) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_force_integration_callback(p_callable, p_udata); } void GodotPhysicsServer3D::body_set_ray_pickable(RID p_body, bool p_enable) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND(!body); + ERR_FAIL_NULL(body); body->set_ray_pickable(p_enable); } bool GodotPhysicsServer3D::body_test_motion(RID p_body, const MotionParameters &p_parameters, MotionResult *r_result) { GodotBody3D *body = body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!body, false); + ERR_FAIL_NULL_V(body, false); ERR_FAIL_COND_V(!body->get_space(), false); ERR_FAIL_COND_V(body->get_space()->is_locked(), false); @@ -950,19 +950,19 @@ RID GodotPhysicsServer3D::soft_body_create() { void GodotPhysicsServer3D::soft_body_update_rendering_server(RID p_body, PhysicsServer3DRenderingServerHandler *p_rendering_server_handler) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->update_rendering_server(p_rendering_server_handler); } void GodotPhysicsServer3D::soft_body_set_space(RID p_body, RID p_space) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); GodotSpace3D *space = nullptr; if (p_space.is_valid()) { space = space_owner.get_or_null(p_space); - ERR_FAIL_COND(!space); + ERR_FAIL_NULL(space); } if (soft_body->get_space() == space) { @@ -974,7 +974,7 @@ void GodotPhysicsServer3D::soft_body_set_space(RID p_body, RID p_space) { RID GodotPhysicsServer3D::soft_body_get_space(RID p_body) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, RID()); + ERR_FAIL_NULL_V(soft_body, RID()); GodotSpace3D *space = soft_body->get_space(); if (!space) { @@ -985,49 +985,49 @@ RID GodotPhysicsServer3D::soft_body_get_space(RID p_body) const { void GodotPhysicsServer3D::soft_body_set_collision_layer(RID p_body, uint32_t p_layer) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_collision_layer(p_layer); } uint32_t GodotPhysicsServer3D::soft_body_get_collision_layer(RID p_body) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, 0); + ERR_FAIL_NULL_V(soft_body, 0); return soft_body->get_collision_layer(); } void GodotPhysicsServer3D::soft_body_set_collision_mask(RID p_body, uint32_t p_mask) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_collision_mask(p_mask); } uint32_t GodotPhysicsServer3D::soft_body_get_collision_mask(RID p_body) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, 0); + ERR_FAIL_NULL_V(soft_body, 0); return soft_body->get_collision_mask(); } void GodotPhysicsServer3D::soft_body_add_collision_exception(RID p_body, RID p_body_b) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->add_exception(p_body_b); } void GodotPhysicsServer3D::soft_body_remove_collision_exception(RID p_body, RID p_body_b) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->remove_exception(p_body_b); } void GodotPhysicsServer3D::soft_body_get_collision_exceptions(RID p_body, List *p_exceptions) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); for (int i = 0; i < soft_body->get_exceptions().size(); i++) { p_exceptions->push_back(soft_body->get_exceptions()[i]); @@ -1036,154 +1036,154 @@ void GodotPhysicsServer3D::soft_body_get_collision_exceptions(RID p_body, Listset_state(p_state, p_variant); } Variant GodotPhysicsServer3D::soft_body_get_state(RID p_body, BodyState p_state) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, Variant()); + ERR_FAIL_NULL_V(soft_body, Variant()); return soft_body->get_state(p_state); } void GodotPhysicsServer3D::soft_body_set_transform(RID p_body, const Transform3D &p_transform) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_state(BODY_STATE_TRANSFORM, p_transform); } void GodotPhysicsServer3D::soft_body_set_ray_pickable(RID p_body, bool p_enable) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_ray_pickable(p_enable); } void GodotPhysicsServer3D::soft_body_set_simulation_precision(RID p_body, int p_simulation_precision) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_iteration_count(p_simulation_precision); } int GodotPhysicsServer3D::soft_body_get_simulation_precision(RID p_body) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, 0.f); + ERR_FAIL_NULL_V(soft_body, 0.f); return soft_body->get_iteration_count(); } void GodotPhysicsServer3D::soft_body_set_total_mass(RID p_body, real_t p_total_mass) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_total_mass(p_total_mass); } real_t GodotPhysicsServer3D::soft_body_get_total_mass(RID p_body) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, 0.f); + ERR_FAIL_NULL_V(soft_body, 0.f); return soft_body->get_total_mass(); } void GodotPhysicsServer3D::soft_body_set_linear_stiffness(RID p_body, real_t p_stiffness) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_linear_stiffness(p_stiffness); } real_t GodotPhysicsServer3D::soft_body_get_linear_stiffness(RID p_body) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, 0.f); + ERR_FAIL_NULL_V(soft_body, 0.f); return soft_body->get_linear_stiffness(); } void GodotPhysicsServer3D::soft_body_set_pressure_coefficient(RID p_body, real_t p_pressure_coefficient) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_pressure_coefficient(p_pressure_coefficient); } real_t GodotPhysicsServer3D::soft_body_get_pressure_coefficient(RID p_body) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, 0.f); + ERR_FAIL_NULL_V(soft_body, 0.f); return soft_body->get_pressure_coefficient(); } void GodotPhysicsServer3D::soft_body_set_damping_coefficient(RID p_body, real_t p_damping_coefficient) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_damping_coefficient(p_damping_coefficient); } real_t GodotPhysicsServer3D::soft_body_get_damping_coefficient(RID p_body) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, 0.f); + ERR_FAIL_NULL_V(soft_body, 0.f); return soft_body->get_damping_coefficient(); } void GodotPhysicsServer3D::soft_body_set_drag_coefficient(RID p_body, real_t p_drag_coefficient) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_drag_coefficient(p_drag_coefficient); } real_t GodotPhysicsServer3D::soft_body_get_drag_coefficient(RID p_body) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, 0.f); + ERR_FAIL_NULL_V(soft_body, 0.f); return soft_body->get_drag_coefficient(); } void GodotPhysicsServer3D::soft_body_set_mesh(RID p_body, RID p_mesh) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_mesh(p_mesh); } AABB GodotPhysicsServer3D::soft_body_get_bounds(RID p_body) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, AABB()); + ERR_FAIL_NULL_V(soft_body, AABB()); return soft_body->get_bounds(); } void GodotPhysicsServer3D::soft_body_move_point(RID p_body, int p_point_index, const Vector3 &p_global_position) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->set_vertex_position(p_point_index, p_global_position); } Vector3 GodotPhysicsServer3D::soft_body_get_point_global_position(RID p_body, int p_point_index) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, Vector3()); + ERR_FAIL_NULL_V(soft_body, Vector3()); return soft_body->get_vertex_position(p_point_index); } void GodotPhysicsServer3D::soft_body_remove_all_pinned_points(RID p_body) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); soft_body->unpin_all_vertices(); } void GodotPhysicsServer3D::soft_body_pin_point(RID p_body, int p_point_index, bool p_pin) { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); if (p_pin) { soft_body->pin_vertex(p_point_index); @@ -1194,7 +1194,7 @@ void GodotPhysicsServer3D::soft_body_pin_point(RID p_body, int p_point_index, bo bool GodotPhysicsServer3D::soft_body_is_point_pinned(RID p_body, int p_point_index) const { GodotSoftBody3D *soft_body = soft_body_owner.get_or_null(p_body); - ERR_FAIL_COND_V(!soft_body, false); + ERR_FAIL_NULL_V(soft_body, false); return soft_body->is_vertex_pinned(p_point_index); } @@ -1222,7 +1222,7 @@ void GodotPhysicsServer3D::joint_clear(RID p_joint) { void GodotPhysicsServer3D::joint_make_pin(RID p_joint, RID p_body_A, const Vector3 &p_local_A, RID p_body_B, const Vector3 &p_local_B) { GodotBody3D *body_A = body_owner.get_or_null(p_body_A); - ERR_FAIL_COND(!body_A); + ERR_FAIL_NULL(body_A); if (!p_body_B.is_valid()) { ERR_FAIL_COND(!body_A->get_space()); @@ -1230,12 +1230,12 @@ void GodotPhysicsServer3D::joint_make_pin(RID p_joint, RID p_body_A, const Vecto } GodotBody3D *body_B = body_owner.get_or_null(p_body_B); - ERR_FAIL_COND(!body_B); + ERR_FAIL_NULL(body_B); ERR_FAIL_COND(body_A == body_B); GodotJoint3D *prev_joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(prev_joint == nullptr); + ERR_FAIL_NULL(prev_joint); GodotJoint3D *joint = memnew(GodotPinJoint3D(body_A, p_local_A, body_B, p_local_B)); @@ -1246,7 +1246,7 @@ void GodotPhysicsServer3D::joint_make_pin(RID p_joint, RID p_body_A, const Vecto void GodotPhysicsServer3D::pin_joint_set_param(RID p_joint, PinJointParam p_param, real_t p_value) { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_PIN); GodotPinJoint3D *pin_joint = static_cast(joint); pin_joint->set_param(p_param, p_value); @@ -1254,7 +1254,7 @@ void GodotPhysicsServer3D::pin_joint_set_param(RID p_joint, PinJointParam p_para real_t GodotPhysicsServer3D::pin_joint_get_param(RID p_joint, PinJointParam p_param) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, 0); + ERR_FAIL_NULL_V(joint, 0); ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_PIN, 0); GodotPinJoint3D *pin_joint = static_cast(joint); return pin_joint->get_param(p_param); @@ -1262,7 +1262,7 @@ real_t GodotPhysicsServer3D::pin_joint_get_param(RID p_joint, PinJointParam p_pa void GodotPhysicsServer3D::pin_joint_set_local_a(RID p_joint, const Vector3 &p_A) { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_PIN); GodotPinJoint3D *pin_joint = static_cast(joint); pin_joint->set_pos_a(p_A); @@ -1270,7 +1270,7 @@ void GodotPhysicsServer3D::pin_joint_set_local_a(RID p_joint, const Vector3 &p_A Vector3 GodotPhysicsServer3D::pin_joint_get_local_a(RID p_joint) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, Vector3()); + ERR_FAIL_NULL_V(joint, Vector3()); ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_PIN, Vector3()); GodotPinJoint3D *pin_joint = static_cast(joint); return pin_joint->get_position_a(); @@ -1278,7 +1278,7 @@ Vector3 GodotPhysicsServer3D::pin_joint_get_local_a(RID p_joint) const { void GodotPhysicsServer3D::pin_joint_set_local_b(RID p_joint, const Vector3 &p_B) { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_PIN); GodotPinJoint3D *pin_joint = static_cast(joint); pin_joint->set_pos_b(p_B); @@ -1286,7 +1286,7 @@ void GodotPhysicsServer3D::pin_joint_set_local_b(RID p_joint, const Vector3 &p_B Vector3 GodotPhysicsServer3D::pin_joint_get_local_b(RID p_joint) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, Vector3()); + ERR_FAIL_NULL_V(joint, Vector3()); ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_PIN, Vector3()); GodotPinJoint3D *pin_joint = static_cast(joint); return pin_joint->get_position_b(); @@ -1294,7 +1294,7 @@ Vector3 GodotPhysicsServer3D::pin_joint_get_local_b(RID p_joint) const { void GodotPhysicsServer3D::joint_make_hinge(RID p_joint, RID p_body_A, const Transform3D &p_frame_A, RID p_body_B, const Transform3D &p_frame_B) { GodotBody3D *body_A = body_owner.get_or_null(p_body_A); - ERR_FAIL_COND(!body_A); + ERR_FAIL_NULL(body_A); if (!p_body_B.is_valid()) { ERR_FAIL_COND(!body_A->get_space()); @@ -1302,12 +1302,12 @@ void GodotPhysicsServer3D::joint_make_hinge(RID p_joint, RID p_body_A, const Tra } GodotBody3D *body_B = body_owner.get_or_null(p_body_B); - ERR_FAIL_COND(!body_B); + ERR_FAIL_NULL(body_B); ERR_FAIL_COND(body_A == body_B); GodotJoint3D *prev_joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(prev_joint == nullptr); + ERR_FAIL_NULL(prev_joint); GodotJoint3D *joint = memnew(GodotHingeJoint3D(body_A, body_B, p_frame_A, p_frame_B)); @@ -1318,7 +1318,7 @@ void GodotPhysicsServer3D::joint_make_hinge(RID p_joint, RID p_body_A, const Tra void GodotPhysicsServer3D::joint_make_hinge_simple(RID p_joint, RID p_body_A, const Vector3 &p_pivot_A, const Vector3 &p_axis_A, RID p_body_B, const Vector3 &p_pivot_B, const Vector3 &p_axis_B) { GodotBody3D *body_A = body_owner.get_or_null(p_body_A); - ERR_FAIL_COND(!body_A); + ERR_FAIL_NULL(body_A); if (!p_body_B.is_valid()) { ERR_FAIL_COND(!body_A->get_space()); @@ -1326,12 +1326,12 @@ void GodotPhysicsServer3D::joint_make_hinge_simple(RID p_joint, RID p_body_A, co } GodotBody3D *body_B = body_owner.get_or_null(p_body_B); - ERR_FAIL_COND(!body_B); + ERR_FAIL_NULL(body_B); ERR_FAIL_COND(body_A == body_B); GodotJoint3D *prev_joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(prev_joint == nullptr); + ERR_FAIL_NULL(prev_joint); GodotJoint3D *joint = memnew(GodotHingeJoint3D(body_A, body_B, p_pivot_A, p_pivot_B, p_axis_A, p_axis_B)); @@ -1342,7 +1342,7 @@ void GodotPhysicsServer3D::joint_make_hinge_simple(RID p_joint, RID p_body_A, co void GodotPhysicsServer3D::hinge_joint_set_param(RID p_joint, HingeJointParam p_param, real_t p_value) { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_HINGE); GodotHingeJoint3D *hinge_joint = static_cast(joint); hinge_joint->set_param(p_param, p_value); @@ -1350,7 +1350,7 @@ void GodotPhysicsServer3D::hinge_joint_set_param(RID p_joint, HingeJointParam p_ real_t GodotPhysicsServer3D::hinge_joint_get_param(RID p_joint, HingeJointParam p_param) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, 0); + ERR_FAIL_NULL_V(joint, 0); ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_HINGE, 0); GodotHingeJoint3D *hinge_joint = static_cast(joint); return hinge_joint->get_param(p_param); @@ -1358,7 +1358,7 @@ real_t GodotPhysicsServer3D::hinge_joint_get_param(RID p_joint, HingeJointParam void GodotPhysicsServer3D::hinge_joint_set_flag(RID p_joint, HingeJointFlag p_flag, bool p_value) { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_HINGE); GodotHingeJoint3D *hinge_joint = static_cast(joint); hinge_joint->set_flag(p_flag, p_value); @@ -1366,7 +1366,7 @@ void GodotPhysicsServer3D::hinge_joint_set_flag(RID p_joint, HingeJointFlag p_fl bool GodotPhysicsServer3D::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_flag) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, false); + ERR_FAIL_NULL_V(joint, false); ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_HINGE, false); GodotHingeJoint3D *hinge_joint = static_cast(joint); return hinge_joint->get_flag(p_flag); @@ -1374,19 +1374,19 @@ bool GodotPhysicsServer3D::hinge_joint_get_flag(RID p_joint, HingeJointFlag p_fl void GodotPhysicsServer3D::joint_set_solver_priority(RID p_joint, int p_priority) { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); joint->set_priority(p_priority); } int GodotPhysicsServer3D::joint_get_solver_priority(RID p_joint) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, 0); + ERR_FAIL_NULL_V(joint, 0); return joint->get_priority(); } void GodotPhysicsServer3D::joint_disable_collisions_between_bodies(RID p_joint, bool p_disable) { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); joint->disable_collisions_between_bodies(p_disable); @@ -1406,20 +1406,20 @@ void GodotPhysicsServer3D::joint_disable_collisions_between_bodies(RID p_joint, bool GodotPhysicsServer3D::joint_is_disabled_collisions_between_bodies(RID p_joint) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, true); + ERR_FAIL_NULL_V(joint, true); return joint->is_disabled_collisions_between_bodies(); } GodotPhysicsServer3D::JointType GodotPhysicsServer3D::joint_get_type(RID p_joint) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, JOINT_TYPE_PIN); + ERR_FAIL_NULL_V(joint, JOINT_TYPE_PIN); return joint->get_type(); } void GodotPhysicsServer3D::joint_make_slider(RID p_joint, RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) { GodotBody3D *body_A = body_owner.get_or_null(p_body_A); - ERR_FAIL_COND(!body_A); + ERR_FAIL_NULL(body_A); if (!p_body_B.is_valid()) { ERR_FAIL_COND(!body_A->get_space()); @@ -1427,12 +1427,12 @@ void GodotPhysicsServer3D::joint_make_slider(RID p_joint, RID p_body_A, const Tr } GodotBody3D *body_B = body_owner.get_or_null(p_body_B); - ERR_FAIL_COND(!body_B); + ERR_FAIL_NULL(body_B); ERR_FAIL_COND(body_A == body_B); GodotJoint3D *prev_joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(prev_joint == nullptr); + ERR_FAIL_NULL(prev_joint); GodotJoint3D *joint = memnew(GodotSliderJoint3D(body_A, body_B, p_local_frame_A, p_local_frame_B)); @@ -1443,7 +1443,7 @@ void GodotPhysicsServer3D::joint_make_slider(RID p_joint, RID p_body_A, const Tr void GodotPhysicsServer3D::slider_joint_set_param(RID p_joint, SliderJointParam p_param, real_t p_value) { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_SLIDER); GodotSliderJoint3D *slider_joint = static_cast(joint); slider_joint->set_param(p_param, p_value); @@ -1451,7 +1451,7 @@ void GodotPhysicsServer3D::slider_joint_set_param(RID p_joint, SliderJointParam real_t GodotPhysicsServer3D::slider_joint_get_param(RID p_joint, SliderJointParam p_param) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, 0); + ERR_FAIL_NULL_V(joint, 0); ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_CONE_TWIST, 0); GodotSliderJoint3D *slider_joint = static_cast(joint); return slider_joint->get_param(p_param); @@ -1459,7 +1459,7 @@ real_t GodotPhysicsServer3D::slider_joint_get_param(RID p_joint, SliderJointPara void GodotPhysicsServer3D::joint_make_cone_twist(RID p_joint, RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) { GodotBody3D *body_A = body_owner.get_or_null(p_body_A); - ERR_FAIL_COND(!body_A); + ERR_FAIL_NULL(body_A); if (!p_body_B.is_valid()) { ERR_FAIL_COND(!body_A->get_space()); @@ -1467,12 +1467,12 @@ void GodotPhysicsServer3D::joint_make_cone_twist(RID p_joint, RID p_body_A, cons } GodotBody3D *body_B = body_owner.get_or_null(p_body_B); - ERR_FAIL_COND(!body_B); + ERR_FAIL_NULL(body_B); ERR_FAIL_COND(body_A == body_B); GodotJoint3D *prev_joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(prev_joint == nullptr); + ERR_FAIL_NULL(prev_joint); GodotJoint3D *joint = memnew(GodotConeTwistJoint3D(body_A, body_B, p_local_frame_A, p_local_frame_B)); @@ -1483,7 +1483,7 @@ void GodotPhysicsServer3D::joint_make_cone_twist(RID p_joint, RID p_body_A, cons void GodotPhysicsServer3D::cone_twist_joint_set_param(RID p_joint, ConeTwistJointParam p_param, real_t p_value) { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_CONE_TWIST); GodotConeTwistJoint3D *cone_twist_joint = static_cast(joint); cone_twist_joint->set_param(p_param, p_value); @@ -1491,7 +1491,7 @@ void GodotPhysicsServer3D::cone_twist_joint_set_param(RID p_joint, ConeTwistJoin real_t GodotPhysicsServer3D::cone_twist_joint_get_param(RID p_joint, ConeTwistJointParam p_param) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, 0); + ERR_FAIL_NULL_V(joint, 0); ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_CONE_TWIST, 0); GodotConeTwistJoint3D *cone_twist_joint = static_cast(joint); return cone_twist_joint->get_param(p_param); @@ -1499,7 +1499,7 @@ real_t GodotPhysicsServer3D::cone_twist_joint_get_param(RID p_joint, ConeTwistJo void GodotPhysicsServer3D::joint_make_generic_6dof(RID p_joint, RID p_body_A, const Transform3D &p_local_frame_A, RID p_body_B, const Transform3D &p_local_frame_B) { GodotBody3D *body_A = body_owner.get_or_null(p_body_A); - ERR_FAIL_COND(!body_A); + ERR_FAIL_NULL(body_A); if (!p_body_B.is_valid()) { ERR_FAIL_COND(!body_A->get_space()); @@ -1507,12 +1507,12 @@ void GodotPhysicsServer3D::joint_make_generic_6dof(RID p_joint, RID p_body_A, co } GodotBody3D *body_B = body_owner.get_or_null(p_body_B); - ERR_FAIL_COND(!body_B); + ERR_FAIL_NULL(body_B); ERR_FAIL_COND(body_A == body_B); GodotJoint3D *prev_joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(prev_joint == nullptr); + ERR_FAIL_NULL(prev_joint); GodotJoint3D *joint = memnew(GodotGeneric6DOFJoint3D(body_A, body_B, p_local_frame_A, p_local_frame_B, true)); @@ -1523,7 +1523,7 @@ void GodotPhysicsServer3D::joint_make_generic_6dof(RID p_joint, RID p_body_A, co void GodotPhysicsServer3D::generic_6dof_joint_set_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param, real_t p_value) { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_6DOF); GodotGeneric6DOFJoint3D *generic_6dof_joint = static_cast(joint); generic_6dof_joint->set_param(p_axis, p_param, p_value); @@ -1531,7 +1531,7 @@ void GodotPhysicsServer3D::generic_6dof_joint_set_param(RID p_joint, Vector3::Ax real_t GodotPhysicsServer3D::generic_6dof_joint_get_param(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisParam p_param) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, 0); + ERR_FAIL_NULL_V(joint, 0); ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_6DOF, 0); GodotGeneric6DOFJoint3D *generic_6dof_joint = static_cast(joint); return generic_6dof_joint->get_param(p_axis, p_param); @@ -1539,7 +1539,7 @@ real_t GodotPhysicsServer3D::generic_6dof_joint_get_param(RID p_joint, Vector3:: void GodotPhysicsServer3D::generic_6dof_joint_set_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag, bool p_enable) { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND(!joint); + ERR_FAIL_NULL(joint); ERR_FAIL_COND(joint->get_type() != JOINT_TYPE_6DOF); GodotGeneric6DOFJoint3D *generic_6dof_joint = static_cast(joint); generic_6dof_joint->set_flag(p_axis, p_flag, p_enable); @@ -1547,7 +1547,7 @@ void GodotPhysicsServer3D::generic_6dof_joint_set_flag(RID p_joint, Vector3::Axi bool GodotPhysicsServer3D::generic_6dof_joint_get_flag(RID p_joint, Vector3::Axis p_axis, G6DOFJointAxisFlag p_flag) const { GodotJoint3D *joint = joint_owner.get_or_null(p_joint); - ERR_FAIL_COND_V(!joint, false); + ERR_FAIL_NULL_V(joint, false); ERR_FAIL_COND_V(joint->get_type() != JOINT_TYPE_6DOF, false); GodotGeneric6DOFJoint3D *generic_6dof_joint = static_cast(joint); return generic_6dof_joint->get_flag(p_axis, p_flag); diff --git a/servers/physics_3d/godot_soft_body_3d.cpp b/servers/physics_3d/godot_soft_body_3d.cpp index 2081c132afb..20b19ab2437 100644 --- a/servers/physics_3d/godot_soft_body_3d.cpp +++ b/servers/physics_3d/godot_soft_body_3d.cpp @@ -1010,7 +1010,7 @@ void GodotSoftBody3D::predict_motion(real_t p_delta) { // Add default gravity and damping from space area. if (!gravity_done) { GodotArea3D *default_area = get_space()->get_default_area(); - ERR_FAIL_COND(!default_area); + ERR_FAIL_NULL(default_area); Vector3 default_gravity; default_area->compute_gravity(get_transform().get_origin(), default_gravity); @@ -1223,7 +1223,7 @@ void GodotSoftBody3D::destroy() { } void GodotSoftBodyShape3D::update_bounds() { - ERR_FAIL_COND(!soft_body); + ERR_FAIL_NULL(soft_body); AABB collision_aabb = soft_body->get_bounds(); collision_aabb.grow_by(soft_body->get_collision_margin()); diff --git a/servers/physics_3d/godot_space_3d.cpp b/servers/physics_3d/godot_space_3d.cpp index 92b5f31e417..46b6689533d 100644 --- a/servers/physics_3d/godot_space_3d.cpp +++ b/servers/physics_3d/godot_space_3d.cpp @@ -211,7 +211,7 @@ int GodotPhysicsDirectSpaceState3D::intersect_shape(const ShapeParameters &p_par } GodotShape3D *shape = GodotPhysicsServer3D::godot_singleton->shape_owner.get_or_null(p_parameters.shape_rid); - ERR_FAIL_COND_V(!shape, 0); + ERR_FAIL_NULL_V(shape, 0); AABB aabb = p_parameters.transform.xform(shape->get_aabb()); @@ -262,7 +262,7 @@ int GodotPhysicsDirectSpaceState3D::intersect_shape(const ShapeParameters &p_par bool GodotPhysicsDirectSpaceState3D::cast_motion(const ShapeParameters &p_parameters, real_t &p_closest_safe, real_t &p_closest_unsafe, ShapeRestInfo *r_info) { GodotShape3D *shape = GodotPhysicsServer3D::godot_singleton->shape_owner.get_or_null(p_parameters.shape_rid); - ERR_FAIL_COND_V(!shape, false); + ERR_FAIL_NULL_V(shape, false); AABB aabb = p_parameters.transform.xform(shape->get_aabb()); aabb = aabb.merge(AABB(aabb.position + p_parameters.motion, aabb.size)); //motion @@ -385,7 +385,7 @@ bool GodotPhysicsDirectSpaceState3D::collide_shape(const ShapeParameters &p_para } GodotShape3D *shape = GodotPhysicsServer3D::godot_singleton->shape_owner.get_or_null(p_parameters.shape_rid); - ERR_FAIL_COND_V(!shape, 0); + ERR_FAIL_NULL_V(shape, 0); AABB aabb = p_parameters.transform.xform(shape->get_aabb()); aabb = aabb.grow(p_parameters.margin); @@ -511,7 +511,7 @@ static void _rest_cbk_result(const Vector3 &p_point_A, int p_index_A, const Vect bool GodotPhysicsDirectSpaceState3D::rest_info(const ShapeParameters &p_parameters, ShapeRestInfo *r_info) { GodotShape3D *shape = GodotPhysicsServer3D::godot_singleton->shape_owner.get_or_null(p_parameters.shape_rid); - ERR_FAIL_COND_V(!shape, 0); + ERR_FAIL_NULL_V(shape, 0); real_t margin = MAX(p_parameters.margin, TEST_MOTION_MARGIN_MIN_VALUE); @@ -574,7 +574,7 @@ Vector3 GodotPhysicsDirectSpaceState3D::get_closest_point_to_object_volume(RID p if (!obj) { obj = GodotPhysicsServer3D::godot_singleton->body_owner.get_or_null(p_object); } - ERR_FAIL_COND_V(!obj, Vector3()); + ERR_FAIL_NULL_V(obj, Vector3()); ERR_FAIL_COND_V(obj->get_space() != space, Vector3()); diff --git a/servers/rendering/dummy/rasterizer_scene_dummy.h b/servers/rendering/dummy/rasterizer_scene_dummy.h index 965d837ea80..fdf8df7587b 100644 --- a/servers/rendering/dummy/rasterizer_scene_dummy.h +++ b/servers/rendering/dummy/rasterizer_scene_dummy.h @@ -87,7 +87,7 @@ public: void geometry_instance_free(RenderGeometryInstance *p_geometry_instance) override { GeometryInstanceDummy *ginstance = static_cast(p_geometry_instance); - ERR_FAIL_COND(!ginstance); + ERR_FAIL_NULL(ginstance); geometry_instance_alloc.free(ginstance); } diff --git a/servers/rendering/dummy/storage/mesh_storage.cpp b/servers/rendering/dummy/storage/mesh_storage.cpp index 20980e0db84..ab27711d6e1 100644 --- a/servers/rendering/dummy/storage/mesh_storage.cpp +++ b/servers/rendering/dummy/storage/mesh_storage.cpp @@ -52,14 +52,14 @@ void MeshStorage::mesh_initialize(RID p_rid) { void MeshStorage::mesh_free(RID p_rid) { DummyMesh *mesh = mesh_owner.get_or_null(p_rid); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); mesh_owner.free(p_rid); } void MeshStorage::mesh_clear(RID p_mesh) { DummyMesh *m = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!m); + ERR_FAIL_NULL(m); m->surfaces.clear(); } diff --git a/servers/rendering/dummy/storage/mesh_storage.h b/servers/rendering/dummy/storage/mesh_storage.h index aba362c9565..89cccec54b5 100644 --- a/servers/rendering/dummy/storage/mesh_storage.h +++ b/servers/rendering/dummy/storage/mesh_storage.h @@ -71,7 +71,7 @@ public: virtual void mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface) override { DummyMesh *m = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!m); + ERR_FAIL_NULL(m); m->surfaces.push_back(RS::SurfaceData()); RS::SurfaceData *s = &m->surfaces.write[m->surfaces.size() - 1]; s->format = p_surface.format; @@ -99,7 +99,7 @@ public: virtual RS::SurfaceData mesh_get_surface(RID p_mesh, int p_surface) const override { DummyMesh *m = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!m, RS::SurfaceData()); + ERR_FAIL_NULL_V(m, RS::SurfaceData()); ERR_FAIL_INDEX_V(p_surface, m->surfaces.size(), RS::SurfaceData()); RS::SurfaceData s = m->surfaces[p_surface]; return s; @@ -107,7 +107,7 @@ public: virtual int mesh_get_surface_count(RID p_mesh) const override { DummyMesh *m = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!m, 0); + ERR_FAIL_NULL_V(m, 0); return m->surfaces.size(); } diff --git a/servers/rendering/dummy/storage/texture_storage.h b/servers/rendering/dummy/storage/texture_storage.h index d9bde5903c6..2a72547810f 100644 --- a/servers/rendering/dummy/storage/texture_storage.h +++ b/servers/rendering/dummy/storage/texture_storage.h @@ -73,21 +73,21 @@ public: virtual RID texture_allocate() override { DummyTexture *texture = memnew(DummyTexture); - ERR_FAIL_COND_V(!texture, RID()); + ERR_FAIL_NULL_V(texture, RID()); return texture_owner.make_rid(texture); }; virtual void texture_free(RID p_rid) override { // delete the texture DummyTexture *texture = texture_owner.get_or_null(p_rid); - ERR_FAIL_COND(!texture); + ERR_FAIL_NULL(texture); texture_owner.free(p_rid); memdelete(texture); }; virtual void texture_2d_initialize(RID p_texture, const Ref &p_image) override { DummyTexture *t = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND(!t); + ERR_FAIL_NULL(t); t->image = p_image->duplicate(); }; virtual void texture_2d_layered_initialize(RID p_texture, const Vector> &p_layers, RS::TextureLayeredType p_layered_type) override{}; @@ -105,7 +105,7 @@ public: virtual Ref texture_2d_get(RID p_texture) const override { DummyTexture *t = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND_V(!t, Ref()); + ERR_FAIL_NULL_V(t, Ref()); return t->image; }; virtual Ref texture_2d_layer_get(RID p_texture, int p_layer) const override { return Ref(); }; diff --git a/servers/rendering/renderer_canvas_cull.cpp b/servers/rendering/renderer_canvas_cull.cpp index 2cb7f32cc30..7c533f207cf 100644 --- a/servers/rendering/renderer_canvas_cull.cpp +++ b/servers/rendering/renderer_canvas_cull.cpp @@ -416,9 +416,9 @@ void RendererCanvasCull::canvas_initialize(RID p_rid) { void RendererCanvasCull::canvas_set_item_mirroring(RID p_canvas, RID p_item, const Point2 &p_mirroring) { Canvas *canvas = canvas_owner.get_or_null(p_canvas); - ERR_FAIL_COND(!canvas); + ERR_FAIL_NULL(canvas); Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); int idx = canvas->find_item(canvas_item); ERR_FAIL_COND(idx == -1); @@ -427,7 +427,7 @@ void RendererCanvasCull::canvas_set_item_mirroring(RID p_canvas, RID p_item, con void RendererCanvasCull::canvas_set_modulate(RID p_canvas, const Color &p_color) { Canvas *canvas = canvas_owner.get_or_null(p_canvas); - ERR_FAIL_COND(!canvas); + ERR_FAIL_NULL(canvas); canvas->modulate = p_color; } @@ -437,7 +437,7 @@ void RendererCanvasCull::canvas_set_disable_scale(bool p_disable) { void RendererCanvasCull::canvas_set_parent(RID p_canvas, RID p_parent, float p_scale) { Canvas *canvas = canvas_owner.get_or_null(p_canvas); - ERR_FAIL_COND(!canvas); + ERR_FAIL_NULL(canvas); canvas->parent = p_parent; canvas->parent_scale = p_scale; @@ -452,7 +452,7 @@ void RendererCanvasCull::canvas_item_initialize(RID p_rid) { void RendererCanvasCull::canvas_item_set_parent(RID p_item, RID p_parent) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); if (canvas_item->parent.is_valid()) { if (canvas_owner.owns(canvas_item->parent)) { @@ -496,7 +496,7 @@ void RendererCanvasCull::canvas_item_set_parent(RID p_item, RID p_parent) { void RendererCanvasCull::canvas_item_set_visible(RID p_item, bool p_visible) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->visible = p_visible; @@ -505,21 +505,21 @@ void RendererCanvasCull::canvas_item_set_visible(RID p_item, bool p_visible) { void RendererCanvasCull::canvas_item_set_light_mask(RID p_item, int p_mask) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->light_mask = p_mask; } void RendererCanvasCull::canvas_item_set_transform(RID p_item, const Transform2D &p_transform) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->xform = p_transform; } void RendererCanvasCull::canvas_item_set_visibility_layer(RID p_item, uint32_t p_visibility_layer) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->visibility_layer = p_visibility_layer; } @@ -533,21 +533,21 @@ uint32_t RendererCanvasCull::canvas_item_get_visibility_layer(RID p_item) { void RendererCanvasCull::canvas_item_set_clip(RID p_item, bool p_clip) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->clip = p_clip; } void RendererCanvasCull::canvas_item_set_distance_field_mode(RID p_item, bool p_enable) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->distance_field = p_enable; } void RendererCanvasCull::canvas_item_set_custom_rect(RID p_item, bool p_custom_rect, const Rect2 &p_rect) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->custom_rect = p_custom_rect; canvas_item->rect = p_rect; @@ -555,38 +555,38 @@ void RendererCanvasCull::canvas_item_set_custom_rect(RID p_item, bool p_custom_r void RendererCanvasCull::canvas_item_set_modulate(RID p_item, const Color &p_color) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->modulate = p_color; } void RendererCanvasCull::canvas_item_set_self_modulate(RID p_item, const Color &p_color) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->self_modulate = p_color; } void RendererCanvasCull::canvas_item_set_draw_behind_parent(RID p_item, bool p_enable) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->behind = p_enable; } void RendererCanvasCull::canvas_item_set_update_when_visible(RID p_item, bool p_update) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->update_when_visible = p_update; } void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from, const Point2 &p_to, const Color &p_color, float p_width, bool p_antialiased) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandPrimitive *line = canvas_item->alloc_command(); - ERR_FAIL_COND(!line); + ERR_FAIL_NULL(line); Vector2 diff = (p_from - p_to); Vector2 dir = diff.orthogonal().normalized(); @@ -640,7 +640,7 @@ void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from, { Item::CommandPrimitive *left_border = canvas_item->alloc_command(); - ERR_FAIL_COND(!left_border); + ERR_FAIL_NULL(left_border); left_border->points[0] = begin_left; left_border->points[1] = begin_left + border; @@ -656,7 +656,7 @@ void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from, } { Item::CommandPrimitive *right_border = canvas_item->alloc_command(); - ERR_FAIL_COND(!right_border); + ERR_FAIL_NULL(right_border); right_border->points[0] = begin_right; right_border->points[1] = begin_right - border; @@ -672,7 +672,7 @@ void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from, } { Item::CommandPrimitive *top_border = canvas_item->alloc_command(); - ERR_FAIL_COND(!top_border); + ERR_FAIL_NULL(top_border); top_border->points[0] = begin_left; top_border->points[1] = begin_left + border2; @@ -688,7 +688,7 @@ void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from, } { Item::CommandPrimitive *bottom_border = canvas_item->alloc_command(); - ERR_FAIL_COND(!bottom_border); + ERR_FAIL_NULL(bottom_border); bottom_border->points[0] = end_left; bottom_border->points[1] = end_left - border2; @@ -704,7 +704,7 @@ void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from, } { Item::CommandPrimitive *top_left_corner = canvas_item->alloc_command(); - ERR_FAIL_COND(!top_left_corner); + ERR_FAIL_NULL(top_left_corner); top_left_corner->points[0] = begin_left; top_left_corner->points[1] = begin_left + border2; @@ -720,7 +720,7 @@ void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from, } { Item::CommandPrimitive *top_right_corner = canvas_item->alloc_command(); - ERR_FAIL_COND(!top_right_corner); + ERR_FAIL_NULL(top_right_corner); top_right_corner->points[0] = begin_right; top_right_corner->points[1] = begin_right + border2; @@ -736,7 +736,7 @@ void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from, } { Item::CommandPrimitive *bottom_left_corner = canvas_item->alloc_command(); - ERR_FAIL_COND(!bottom_left_corner); + ERR_FAIL_NULL(bottom_left_corner); bottom_left_corner->points[0] = end_left; bottom_left_corner->points[1] = end_left - border2; @@ -752,7 +752,7 @@ void RendererCanvasCull::canvas_item_add_line(RID p_item, const Point2 &p_from, } { Item::CommandPrimitive *bottom_right_corner = canvas_item->alloc_command(); - ERR_FAIL_COND(!bottom_right_corner); + ERR_FAIL_NULL(bottom_right_corner); bottom_right_corner->points[0] = end_right; bottom_right_corner->points[1] = end_right - border2; @@ -815,7 +815,7 @@ static Vector2 compute_polyline_edge_offset_clamped(const Vector2 &p_segment_dir void RendererCanvasCull::canvas_item_add_polyline(RID p_item, const Vector &p_points, const Vector &p_colors, float p_width, bool p_antialiased) { ERR_FAIL_COND(p_points.size() < 2); Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Color color = Color(1, 1, 1, 1); @@ -823,7 +823,7 @@ void RendererCanvasCull::canvas_item_add_polyline(RID p_item, const Vectoralloc_command(); - ERR_FAIL_COND(!pline); + ERR_FAIL_NULL(pline); if (p_width < 0) { if (p_antialiased) { @@ -899,10 +899,10 @@ void RendererCanvasCull::canvas_item_add_polyline(RID p_item, const Vectoralloc_command(); - ERR_FAIL_COND(!pline_left); + ERR_FAIL_NULL(pline_left); Item::CommandPolygon *pline_right = canvas_item->alloc_command(); - ERR_FAIL_COND(!pline_right); + ERR_FAIL_NULL(pline_right); PackedColorArray colors_left; PackedVector2Array points_left; @@ -1086,7 +1086,7 @@ void RendererCanvasCull::canvas_item_add_multiline(RID p_item, const Vector colors; if (p_colors.size() == 1) { @@ -1102,7 +1102,7 @@ void RendererCanvasCull::canvas_item_add_multiline(RID p_item, const Vectoralloc_command(); - ERR_FAIL_COND(!pline); + ERR_FAIL_NULL(pline); pline->primitive = RS::PRIMITIVE_LINES; pline->polygon.create(Vector(), p_points, colors); } else { @@ -1128,20 +1128,20 @@ void RendererCanvasCull::canvas_item_add_multiline(RID p_item, const Vectoralloc_command(); - ERR_FAIL_COND(!rect); + ERR_FAIL_NULL(rect); rect->modulate = p_color; rect->rect = p_rect; } void RendererCanvasCull::canvas_item_add_circle(RID p_item, const Point2 &p_pos, float p_radius, const Color &p_color) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandPolygon *circle = canvas_item->alloc_command(); - ERR_FAIL_COND(!circle); + ERR_FAIL_NULL(circle); circle->primitive = RS::PRIMITIVE_TRIANGLES; @@ -1177,10 +1177,10 @@ void RendererCanvasCull::canvas_item_add_circle(RID p_item, const Point2 &p_pos, void RendererCanvasCull::canvas_item_add_texture_rect(RID p_item, const Rect2 &p_rect, RID p_texture, bool p_tile, const Color &p_modulate, bool p_transpose) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandRect *rect = canvas_item->alloc_command(); - ERR_FAIL_COND(!rect); + ERR_FAIL_NULL(rect); rect->modulate = p_modulate; rect->rect = p_rect; rect->flags = 0; @@ -1208,10 +1208,10 @@ void RendererCanvasCull::canvas_item_add_texture_rect(RID p_item, const Rect2 &p void RendererCanvasCull::canvas_item_add_msdf_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate, int p_outline_size, float p_px_range, float p_scale) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandRect *rect = canvas_item->alloc_command(); - ERR_FAIL_COND(!rect); + ERR_FAIL_NULL(rect); rect->modulate = p_modulate; rect->rect = p_rect; @@ -1242,10 +1242,10 @@ void RendererCanvasCull::canvas_item_add_msdf_texture_rect_region(RID p_item, co void RendererCanvasCull::canvas_item_add_lcd_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandRect *rect = canvas_item->alloc_command(); - ERR_FAIL_COND(!rect); + ERR_FAIL_NULL(rect); rect->modulate = p_modulate; rect->rect = p_rect; @@ -1274,10 +1274,10 @@ void RendererCanvasCull::canvas_item_add_lcd_texture_rect_region(RID p_item, con void RendererCanvasCull::canvas_item_add_texture_rect_region(RID p_item, const Rect2 &p_rect, RID p_texture, const Rect2 &p_src_rect, const Color &p_modulate, bool p_transpose, bool p_clip_uv) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandRect *rect = canvas_item->alloc_command(); - ERR_FAIL_COND(!rect); + ERR_FAIL_NULL(rect); rect->modulate = p_modulate; rect->rect = p_rect; @@ -1315,10 +1315,10 @@ void RendererCanvasCull::canvas_item_add_texture_rect_region(RID p_item, const R void RendererCanvasCull::canvas_item_add_nine_patch(RID p_item, const Rect2 &p_rect, const Rect2 &p_source, RID p_texture, const Vector2 &p_topleft, const Vector2 &p_bottomright, RS::NinePatchAxisMode p_x_axis_mode, RS::NinePatchAxisMode p_y_axis_mode, bool p_draw_center, const Color &p_modulate) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandNinePatch *style = canvas_item->alloc_command(); - ERR_FAIL_COND(!style); + ERR_FAIL_NULL(style); style->texture = p_texture; @@ -1339,10 +1339,10 @@ void RendererCanvasCull::canvas_item_add_primitive(RID p_item, const Vector 4); Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandPrimitive *prim = canvas_item->alloc_command(); - ERR_FAIL_COND(!prim); + ERR_FAIL_NULL(prim); for (int i = 0; i < p_points.size(); i++) { prim->points[i] = p_points[i]; @@ -1365,7 +1365,7 @@ void RendererCanvasCull::canvas_item_add_primitive(RID p_item, const Vector &p_points, const Vector &p_colors, const Vector &p_uvs, RID p_texture) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); #ifdef DEBUG_ENABLED int pointcount = p_points.size(); ERR_FAIL_COND(pointcount < 3); @@ -1378,7 +1378,7 @@ void RendererCanvasCull::canvas_item_add_polygon(RID p_item, const Vectoralloc_command(); - ERR_FAIL_COND(!polygon); + ERR_FAIL_NULL(polygon); polygon->primitive = RS::PRIMITIVE_TRIANGLES; polygon->texture = p_texture; polygon->polygon.create(indices, p_points, p_colors, p_uvs); @@ -1386,7 +1386,7 @@ void RendererCanvasCull::canvas_item_add_polygon(RID p_item, const Vector &p_indices, const Vector &p_points, const Vector &p_colors, const Vector &p_uvs, const Vector &p_bones, const Vector &p_weights, RID p_texture, int p_count) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); int vertex_count = p_points.size(); ERR_FAIL_COND(vertex_count == 0); @@ -1398,7 +1398,7 @@ void RendererCanvasCull::canvas_item_add_triangle_array(RID p_item, const Vector Vector indices = p_indices; Item::CommandPolygon *polygon = canvas_item->alloc_command(); - ERR_FAIL_COND(!polygon); + ERR_FAIL_NULL(polygon); polygon->texture = p_texture; @@ -1409,20 +1409,20 @@ void RendererCanvasCull::canvas_item_add_triangle_array(RID p_item, const Vector void RendererCanvasCull::canvas_item_add_set_transform(RID p_item, const Transform2D &p_transform) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandTransform *tr = canvas_item->alloc_command(); - ERR_FAIL_COND(!tr); + ERR_FAIL_NULL(tr); tr->xform = p_transform; } void RendererCanvasCull::canvas_item_add_mesh(RID p_item, const RID &p_mesh, const Transform2D &p_transform, const Color &p_modulate, RID p_texture) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); ERR_FAIL_COND(!p_mesh.is_valid()); Item::CommandMesh *m = canvas_item->alloc_command(); - ERR_FAIL_COND(!m); + ERR_FAIL_NULL(m); m->mesh = p_mesh; if (canvas_item->skeleton.is_valid()) { m->mesh_instance = RSG::mesh_storage->mesh_instance_create(p_mesh); @@ -1437,10 +1437,10 @@ void RendererCanvasCull::canvas_item_add_mesh(RID p_item, const RID &p_mesh, con void RendererCanvasCull::canvas_item_add_particles(RID p_item, RID p_particles, RID p_texture) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandParticles *part = canvas_item->alloc_command(); - ERR_FAIL_COND(!part); + ERR_FAIL_NULL(part); part->particles = p_particles; part->texture = p_texture; @@ -1451,10 +1451,10 @@ void RendererCanvasCull::canvas_item_add_particles(RID p_item, RID p_particles, void RendererCanvasCull::canvas_item_add_multimesh(RID p_item, RID p_mesh, RID p_texture) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandMultiMesh *mm = canvas_item->alloc_command(); - ERR_FAIL_COND(!mm); + ERR_FAIL_NULL(mm); mm->multimesh = p_mesh; mm->texture = p_texture; @@ -1462,19 +1462,19 @@ void RendererCanvasCull::canvas_item_add_multimesh(RID p_item, RID p_mesh, RID p void RendererCanvasCull::canvas_item_add_clip_ignore(RID p_item, bool p_ignore) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandClipIgnore *ci = canvas_item->alloc_command(); - ERR_FAIL_COND(!ci); + ERR_FAIL_NULL(ci); ci->ignore = p_ignore; } void RendererCanvasCull::canvas_item_add_animation_slice(RID p_item, double p_animation_length, double p_slice_begin, double p_slice_end, double p_offset) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); Item::CommandAnimationSlice *as = canvas_item->alloc_command(); - ERR_FAIL_COND(!as); + ERR_FAIL_NULL(as); as->animation_length = p_animation_length; as->slice_begin = p_slice_begin; as->slice_end = p_slice_end; @@ -1483,7 +1483,7 @@ void RendererCanvasCull::canvas_item_add_animation_slice(RID p_item, double p_an void RendererCanvasCull::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->sort_y = p_enable; @@ -1494,21 +1494,21 @@ void RendererCanvasCull::canvas_item_set_z_index(RID p_item, int p_z) { ERR_FAIL_COND(p_z < RS::CANVAS_ITEM_Z_MIN || p_z > RS::CANVAS_ITEM_Z_MAX); Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->z_index = p_z; } void RendererCanvasCull::canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->z_relative = p_enable; } void RendererCanvasCull::canvas_item_attach_skeleton(RID p_item, RID p_skeleton) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); if (canvas_item->skeleton == p_skeleton) { return; } @@ -1537,7 +1537,7 @@ void RendererCanvasCull::canvas_item_attach_skeleton(RID p_item, RID p_skeleton) void RendererCanvasCull::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_enable, const Rect2 &p_rect) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); if (p_enable && (canvas_item->copy_back_buffer == nullptr)) { canvas_item->copy_back_buffer = memnew(RendererCanvasRender::Item::CopyBackBuffer); } @@ -1554,14 +1554,14 @@ void RendererCanvasCull::canvas_item_set_copy_to_backbuffer(RID p_item, bool p_e void RendererCanvasCull::canvas_item_clear(RID p_item) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->clear(); } void RendererCanvasCull::canvas_item_set_draw_index(RID p_item, int p_index) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->index = p_index; @@ -1580,21 +1580,21 @@ void RendererCanvasCull::canvas_item_set_draw_index(RID p_item, int p_index) { void RendererCanvasCull::canvas_item_set_material(RID p_item, RID p_material) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->material = p_material; } void RendererCanvasCull::canvas_item_set_use_parent_material(RID p_item, bool p_enable) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); canvas_item->use_parent_material = p_enable; } void RendererCanvasCull::canvas_item_set_visibility_notifier(RID p_item, bool p_enable, const Rect2 &p_area, const Callable &p_enter_callable, const Callable &p_exit_callable) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); if (p_enable) { if (!canvas_item->visibility_notifier) { @@ -1614,7 +1614,7 @@ void RendererCanvasCull::canvas_item_set_visibility_notifier(RID p_item, bool p_ void RendererCanvasCull::canvas_item_set_canvas_group_mode(RID p_item, RS::CanvasGroupMode p_mode, float p_clear_margin, bool p_fit_empty, float p_fit_margin, bool p_blur_mipmaps) { Item *canvas_item = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!canvas_item); + ERR_FAIL_NULL(canvas_item); if (p_mode == RS::CANVAS_GROUP_MODE_DISABLED) { if (canvas_item->canvas_group != nullptr) { @@ -1644,7 +1644,7 @@ void RendererCanvasCull::canvas_light_initialize(RID p_rid) { void RendererCanvasCull::canvas_light_set_mode(RID p_light, RS::CanvasLightMode p_mode) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); if (clight->mode == p_mode) { return; @@ -1665,7 +1665,7 @@ void RendererCanvasCull::canvas_light_set_mode(RID p_light, RS::CanvasLightMode void RendererCanvasCull::canvas_light_attach_to_canvas(RID p_light, RID p_canvas) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); if (clight->canvas.is_valid()) { Canvas *canvas = canvas_owner.get_or_null(clight->canvas); @@ -1694,28 +1694,28 @@ void RendererCanvasCull::canvas_light_attach_to_canvas(RID p_light, RID p_canvas void RendererCanvasCull::canvas_light_set_enabled(RID p_light, bool p_enabled) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->enabled = p_enabled; } void RendererCanvasCull::canvas_light_set_texture_scale(RID p_light, float p_scale) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->scale = p_scale; } void RendererCanvasCull::canvas_light_set_transform(RID p_light, const Transform2D &p_transform) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->xform = p_transform; } void RendererCanvasCull::canvas_light_set_texture(RID p_light, RID p_texture) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); if (clight->texture == p_texture) { return; @@ -1727,35 +1727,35 @@ void RendererCanvasCull::canvas_light_set_texture(RID p_light, RID p_texture) { void RendererCanvasCull::canvas_light_set_texture_offset(RID p_light, const Vector2 &p_offset) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->texture_offset = p_offset; } void RendererCanvasCull::canvas_light_set_color(RID p_light, const Color &p_color) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->color = p_color; } void RendererCanvasCull::canvas_light_set_height(RID p_light, float p_height) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->height = p_height; } void RendererCanvasCull::canvas_light_set_energy(RID p_light, float p_energy) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->energy = p_energy; } void RendererCanvasCull::canvas_light_set_z_range(RID p_light, int p_min_z, int p_max_z) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->z_min = p_min_z; clight->z_max = p_max_z; @@ -1763,7 +1763,7 @@ void RendererCanvasCull::canvas_light_set_z_range(RID p_light, int p_min_z, int void RendererCanvasCull::canvas_light_set_layer_range(RID p_light, int p_min_layer, int p_max_layer) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->layer_max = p_max_layer; clight->layer_min = p_min_layer; @@ -1771,35 +1771,35 @@ void RendererCanvasCull::canvas_light_set_layer_range(RID p_light, int p_min_lay void RendererCanvasCull::canvas_light_set_item_cull_mask(RID p_light, int p_mask) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->item_mask = p_mask; } void RendererCanvasCull::canvas_light_set_item_shadow_cull_mask(RID p_light, int p_mask) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->item_shadow_mask = p_mask; } void RendererCanvasCull::canvas_light_set_directional_distance(RID p_light, float p_distance) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->directional_distance = p_distance; } void RendererCanvasCull::canvas_light_set_blend_mode(RID p_light, RS::CanvasLightBlendMode p_mode) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->blend_mode = p_mode; } void RendererCanvasCull::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); if (clight->use_shadow == p_enabled) { return; @@ -1811,21 +1811,21 @@ void RendererCanvasCull::canvas_light_set_shadow_enabled(RID p_light, bool p_ena void RendererCanvasCull::canvas_light_set_shadow_filter(RID p_light, RS::CanvasLightShadowFilter p_filter) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->shadow_filter = p_filter; } void RendererCanvasCull::canvas_light_set_shadow_color(RID p_light, const Color &p_color) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->shadow_color = p_color; } void RendererCanvasCull::canvas_light_set_shadow_smooth(RID p_light, float p_smooth) { RendererCanvasRender::Light *clight = canvas_light_owner.get_or_null(p_light); - ERR_FAIL_COND(!clight); + ERR_FAIL_NULL(clight); clight->shadow_smooth = p_smooth; } @@ -1838,7 +1838,7 @@ void RendererCanvasCull::canvas_light_occluder_initialize(RID p_rid) { void RendererCanvasCull::canvas_light_occluder_attach_to_canvas(RID p_occluder, RID p_canvas) { RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder); - ERR_FAIL_COND(!occluder); + ERR_FAIL_NULL(occluder); if (occluder->canvas.is_valid()) { Canvas *canvas = canvas_owner.get_or_null(occluder->canvas); @@ -1859,14 +1859,14 @@ void RendererCanvasCull::canvas_light_occluder_attach_to_canvas(RID p_occluder, void RendererCanvasCull::canvas_light_occluder_set_enabled(RID p_occluder, bool p_enabled) { RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder); - ERR_FAIL_COND(!occluder); + ERR_FAIL_NULL(occluder); occluder->enabled = p_enabled; } void RendererCanvasCull::canvas_light_occluder_set_polygon(RID p_occluder, RID p_polygon) { RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder); - ERR_FAIL_COND(!occluder); + ERR_FAIL_NULL(occluder); if (occluder->polygon.is_valid()) { LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(occluder->polygon); @@ -1882,7 +1882,7 @@ void RendererCanvasCull::canvas_light_occluder_set_polygon(RID p_occluder, RID p LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(p_polygon); if (!occluder_poly) { occluder->polygon = RID(); - ERR_FAIL_COND(!occluder_poly); + ERR_FAIL_NULL(occluder_poly); } else { occluder_poly->owners.insert(occluder); occluder->occluder = occluder_poly->occluder; @@ -1894,19 +1894,19 @@ void RendererCanvasCull::canvas_light_occluder_set_polygon(RID p_occluder, RID p void RendererCanvasCull::canvas_light_occluder_set_as_sdf_collision(RID p_occluder, bool p_enable) { RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder); - ERR_FAIL_COND(!occluder); + ERR_FAIL_NULL(occluder); } void RendererCanvasCull::canvas_light_occluder_set_transform(RID p_occluder, const Transform2D &p_xform) { RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder); - ERR_FAIL_COND(!occluder); + ERR_FAIL_NULL(occluder); occluder->xform = p_xform; } void RendererCanvasCull::canvas_light_occluder_set_light_mask(RID p_occluder, int p_mask) { RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_occluder); - ERR_FAIL_COND(!occluder); + ERR_FAIL_NULL(occluder); occluder->light_mask = p_mask; } @@ -1922,7 +1922,7 @@ void RendererCanvasCull::canvas_occluder_polygon_initialize(RID p_rid) { void RendererCanvasCull::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const Vector &p_shape, bool p_closed) { LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(p_occluder_polygon); - ERR_FAIL_COND(!occluder_poly); + ERR_FAIL_NULL(occluder_poly); uint32_t pc = p_shape.size(); ERR_FAIL_COND(pc < 2); @@ -1946,7 +1946,7 @@ void RendererCanvasCull::canvas_occluder_polygon_set_shape(RID p_occluder_polygo void RendererCanvasCull::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon, RS::CanvasOccluderPolygonCullMode p_mode) { LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(p_occluder_polygon); - ERR_FAIL_COND(!occluder_poly); + ERR_FAIL_NULL(occluder_poly); occluder_poly->cull_mode = p_mode; RSG::canvas_render->occluder_polygon_set_cull_mode(occluder_poly->occluder, p_mode); for (RendererCanvasRender::LightOccluderInstance *E : occluder_poly->owners) { @@ -1983,12 +1983,12 @@ void RendererCanvasCull::canvas_texture_set_texture_repeat(RID p_canvas_texture, void RendererCanvasCull::canvas_item_set_default_texture_filter(RID p_item, RS::CanvasItemTextureFilter p_filter) { Item *ci = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!ci); + ERR_FAIL_NULL(ci); ci->texture_filter = p_filter; } void RendererCanvasCull::canvas_item_set_default_texture_repeat(RID p_item, RS::CanvasItemTextureRepeat p_repeat) { Item *ci = canvas_item_owner.get_or_null(p_item); - ERR_FAIL_COND(!ci); + ERR_FAIL_NULL(ci); ci->texture_repeat = p_repeat; } @@ -2033,11 +2033,11 @@ void RendererCanvasCull::update_visibility_notifiers() { bool RendererCanvasCull::free(RID p_rid) { if (canvas_owner.owns(p_rid)) { Canvas *canvas = canvas_owner.get_or_null(p_rid); - ERR_FAIL_COND_V(!canvas, false); + ERR_FAIL_NULL_V(canvas, false); while (canvas->viewports.size()) { RendererViewport::Viewport *vp = RSG::viewport->viewport_owner.get_or_null(*canvas->viewports.begin()); - ERR_FAIL_COND_V(!vp, true); + ERR_FAIL_NULL_V(vp, true); HashMap::Iterator E = vp->canvas_map.find(p_rid); ERR_FAIL_COND_V(!E, true); @@ -2062,7 +2062,7 @@ bool RendererCanvasCull::free(RID p_rid) { } else if (canvas_item_owner.owns(p_rid)) { Item *canvas_item = canvas_item_owner.get_or_null(p_rid); - ERR_FAIL_COND_V(!canvas_item, true); + ERR_FAIL_NULL_V(canvas_item, true); if (canvas_item->parent.is_valid()) { if (canvas_owner.owns(canvas_item->parent)) { @@ -2101,7 +2101,7 @@ bool RendererCanvasCull::free(RID p_rid) { } else if (canvas_light_owner.owns(p_rid)) { RendererCanvasRender::Light *canvas_light = canvas_light_owner.get_or_null(p_rid); - ERR_FAIL_COND_V(!canvas_light, true); + ERR_FAIL_NULL_V(canvas_light, true); if (canvas_light->canvas.is_valid()) { Canvas *canvas = canvas_owner.get_or_null(canvas_light->canvas); @@ -2116,7 +2116,7 @@ bool RendererCanvasCull::free(RID p_rid) { } else if (canvas_light_occluder_owner.owns(p_rid)) { RendererCanvasRender::LightOccluderInstance *occluder = canvas_light_occluder_owner.get_or_null(p_rid); - ERR_FAIL_COND_V(!occluder, true); + ERR_FAIL_NULL_V(occluder, true); if (occluder->polygon.is_valid()) { LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(occluder->polygon); @@ -2134,7 +2134,7 @@ bool RendererCanvasCull::free(RID p_rid) { } else if (canvas_light_occluder_polygon_owner.owns(p_rid)) { LightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get_or_null(p_rid); - ERR_FAIL_COND_V(!occluder_poly, true); + ERR_FAIL_NULL_V(occluder_poly, true); RSG::canvas_render->free(occluder_poly->occluder); while (occluder_poly->owners.size()) { diff --git a/servers/rendering/renderer_rd/environment/fog.cpp b/servers/rendering/renderer_rd/environment/fog.cpp index 634f8c69df3..5e1014e0de1 100644 --- a/servers/rendering/renderer_rd/environment/fog.cpp +++ b/servers/rendering/renderer_rd/environment/fog.cpp @@ -72,7 +72,7 @@ Dependency *Fog::fog_volume_get_dependency(RID p_fog_volume) const { void Fog::fog_volume_set_shape(RID p_fog_volume, RS::FogVolumeShape p_shape) { FogVolume *fog_volume = fog_volume_owner.get_or_null(p_fog_volume); - ERR_FAIL_COND(!fog_volume); + ERR_FAIL_NULL(fog_volume); if (p_shape == fog_volume->shape) { return; @@ -84,7 +84,7 @@ void Fog::fog_volume_set_shape(RID p_fog_volume, RS::FogVolumeShape p_shape) { void Fog::fog_volume_set_size(RID p_fog_volume, const Vector3 &p_size) { FogVolume *fog_volume = fog_volume_owner.get_or_null(p_fog_volume); - ERR_FAIL_COND(!fog_volume); + ERR_FAIL_NULL(fog_volume); fog_volume->size = p_size; fog_volume->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_AABB); @@ -92,27 +92,27 @@ void Fog::fog_volume_set_size(RID p_fog_volume, const Vector3 &p_size) { void Fog::fog_volume_set_material(RID p_fog_volume, RID p_material) { FogVolume *fog_volume = fog_volume_owner.get_or_null(p_fog_volume); - ERR_FAIL_COND(!fog_volume); + ERR_FAIL_NULL(fog_volume); fog_volume->material = p_material; } RID Fog::fog_volume_get_material(RID p_fog_volume) const { FogVolume *fog_volume = fog_volume_owner.get_or_null(p_fog_volume); - ERR_FAIL_COND_V(!fog_volume, RID()); + ERR_FAIL_NULL_V(fog_volume, RID()); return fog_volume->material; } RS::FogVolumeShape Fog::fog_volume_get_shape(RID p_fog_volume) const { FogVolume *fog_volume = fog_volume_owner.get_or_null(p_fog_volume); - ERR_FAIL_COND_V(!fog_volume, RS::FOG_VOLUME_SHAPE_BOX); + ERR_FAIL_NULL_V(fog_volume, RS::FOG_VOLUME_SHAPE_BOX); return fog_volume->shape; } AABB Fog::fog_volume_get_aabb(RID p_fog_volume) const { FogVolume *fog_volume = fog_volume_owner.get_or_null(p_fog_volume); - ERR_FAIL_COND_V(!fog_volume, AABB()); + ERR_FAIL_NULL_V(fog_volume, AABB()); switch (fog_volume->shape) { case RS::FOG_VOLUME_SHAPE_ELLIPSOID: @@ -133,7 +133,7 @@ AABB Fog::fog_volume_get_aabb(RID p_fog_volume) const { Vector3 Fog::fog_volume_get_size(RID p_fog_volume) const { const FogVolume *fog_volume = fog_volume_owner.get_or_null(p_fog_volume); - ERR_FAIL_COND_V(!fog_volume, Vector3()); + ERR_FAIL_NULL_V(fog_volume, Vector3()); return fog_volume->size; } @@ -370,7 +370,7 @@ RS::ShaderNativeSourceCode Fog::FogShaderData::get_native_source_code() const { Fog::FogShaderData::~FogShaderData() { Fog *fog_singleton = Fog::get_singleton(); - ERR_FAIL_COND(!fog_singleton); + ERR_FAIL_NULL(fog_singleton); //pipeline variants will clear themselves if shader is gone if (version.is_valid()) { fog_singleton->volumetric_fog.shader.version_free(version); @@ -627,7 +627,7 @@ void Fog::volumetric_fog_update(const VolumetricFogSettings &p_settings, const P for (int i = 0; i < (int)p_fog_volumes.size(); i++) { FogVolumeInstance *fog_volume_instance = fog_volume_instance_owner.get_or_null(p_fog_volumes[i]); - ERR_FAIL_COND(!fog_volume_instance); + ERR_FAIL_NULL(fog_volume_instance); RID fog_volume = fog_volume_instance->volume; RID fog_material = RendererRD::Fog::get_singleton()->fog_volume_get_material(fog_volume); @@ -646,11 +646,11 @@ void Fog::volumetric_fog_update(const VolumetricFogSettings &p_settings, const P material = static_cast(material_storage->material_get_data(fog_material, RendererRD::MaterialStorage::SHADER_TYPE_FOG)); } - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); FogShaderData *shader_data = material->shader_data; - ERR_FAIL_COND(!shader_data); + ERR_FAIL_NULL(shader_data); any_uses_time |= shader_data->uses_time; diff --git a/servers/rendering/renderer_rd/environment/fog.h b/servers/rendering/renderer_rd/environment/fog.h index 206d7852a79..25fb190f444 100644 --- a/servers/rendering/renderer_rd/environment/fog.h +++ b/servers/rendering/renderer_rd/environment/fog.h @@ -257,25 +257,25 @@ public: void fog_volume_instance_set_transform(RID p_fog_volume_instance, const Transform3D &p_transform) { Fog::FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance); - ERR_FAIL_COND(!fvi); + ERR_FAIL_NULL(fvi); fvi->transform = p_transform; } void fog_volume_instance_set_active(RID p_fog_volume_instance, bool p_active) { Fog::FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance); - ERR_FAIL_COND(!fvi); + ERR_FAIL_NULL(fvi); fvi->active = p_active; } RID fog_volume_instance_get_volume(RID p_fog_volume_instance) const { Fog::FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance); - ERR_FAIL_COND_V(!fvi, RID()); + ERR_FAIL_NULL_V(fvi, RID()); return fvi->volume; } Vector3 fog_volume_instance_get_position(RID p_fog_volume_instance) const { Fog::FogVolumeInstance *fvi = fog_volume_instance_owner.get_or_null(p_fog_volume_instance); - ERR_FAIL_COND_V(!fvi, Vector3()); + ERR_FAIL_NULL_V(fvi, Vector3()); return fvi->transform.get_origin(); } diff --git a/servers/rendering/renderer_rd/environment/gi.cpp b/servers/rendering/renderer_rd/environment/gi.cpp index d623553273e..0667ae87e53 100644 --- a/servers/rendering/renderer_rd/environment/gi.cpp +++ b/servers/rendering/renderer_rd/environment/gi.cpp @@ -64,7 +64,7 @@ void GI::voxel_gi_initialize(RID p_voxel_gi) { void GI::voxel_gi_allocate_data(RID p_voxel_gi, const Transform3D &p_to_cell_xform, const AABB &p_aabb, const Vector3i &p_octree_size, const Vector &p_octree_cells, const Vector &p_data_cells, const Vector &p_distance_field, const Vector &p_level_counts) { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); if (voxel_gi->octree_buffer.is_valid()) { RD::get_singleton()->free(voxel_gi->octree_buffer); @@ -191,20 +191,20 @@ void GI::voxel_gi_allocate_data(RID p_voxel_gi, const Transform3D &p_to_cell_xfo AABB GI::voxel_gi_get_bounds(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, AABB()); + ERR_FAIL_NULL_V(voxel_gi, AABB()); return voxel_gi->bounds; } Vector3i GI::voxel_gi_get_octree_size(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, Vector3i()); + ERR_FAIL_NULL_V(voxel_gi, Vector3i()); return voxel_gi->octree_size; } Vector GI::voxel_gi_get_octree_cells(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, Vector()); + ERR_FAIL_NULL_V(voxel_gi, Vector()); if (voxel_gi->octree_buffer.is_valid()) { return RD::get_singleton()->buffer_get_data(voxel_gi->octree_buffer); @@ -214,7 +214,7 @@ Vector GI::voxel_gi_get_octree_cells(RID p_voxel_gi) const { Vector GI::voxel_gi_get_data_cells(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, Vector()); + ERR_FAIL_NULL_V(voxel_gi, Vector()); if (voxel_gi->data_buffer.is_valid()) { return RD::get_singleton()->buffer_get_data(voxel_gi->data_buffer); @@ -224,7 +224,7 @@ Vector GI::voxel_gi_get_data_cells(RID p_voxel_gi) const { Vector GI::voxel_gi_get_distance_field(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, Vector()); + ERR_FAIL_NULL_V(voxel_gi, Vector()); if (voxel_gi->data_buffer.is_valid()) { return RD::get_singleton()->texture_get_data(voxel_gi->sdf_texture, 0); @@ -234,21 +234,21 @@ Vector GI::voxel_gi_get_distance_field(RID p_voxel_gi) const { Vector GI::voxel_gi_get_level_counts(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, Vector()); + ERR_FAIL_NULL_V(voxel_gi, Vector()); return voxel_gi->level_counts; } Transform3D GI::voxel_gi_get_to_cell_xform(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, Transform3D()); + ERR_FAIL_NULL_V(voxel_gi, Transform3D()); return voxel_gi->to_cell_xform; } void GI::voxel_gi_set_dynamic_range(RID p_voxel_gi, float p_range) { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); voxel_gi->dynamic_range = p_range; voxel_gi->version++; @@ -256,14 +256,14 @@ void GI::voxel_gi_set_dynamic_range(RID p_voxel_gi, float p_range) { float GI::voxel_gi_get_dynamic_range(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, 0); + ERR_FAIL_NULL_V(voxel_gi, 0); return voxel_gi->dynamic_range; } void GI::voxel_gi_set_propagation(RID p_voxel_gi, float p_range) { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); voxel_gi->propagation = p_range; voxel_gi->version++; @@ -271,72 +271,72 @@ void GI::voxel_gi_set_propagation(RID p_voxel_gi, float p_range) { float GI::voxel_gi_get_propagation(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, 0); + ERR_FAIL_NULL_V(voxel_gi, 0); return voxel_gi->propagation; } void GI::voxel_gi_set_energy(RID p_voxel_gi, float p_energy) { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); voxel_gi->energy = p_energy; } float GI::voxel_gi_get_energy(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, 0); + ERR_FAIL_NULL_V(voxel_gi, 0); return voxel_gi->energy; } void GI::voxel_gi_set_baked_exposure_normalization(RID p_voxel_gi, float p_baked_exposure) { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); voxel_gi->baked_exposure = p_baked_exposure; } float GI::voxel_gi_get_baked_exposure_normalization(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, 0); + ERR_FAIL_NULL_V(voxel_gi, 0); return voxel_gi->baked_exposure; } void GI::voxel_gi_set_bias(RID p_voxel_gi, float p_bias) { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); voxel_gi->bias = p_bias; } float GI::voxel_gi_get_bias(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, 0); + ERR_FAIL_NULL_V(voxel_gi, 0); return voxel_gi->bias; } void GI::voxel_gi_set_normal_bias(RID p_voxel_gi, float p_normal_bias) { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); voxel_gi->normal_bias = p_normal_bias; } float GI::voxel_gi_get_normal_bias(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, 0); + ERR_FAIL_NULL_V(voxel_gi, 0); return voxel_gi->normal_bias; } void GI::voxel_gi_set_interior(RID p_voxel_gi, bool p_enable) { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); voxel_gi->interior = p_enable; } void GI::voxel_gi_set_use_two_bounces(RID p_voxel_gi, bool p_enable) { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); voxel_gi->use_two_bounces = p_enable; voxel_gi->version++; @@ -344,50 +344,50 @@ void GI::voxel_gi_set_use_two_bounces(RID p_voxel_gi, bool p_enable) { bool GI::voxel_gi_is_using_two_bounces(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, false); + ERR_FAIL_NULL_V(voxel_gi, false); return voxel_gi->use_two_bounces; } bool GI::voxel_gi_is_interior(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, 0); + ERR_FAIL_NULL_V(voxel_gi, 0); return voxel_gi->interior; } uint32_t GI::voxel_gi_get_version(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, 0); + ERR_FAIL_NULL_V(voxel_gi, 0); return voxel_gi->version; } uint32_t GI::voxel_gi_get_data_version(RID p_voxel_gi) { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, 0); + ERR_FAIL_NULL_V(voxel_gi, 0); return voxel_gi->data_version; } RID GI::voxel_gi_get_octree_buffer(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, RID()); + ERR_FAIL_NULL_V(voxel_gi, RID()); return voxel_gi->octree_buffer; } RID GI::voxel_gi_get_data_buffer(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, RID()); + ERR_FAIL_NULL_V(voxel_gi, RID()); return voxel_gi->data_buffer; } RID GI::voxel_gi_get_sdf_texture(RID p_voxel_gi) { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, RID()); + ERR_FAIL_NULL_V(voxel_gi, RID()); return voxel_gi->sdf_texture; } Dependency *GI::voxel_gi_get_dependency(RID p_voxel_gi) const { VoxelGI *voxel_gi = voxel_gi_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND_V(!voxel_gi, nullptr); + ERR_FAIL_NULL_V(voxel_gi, nullptr); return &voxel_gi->dependency; } @@ -4054,28 +4054,28 @@ void GI::voxel_gi_instance_free(RID p_rid) { void GI::voxel_gi_instance_set_transform_to_data(RID p_probe, const Transform3D &p_xform) { VoxelGIInstance *voxel_gi = voxel_gi_instance_owner.get_or_null(p_probe); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); voxel_gi->transform = p_xform; } bool GI::voxel_gi_needs_update(RID p_probe) const { VoxelGIInstance *voxel_gi = voxel_gi_instance_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!voxel_gi, false); + ERR_FAIL_NULL_V(voxel_gi, false); return voxel_gi->last_probe_version != voxel_gi_get_version(voxel_gi->probe); } void GI::voxel_gi_update(RID p_probe, bool p_update_light_instances, const Vector &p_light_instances, const PagedArray &p_dynamic_objects) { VoxelGIInstance *voxel_gi = voxel_gi_instance_owner.get_or_null(p_probe); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); voxel_gi->update(p_update_light_instances, p_light_instances, p_dynamic_objects); } void GI::debug_voxel_gi(RID p_voxel_gi, RD::DrawListID p_draw_list, RID p_framebuffer, const Projection &p_camera_with_transform, bool p_lighting, bool p_emission, float p_alpha) { VoxelGIInstance *voxel_gi = voxel_gi_instance_owner.get_or_null(p_voxel_gi); - ERR_FAIL_COND(!voxel_gi); + ERR_FAIL_NULL(voxel_gi); voxel_gi->debug(p_draw_list, p_framebuffer, p_camera_with_transform, p_lighting, p_emission, p_alpha); } diff --git a/servers/rendering/renderer_rd/environment/gi.h b/servers/rendering/renderer_rd/environment/gi.h index 651a660f5c7..9a45919a2f8 100644 --- a/servers/rendering/renderer_rd/environment/gi.h +++ b/servers/rendering/renderer_rd/environment/gi.h @@ -522,7 +522,7 @@ public: _FORCE_INLINE_ RID voxel_gi_instance_get_texture(RID p_probe) { VoxelGIInstance *voxel_gi = voxel_gi_instance_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!voxel_gi, RID()); + ERR_FAIL_NULL_V(voxel_gi, RID()); return voxel_gi->texture; }; diff --git a/servers/rendering/renderer_rd/environment/sky.cpp b/servers/rendering/renderer_rd/environment/sky.cpp index 0ccd36b340e..ba72ab3b08b 100644 --- a/servers/rendering/renderer_rd/environment/sky.cpp +++ b/servers/rendering/renderer_rd/environment/sky.cpp @@ -170,7 +170,7 @@ RS::ShaderNativeSourceCode SkyRD::SkyShaderData::get_native_source_code() const SkyRD::SkyShaderData::~SkyShaderData() { RendererSceneRenderRD *scene_singleton = static_cast(RendererSceneRenderRD::singleton); - ERR_FAIL_COND(!scene_singleton); + ERR_FAIL_NULL(scene_singleton); //pipeline variants will clear themselves if shader is gone if (version.is_valid()) { scene_singleton->sky.sky_shader.shader.version_free(version); @@ -1007,11 +1007,11 @@ void SkyRD::setup_sky(RID p_env, Ref p_render_buffers, con material = static_cast(material_storage->material_get_data(sky_material, RendererRD::MaterialStorage::SHADER_TYPE_SKY)); } - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); shader_data = material->shader_data; - ERR_FAIL_COND(!shader_data); + ERR_FAIL_NULL(shader_data); material->set_as_used(); @@ -1220,7 +1220,7 @@ void SkyRD::update_radiance_buffers(Ref p_render_buffers, ERR_FAIL_COND(p_env.is_null()); Sky *sky = get_sky(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env)); - ERR_FAIL_COND(!sky); + ERR_FAIL_NULL(sky); RID sky_material = sky_get_material(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env)); @@ -1238,11 +1238,11 @@ void SkyRD::update_radiance_buffers(Ref p_render_buffers, material = static_cast(material_storage->material_get_data(sky_material, RendererRD::MaterialStorage::SHADER_TYPE_SKY)); } - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); SkyShaderData *shader_data = material->shader_data; - ERR_FAIL_COND(!shader_data); + ERR_FAIL_NULL(shader_data); bool update_single_frame = sky->mode == RS::SKY_MODE_REALTIME || sky->mode == RS::SKY_MODE_QUALITY; RS::SkyMode sky_mode = sky->mode; @@ -1401,7 +1401,7 @@ void SkyRD::update_res_buffers(Ref p_render_buffers, RID p RS::EnvironmentBG background = RendererSceneRenderRD::get_singleton()->environment_get_background(p_env); if (!(background == RS::ENV_BG_CLEAR_COLOR || background == RS::ENV_BG_COLOR) || sky) { - ERR_FAIL_COND(!sky); + ERR_FAIL_NULL(sky); sky_material = sky_get_material(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env)); if (sky_material.is_valid()) { @@ -1422,10 +1422,10 @@ void SkyRD::update_res_buffers(Ref p_render_buffers, RID p material = static_cast(material_storage->material_get_data(sky_material, RendererRD::MaterialStorage::SHADER_TYPE_SKY)); } - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); SkyShaderData *shader_data = material->shader_data; - ERR_FAIL_COND(!shader_data); + ERR_FAIL_NULL(shader_data); if (!shader_data->uses_quarter_res && !shader_data->uses_half_res) { return; @@ -1509,7 +1509,7 @@ void SkyRD::draw_sky(RD::DrawListID p_draw_list, Ref p_ren RS::EnvironmentBG background = RendererSceneRenderRD::get_singleton()->environment_get_background(p_env); if (!(background == RS::ENV_BG_CLEAR_COLOR || background == RS::ENV_BG_COLOR) || sky) { - ERR_FAIL_COND(!sky); + ERR_FAIL_NULL(sky); sky_material = sky_get_material(RendererSceneRenderRD::get_singleton()->environment_get_sky(p_env)); if (sky_material.is_valid()) { @@ -1530,10 +1530,10 @@ void SkyRD::draw_sky(RD::DrawListID p_draw_list, Ref p_ren material = static_cast(material_storage->material_get_data(sky_material, RendererRD::MaterialStorage::SHADER_TYPE_SKY)); } - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); SkyShaderData *shader_data = material->shader_data; - ERR_FAIL_COND(!shader_data); + ERR_FAIL_NULL(shader_data); material->set_as_used(); @@ -1649,14 +1649,14 @@ void SkyRD::update_dirty_skys() { RID SkyRD::sky_get_material(RID p_sky) const { Sky *sky = get_sky(p_sky); - ERR_FAIL_COND_V(!sky, RID()); + ERR_FAIL_NULL_V(sky, RID()); return sky->material; } float SkyRD::sky_get_baked_exposure(RID p_sky) const { Sky *sky = get_sky(p_sky); - ERR_FAIL_COND_V(!sky, 1.0); + ERR_FAIL_NULL_V(sky, 1.0); return sky->baked_exposure; } @@ -1675,7 +1675,7 @@ SkyRD::Sky *SkyRD::get_sky(RID p_sky) const { void SkyRD::free_sky(RID p_sky) { Sky *sky = get_sky(p_sky); - ERR_FAIL_COND(!sky); + ERR_FAIL_NULL(sky); sky->free(); sky_owner.free(p_sky); @@ -1683,7 +1683,7 @@ void SkyRD::free_sky(RID p_sky) { void SkyRD::sky_set_radiance_size(RID p_sky, int p_radiance_size) { Sky *sky = get_sky(p_sky); - ERR_FAIL_COND(!sky); + ERR_FAIL_NULL(sky); if (sky->set_radiance_size(p_radiance_size)) { invalidate_sky(sky); @@ -1692,7 +1692,7 @@ void SkyRD::sky_set_radiance_size(RID p_sky, int p_radiance_size) { void SkyRD::sky_set_mode(RID p_sky, RS::SkyMode p_mode) { Sky *sky = get_sky(p_sky); - ERR_FAIL_COND(!sky); + ERR_FAIL_NULL(sky); if (sky->set_mode(p_mode)) { invalidate_sky(sky); @@ -1701,7 +1701,7 @@ void SkyRD::sky_set_mode(RID p_sky, RS::SkyMode p_mode) { void SkyRD::sky_set_material(RID p_sky, RID p_material) { Sky *sky = get_sky(p_sky); - ERR_FAIL_COND(!sky); + ERR_FAIL_NULL(sky); if (sky->set_material(p_material)) { invalidate_sky(sky); @@ -1710,7 +1710,7 @@ void SkyRD::sky_set_material(RID p_sky, RID p_material) { Ref SkyRD::sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irradiance, const Size2i &p_size) { Sky *sky = get_sky(p_sky); - ERR_FAIL_COND_V(!sky, Ref()); + ERR_FAIL_NULL_V(sky, Ref()); update_dirty_skys(); @@ -1719,7 +1719,7 @@ Ref SkyRD::sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irrad RID SkyRD::sky_get_radiance_texture_rd(RID p_sky) const { Sky *sky = get_sky(p_sky); - ERR_FAIL_COND_V(!sky, RID()); + ERR_FAIL_NULL_V(sky, RID()); return sky->radiance; } diff --git a/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp b/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp index 4709ae91264..ece3b5597da 100644 --- a/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp +++ b/servers/rendering/renderer_rd/forward_clustered/render_forward_clustered.cpp @@ -3716,7 +3716,7 @@ void RenderForwardClustered::_geometry_instance_add_surface(GeometryInstanceForw m_src = scene_shader.default_material; } - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); _geometry_instance_add_surface_with_material_chain(ginstance, p_surface, material, m_src, p_mesh); @@ -3979,7 +3979,7 @@ void RenderForwardClustered::GeometryInstanceForwardClustered::set_lightmap_capt void RenderForwardClustered::geometry_instance_free(RenderGeometryInstance *p_geometry_instance) { GeometryInstanceForwardClustered *ginstance = static_cast(p_geometry_instance); - ERR_FAIL_COND(!ginstance); + ERR_FAIL_NULL(ginstance); if (ginstance->lightmap_sh != nullptr) { geometry_instance_lightmap_sh.free(ginstance->lightmap_sh); } diff --git a/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp b/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp index 509072bbece..7e8dc358d0a 100644 --- a/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp +++ b/servers/rendering/renderer_rd/forward_clustered/scene_shader_forward_clustered.cpp @@ -412,7 +412,7 @@ SceneShaderForwardClustered::ShaderData::ShaderData() : SceneShaderForwardClustered::ShaderData::~ShaderData() { SceneShaderForwardClustered *shader_singleton = (SceneShaderForwardClustered *)SceneShaderForwardClustered::singleton; - ERR_FAIL_COND(!shader_singleton); + ERR_FAIL_NULL(shader_singleton); //pipeline variants will clear themselves if shader is gone if (version.is_valid()) { shader_singleton->shader.version_free(version); diff --git a/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp b/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp index 71852b5aedf..4706249142b 100644 --- a/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp +++ b/servers/rendering/renderer_rd/forward_mobile/render_forward_mobile.cpp @@ -2246,7 +2246,7 @@ void RenderForwardMobile::GeometryInstanceForwardMobile::set_lightmap_capture(co void RenderForwardMobile::geometry_instance_free(RenderGeometryInstance *p_geometry_instance) { GeometryInstanceForwardMobile *ginstance = static_cast(p_geometry_instance); - ERR_FAIL_COND(!ginstance); + ERR_FAIL_NULL(ginstance); if (ginstance->lightmap_sh != nullptr) { geometry_instance_lightmap_sh.free(ginstance->lightmap_sh); } @@ -2473,7 +2473,7 @@ void RenderForwardMobile::_geometry_instance_add_surface(GeometryInstanceForward m_src = scene_shader.default_material; } - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); _geometry_instance_add_surface_with_material_chain(ginstance, p_surface, material, m_src, p_mesh); diff --git a/servers/rendering/renderer_rd/forward_mobile/scene_shader_forward_mobile.cpp b/servers/rendering/renderer_rd/forward_mobile/scene_shader_forward_mobile.cpp index ffbe7f7e596..eeaff0ccb11 100644 --- a/servers/rendering/renderer_rd/forward_mobile/scene_shader_forward_mobile.cpp +++ b/servers/rendering/renderer_rd/forward_mobile/scene_shader_forward_mobile.cpp @@ -364,7 +364,7 @@ SceneShaderForwardMobile::ShaderData::ShaderData() : SceneShaderForwardMobile::ShaderData::~ShaderData() { SceneShaderForwardMobile *shader_singleton = (SceneShaderForwardMobile *)SceneShaderForwardMobile::singleton; - ERR_FAIL_COND(!shader_singleton); + ERR_FAIL_NULL(shader_singleton); //pipeline variants will clear themselves if shader is gone if (version.is_valid()) { shader_singleton->shader.version_free(version); diff --git a/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp b/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp index f3ffc688e7d..3c23e68d724 100644 --- a/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp +++ b/servers/rendering/renderer_rd/renderer_canvas_render_rd.cpp @@ -329,7 +329,7 @@ RendererCanvasRender::PolygonID RendererCanvasRenderRD::request_polygon(const Ve void RendererCanvasRenderRD::free_polygon(PolygonID p_polygon) { PolygonBuffers *pb_ptr = polygon_buffers.polygons.getptr(p_polygon); - ERR_FAIL_COND(!pb_ptr); + ERR_FAIL_NULL(pb_ptr); PolygonBuffers &pb = *pb_ptr; @@ -1561,7 +1561,7 @@ void RendererCanvasRenderRD::light_set_texture(RID p_rid, RID p_texture) { RendererRD::TextureStorage *texture_storage = RendererRD::TextureStorage::get_singleton(); CanvasLight *cl = canvas_light_owner.get_or_null(p_rid); - ERR_FAIL_COND(!cl); + ERR_FAIL_NULL(cl); if (cl->texture == p_texture) { return; } @@ -1580,7 +1580,7 @@ void RendererCanvasRenderRD::light_set_texture(RID p_rid, RID p_texture) { void RendererCanvasRenderRD::light_set_use_shadow(RID p_rid, bool p_enable) { CanvasLight *cl = canvas_light_owner.get_or_null(p_rid); - ERR_FAIL_COND(!cl); + ERR_FAIL_NULL(cl); cl->shadow.enabled = p_enable; } @@ -1849,7 +1849,7 @@ RID RendererCanvasRenderRD::occluder_polygon_create() { void RendererCanvasRenderRD::occluder_polygon_set_shape(RID p_occluder, const Vector &p_points, bool p_closed) { OccluderPolygon *oc = occluder_polygon_owner.get_or_null(p_occluder); - ERR_FAIL_COND(!oc); + ERR_FAIL_NULL(oc); Vector lines; @@ -2020,7 +2020,7 @@ void RendererCanvasRenderRD::occluder_polygon_set_shape(RID p_occluder, const Ve void RendererCanvasRenderRD::occluder_polygon_set_cull_mode(RID p_occluder, RS::CanvasOccluderPolygonCullMode p_mode) { OccluderPolygon *oc = occluder_polygon_owner.get_or_null(p_occluder); - ERR_FAIL_COND(!oc); + ERR_FAIL_NULL(oc); oc->cull_mode = p_mode; } @@ -2250,7 +2250,7 @@ RS::ShaderNativeSourceCode RendererCanvasRenderRD::CanvasShaderData::get_native_ RendererCanvasRenderRD::CanvasShaderData::~CanvasShaderData() { RendererCanvasRenderRD *canvas_singleton = static_cast(RendererCanvasRender::singleton); - ERR_FAIL_COND(!canvas_singleton); + ERR_FAIL_NULL(canvas_singleton); //pipeline variants will clear themselves if shader is gone if (version.is_valid()) { canvas_singleton->shader.canvas_shader.version_free(version); @@ -2704,7 +2704,7 @@ void fragment() { bool RendererCanvasRenderRD::free(RID p_rid) { if (canvas_light_owner.owns(p_rid)) { CanvasLight *cl = canvas_light_owner.get_or_null(p_rid); - ERR_FAIL_COND_V(!cl, false); + ERR_FAIL_NULL_V(cl, false); light_set_use_shadow(p_rid, false); canvas_light_owner.free(p_rid); } else if (occluder_polygon_owner.owns(p_rid)) { diff --git a/servers/rendering/renderer_rd/shader_rd.cpp b/servers/rendering/renderer_rd/shader_rd.cpp index 46ae2d95518..10e37c7da8b 100644 --- a/servers/rendering/renderer_rd/shader_rd.cpp +++ b/servers/rendering/renderer_rd/shader_rd.cpp @@ -314,7 +314,7 @@ void ShaderRD::_compile_variant(uint32_t p_variant, const CompileData *p_data) { RS::ShaderNativeSourceCode ShaderRD::version_get_native_source_code(RID p_version) { Version *version = version_owner.get_or_null(p_version); RS::ShaderNativeSourceCode source_code; - ERR_FAIL_COND_V(!version, source_code); + ERR_FAIL_NULL_V(version, source_code); source_code.versions.resize(variant_defines.size()); @@ -567,7 +567,7 @@ void ShaderRD::version_set_code(RID p_version, const HashMap &p_ ERR_FAIL_COND(is_compute); Version *version = version_owner.get_or_null(p_version); - ERR_FAIL_COND(!version); + ERR_FAIL_NULL(version); version->vertex_globals = p_vertex_globals.utf8(); version->fragment_globals = p_fragment_globals.utf8(); version->uniforms = p_uniforms.utf8(); @@ -599,7 +599,7 @@ void ShaderRD::version_set_compute_code(RID p_version, const HashMapcompute_globals = p_compute_globals.utf8(); version->uniforms = p_uniforms.utf8(); @@ -630,7 +630,7 @@ void ShaderRD::version_set_compute_code(RID p_version, const HashMapdirty) { _initialize_version(version); diff --git a/servers/rendering/renderer_rd/shader_rd.h b/servers/rendering/renderer_rd/shader_rd.h index 01eb99f7a2a..9ce510386fd 100644 --- a/servers/rendering/renderer_rd/shader_rd.h +++ b/servers/rendering/renderer_rd/shader_rd.h @@ -162,7 +162,7 @@ public: ERR_FAIL_COND_V(!variants_enabled[p_variant], RID()); Version *version = version_owner.get_or_null(p_version); - ERR_FAIL_COND_V(!version, RID()); + ERR_FAIL_NULL_V(version, RID()); if (version->dirty) { _initialize_version(version); diff --git a/servers/rendering/renderer_rd/storage_rd/light_storage.cpp b/servers/rendering/renderer_rd/storage_rd/light_storage.cpp index a5ec62b546d..4fd33ad71ac 100644 --- a/servers/rendering/renderer_rd/storage_rd/light_storage.cpp +++ b/servers/rendering/renderer_rd/storage_rd/light_storage.cpp @@ -174,14 +174,14 @@ void LightStorage::light_free(RID p_rid) { void LightStorage::light_set_color(RID p_light, const Color &p_color) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->color = p_color; } void LightStorage::light_set_param(RID p_light, RS::LightParam p_param, float p_value) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); ERR_FAIL_INDEX(p_param, RS::LIGHT_PARAM_MAX); if (light->param[p_param] == p_value) { @@ -216,7 +216,7 @@ void LightStorage::light_set_param(RID p_light, RS::LightParam p_param, float p_ void LightStorage::light_set_shadow(RID p_light, bool p_enabled) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->shadow = p_enabled; light->version++; @@ -226,7 +226,7 @@ void LightStorage::light_set_shadow(RID p_light, bool p_enabled) { void LightStorage::light_set_projector(RID p_light, RID p_texture) { TextureStorage *texture_storage = TextureStorage::get_singleton(); Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); if (light->projector == p_texture) { return; @@ -250,14 +250,14 @@ void LightStorage::light_set_projector(RID p_light, RID p_texture) { void LightStorage::light_set_negative(RID p_light, bool p_enable) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->negative = p_enable; } void LightStorage::light_set_cull_mask(RID p_light, uint32_t p_mask) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->cull_mask = p_mask; @@ -267,7 +267,7 @@ void LightStorage::light_set_cull_mask(RID p_light, uint32_t p_mask) { void LightStorage::light_set_distance_fade(RID p_light, bool p_enabled, float p_begin, float p_shadow, float p_length) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->distance_fade = p_enabled; light->distance_fade_begin = p_begin; @@ -277,7 +277,7 @@ void LightStorage::light_set_distance_fade(RID p_light, bool p_enabled, float p_ void LightStorage::light_set_reverse_cull_face_mode(RID p_light, bool p_enabled) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->reverse_cull = p_enabled; @@ -287,7 +287,7 @@ void LightStorage::light_set_reverse_cull_face_mode(RID p_light, bool p_enabled) void LightStorage::light_set_bake_mode(RID p_light, RS::LightBakeMode p_bake_mode) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->bake_mode = p_bake_mode; @@ -297,7 +297,7 @@ void LightStorage::light_set_bake_mode(RID p_light, RS::LightBakeMode p_bake_mod void LightStorage::light_set_max_sdfgi_cascade(RID p_light, uint32_t p_cascade) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->max_sdfgi_cascade = p_cascade; @@ -307,7 +307,7 @@ void LightStorage::light_set_max_sdfgi_cascade(RID p_light, uint32_t p_cascade) void LightStorage::light_omni_set_shadow_mode(RID p_light, RS::LightOmniShadowMode p_mode) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->omni_shadow_mode = p_mode; @@ -317,14 +317,14 @@ void LightStorage::light_omni_set_shadow_mode(RID p_light, RS::LightOmniShadowMo RS::LightOmniShadowMode LightStorage::light_omni_get_shadow_mode(RID p_light) { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, RS::LIGHT_OMNI_SHADOW_CUBE); + ERR_FAIL_NULL_V(light, RS::LIGHT_OMNI_SHADOW_CUBE); return light->omni_shadow_mode; } void LightStorage::light_directional_set_shadow_mode(RID p_light, RS::LightDirectionalShadowMode p_mode) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->directional_shadow_mode = p_mode; light->version++; @@ -333,7 +333,7 @@ void LightStorage::light_directional_set_shadow_mode(RID p_light, RS::LightDirec void LightStorage::light_directional_set_blend_splits(RID p_light, bool p_enable) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->directional_blend_splits = p_enable; light->version++; @@ -342,63 +342,63 @@ void LightStorage::light_directional_set_blend_splits(RID p_light, bool p_enable bool LightStorage::light_directional_get_blend_splits(RID p_light) const { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, false); + ERR_FAIL_NULL_V(light, false); return light->directional_blend_splits; } void LightStorage::light_directional_set_sky_mode(RID p_light, RS::LightDirectionalSkyMode p_mode) { Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND(!light); + ERR_FAIL_NULL(light); light->directional_sky_mode = p_mode; } RS::LightDirectionalSkyMode LightStorage::light_directional_get_sky_mode(RID p_light) const { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL_SKY_MODE_LIGHT_AND_SKY); + ERR_FAIL_NULL_V(light, RS::LIGHT_DIRECTIONAL_SKY_MODE_LIGHT_AND_SKY); return light->directional_sky_mode; } RS::LightDirectionalShadowMode LightStorage::light_directional_get_shadow_mode(RID p_light) { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL); + ERR_FAIL_NULL_V(light, RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL); return light->directional_shadow_mode; } uint32_t LightStorage::light_get_max_sdfgi_cascade(RID p_light) { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, 0); + ERR_FAIL_NULL_V(light, 0); return light->max_sdfgi_cascade; } RS::LightBakeMode LightStorage::light_get_bake_mode(RID p_light) { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, RS::LIGHT_BAKE_DISABLED); + ERR_FAIL_NULL_V(light, RS::LIGHT_BAKE_DISABLED); return light->bake_mode; } uint64_t LightStorage::light_get_version(RID p_light) const { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, 0); + ERR_FAIL_NULL_V(light, 0); return light->version; } uint32_t LightStorage::light_get_cull_mask(RID p_light) const { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, 0); + ERR_FAIL_NULL_V(light, 0); return light->cull_mask; } AABB LightStorage::light_get_aabb(RID p_light) const { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, AABB()); + ERR_FAIL_NULL_V(light, AABB()); switch (light->type) { case RS::LIGHT_SPOT: { @@ -471,21 +471,21 @@ void LightStorage::light_instance_free(RID p_light) { void LightStorage::light_instance_set_transform(RID p_light_instance, const Transform3D &p_transform) { LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance); - ERR_FAIL_COND(!light_instance); + ERR_FAIL_NULL(light_instance); light_instance->transform = p_transform; } void LightStorage::light_instance_set_aabb(RID p_light_instance, const AABB &p_aabb) { LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance); - ERR_FAIL_COND(!light_instance); + ERR_FAIL_NULL(light_instance); light_instance->aabb = p_aabb; } void LightStorage::light_instance_set_shadow_transform(RID p_light_instance, const Projection &p_projection, const Transform3D &p_transform, float p_far, float p_split, int p_pass, float p_shadow_texel_size, float p_bias_scale, float p_range_begin, const Vector2 &p_uv_scale) { LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance); - ERR_FAIL_COND(!light_instance); + ERR_FAIL_NULL(light_instance); ERR_FAIL_INDEX(p_pass, 6); @@ -501,7 +501,7 @@ void LightStorage::light_instance_set_shadow_transform(RID p_light_instance, con void LightStorage::light_instance_mark_visible(RID p_light_instance) { LightInstance *light_instance = light_instance_owner.get_or_null(p_light_instance); - ERR_FAIL_COND(!light_instance); + ERR_FAIL_NULL(light_instance); light_instance->last_scene_pass = RendererSceneRenderRD::get_singleton()->get_scene_pass(); } @@ -1026,7 +1026,7 @@ void LightStorage::reflection_probe_free(RID p_rid) { void LightStorage::reflection_probe_set_update_mode(RID p_probe, RS::ReflectionProbeUpdateMode p_mode) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->update_mode = p_mode; reflection_probe->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_REFLECTION_PROBE); @@ -1034,35 +1034,35 @@ void LightStorage::reflection_probe_set_update_mode(RID p_probe, RS::ReflectionP void LightStorage::reflection_probe_set_intensity(RID p_probe, float p_intensity) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->intensity = p_intensity; } void LightStorage::reflection_probe_set_ambient_mode(RID p_probe, RS::ReflectionProbeAmbientMode p_mode) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->ambient_mode = p_mode; } void LightStorage::reflection_probe_set_ambient_color(RID p_probe, const Color &p_color) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->ambient_color = p_color; } void LightStorage::reflection_probe_set_ambient_energy(RID p_probe, float p_energy) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->ambient_color_energy = p_energy; } void LightStorage::reflection_probe_set_max_distance(RID p_probe, float p_distance) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->max_distance = p_distance; @@ -1071,7 +1071,7 @@ void LightStorage::reflection_probe_set_max_distance(RID p_probe, float p_distan void LightStorage::reflection_probe_set_size(RID p_probe, const Vector3 &p_size) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); if (reflection_probe->size == p_size) { return; @@ -1082,7 +1082,7 @@ void LightStorage::reflection_probe_set_size(RID p_probe, const Vector3 &p_size) void LightStorage::reflection_probe_set_origin_offset(RID p_probe, const Vector3 &p_offset) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->origin_offset = p_offset; reflection_probe->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_REFLECTION_PROBE); @@ -1090,7 +1090,7 @@ void LightStorage::reflection_probe_set_origin_offset(RID p_probe, const Vector3 void LightStorage::reflection_probe_set_as_interior(RID p_probe, bool p_enable) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->interior = p_enable; reflection_probe->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_REFLECTION_PROBE); @@ -1098,14 +1098,14 @@ void LightStorage::reflection_probe_set_as_interior(RID p_probe, bool p_enable) void LightStorage::reflection_probe_set_enable_box_projection(RID p_probe, bool p_enable) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->box_projection = p_enable; } void LightStorage::reflection_probe_set_enable_shadows(RID p_probe, bool p_enable) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->enable_shadows = p_enable; reflection_probe->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_REFLECTION_PROBE); @@ -1113,7 +1113,7 @@ void LightStorage::reflection_probe_set_enable_shadows(RID p_probe, bool p_enabl void LightStorage::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->cull_mask = p_layers; reflection_probe->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_REFLECTION_PROBE); @@ -1121,7 +1121,7 @@ void LightStorage::reflection_probe_set_cull_mask(RID p_probe, uint32_t p_layers void LightStorage::reflection_probe_set_resolution(RID p_probe, int p_resolution) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); ERR_FAIL_COND(p_resolution < 32); reflection_probe->resolution = p_resolution; @@ -1129,7 +1129,7 @@ void LightStorage::reflection_probe_set_resolution(RID p_probe, int p_resolution void LightStorage::reflection_probe_set_mesh_lod_threshold(RID p_probe, float p_ratio) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->mesh_lod_threshold = p_ratio; @@ -1138,14 +1138,14 @@ void LightStorage::reflection_probe_set_mesh_lod_threshold(RID p_probe, float p_ void LightStorage::reflection_probe_set_baked_exposure(RID p_probe, float p_exposure) { ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND(!reflection_probe); + ERR_FAIL_NULL(reflection_probe); reflection_probe->baked_exposure = p_exposure; } AABB LightStorage::reflection_probe_get_aabb(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, AABB()); + ERR_FAIL_NULL_V(reflection_probe, AABB()); AABB aabb; aabb.position = -reflection_probe->size / 2; @@ -1156,103 +1156,103 @@ AABB LightStorage::reflection_probe_get_aabb(RID p_probe) const { RS::ReflectionProbeUpdateMode LightStorage::reflection_probe_get_update_mode(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, RS::REFLECTION_PROBE_UPDATE_ALWAYS); + ERR_FAIL_NULL_V(reflection_probe, RS::REFLECTION_PROBE_UPDATE_ALWAYS); return reflection_probe->update_mode; } uint32_t LightStorage::reflection_probe_get_cull_mask(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, 0); + ERR_FAIL_NULL_V(reflection_probe, 0); return reflection_probe->cull_mask; } Vector3 LightStorage::reflection_probe_get_size(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, Vector3()); + ERR_FAIL_NULL_V(reflection_probe, Vector3()); return reflection_probe->size; } Vector3 LightStorage::reflection_probe_get_origin_offset(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, Vector3()); + ERR_FAIL_NULL_V(reflection_probe, Vector3()); return reflection_probe->origin_offset; } bool LightStorage::reflection_probe_renders_shadows(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, false); + ERR_FAIL_NULL_V(reflection_probe, false); return reflection_probe->enable_shadows; } float LightStorage::reflection_probe_get_origin_max_distance(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, 0); + ERR_FAIL_NULL_V(reflection_probe, 0); return reflection_probe->max_distance; } float LightStorage::reflection_probe_get_mesh_lod_threshold(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, 0); + ERR_FAIL_NULL_V(reflection_probe, 0); return reflection_probe->mesh_lod_threshold; } int LightStorage::reflection_probe_get_resolution(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, 0); + ERR_FAIL_NULL_V(reflection_probe, 0); return reflection_probe->resolution; } float LightStorage::reflection_probe_get_baked_exposure(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, 1.0); + ERR_FAIL_NULL_V(reflection_probe, 1.0); return reflection_probe->baked_exposure; } float LightStorage::reflection_probe_get_intensity(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, 0); + ERR_FAIL_NULL_V(reflection_probe, 0); return reflection_probe->intensity; } bool LightStorage::reflection_probe_is_interior(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, false); + ERR_FAIL_NULL_V(reflection_probe, false); return reflection_probe->interior; } bool LightStorage::reflection_probe_is_box_projection(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, false); + ERR_FAIL_NULL_V(reflection_probe, false); return reflection_probe->box_projection; } RS::ReflectionProbeAmbientMode LightStorage::reflection_probe_get_ambient_mode(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, RS::REFLECTION_PROBE_AMBIENT_DISABLED); + ERR_FAIL_NULL_V(reflection_probe, RS::REFLECTION_PROBE_AMBIENT_DISABLED); return reflection_probe->ambient_mode; } Color LightStorage::reflection_probe_get_ambient_color(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, Color()); + ERR_FAIL_NULL_V(reflection_probe, Color()); return reflection_probe->ambient_color; } float LightStorage::reflection_probe_get_ambient_color_energy(RID p_probe) const { const ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_probe); - ERR_FAIL_COND_V(!reflection_probe, 0); + ERR_FAIL_NULL_V(reflection_probe, 0); return reflection_probe->ambient_color_energy; } @@ -1286,7 +1286,7 @@ void LightStorage::reflection_atlas_free(RID p_ref_atlas) { void LightStorage::reflection_atlas_set_size(RID p_ref_atlas, int p_reflection_size, int p_reflection_count) { ReflectionAtlas *ra = reflection_atlas_owner.get_or_null(p_ref_atlas); - ERR_FAIL_COND(!ra); + ERR_FAIL_NULL(ra); if (ra->size == p_reflection_size && ra->count == p_reflection_count) { return; //no changes @@ -1325,7 +1325,7 @@ void LightStorage::reflection_atlas_set_size(RID p_ref_atlas, int p_reflection_s int LightStorage::reflection_atlas_get_size(RID p_ref_atlas) const { ReflectionAtlas *ra = reflection_atlas_owner.get_or_null(p_ref_atlas); - ERR_FAIL_COND_V(!ra, 0); + ERR_FAIL_NULL_V(ra, 0); return ra->size; } @@ -1349,7 +1349,7 @@ void LightStorage::reflection_probe_instance_free(RID p_instance) { void LightStorage::reflection_probe_instance_set_transform(RID p_instance, const Transform3D &p_transform) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!rpi); + ERR_FAIL_NULL(rpi); rpi->transform = p_transform; rpi->dirty = true; @@ -1357,13 +1357,13 @@ void LightStorage::reflection_probe_instance_set_transform(RID p_instance, const void LightStorage::reflection_probe_release_atlas_index(RID p_instance) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!rpi); + ERR_FAIL_NULL(rpi); if (rpi->atlas.is_null()) { return; //nothing to release } ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas); - ERR_FAIL_COND(!atlas); + ERR_FAIL_NULL(atlas); ERR_FAIL_INDEX(rpi->atlas_index, atlas->reflections.size()); atlas->reflections.write[rpi->atlas_index].owner = RID(); @@ -1375,7 +1375,7 @@ void LightStorage::reflection_probe_release_atlas_index(RID p_instance) { bool LightStorage::reflection_probe_instance_needs_redraw(RID p_instance) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, false); + ERR_FAIL_NULL_V(rpi, false); if (rpi->rendering) { return false; @@ -1394,7 +1394,7 @@ bool LightStorage::reflection_probe_instance_needs_redraw(RID p_instance) { bool LightStorage::reflection_probe_instance_has_reflection(RID p_instance) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, false); + ERR_FAIL_NULL_V(rpi, false); return rpi->atlas.is_valid(); } @@ -1402,10 +1402,10 @@ bool LightStorage::reflection_probe_instance_has_reflection(RID p_instance) { bool LightStorage::reflection_probe_instance_begin_render(RID p_instance, RID p_reflection_atlas) { ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(p_reflection_atlas); - ERR_FAIL_COND_V(!atlas, false); + ERR_FAIL_NULL_V(atlas, false); ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, false); + ERR_FAIL_NULL_V(rpi, false); if (atlas->render_buffers.is_null()) { atlas->render_buffers.instantiate(); @@ -1511,14 +1511,14 @@ bool LightStorage::reflection_probe_instance_begin_render(RID p_instance, RID p_ Ref LightStorage::reflection_probe_atlas_get_render_buffers(RID p_reflection_atlas) { ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(p_reflection_atlas); - ERR_FAIL_COND_V(!atlas, Ref()); + ERR_FAIL_NULL_V(atlas, Ref()); return atlas->render_buffers; } bool LightStorage::reflection_probe_instance_postprocess_step(RID p_instance) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, false); + ERR_FAIL_NULL_V(rpi, false); ERR_FAIL_COND_V(!rpi->rendering, false); ERR_FAIL_COND_V(rpi->atlas.is_null(), false); @@ -1569,30 +1569,30 @@ bool LightStorage::reflection_probe_instance_postprocess_step(RID p_instance) { uint32_t LightStorage::reflection_probe_instance_get_resolution(RID p_instance) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, 0); + ERR_FAIL_NULL_V(rpi, 0); ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas); - ERR_FAIL_COND_V(!atlas, 0); + ERR_FAIL_NULL_V(atlas, 0); return atlas->size; } RID LightStorage::reflection_probe_instance_get_framebuffer(RID p_instance, int p_index) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, RID()); + ERR_FAIL_NULL_V(rpi, RID()); ERR_FAIL_INDEX_V(p_index, 6, RID()); ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas); - ERR_FAIL_COND_V(!atlas, RID()); + ERR_FAIL_NULL_V(atlas, RID()); return atlas->reflections[rpi->atlas_index].fbs[p_index]; } RID LightStorage::reflection_probe_instance_get_depth_framebuffer(RID p_instance, int p_index) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, RID()); + ERR_FAIL_NULL_V(rpi, RID()); ERR_FAIL_INDEX_V(p_index, 6, RID()); ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(rpi->atlas); - ERR_FAIL_COND_V(!atlas, RID()); + ERR_FAIL_NULL_V(atlas, RID()); return atlas->depth_fb; } @@ -1747,7 +1747,7 @@ void LightStorage::lightmap_set_textures(RID p_lightmap, RID p_light, bool p_use TextureStorage *texture_storage = TextureStorage::get_singleton(); Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND(!lm); + ERR_FAIL_NULL(lm); lightmap_array_version++; @@ -1795,19 +1795,19 @@ void LightStorage::lightmap_set_textures(RID p_lightmap, RID p_light, bool p_use void LightStorage::lightmap_set_probe_bounds(RID p_lightmap, const AABB &p_bounds) { Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND(!lm); + ERR_FAIL_NULL(lm); lm->bounds = p_bounds; } void LightStorage::lightmap_set_probe_interior(RID p_lightmap, bool p_interior) { Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND(!lm); + ERR_FAIL_NULL(lm); lm->interior = p_interior; } void LightStorage::lightmap_set_probe_capture_data(RID p_lightmap, const PackedVector3Array &p_points, const PackedColorArray &p_point_sh, const PackedInt32Array &p_tetrahedra, const PackedInt32Array &p_bsp_tree) { Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND(!lm); + ERR_FAIL_NULL(lm); if (p_points.size()) { ERR_FAIL_COND(p_points.size() * 9 != p_point_sh.size()); @@ -1823,33 +1823,33 @@ void LightStorage::lightmap_set_probe_capture_data(RID p_lightmap, const PackedV void LightStorage::lightmap_set_baked_exposure_normalization(RID p_lightmap, float p_exposure) { Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND(!lm); + ERR_FAIL_NULL(lm); lm->baked_exposure = p_exposure; } PackedVector3Array LightStorage::lightmap_get_probe_capture_points(RID p_lightmap) const { Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND_V(!lm, PackedVector3Array()); + ERR_FAIL_NULL_V(lm, PackedVector3Array()); return lm->points; } PackedColorArray LightStorage::lightmap_get_probe_capture_sh(RID p_lightmap) const { Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND_V(!lm, PackedColorArray()); + ERR_FAIL_NULL_V(lm, PackedColorArray()); return lm->point_sh; } PackedInt32Array LightStorage::lightmap_get_probe_capture_tetrahedra(RID p_lightmap) const { Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND_V(!lm, PackedInt32Array()); + ERR_FAIL_NULL_V(lm, PackedInt32Array()); return lm->tetrahedra; } PackedInt32Array LightStorage::lightmap_get_probe_capture_bsp_tree(RID p_lightmap) const { Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND_V(!lm, PackedInt32Array()); + ERR_FAIL_NULL_V(lm, PackedInt32Array()); return lm->bsp_tree; } @@ -1866,7 +1866,7 @@ Dependency *LightStorage::lightmap_get_dependency(RID p_lightmap) const { void LightStorage::lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p_point, Color *r_sh) { Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND(!lm); + ERR_FAIL_NULL(lm); for (int i = 0; i < 9; i++) { r_sh[i] = Color(0, 0, 0, 0); @@ -1916,13 +1916,13 @@ void LightStorage::lightmap_tap_sh_light(RID p_lightmap, const Vector3 &p_point, bool LightStorage::lightmap_is_interior(RID p_lightmap) const { const Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND_V(!lm, false); + ERR_FAIL_NULL_V(lm, false); return lm->interior; } AABB LightStorage::lightmap_get_aabb(RID p_lightmap) const { const Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND_V(!lm, AABB()); + ERR_FAIL_NULL_V(lm, AABB()); return lm->bounds; } @@ -1940,7 +1940,7 @@ void LightStorage::lightmap_instance_free(RID p_lightmap) { void LightStorage::lightmap_instance_set_transform(RID p_lightmap, const Transform3D &p_transform) { LightmapInstance *li = lightmap_instance_owner.get_or_null(p_lightmap); - ERR_FAIL_COND(!li); + ERR_FAIL_NULL(li); li->transform = p_transform; } @@ -1972,7 +1972,7 @@ void LightStorage::_update_shadow_atlas(ShadowAtlas *shadow_atlas) { void LightStorage::shadow_atlas_set_size(RID p_atlas, int p_size, bool p_16_bits) { ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_atlas); - ERR_FAIL_COND(!shadow_atlas); + ERR_FAIL_NULL(shadow_atlas); ERR_FAIL_COND(p_size < 0); p_size = next_power_of_2(p_size); @@ -2007,7 +2007,7 @@ void LightStorage::shadow_atlas_set_size(RID p_atlas, int p_size, bool p_16_bits void LightStorage::shadow_atlas_set_quadrant_subdivision(RID p_atlas, int p_quadrant, int p_subdivision) { ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_atlas); - ERR_FAIL_COND(!shadow_atlas); + ERR_FAIL_NULL(shadow_atlas); ERR_FAIL_INDEX(p_quadrant, 4); ERR_FAIL_INDEX(p_subdivision, 16384); @@ -2196,10 +2196,10 @@ bool LightStorage::_shadow_atlas_find_omni_shadows(ShadowAtlas *shadow_atlas, in bool LightStorage::shadow_atlas_update_light(RID p_atlas, RID p_light_instance, float p_coverage, uint64_t p_light_version) { ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_atlas); - ERR_FAIL_COND_V(!shadow_atlas, false); + ERR_FAIL_NULL_V(shadow_atlas, false); LightInstance *li = light_instance_owner.get_or_null(p_light_instance); - ERR_FAIL_COND_V(!li, false); + ERR_FAIL_NULL_V(li, false); if (shadow_atlas->size == 0 || shadow_atlas->smallest_subdiv == 0) { return false; @@ -2341,7 +2341,7 @@ void LightStorage::_shadow_atlas_invalidate_shadow(ShadowAtlas::Quadrant::Shadow void LightStorage::shadow_atlas_update(RID p_atlas) { ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_atlas); - ERR_FAIL_COND(!shadow_atlas); + ERR_FAIL_NULL(shadow_atlas); _update_shadow_atlas(shadow_atlas); } @@ -2416,7 +2416,7 @@ int LightStorage::get_directional_light_shadow_size(RID p_light_intance) { Rect2i r = _get_directional_shadow_rect(directional_shadow.size, directional_shadow.light_count, 0); LightInstance *light_instance = light_instance_owner.get_or_null(p_light_intance); - ERR_FAIL_COND_V(!light_instance, 0); + ERR_FAIL_NULL_V(light_instance, 0); switch (light_directional_get_shadow_mode(light_instance->light)) { case RS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: diff --git a/servers/rendering/renderer_rd/storage_rd/light_storage.h b/servers/rendering/renderer_rd/storage_rd/light_storage.h index 512c440ae8f..f0b27103fb7 100644 --- a/servers/rendering/renderer_rd/storage_rd/light_storage.h +++ b/servers/rendering/renderer_rd/storage_rd/light_storage.h @@ -490,7 +490,7 @@ public: virtual RS::LightType light_get_type(RID p_light) const override { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL); + ERR_FAIL_NULL_V(light, RS::LIGHT_DIRECTIONAL); return light->type; } @@ -498,21 +498,21 @@ public: virtual float light_get_param(RID p_light, RS::LightParam p_param) override { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, 0); + ERR_FAIL_NULL_V(light, 0); return light->param[p_param]; } _FORCE_INLINE_ RID light_get_projector(RID p_light) { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, RID()); + ERR_FAIL_NULL_V(light, RID()); return light->projector; } virtual Color light_get_color(RID p_light) override { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, Color()); + ERR_FAIL_NULL_V(light, Color()); return light->color; } @@ -539,35 +539,35 @@ public: virtual bool light_has_shadow(RID p_light) const override { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL); + ERR_FAIL_NULL_V(light, RS::LIGHT_DIRECTIONAL); return light->shadow; } virtual bool light_has_projector(RID p_light) const override { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL); + ERR_FAIL_NULL_V(light, RS::LIGHT_DIRECTIONAL); return TextureStorage::get_singleton()->owns_texture(light->projector); } _FORCE_INLINE_ bool light_is_negative(RID p_light) const { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, RS::LIGHT_DIRECTIONAL); + ERR_FAIL_NULL_V(light, RS::LIGHT_DIRECTIONAL); return light->negative; } _FORCE_INLINE_ float light_get_transmittance_bias(RID p_light) const { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, 0.0); + ERR_FAIL_NULL_V(light, 0.0); return light->param[RS::LIGHT_PARAM_TRANSMITTANCE_BIAS]; } virtual bool light_get_reverse_cull_face_mode(RID p_light) const override { const Light *light = light_owner.get_or_null(p_light); - ERR_FAIL_COND_V(!light, false); + ERR_FAIL_NULL_V(light, false); return light->reverse_cull; } @@ -657,7 +657,7 @@ public: ERR_FAIL_COND_V(!li->shadow_atlases.has(p_shadow_atlas), 0); #endif ShadowAtlas *shadow_atlas = shadow_atlas_owner.get_or_null(p_shadow_atlas); - ERR_FAIL_COND_V(!shadow_atlas, 0); + ERR_FAIL_NULL_V(shadow_atlas, 0); #ifdef DEBUG_ENABLED ERR_FAIL_COND_V(!shadow_atlas->shadow_owners.has(p_light_instance), 0); #endif @@ -835,7 +835,7 @@ public: _FORCE_INLINE_ RID reflection_atlas_get_texture(RID p_ref_atlas) { ReflectionAtlas *atlas = reflection_atlas_owner.get_or_null(p_ref_atlas); - ERR_FAIL_COND_V(!atlas, RID()); + ERR_FAIL_NULL_V(atlas, RID()); return atlas->reflection; } @@ -859,47 +859,47 @@ public: _FORCE_INLINE_ RID reflection_probe_instance_get_probe(RID p_instance) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, RID()); + ERR_FAIL_NULL_V(rpi, RID()); return rpi->probe; } _FORCE_INLINE_ RendererRD::ForwardID reflection_probe_instance_get_forward_id(RID p_instance) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, 0); + ERR_FAIL_NULL_V(rpi, 0); return rpi->forward_id; } _FORCE_INLINE_ void reflection_probe_instance_set_cull_mask(RID p_instance, uint32_t p_render_pass) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!rpi); + ERR_FAIL_NULL(rpi); rpi->cull_mask = p_render_pass; } _FORCE_INLINE_ void reflection_probe_instance_set_render_pass(RID p_instance, uint32_t p_render_pass) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!rpi); + ERR_FAIL_NULL(rpi); rpi->last_pass = p_render_pass; } _FORCE_INLINE_ uint32_t reflection_probe_instance_get_render_pass(RID p_instance) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, 0); + ERR_FAIL_NULL_V(rpi, 0); return rpi->last_pass; } _FORCE_INLINE_ Transform3D reflection_probe_instance_get_transform(RID p_instance) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, Transform3D()); + ERR_FAIL_NULL_V(rpi, Transform3D()); return rpi->transform; } _FORCE_INLINE_ int reflection_probe_instance_get_atlas_index(RID p_instance) { ReflectionProbeInstance *rpi = reflection_probe_instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!rpi, -1); + ERR_FAIL_NULL_V(rpi, -1); return rpi->atlas_index; } @@ -942,12 +942,12 @@ public: } _FORCE_INLINE_ RID lightmap_get_texture(RID p_lightmap) const { const Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND_V(!lm, RID()); + ERR_FAIL_NULL_V(lm, RID()); return lm->light_texture; } _FORCE_INLINE_ float lightmap_get_baked_exposure_normalization(RID p_lightmap) const { const Lightmap *lm = lightmap_owner.get_or_null(p_lightmap); - ERR_FAIL_COND_V(!lm, 1.0); + ERR_FAIL_NULL_V(lm, 1.0); return lm->baked_exposure; } _FORCE_INLINE_ int32_t lightmap_get_array_index(RID p_lightmap) const { @@ -1007,44 +1007,44 @@ public: virtual bool shadow_atlas_update_light(RID p_atlas, RID p_light_instance, float p_coverage, uint64_t p_light_version) override; _FORCE_INLINE_ bool shadow_atlas_owns_light_instance(RID p_atlas, RID p_light_intance) { ShadowAtlas *atlas = shadow_atlas_owner.get_or_null(p_atlas); - ERR_FAIL_COND_V(!atlas, false); + ERR_FAIL_NULL_V(atlas, false); return atlas->shadow_owners.has(p_light_intance); } _FORCE_INLINE_ uint32_t shadow_atlas_get_light_instance_key(RID p_atlas, RID p_light_intance) { ShadowAtlas *atlas = shadow_atlas_owner.get_or_null(p_atlas); - ERR_FAIL_COND_V(!atlas, -1); + ERR_FAIL_NULL_V(atlas, -1); return atlas->shadow_owners[p_light_intance]; } _FORCE_INLINE_ RID shadow_atlas_get_texture(RID p_atlas) { ShadowAtlas *atlas = shadow_atlas_owner.get_or_null(p_atlas); - ERR_FAIL_COND_V(!atlas, RID()); + ERR_FAIL_NULL_V(atlas, RID()); return atlas->depth; } _FORCE_INLINE_ int shadow_atlas_get_size(RID p_atlas) { ShadowAtlas *atlas = shadow_atlas_owner.get_or_null(p_atlas); - ERR_FAIL_COND_V(!atlas, 0); + ERR_FAIL_NULL_V(atlas, 0); return atlas->size; } _FORCE_INLINE_ int shadow_atlas_get_quadrant_shadow_size(RID p_atlas, uint32_t p_quadrant) { ShadowAtlas *atlas = shadow_atlas_owner.get_or_null(p_atlas); - ERR_FAIL_COND_V(!atlas, 0); + ERR_FAIL_NULL_V(atlas, 0); ERR_FAIL_UNSIGNED_INDEX_V(p_quadrant, 4, 0); return atlas->quadrants[p_quadrant].shadows.size(); } _FORCE_INLINE_ uint32_t shadow_atlas_get_quadrant_subdivision(RID p_atlas, uint32_t p_quadrant) { ShadowAtlas *atlas = shadow_atlas_owner.get_or_null(p_atlas); - ERR_FAIL_COND_V(!atlas, 0); + ERR_FAIL_NULL_V(atlas, 0); ERR_FAIL_UNSIGNED_INDEX_V(p_quadrant, 4, 0); return atlas->quadrants[p_quadrant].subdivision; } _FORCE_INLINE_ RID shadow_atlas_get_fb(RID p_atlas) { ShadowAtlas *atlas = shadow_atlas_owner.get_or_null(p_atlas); - ERR_FAIL_COND_V(!atlas, RID()); + ERR_FAIL_NULL_V(atlas, RID()); return atlas->fb; } diff --git a/servers/rendering/renderer_rd/storage_rd/material_storage.cpp b/servers/rendering/renderer_rd/storage_rd/material_storage.cpp index c40b74743b2..fd65b739ab6 100644 --- a/servers/rendering/renderer_rd/storage_rd/material_storage.cpp +++ b/servers/rendering/renderer_rd/storage_rd/material_storage.cpp @@ -1834,7 +1834,7 @@ void MaterialStorage::shader_initialize(RID p_rid) { void MaterialStorage::shader_free(RID p_rid) { Shader *shader = shader_owner.get_or_null(p_rid); - ERR_FAIL_COND(!shader); + ERR_FAIL_NULL(shader); //make material unreference this while (shader->owners.size()) { @@ -1850,7 +1850,7 @@ void MaterialStorage::shader_free(RID p_rid) { void MaterialStorage::shader_set_code(RID p_shader, const String &p_code) { Shader *shader = shader_owner.get_or_null(p_shader); - ERR_FAIL_COND(!shader); + ERR_FAIL_NULL(shader); shader->code = p_code; String mode_string = ShaderLanguage::get_shader_type(p_code); @@ -1927,7 +1927,7 @@ void MaterialStorage::shader_set_code(RID p_shader, const String &p_code) { void MaterialStorage::shader_set_path_hint(RID p_shader, const String &p_path) { Shader *shader = shader_owner.get_or_null(p_shader); - ERR_FAIL_COND(!shader); + ERR_FAIL_NULL(shader); shader->path_hint = p_path; if (shader->data) { @@ -1937,13 +1937,13 @@ void MaterialStorage::shader_set_path_hint(RID p_shader, const String &p_path) { String MaterialStorage::shader_get_code(RID p_shader) const { Shader *shader = shader_owner.get_or_null(p_shader); - ERR_FAIL_COND_V(!shader, String()); + ERR_FAIL_NULL_V(shader, String()); return shader->code; } void MaterialStorage::get_shader_parameter_list(RID p_shader, List *p_param_list) const { Shader *shader = shader_owner.get_or_null(p_shader); - ERR_FAIL_COND(!shader); + ERR_FAIL_NULL(shader); if (shader->data) { return shader->data->get_shader_uniform_list(p_param_list); } @@ -1951,7 +1951,7 @@ void MaterialStorage::get_shader_parameter_list(RID p_shader, List void MaterialStorage::shader_set_default_texture_parameter(RID p_shader, const StringName &p_name, RID p_texture, int p_index) { Shader *shader = shader_owner.get_or_null(p_shader); - ERR_FAIL_COND(!shader); + ERR_FAIL_NULL(shader); if (p_texture.is_valid() && TextureStorage::get_singleton()->owns_texture(p_texture)) { if (!shader->default_texture_parameter.has(p_name)) { @@ -1978,7 +1978,7 @@ void MaterialStorage::shader_set_default_texture_parameter(RID p_shader, const S RID MaterialStorage::shader_get_default_texture_parameter(RID p_shader, const StringName &p_name, int p_index) const { Shader *shader = shader_owner.get_or_null(p_shader); - ERR_FAIL_COND_V(!shader, RID()); + ERR_FAIL_NULL_V(shader, RID()); if (shader->default_texture_parameter.has(p_name) && shader->default_texture_parameter[p_name].has(p_index)) { return shader->default_texture_parameter[p_name][p_index]; } @@ -1988,7 +1988,7 @@ RID MaterialStorage::shader_get_default_texture_parameter(RID p_shader, const St Variant MaterialStorage::shader_get_parameter_default(RID p_shader, const StringName &p_param) const { Shader *shader = shader_owner.get_or_null(p_shader); - ERR_FAIL_COND_V(!shader, Variant()); + ERR_FAIL_NULL_V(shader, Variant()); if (shader->data) { return shader->data->get_default_parameter(p_param); } @@ -2002,7 +2002,7 @@ void MaterialStorage::shader_set_data_request_function(ShaderType p_shader_type, RS::ShaderNativeSourceCode MaterialStorage::shader_get_native_source_code(RID p_shader) const { Shader *shader = shader_owner.get_or_null(p_shader); - ERR_FAIL_COND_V(!shader, RS::ShaderNativeSourceCode()); + ERR_FAIL_NULL_V(shader, RS::ShaderNativeSourceCode()); if (shader->data) { return shader->data->get_native_source_code(); } @@ -2067,7 +2067,7 @@ void MaterialStorage::material_initialize(RID p_rid) { void MaterialStorage::material_free(RID p_rid) { Material *material = material_owner.get_or_null(p_rid); - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); // Need to clear texture arrays to prevent spin locking of their RID's. // This happens when the app is being closed. @@ -2085,7 +2085,7 @@ void MaterialStorage::material_free(RID p_rid) { void MaterialStorage::material_set_shader(RID p_material, RID p_shader) { Material *material = material_owner.get_or_null(p_material); - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); if (material->data) { memdelete(material->data); @@ -2105,7 +2105,7 @@ void MaterialStorage::material_set_shader(RID p_material, RID p_shader) { } Shader *shader = get_shader(p_shader); - ERR_FAIL_COND(!shader); + ERR_FAIL_NULL(shader); material->shader = shader; material->shader_type = shader->type; material->shader_id = p_shader.get_local_index(); @@ -2137,7 +2137,7 @@ MaterialStorage::ShaderData *MaterialStorage::material_get_shader_data(RID p_mat void MaterialStorage::material_set_param(RID p_material, const StringName &p_param, const Variant &p_value) { Material *material = material_owner.get_or_null(p_material); - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); if (p_value.get_type() == Variant::NIL) { material->params.erase(p_param); @@ -2156,7 +2156,7 @@ void MaterialStorage::material_set_param(RID p_material, const StringName &p_par Variant MaterialStorage::material_get_param(RID p_material, const StringName &p_param) const { Material *material = material_owner.get_or_null(p_material); - ERR_FAIL_COND_V(!material, Variant()); + ERR_FAIL_NULL_V(material, Variant()); if (material->params.has(p_param)) { return material->params[p_param]; } else { @@ -2166,7 +2166,7 @@ Variant MaterialStorage::material_get_param(RID p_material, const StringName &p_ void MaterialStorage::material_set_next_pass(RID p_material, RID p_next_material) { Material *material = material_owner.get_or_null(p_material); - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); if (material->next_pass == p_next_material) { return; @@ -2182,7 +2182,7 @@ void MaterialStorage::material_set_next_pass(RID p_material, RID p_next_material void MaterialStorage::material_set_render_priority(RID p_material, int priority) { Material *material = material_owner.get_or_null(p_material); - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); material->priority = priority; if (material->data) { material->data->set_render_priority(priority); @@ -2192,7 +2192,7 @@ void MaterialStorage::material_set_render_priority(RID p_material, int priority) bool MaterialStorage::material_is_animated(RID p_material) { Material *material = material_owner.get_or_null(p_material); - ERR_FAIL_COND_V(!material, false); + ERR_FAIL_NULL_V(material, false); if (material->shader && material->shader->data) { if (material->shader->data->is_animated()) { return true; @@ -2205,7 +2205,7 @@ bool MaterialStorage::material_is_animated(RID p_material) { bool MaterialStorage::material_casts_shadows(RID p_material) { Material *material = material_owner.get_or_null(p_material); - ERR_FAIL_COND_V(!material, true); + ERR_FAIL_NULL_V(material, true); if (material->shader && material->shader->data) { if (material->shader->data->casts_shadows()) { return true; @@ -2218,7 +2218,7 @@ bool MaterialStorage::material_casts_shadows(RID p_material) { void MaterialStorage::material_get_instance_shader_parameters(RID p_material, List *r_parameters) { Material *material = material_owner.get_or_null(p_material); - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); if (material->shader && material->shader->data) { material->shader->data->get_instance_param_list(r_parameters); @@ -2230,7 +2230,7 @@ void MaterialStorage::material_get_instance_shader_parameters(RID p_material, Li void MaterialStorage::material_update_dependency(RID p_material, DependencyTracker *p_instance) { Material *material = material_owner.get_or_null(p_material); - ERR_FAIL_COND(!material); + ERR_FAIL_NULL(material); p_instance->update_dependency(&material->dependency); if (material->next_pass.is_valid()) { material_update_dependency(material->next_pass, p_instance); diff --git a/servers/rendering/renderer_rd/storage_rd/mesh_storage.cpp b/servers/rendering/renderer_rd/storage_rd/mesh_storage.cpp index 487c3144720..9c7bcbb54fe 100644 --- a/servers/rendering/renderer_rd/storage_rd/mesh_storage.cpp +++ b/servers/rendering/renderer_rd/storage_rd/mesh_storage.cpp @@ -228,7 +228,7 @@ void MeshStorage::mesh_free(RID p_rid) { mesh_clear(p_rid); mesh_set_shadow_mesh(p_rid, RID()); Mesh *mesh = mesh_owner.get_or_null(p_rid); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); mesh->dependency.deleted_notify(p_rid); if (mesh->instances.size()) { @@ -248,7 +248,7 @@ void MeshStorage::mesh_set_blend_shape_count(RID p_mesh, int p_blend_shape_count ERR_FAIL_COND(p_blend_shape_count < 0); Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); ERR_FAIL_COND(mesh->surface_count > 0); //surfaces already exist @@ -258,7 +258,7 @@ void MeshStorage::mesh_set_blend_shape_count(RID p_mesh, int p_blend_shape_count /// Returns stride void MeshStorage::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); ERR_FAIL_COND(mesh->surface_count == RS::MAX_MESH_SURFACES); @@ -462,13 +462,13 @@ void MeshStorage::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface) int MeshStorage::mesh_get_blend_shape_count(RID p_mesh) const { const Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, -1); + ERR_FAIL_NULL_V(mesh, -1); return mesh->blend_shape_count; } void MeshStorage::mesh_set_blend_shape_mode(RID p_mesh, RS::BlendShapeMode p_mode) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); ERR_FAIL_INDEX((int)p_mode, 2); mesh->blend_shape_mode = p_mode; @@ -476,13 +476,13 @@ void MeshStorage::mesh_set_blend_shape_mode(RID p_mesh, RS::BlendShapeMode p_mod RS::BlendShapeMode MeshStorage::mesh_get_blend_shape_mode(RID p_mesh) const { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, RS::BLEND_SHAPE_MODE_NORMALIZED); + ERR_FAIL_NULL_V(mesh, RS::BLEND_SHAPE_MODE_NORMALIZED); return mesh->blend_shape_mode; } void MeshStorage::mesh_surface_update_vertex_region(RID p_mesh, int p_surface, int p_offset, const Vector &p_data) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); ERR_FAIL_UNSIGNED_INDEX((uint32_t)p_surface, mesh->surface_count); ERR_FAIL_COND(p_data.size() == 0); ERR_FAIL_COND(mesh->surfaces[p_surface]->vertex_buffer.is_null()); @@ -494,7 +494,7 @@ void MeshStorage::mesh_surface_update_vertex_region(RID p_mesh, int p_surface, i void MeshStorage::mesh_surface_update_attribute_region(RID p_mesh, int p_surface, int p_offset, const Vector &p_data) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); ERR_FAIL_UNSIGNED_INDEX((uint32_t)p_surface, mesh->surface_count); ERR_FAIL_COND(p_data.size() == 0); ERR_FAIL_COND(mesh->surfaces[p_surface]->attribute_buffer.is_null()); @@ -506,7 +506,7 @@ void MeshStorage::mesh_surface_update_attribute_region(RID p_mesh, int p_surface void MeshStorage::mesh_surface_update_skin_region(RID p_mesh, int p_surface, int p_offset, const Vector &p_data) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); ERR_FAIL_UNSIGNED_INDEX((uint32_t)p_surface, mesh->surface_count); ERR_FAIL_COND(p_data.size() == 0); ERR_FAIL_COND(mesh->surfaces[p_surface]->skin_buffer.is_null()); @@ -518,7 +518,7 @@ void MeshStorage::mesh_surface_update_skin_region(RID p_mesh, int p_surface, int void MeshStorage::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_material) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); ERR_FAIL_UNSIGNED_INDEX((uint32_t)p_surface, mesh->surface_count); mesh->surfaces[p_surface]->material = p_material; @@ -528,7 +528,7 @@ void MeshStorage::mesh_surface_set_material(RID p_mesh, int p_surface, RID p_mat RID MeshStorage::mesh_surface_get_material(RID p_mesh, int p_surface) const { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, RID()); + ERR_FAIL_NULL_V(mesh, RID()); ERR_FAIL_UNSIGNED_INDEX_V((uint32_t)p_surface, mesh->surface_count, RID()); return mesh->surfaces[p_surface]->material; @@ -536,7 +536,7 @@ RID MeshStorage::mesh_surface_get_material(RID p_mesh, int p_surface) const { RS::SurfaceData MeshStorage::mesh_get_surface(RID p_mesh, int p_surface) const { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, RS::SurfaceData()); + ERR_FAIL_NULL_V(mesh, RS::SurfaceData()); ERR_FAIL_UNSIGNED_INDEX_V((uint32_t)p_surface, mesh->surface_count, RS::SurfaceData()); Mesh::Surface &s = *mesh->surfaces[p_surface]; @@ -578,13 +578,13 @@ RS::SurfaceData MeshStorage::mesh_get_surface(RID p_mesh, int p_surface) const { int MeshStorage::mesh_get_surface_count(RID p_mesh) const { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, 0); + ERR_FAIL_NULL_V(mesh, 0); return mesh->surface_count; } void MeshStorage::mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); mesh->custom_aabb = p_aabb; mesh->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_AABB); @@ -592,13 +592,13 @@ void MeshStorage::mesh_set_custom_aabb(RID p_mesh, const AABB &p_aabb) { AABB MeshStorage::mesh_get_custom_aabb(RID p_mesh) const { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, AABB()); + ERR_FAIL_NULL_V(mesh, AABB()); return mesh->custom_aabb; } AABB MeshStorage::mesh_get_aabb(RID p_mesh, RID p_skeleton) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, AABB()); + ERR_FAIL_NULL_V(mesh, AABB()); if (mesh->custom_aabb != AABB()) { return mesh->custom_aabb; @@ -706,7 +706,7 @@ AABB MeshStorage::mesh_get_aabb(RID p_mesh, RID p_skeleton) { void MeshStorage::mesh_set_shadow_mesh(RID p_mesh, RID p_shadow_mesh) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); Mesh *shadow_mesh = mesh_owner.get_or_null(mesh->shadow_mesh); if (shadow_mesh) { @@ -725,7 +725,7 @@ void MeshStorage::mesh_set_shadow_mesh(RID p_mesh, RID p_shadow_mesh) { void MeshStorage::mesh_clear(RID p_mesh) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND(!mesh); + ERR_FAIL_NULL(mesh); // Clear instance data before mesh data. for (MeshInstance *mi : mesh->instances) { @@ -783,14 +783,14 @@ void MeshStorage::mesh_clear(RID p_mesh) { bool MeshStorage::mesh_needs_instance(RID p_mesh, bool p_has_skeleton) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, false); + ERR_FAIL_NULL_V(mesh, false); return mesh->blend_shape_count > 0 || (mesh->has_bone_weights && p_has_skeleton); } Dependency *MeshStorage::mesh_get_dependency(RID p_mesh) const { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, nullptr); + ERR_FAIL_NULL_V(mesh, nullptr); return &mesh->dependency; } @@ -799,7 +799,7 @@ Dependency *MeshStorage::mesh_get_dependency(RID p_mesh) const { RID MeshStorage::mesh_instance_create(RID p_base) { Mesh *mesh = mesh_owner.get_or_null(p_base); - ERR_FAIL_COND_V(!mesh, RID()); + ERR_FAIL_NULL_V(mesh, RID()); RID rid = mesh_instance_owner.make_rid(); MeshInstance *mi = mesh_instance_owner.get_or_null(rid); @@ -838,7 +838,7 @@ void MeshStorage::mesh_instance_set_skeleton(RID p_mesh_instance, RID p_skeleton void MeshStorage::mesh_instance_set_blend_shape_weight(RID p_mesh_instance, int p_shape, float p_weight) { MeshInstance *mi = mesh_instance_owner.get_or_null(p_mesh_instance); - ERR_FAIL_COND(!mi); + ERR_FAIL_NULL(mi); ERR_FAIL_INDEX(p_shape, (int)mi->blend_weights.size()); mi->blend_weights[p_shape] = p_weight; mi->weights_dirty = true; @@ -1293,7 +1293,7 @@ void MeshStorage::multimesh_free(RID p_rid) { void MeshStorage::multimesh_allocate_data(RID p_multimesh, int p_instances, RS::MultimeshTransformFormat p_transform_format, bool p_use_colors, bool p_use_custom_data) { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND(!multimesh); + ERR_FAIL_NULL(multimesh); if (multimesh->instances == p_instances && multimesh->xform_format == p_transform_format && multimesh->uses_colors == p_use_colors && multimesh->uses_custom_data == p_use_custom_data) { return; @@ -1390,7 +1390,7 @@ void MeshStorage::_multimesh_enable_motion_vectors(MultiMesh *multimesh) { void MeshStorage::_multimesh_get_motion_vectors_offsets(RID p_multimesh, uint32_t &r_current_offset, uint32_t &r_prev_offset) { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND(!multimesh); + ERR_FAIL_NULL(multimesh); r_current_offset = multimesh->motion_vectors_current_offset; if (!_multimesh_uses_motion_vectors(multimesh)) { multimesh->motion_vectors_previous_offset = multimesh->motion_vectors_current_offset; @@ -1406,13 +1406,13 @@ bool MeshStorage::_multimesh_uses_motion_vectors_offsets(RID p_multimesh) { int MeshStorage::multimesh_get_instance_count(RID p_multimesh) const { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND_V(!multimesh, 0); + ERR_FAIL_NULL_V(multimesh, 0); return multimesh->instances; } void MeshStorage::multimesh_set_mesh(RID p_multimesh, RID p_mesh) { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND(!multimesh); + ERR_FAIL_NULL(multimesh); if (multimesh->mesh == p_mesh) { return; } @@ -1599,7 +1599,7 @@ void MeshStorage::_multimesh_re_create_aabb(MultiMesh *multimesh, const float *p void MeshStorage::multimesh_instance_set_transform(RID p_multimesh, int p_index, const Transform3D &p_transform) { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND(!multimesh); + ERR_FAIL_NULL(multimesh); ERR_FAIL_INDEX(p_index, multimesh->instances); ERR_FAIL_COND(multimesh->xform_format != RS::MULTIMESH_TRANSFORM_3D); @@ -1636,7 +1636,7 @@ void MeshStorage::multimesh_instance_set_transform(RID p_multimesh, int p_index, void MeshStorage::multimesh_instance_set_transform_2d(RID p_multimesh, int p_index, const Transform2D &p_transform) { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND(!multimesh); + ERR_FAIL_NULL(multimesh); ERR_FAIL_INDEX(p_index, multimesh->instances); ERR_FAIL_COND(multimesh->xform_format != RS::MULTIMESH_TRANSFORM_2D); @@ -1663,7 +1663,7 @@ void MeshStorage::multimesh_instance_set_transform_2d(RID p_multimesh, int p_ind void MeshStorage::multimesh_instance_set_color(RID p_multimesh, int p_index, const Color &p_color) { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND(!multimesh); + ERR_FAIL_NULL(multimesh); ERR_FAIL_INDEX(p_index, multimesh->instances); ERR_FAIL_COND(!multimesh->uses_colors); @@ -1686,7 +1686,7 @@ void MeshStorage::multimesh_instance_set_color(RID p_multimesh, int p_index, con void MeshStorage::multimesh_instance_set_custom_data(RID p_multimesh, int p_index, const Color &p_color) { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND(!multimesh); + ERR_FAIL_NULL(multimesh); ERR_FAIL_INDEX(p_index, multimesh->instances); ERR_FAIL_COND(!multimesh->uses_custom_data); @@ -1709,21 +1709,21 @@ void MeshStorage::multimesh_instance_set_custom_data(RID p_multimesh, int p_inde RID MeshStorage::multimesh_get_mesh(RID p_multimesh) const { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND_V(!multimesh, RID()); + ERR_FAIL_NULL_V(multimesh, RID()); return multimesh->mesh; } Dependency *MeshStorage::multimesh_get_dependency(RID p_multimesh) const { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND_V(!multimesh, nullptr); + ERR_FAIL_NULL_V(multimesh, nullptr); return &multimesh->dependency; } Transform3D MeshStorage::multimesh_instance_get_transform(RID p_multimesh, int p_index) const { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND_V(!multimesh, Transform3D()); + ERR_FAIL_NULL_V(multimesh, Transform3D()); ERR_FAIL_INDEX_V(p_index, multimesh->instances, Transform3D()); ERR_FAIL_COND_V(multimesh->xform_format != RS::MULTIMESH_TRANSFORM_3D, Transform3D()); @@ -1754,7 +1754,7 @@ Transform3D MeshStorage::multimesh_instance_get_transform(RID p_multimesh, int p Transform2D MeshStorage::multimesh_instance_get_transform_2d(RID p_multimesh, int p_index) const { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND_V(!multimesh, Transform2D()); + ERR_FAIL_NULL_V(multimesh, Transform2D()); ERR_FAIL_INDEX_V(p_index, multimesh->instances, Transform2D()); ERR_FAIL_COND_V(multimesh->xform_format != RS::MULTIMESH_TRANSFORM_2D, Transform2D()); @@ -1779,7 +1779,7 @@ Transform2D MeshStorage::multimesh_instance_get_transform_2d(RID p_multimesh, in Color MeshStorage::multimesh_instance_get_color(RID p_multimesh, int p_index) const { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND_V(!multimesh, Color()); + ERR_FAIL_NULL_V(multimesh, Color()); ERR_FAIL_INDEX_V(p_index, multimesh->instances, Color()); ERR_FAIL_COND_V(!multimesh->uses_colors, Color()); @@ -1802,7 +1802,7 @@ Color MeshStorage::multimesh_instance_get_color(RID p_multimesh, int p_index) co Color MeshStorage::multimesh_instance_get_custom_data(RID p_multimesh, int p_index) const { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND_V(!multimesh, Color()); + ERR_FAIL_NULL_V(multimesh, Color()); ERR_FAIL_INDEX_V(p_index, multimesh->instances, Color()); ERR_FAIL_COND_V(!multimesh->uses_custom_data, Color()); @@ -1825,7 +1825,7 @@ Color MeshStorage::multimesh_instance_get_custom_data(RID p_multimesh, int p_ind void MeshStorage::multimesh_set_buffer(RID p_multimesh, const Vector &p_buffer) { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND(!multimesh); + ERR_FAIL_NULL(multimesh); ERR_FAIL_COND(p_buffer.size() != (multimesh->instances * (int)multimesh->stride_cache)); bool uses_motion_vectors = (RSG::viewport->get_num_viewports_with_motion_vectors() > 0); @@ -1864,7 +1864,7 @@ void MeshStorage::multimesh_set_buffer(RID p_multimesh, const Vector &p_b Vector MeshStorage::multimesh_get_buffer(RID p_multimesh) const { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND_V(!multimesh, Vector()); + ERR_FAIL_NULL_V(multimesh, Vector()); if (multimesh->buffer.is_null()) { return Vector(); } else { @@ -1886,7 +1886,7 @@ Vector MeshStorage::multimesh_get_buffer(RID p_multimesh) const { void MeshStorage::multimesh_set_visible_instances(RID p_multimesh, int p_visible) { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND(!multimesh); + ERR_FAIL_NULL(multimesh); ERR_FAIL_COND(p_visible < -1 || p_visible > multimesh->instances); if (multimesh->visible_instances == p_visible) { return; @@ -1908,13 +1908,13 @@ void MeshStorage::multimesh_set_visible_instances(RID p_multimesh, int p_visible int MeshStorage::multimesh_get_visible_instances(RID p_multimesh) const { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND_V(!multimesh, 0); + ERR_FAIL_NULL_V(multimesh, 0); return multimesh->visible_instances; } AABB MeshStorage::multimesh_get_aabb(RID p_multimesh) const { MultiMesh *multimesh = multimesh_owner.get_or_null(p_multimesh); - ERR_FAIL_COND_V(!multimesh, AABB()); + ERR_FAIL_NULL_V(multimesh, AABB()); if (multimesh->aabb_dirty) { const_cast(this)->_update_dirty_multimeshes(); } @@ -2004,7 +2004,7 @@ void MeshStorage::_skeleton_make_dirty(Skeleton *skeleton) { void MeshStorage::skeleton_allocate_data(RID p_skeleton, int p_bones, bool p_2d_skeleton) { Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton); - ERR_FAIL_COND(!skeleton); + ERR_FAIL_NULL(skeleton); ERR_FAIL_COND(p_bones < 0); if (skeleton->size == p_bones && skeleton->use_2d == p_2d_skeleton) { @@ -2047,7 +2047,7 @@ void MeshStorage::skeleton_allocate_data(RID p_skeleton, int p_bones, bool p_2d_ int MeshStorage::skeleton_get_bone_count(RID p_skeleton) const { Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton); - ERR_FAIL_COND_V(!skeleton, 0); + ERR_FAIL_NULL_V(skeleton, 0); return skeleton->size; } @@ -2055,7 +2055,7 @@ int MeshStorage::skeleton_get_bone_count(RID p_skeleton) const { void MeshStorage::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform3D &p_transform) { Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton); - ERR_FAIL_COND(!skeleton); + ERR_FAIL_NULL(skeleton); ERR_FAIL_INDEX(p_bone, skeleton->size); ERR_FAIL_COND(skeleton->use_2d); @@ -2080,7 +2080,7 @@ void MeshStorage::skeleton_bone_set_transform(RID p_skeleton, int p_bone, const Transform3D MeshStorage::skeleton_bone_get_transform(RID p_skeleton, int p_bone) const { Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton); - ERR_FAIL_COND_V(!skeleton, Transform3D()); + ERR_FAIL_NULL_V(skeleton, Transform3D()); ERR_FAIL_INDEX_V(p_bone, skeleton->size, Transform3D()); ERR_FAIL_COND_V(skeleton->use_2d, Transform3D()); @@ -2107,7 +2107,7 @@ Transform3D MeshStorage::skeleton_bone_get_transform(RID p_skeleton, int p_bone) void MeshStorage::skeleton_bone_set_transform_2d(RID p_skeleton, int p_bone, const Transform2D &p_transform) { Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton); - ERR_FAIL_COND(!skeleton); + ERR_FAIL_NULL(skeleton); ERR_FAIL_INDEX(p_bone, skeleton->size); ERR_FAIL_COND(!skeleton->use_2d); @@ -2128,7 +2128,7 @@ void MeshStorage::skeleton_bone_set_transform_2d(RID p_skeleton, int p_bone, con Transform2D MeshStorage::skeleton_bone_get_transform_2d(RID p_skeleton, int p_bone) const { Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton); - ERR_FAIL_COND_V(!skeleton, Transform2D()); + ERR_FAIL_NULL_V(skeleton, Transform2D()); ERR_FAIL_INDEX_V(p_bone, skeleton->size, Transform2D()); ERR_FAIL_COND_V(!skeleton->use_2d, Transform2D()); @@ -2177,7 +2177,7 @@ void MeshStorage::_update_dirty_skeletons() { void MeshStorage::skeleton_update_dependency(RID p_skeleton, DependencyTracker *p_instance) { Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton); - ERR_FAIL_COND(!skeleton); + ERR_FAIL_NULL(skeleton); p_instance->update_dependency(&skeleton->dependency); } diff --git a/servers/rendering/renderer_rd/storage_rd/mesh_storage.h b/servers/rendering/renderer_rd/storage_rd/mesh_storage.h index ba973b92a76..86e81d56cc3 100644 --- a/servers/rendering/renderer_rd/storage_rd/mesh_storage.h +++ b/servers/rendering/renderer_rd/storage_rd/mesh_storage.h @@ -377,7 +377,7 @@ public: _FORCE_INLINE_ const RID *mesh_get_surface_count_and_materials(RID p_mesh, uint32_t &r_surface_count) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, nullptr); + ERR_FAIL_NULL_V(mesh, nullptr); r_surface_count = mesh->surface_count; if (r_surface_count == 0) { return nullptr; @@ -394,7 +394,7 @@ public: _FORCE_INLINE_ void *mesh_get_surface(RID p_mesh, uint32_t p_surface_index) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, nullptr); + ERR_FAIL_NULL_V(mesh, nullptr); ERR_FAIL_UNSIGNED_INDEX_V(p_surface_index, mesh->surface_count, nullptr); return mesh->surfaces[p_surface_index]; @@ -402,7 +402,7 @@ public: _FORCE_INLINE_ RID mesh_get_shadow_mesh(RID p_mesh) { Mesh *mesh = mesh_owner.get_or_null(p_mesh); - ERR_FAIL_COND_V(!mesh, RID()); + ERR_FAIL_NULL_V(mesh, RID()); return mesh->shadow_mesh; } @@ -486,7 +486,7 @@ public: _FORCE_INLINE_ void mesh_instance_surface_get_vertex_arrays_and_format(RID p_mesh_instance, uint32_t p_surface_index, uint32_t p_input_mask, bool p_input_motion_vectors, RID &r_vertex_array_rd, RD::VertexFormatID &r_vertex_format) { MeshInstance *mi = mesh_instance_owner.get_or_null(p_mesh_instance); - ERR_FAIL_COND(!mi); + ERR_FAIL_NULL(mi); Mesh *mesh = mi->mesh; ERR_FAIL_UNSIGNED_INDEX(p_surface_index, mesh->surface_count); @@ -719,7 +719,7 @@ public: _FORCE_INLINE_ RID skeleton_get_3d_uniform_set(RID p_skeleton, RID p_shader, uint32_t p_set) const { Skeleton *skeleton = skeleton_owner.get_or_null(p_skeleton); - ERR_FAIL_COND_V(!skeleton, RID()); + ERR_FAIL_NULL_V(skeleton, RID()); if (skeleton->size == 0) { return RID(); } diff --git a/servers/rendering/renderer_rd/storage_rd/particles_storage.cpp b/servers/rendering/renderer_rd/storage_rd/particles_storage.cpp index 9f1b2d8c388..bf5a597bb93 100644 --- a/servers/rendering/renderer_rd/storage_rd/particles_storage.cpp +++ b/servers/rendering/renderer_rd/storage_rd/particles_storage.cpp @@ -234,7 +234,7 @@ void ParticlesStorage::particles_free(RID p_rid) { void ParticlesStorage::particles_set_mode(RID p_particles, RS::ParticlesMode p_mode) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); if (particles->mode == p_mode) { return; } @@ -246,7 +246,7 @@ void ParticlesStorage::particles_set_mode(RID p_particles, RS::ParticlesMode p_m void ParticlesStorage::particles_set_emitting(RID p_particles, bool p_emitting) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->emitting = p_emitting; } @@ -254,7 +254,7 @@ void ParticlesStorage::particles_set_emitting(RID p_particles, bool p_emitting) bool ParticlesStorage::particles_get_emitting(RID p_particles) { ERR_FAIL_COND_V_MSG(RSG::threaded, false, "This function should never be used with threaded rendering, as it stalls the renderer."); Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, false); + ERR_FAIL_NULL_V(particles, false); return particles->emitting; } @@ -311,7 +311,7 @@ void ParticlesStorage::_particles_free_data(Particles *particles) { void ParticlesStorage::particles_set_amount(RID p_particles, int p_amount) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); if (particles->amount == p_amount) { return; @@ -331,48 +331,48 @@ void ParticlesStorage::particles_set_amount(RID p_particles, int p_amount) { void ParticlesStorage::particles_set_lifetime(RID p_particles, double p_lifetime) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->lifetime = p_lifetime; } void ParticlesStorage::particles_set_one_shot(RID p_particles, bool p_one_shot) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->one_shot = p_one_shot; } void ParticlesStorage::particles_set_pre_process_time(RID p_particles, double p_time) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->pre_process_time = p_time; } void ParticlesStorage::particles_set_explosiveness_ratio(RID p_particles, real_t p_ratio) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->explosiveness = p_ratio; } void ParticlesStorage::particles_set_randomness_ratio(RID p_particles, real_t p_ratio) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->randomness = p_ratio; } void ParticlesStorage::particles_set_custom_aabb(RID p_particles, const AABB &p_aabb) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->custom_aabb = p_aabb; particles->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_AABB); } void ParticlesStorage::particles_set_speed_scale(RID p_particles, double p_scale) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->speed_scale = p_scale; } void ParticlesStorage::particles_set_use_local_coordinates(RID p_particles, bool p_enable) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->use_local_coords = p_enable; particles->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_PARTICLES); @@ -380,7 +380,7 @@ void ParticlesStorage::particles_set_use_local_coordinates(RID p_particles, bool void ParticlesStorage::particles_set_fixed_fps(RID p_particles, int p_fps) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->fixed_fps = p_fps; @@ -396,21 +396,21 @@ void ParticlesStorage::particles_set_fixed_fps(RID p_particles, int p_fps) { void ParticlesStorage::particles_set_interpolate(RID p_particles, bool p_enable) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->interpolate = p_enable; } void ParticlesStorage::particles_set_fractional_delta(RID p_particles, bool p_enable) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->fractional_delta = p_enable; } void ParticlesStorage::particles_set_trails(RID p_particles, bool p_enable, double p_length) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); ERR_FAIL_COND(p_length < 0.01); p_length = MIN(10.0, p_length); @@ -429,7 +429,7 @@ void ParticlesStorage::particles_set_trails(RID p_particles, bool p_enable, doub void ParticlesStorage::particles_set_trail_bind_poses(RID p_particles, const Vector &p_bind_poses) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); if (particles->trail_bind_pose_buffer.is_valid() && particles->trail_bind_poses.size() != p_bind_poses.size()) { _particles_free_data(particles); @@ -446,21 +446,21 @@ void ParticlesStorage::particles_set_trail_bind_poses(RID p_particles, const Vec void ParticlesStorage::particles_set_collision_base_size(RID p_particles, real_t p_size) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->collision_base_size = p_size; } void ParticlesStorage::particles_set_transform_align(RID p_particles, RS::ParticlesTransformAlign p_transform_align) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->transform_align = p_transform_align; } void ParticlesStorage::particles_set_process_material(RID p_particles, RID p_material) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->process_material = p_material; particles->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_PARTICLES); //the instance buffer may have changed @@ -468,35 +468,35 @@ void ParticlesStorage::particles_set_process_material(RID p_particles, RID p_mat RID ParticlesStorage::particles_get_process_material(RID p_particles) const { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, RID()); + ERR_FAIL_NULL_V(particles, RID()); return particles->process_material; } void ParticlesStorage::particles_set_draw_order(RID p_particles, RS::ParticlesDrawOrder p_order) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->draw_order = p_order; } void ParticlesStorage::particles_set_draw_passes(RID p_particles, int p_passes) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->draw_passes.resize(p_passes); } void ParticlesStorage::particles_set_draw_pass_mesh(RID p_particles, int p_pass, RID p_mesh) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); ERR_FAIL_INDEX(p_pass, particles->draw_passes.size()); particles->draw_passes.write[p_pass] = p_mesh; } void ParticlesStorage::particles_restart(RID p_particles) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->restart_request = true; } @@ -520,7 +520,7 @@ void ParticlesStorage::_particles_allocate_emission_buffer(Particles *particles) void ParticlesStorage::particles_set_subemitter(RID p_particles, RID p_subemitter_particles) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); ERR_FAIL_COND(p_particles == p_subemitter_particles); particles->sub_emitter = p_subemitter_particles; @@ -533,7 +533,7 @@ void ParticlesStorage::particles_set_subemitter(RID p_particles, RID p_subemitte void ParticlesStorage::particles_emit(RID p_particles, const Transform3D &p_transform, const Vector3 &p_velocity, const Color &p_color, const Color &p_custom, uint32_t p_emit_flags) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); ERR_FAIL_COND(particles->amount == 0); if (particles->emitting) { @@ -573,7 +573,7 @@ void ParticlesStorage::particles_emit(RID p_particles, const Transform3D &p_tran void ParticlesStorage::particles_request_process(RID p_particles) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); if (!particles->dirty) { particles->dirty = true; @@ -588,7 +588,7 @@ AABB ParticlesStorage::particles_get_current_aabb(RID p_particles) { } const Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, AABB()); + ERR_FAIL_NULL_V(particles, AABB()); int total_amount = particles->amount; if (particles->trails_enabled && particles->trail_bind_poses.size() > 1) { @@ -639,28 +639,28 @@ AABB ParticlesStorage::particles_get_current_aabb(RID p_particles) { AABB ParticlesStorage::particles_get_aabb(RID p_particles) const { const Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, AABB()); + ERR_FAIL_NULL_V(particles, AABB()); return particles->custom_aabb; } void ParticlesStorage::particles_set_emission_transform(RID p_particles, const Transform3D &p_transform) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->emission_transform = p_transform; } int ParticlesStorage::particles_get_draw_passes(RID p_particles) const { const Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, 0); + ERR_FAIL_NULL_V(particles, 0); return particles->draw_passes.size(); } RID ParticlesStorage::particles_get_draw_pass_mesh(RID p_particles, int p_pass) const { const Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, RID()); + ERR_FAIL_NULL_V(particles, RID()); ERR_FAIL_INDEX_V(p_pass, particles->draw_passes.size(), RID()); return particles->draw_passes[p_pass]; @@ -668,32 +668,32 @@ RID ParticlesStorage::particles_get_draw_pass_mesh(RID p_particles, int p_pass) void ParticlesStorage::particles_update_dependency(RID p_particles, DependencyTracker *p_instance) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); p_instance->update_dependency(&particles->dependency); } void ParticlesStorage::particles_get_instance_buffer_motion_vectors_offsets(RID p_particles, uint32_t &r_current_offset, uint32_t &r_prev_offset) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); r_current_offset = particles->instance_motion_vectors_current_offset; r_prev_offset = particles->instance_motion_vectors_previous_offset; } void ParticlesStorage::particles_add_collision(RID p_particles, RID p_particles_collision_instance) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->collisions.insert(p_particles_collision_instance); } void ParticlesStorage::particles_remove_collision(RID p_particles, RID p_particles_collision_instance) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->collisions.erase(p_particles_collision_instance); } void ParticlesStorage::particles_set_canvas_sdf_collision(RID p_particles, bool p_enable, const Transform2D &p_xform, const Rect2 &p_to_screen, RID p_texture) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); particles->has_sdf_collision = p_enable; particles->sdf_collision_transform = p_xform; particles->sdf_collision_to_screen = p_to_screen; @@ -1106,7 +1106,7 @@ void ParticlesStorage::_particles_process(Particles *p_particles, double p_delta m = static_cast(material_storage->material_get_data(particles_shader.default_material, MaterialStorage::SHADER_TYPE_PARTICLES)); } - ERR_FAIL_COND(!m); + ERR_FAIL_NULL(m); p_particles->has_collision_cache = m->shader_data->uses_collision; @@ -1142,7 +1142,7 @@ void ParticlesStorage::_particles_process(Particles *p_particles, double p_delta void ParticlesStorage::particles_set_view_axis(RID p_particles, const Vector3 &p_axis, const Vector3 &p_up_axis) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND(!particles); + ERR_FAIL_NULL(particles); if (particles->draw_order != RS::PARTICLES_DRAW_ORDER_VIEW_DEPTH && particles->transform_align != RS::PARTICLES_TRANSFORM_ALIGN_Z_BILLBOARD && particles->transform_align != RS::PARTICLES_TRANSFORM_ALIGN_Z_BILLBOARD_Y_TO_VELOCITY) { return; @@ -1590,7 +1590,7 @@ Dependency *ParticlesStorage::particles_get_dependency(RID p_particles) const { bool ParticlesStorage::particles_is_inactive(RID p_particles) const { ERR_FAIL_COND_V_MSG(RSG::threaded, false, "This function should never be used with threaded rendering, as it stalls the renderer."); const Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, false); + ERR_FAIL_NULL_V(particles, false); return !particles->emitting && particles->inactive; } @@ -1722,7 +1722,7 @@ void ParticlesStorage::particles_collision_free(RID p_rid) { RID ParticlesStorage::particles_collision_get_heightfield_framebuffer(RID p_particles_collision) const { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND_V(!particles_collision, RID()); + ERR_FAIL_NULL_V(particles_collision, RID()); ERR_FAIL_COND_V(particles_collision->type != RS::PARTICLES_COLLISION_TYPE_HEIGHTFIELD_COLLIDE, RID()); if (particles_collision->heightfield_texture == RID()) { @@ -1757,7 +1757,7 @@ RID ParticlesStorage::particles_collision_get_heightfield_framebuffer(RID p_part void ParticlesStorage::particles_collision_set_collision_type(RID p_particles_collision, RS::ParticlesCollisionType p_type) { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND(!particles_collision); + ERR_FAIL_NULL(particles_collision); if (p_type == particles_collision->type) { return; @@ -1773,13 +1773,13 @@ void ParticlesStorage::particles_collision_set_collision_type(RID p_particles_co void ParticlesStorage::particles_collision_set_cull_mask(RID p_particles_collision, uint32_t p_cull_mask) { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND(!particles_collision); + ERR_FAIL_NULL(particles_collision); particles_collision->cull_mask = p_cull_mask; } void ParticlesStorage::particles_collision_set_sphere_radius(RID p_particles_collision, real_t p_radius) { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND(!particles_collision); + ERR_FAIL_NULL(particles_collision); particles_collision->radius = p_radius; particles_collision->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_AABB); @@ -1787,7 +1787,7 @@ void ParticlesStorage::particles_collision_set_sphere_radius(RID p_particles_col void ParticlesStorage::particles_collision_set_box_extents(RID p_particles_collision, const Vector3 &p_extents) { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND(!particles_collision); + ERR_FAIL_NULL(particles_collision); particles_collision->extents = p_extents; particles_collision->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_AABB); @@ -1795,41 +1795,41 @@ void ParticlesStorage::particles_collision_set_box_extents(RID p_particles_colli void ParticlesStorage::particles_collision_set_attractor_strength(RID p_particles_collision, real_t p_strength) { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND(!particles_collision); + ERR_FAIL_NULL(particles_collision); particles_collision->attractor_strength = p_strength; } void ParticlesStorage::particles_collision_set_attractor_directionality(RID p_particles_collision, real_t p_directionality) { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND(!particles_collision); + ERR_FAIL_NULL(particles_collision); particles_collision->attractor_directionality = p_directionality; } void ParticlesStorage::particles_collision_set_attractor_attenuation(RID p_particles_collision, real_t p_curve) { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND(!particles_collision); + ERR_FAIL_NULL(particles_collision); particles_collision->attractor_attenuation = p_curve; } void ParticlesStorage::particles_collision_set_field_texture(RID p_particles_collision, RID p_texture) { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND(!particles_collision); + ERR_FAIL_NULL(particles_collision); particles_collision->field_texture = p_texture; } void ParticlesStorage::particles_collision_height_field_update(RID p_particles_collision) { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND(!particles_collision); + ERR_FAIL_NULL(particles_collision); particles_collision->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_AABB); } void ParticlesStorage::particles_collision_set_height_field_resolution(RID p_particles_collision, RS::ParticlesCollisionHeightfieldResolution p_resolution) { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND(!particles_collision); + ERR_FAIL_NULL(particles_collision); ERR_FAIL_INDEX(p_resolution, RS::PARTICLES_COLLISION_HEIGHTFIELD_RESOLUTION_MAX); if (particles_collision->heightfield_resolution == p_resolution) { @@ -1846,7 +1846,7 @@ void ParticlesStorage::particles_collision_set_height_field_resolution(RID p_par AABB ParticlesStorage::particles_collision_get_aabb(RID p_particles_collision) const { ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND_V(!particles_collision, AABB()); + ERR_FAIL_NULL_V(particles_collision, AABB()); switch (particles_collision->type) { case RS::PARTICLES_COLLISION_TYPE_SPHERE_ATTRACT: @@ -1867,13 +1867,13 @@ AABB ParticlesStorage::particles_collision_get_aabb(RID p_particles_collision) c Vector3 ParticlesStorage::particles_collision_get_extents(RID p_particles_collision) const { const ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND_V(!particles_collision, Vector3()); + ERR_FAIL_NULL_V(particles_collision, Vector3()); return particles_collision->extents; } bool ParticlesStorage::particles_collision_is_heightfield(RID p_particles_collision) const { const ParticlesCollision *particles_collision = particles_collision_owner.get_or_null(p_particles_collision); - ERR_FAIL_COND_V(!particles_collision, false); + ERR_FAIL_NULL_V(particles_collision, false); return particles_collision->type == RS::PARTICLES_COLLISION_TYPE_HEIGHTFIELD_COLLIDE; } @@ -1898,12 +1898,12 @@ void ParticlesStorage::particles_collision_instance_free(RID p_rid) { void ParticlesStorage::particles_collision_instance_set_transform(RID p_collision_instance, const Transform3D &p_transform) { ParticlesCollisionInstance *pci = particles_collision_instance_owner.get_or_null(p_collision_instance); - ERR_FAIL_COND(!pci); + ERR_FAIL_NULL(pci); pci->transform = p_transform; } void ParticlesStorage::particles_collision_instance_set_active(RID p_collision_instance, bool p_active) { ParticlesCollisionInstance *pci = particles_collision_instance_owner.get_or_null(p_collision_instance); - ERR_FAIL_COND(!pci); + ERR_FAIL_NULL(pci); pci->active = p_active; } diff --git a/servers/rendering/renderer_rd/storage_rd/particles_storage.h b/servers/rendering/renderer_rd/storage_rd/particles_storage.h index 7cea706a8ca..b93932f482c 100644 --- a/servers/rendering/renderer_rd/storage_rd/particles_storage.h +++ b/servers/rendering/renderer_rd/storage_rd/particles_storage.h @@ -471,19 +471,19 @@ public: _FORCE_INLINE_ RS::ParticlesMode particles_get_mode(RID p_particles) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, RS::PARTICLES_MODE_2D); + ERR_FAIL_NULL_V(particles, RS::PARTICLES_MODE_2D); return particles->mode; } _FORCE_INLINE_ uint32_t particles_get_frame_counter(RID p_particles) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, false); + ERR_FAIL_NULL_V(particles, false); return particles->frame_counter; } _FORCE_INLINE_ uint32_t particles_get_amount(RID p_particles, uint32_t &r_trail_divisor) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, 0); + ERR_FAIL_NULL_V(particles, 0); if (particles->trails_enabled && particles->trail_bind_poses.size() > 1) { r_trail_divisor = particles->trail_bind_poses.size(); @@ -496,21 +496,21 @@ public: _FORCE_INLINE_ bool particles_has_collision(RID p_particles) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, 0); + ERR_FAIL_NULL_V(particles, 0); return particles->has_collision_cache; } _FORCE_INLINE_ uint32_t particles_is_using_local_coords(RID p_particles) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, false); + ERR_FAIL_NULL_V(particles, false); return particles->use_local_coords; } _FORCE_INLINE_ RID particles_get_instance_buffer_uniform_set(RID p_particles, RID p_shader, uint32_t p_set) { Particles *particles = particles_owner.get_or_null(p_particles); - ERR_FAIL_COND_V(!particles, RID()); + ERR_FAIL_NULL_V(particles, RID()); if (particles->particles_transforms_buffer_uniform_set.is_null() || !RD::get_singleton()->uniform_set_is_valid(particles->particles_transforms_buffer_uniform_set)) { _particles_update_buffers(particles); Vector uniforms; diff --git a/servers/rendering/renderer_rd/storage_rd/texture_storage.cpp b/servers/rendering/renderer_rd/storage_rd/texture_storage.cpp index 286a9528fcc..166b8508645 100644 --- a/servers/rendering/renderer_rd/storage_rd/texture_storage.cpp +++ b/servers/rendering/renderer_rd/storage_rd/texture_storage.cpp @@ -764,7 +764,7 @@ RID TextureStorage::texture_allocate() { void TextureStorage::texture_free(RID p_texture) { Texture *t = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND(!t); + ERR_FAIL_NULL(t); ERR_FAIL_COND(t->is_render_target); t->cleanup(); @@ -1089,7 +1089,7 @@ void TextureStorage::texture_3d_initialize(RID p_texture, Image::Format p_format void TextureStorage::texture_proxy_initialize(RID p_texture, RID p_base) { Texture *tex = texture_owner.get_or_null(p_base); - ERR_FAIL_COND(!tex); + ERR_FAIL_NULL(tex); Texture proxy_tex = *tex; proxy_tex.rd_view.format_override = tex->rd_format; @@ -1112,7 +1112,7 @@ void TextureStorage::_texture_2d_update(RID p_texture, const Ref &p_image ERR_FAIL_COND(p_image.is_null() || p_image->is_empty()); Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND(!tex); + ERR_FAIL_NULL(tex); ERR_FAIL_COND(tex->is_render_target); ERR_FAIL_COND(p_image->get_width() != tex->width || p_image->get_height() != tex->height); ERR_FAIL_COND(p_image->get_format() != tex->format); @@ -1136,7 +1136,7 @@ void TextureStorage::texture_2d_update(RID p_texture, const Ref &p_image, void TextureStorage::texture_3d_update(RID p_texture, const Vector> &p_data) { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND(!tex); + ERR_FAIL_NULL(tex); ERR_FAIL_COND(tex->type != TextureStorage::TYPE_3D); Image::Image3DValidateError verr = Image::validate_3d_image(tex->format, tex->width, tex->height, tex->depth, tex->mipmaps > 1, p_data); @@ -1174,10 +1174,10 @@ void TextureStorage::texture_3d_update(RID p_texture, const Vector> & void TextureStorage::texture_proxy_update(RID p_texture, RID p_proxy_to) { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND(!tex); + ERR_FAIL_NULL(tex); ERR_FAIL_COND(!tex->is_proxy); Texture *proxy_to = texture_owner.get_or_null(p_proxy_to); - ERR_FAIL_COND(!proxy_to); + ERR_FAIL_NULL(proxy_to); ERR_FAIL_COND(proxy_to->is_proxy); if (tex->proxy_to.is_valid()) { @@ -1191,7 +1191,7 @@ void TextureStorage::texture_proxy_update(RID p_texture, RID p_proxy_to) { tex->rd_texture_srgb = RID(); } Texture *prev_tex = texture_owner.get_or_null(tex->proxy_to); - ERR_FAIL_COND(!prev_tex); + ERR_FAIL_NULL(prev_tex); prev_tex->proxies.erase(p_texture); } @@ -1261,7 +1261,7 @@ void TextureStorage::texture_3d_placeholder_initialize(RID p_texture) { Ref TextureStorage::texture_2d_get(RID p_texture) const { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND_V(!tex, Ref()); + ERR_FAIL_NULL_V(tex, Ref()); #ifdef TOOLS_ENABLED if (tex->image_cache_2d.is_valid() && !tex->is_render_target) { @@ -1315,7 +1315,7 @@ Ref TextureStorage::texture_2d_get(RID p_texture) const { Ref TextureStorage::texture_2d_layer_get(RID p_texture, int p_layer) const { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND_V(!tex, Ref()); + ERR_FAIL_NULL_V(tex, Ref()); Vector data = RD::get_singleton()->texture_get_data(tex->rd_texture, p_layer); ERR_FAIL_COND_V(data.size() == 0, Ref()); @@ -1330,7 +1330,7 @@ Ref TextureStorage::texture_2d_layer_get(RID p_texture, int p_layer) cons Vector> TextureStorage::texture_3d_get(RID p_texture) const { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND_V(!tex, Vector>()); + ERR_FAIL_NULL_V(tex, Vector>()); ERR_FAIL_COND_V(tex->type != TextureStorage::TYPE_3D, Vector>()); Vector all_data = RD::get_singleton()->texture_get_data(tex->rd_texture, 0); @@ -1359,10 +1359,10 @@ Vector> TextureStorage::texture_3d_get(RID p_texture) const { void TextureStorage::texture_replace(RID p_texture, RID p_by_texture) { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND(!tex); + ERR_FAIL_NULL(tex); ERR_FAIL_COND(tex->proxy_to.is_valid()); //can't replace proxy Texture *by_tex = texture_owner.get_or_null(p_by_texture); - ERR_FAIL_COND(!by_tex); + ERR_FAIL_NULL(by_tex); ERR_FAIL_COND(by_tex->proxy_to.is_valid()); //can't replace proxy if (tex == by_tex) { @@ -1404,7 +1404,7 @@ void TextureStorage::texture_replace(RID p_texture, RID p_by_texture) { void TextureStorage::texture_set_size_override(RID p_texture, int p_width, int p_height) { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND(!tex); + ERR_FAIL_NULL(tex); ERR_FAIL_COND(tex->type != TextureStorage::TYPE_2D); tex->width_2d = p_width; @@ -1413,28 +1413,28 @@ void TextureStorage::texture_set_size_override(RID p_texture, int p_width, int p void TextureStorage::texture_set_path(RID p_texture, const String &p_path) { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND(!tex); + ERR_FAIL_NULL(tex); tex->path = p_path; } String TextureStorage::texture_get_path(RID p_texture) const { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND_V(!tex, String()); + ERR_FAIL_NULL_V(tex, String()); return tex->path; } Image::Format TextureStorage::texture_get_format(RID p_texture) const { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND_V(!tex, Image::FORMAT_MAX); + ERR_FAIL_NULL_V(tex, Image::FORMAT_MAX); return tex->format; } void TextureStorage::texture_set_detect_3d_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND(!tex); + ERR_FAIL_NULL(tex); tex->detect_3d_callback_ud = p_userdata; tex->detect_3d_callback = p_callback; @@ -1442,7 +1442,7 @@ void TextureStorage::texture_set_detect_3d_callback(RID p_texture, RS::TextureDe void TextureStorage::texture_set_detect_normal_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND(!tex); + ERR_FAIL_NULL(tex); tex->detect_normal_callback_ud = p_userdata; tex->detect_normal_callback = p_callback; @@ -1450,7 +1450,7 @@ void TextureStorage::texture_set_detect_normal_callback(RID p_texture, RS::Textu void TextureStorage::texture_set_detect_roughness_callback(RID p_texture, RS::TextureDetectRoughnessCallback p_callback, void *p_userdata) { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND(!tex); + ERR_FAIL_NULL(tex); tex->detect_roughness_callback_ud = p_userdata; tex->detect_roughness_callback = p_callback; @@ -1554,7 +1554,7 @@ RID TextureStorage::texture_get_rd_texture(RID p_texture, bool p_srgb) const { uint64_t TextureStorage::texture_get_native_handle(RID p_texture, bool p_srgb) const { Texture *tex = texture_owner.get_or_null(p_texture); - ERR_FAIL_COND_V(!tex, 0); + ERR_FAIL_NULL_V(tex, 0); if (p_srgb && tex->rd_texture_srgb.is_valid()) { return RD::get_singleton()->texture_get_native_handle(tex->rd_texture_srgb); @@ -2418,14 +2418,14 @@ void TextureStorage::decal_free(RID p_rid) { void TextureStorage::decal_set_size(RID p_decal, const Vector3 &p_size) { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND(!decal); + ERR_FAIL_NULL(decal); decal->size = p_size; decal->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_AABB); } void TextureStorage::decal_set_texture(RID p_decal, RS::DecalTexture p_type, RID p_texture) { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND(!decal); + ERR_FAIL_NULL(decal); ERR_FAIL_INDEX(p_type, RS::DECAL_TEXTURE_MAX); if (decal->textures[p_type] == p_texture) { @@ -2449,32 +2449,32 @@ void TextureStorage::decal_set_texture(RID p_decal, RS::DecalTexture p_type, RID void TextureStorage::decal_set_emission_energy(RID p_decal, float p_energy) { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND(!decal); + ERR_FAIL_NULL(decal); decal->emission_energy = p_energy; } void TextureStorage::decal_set_albedo_mix(RID p_decal, float p_mix) { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND(!decal); + ERR_FAIL_NULL(decal); decal->albedo_mix = p_mix; } void TextureStorage::decal_set_modulate(RID p_decal, const Color &p_modulate) { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND(!decal); + ERR_FAIL_NULL(decal); decal->modulate = p_modulate; } void TextureStorage::decal_set_cull_mask(RID p_decal, uint32_t p_layers) { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND(!decal); + ERR_FAIL_NULL(decal); decal->cull_mask = p_layers; decal->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_DECAL); } void TextureStorage::decal_set_distance_fade(RID p_decal, bool p_enabled, float p_begin, float p_length) { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND(!decal); + ERR_FAIL_NULL(decal); decal->distance_fade = p_enabled; decal->distance_fade_begin = p_begin; decal->distance_fade_length = p_length; @@ -2482,14 +2482,14 @@ void TextureStorage::decal_set_distance_fade(RID p_decal, bool p_enabled, float void TextureStorage::decal_set_fade(RID p_decal, float p_above, float p_below) { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND(!decal); + ERR_FAIL_NULL(decal); decal->upper_fade = p_above; decal->lower_fade = p_below; } void TextureStorage::decal_set_normal_fade(RID p_decal, float p_fade) { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND(!decal); + ERR_FAIL_NULL(decal); decal->normal_fade = p_fade; } @@ -2510,21 +2510,21 @@ void TextureStorage::decal_atlas_remove_texture(RID p_texture) { AABB TextureStorage::decal_get_aabb(RID p_decal) const { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND_V(!decal, AABB()); + ERR_FAIL_NULL_V(decal, AABB()); return AABB(-decal->size / 2, decal->size); } uint32_t TextureStorage::decal_get_cull_mask(RID p_decal) const { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND_V(!decal, 0); + ERR_FAIL_NULL_V(decal, 0); return decal->cull_mask; } Dependency *TextureStorage::decal_get_dependency(RID p_decal) { Decal *decal = decal_owner.get_or_null(p_decal); - ERR_FAIL_COND_V(!decal, nullptr); + ERR_FAIL_NULL_V(decal, nullptr); return &decal->dependency; } @@ -2742,7 +2742,7 @@ void TextureStorage::texture_add_to_decal_atlas(RID p_texture, bool p_panorama_t void TextureStorage::texture_remove_from_decal_atlas(RID p_texture, bool p_panorama_to_dp) { DecalAtlas::Texture *t = decal_atlas.textures.getptr(p_texture); - ERR_FAIL_COND(!t); + ERR_FAIL_NULL(t); t->users--; if (p_panorama_to_dp) { ERR_FAIL_COND(t->panorama_to_dp_users == 0); @@ -2771,13 +2771,13 @@ void TextureStorage::decal_instance_free(RID p_decal_instance) { void TextureStorage::decal_instance_set_transform(RID p_decal_instance, const Transform3D &p_transform) { DecalInstance *di = decal_instance_owner.get_or_null(p_decal_instance); - ERR_FAIL_COND(!di); + ERR_FAIL_NULL(di); di->transform = p_transform; } void TextureStorage::decal_instance_set_sorting_offset(RID p_decal_instance, float p_sorting_offset) { DecalInstance *di = decal_instance_owner.get_or_null(p_decal_instance); - ERR_FAIL_COND(!di); + ERR_FAIL_NULL(di); di->sorting_offset = p_sorting_offset; } @@ -3222,7 +3222,7 @@ Point2i TextureStorage::render_target_get_position(RID p_render_target) const { void TextureStorage::render_target_set_size(RID p_render_target, int p_width, int p_height, uint32_t p_view_count) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); if (rt->size.x != p_width || rt->size.y != p_height || rt->view_count != p_view_count) { rt->size.x = p_width; rt->size.y = p_height; @@ -3233,21 +3233,21 @@ void TextureStorage::render_target_set_size(RID p_render_target, int p_width, in Size2i TextureStorage::render_target_get_size(RID p_render_target) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, Size2i()); + ERR_FAIL_NULL_V(rt, Size2i()); return rt->size; } RID TextureStorage::render_target_get_texture(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); return rt->texture; } void TextureStorage::render_target_set_override(RID p_render_target, RID p_color_texture, RID p_depth_texture, RID p_velocity_texture) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); rt->overridden.color = p_color_texture; rt->overridden.depth = p_depth_texture; @@ -3256,21 +3256,21 @@ void TextureStorage::render_target_set_override(RID p_render_target, RID p_color RID TextureStorage::render_target_get_override_color(RID p_render_target) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); return rt->overridden.color; } RID TextureStorage::render_target_get_override_depth(RID p_render_target) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); return rt->overridden.depth; } RID TextureStorage::render_target_get_override_depth_slice(RID p_render_target, const uint32_t p_layer) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); if (rt->overridden.depth.is_null()) { return RID(); @@ -3289,14 +3289,14 @@ RID TextureStorage::render_target_get_override_depth_slice(RID p_render_target, RID TextureStorage::render_target_get_override_velocity(RID p_render_target) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); return rt->overridden.velocity; } RID TextureStorage::render_target_get_override_velocity_slice(RID p_render_target, const uint32_t p_layer) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); if (rt->overridden.velocity.is_null()) { return RID(); @@ -3315,14 +3315,14 @@ RID TextureStorage::render_target_get_override_velocity_slice(RID p_render_targe void TextureStorage::render_target_set_transparent(RID p_render_target, bool p_is_transparent) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); rt->is_transparent = p_is_transparent; _update_render_target(rt); } bool TextureStorage::render_target_get_transparent(RID p_render_target) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, false); + ERR_FAIL_NULL_V(rt, false); return rt->is_transparent; } @@ -3336,19 +3336,19 @@ bool TextureStorage::render_target_get_direct_to_screen(RID p_render_target) con bool TextureStorage::render_target_was_used(RID p_render_target) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, false); + ERR_FAIL_NULL_V(rt, false); return rt->was_used; } void TextureStorage::render_target_set_as_unused(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); rt->was_used = false; } void TextureStorage::render_target_set_msaa(RID p_render_target, RS::ViewportMSAA p_msaa) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); if (p_msaa == rt->msaa) { return; } @@ -3359,14 +3359,14 @@ void TextureStorage::render_target_set_msaa(RID p_render_target, RS::ViewportMSA RS::ViewportMSAA TextureStorage::render_target_get_msaa(RID p_render_target) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RS::VIEWPORT_MSAA_DISABLED); + ERR_FAIL_NULL_V(rt, RS::VIEWPORT_MSAA_DISABLED); return rt->msaa; } void TextureStorage::render_target_set_use_hdr(RID p_render_target, bool p_use_hdr) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); if (p_use_hdr == rt->use_hdr) { return; @@ -3378,21 +3378,21 @@ void TextureStorage::render_target_set_use_hdr(RID p_render_target, bool p_use_h bool TextureStorage::render_target_is_using_hdr(RID p_render_target) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, false); + ERR_FAIL_NULL_V(rt, false); return rt->use_hdr; } RID TextureStorage::render_target_get_rd_framebuffer(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); return rt->get_framebuffer(); } RID TextureStorage::render_target_get_rd_texture(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); if (rt->overridden.color.is_valid()) { return rt->overridden.color; @@ -3403,7 +3403,7 @@ RID TextureStorage::render_target_get_rd_texture(RID p_render_target) { RID TextureStorage::render_target_get_rd_texture_slice(RID p_render_target, uint32_t p_layer) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); if (rt->view_count == 1) { return rt->color; @@ -3421,20 +3421,20 @@ RID TextureStorage::render_target_get_rd_texture_slice(RID p_render_target, uint RID TextureStorage::render_target_get_rd_texture_msaa(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); return rt->color_multisample; } RID TextureStorage::render_target_get_rd_backbuffer(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); return rt->backbuffer; } RID TextureStorage::render_target_get_rd_backbuffer_framebuffer(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); if (!rt->backbuffer.is_valid()) { _create_render_target_backbuffer(rt); @@ -3445,32 +3445,32 @@ RID TextureStorage::render_target_get_rd_backbuffer_framebuffer(RID p_render_tar void TextureStorage::render_target_request_clear(RID p_render_target, const Color &p_clear_color) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); rt->clear_requested = true; rt->clear_color = p_clear_color; } bool TextureStorage::render_target_is_clear_requested(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, false); + ERR_FAIL_NULL_V(rt, false); return rt->clear_requested; } Color TextureStorage::render_target_get_clear_request_color(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, Color()); + ERR_FAIL_NULL_V(rt, Color()); return rt->use_hdr ? rt->clear_color.srgb_to_linear() : rt->clear_color; } void TextureStorage::render_target_disable_clear_request(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); rt->clear_requested = false; } void TextureStorage::render_target_do_clear_request(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); if (!rt->clear_requested) { return; } @@ -3483,7 +3483,7 @@ void TextureStorage::render_target_do_clear_request(RID p_render_target) { void TextureStorage::render_target_set_sdf_size_and_scale(RID p_render_target, RS::ViewportSDFOversize p_size, RS::ViewportSDFScale p_scale) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); if (rt->sdf_oversize == p_size && rt->sdf_scale == p_scale) { return; } @@ -3525,28 +3525,28 @@ Rect2i TextureStorage::_render_target_get_sdf_rect(const RenderTarget *rt) const Rect2i TextureStorage::render_target_get_sdf_rect(RID p_render_target) const { const RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, Rect2i()); + ERR_FAIL_NULL_V(rt, Rect2i()); return _render_target_get_sdf_rect(rt); } void TextureStorage::render_target_mark_sdf_enabled(RID p_render_target, bool p_enabled) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); rt->sdf_enabled = p_enabled; } bool TextureStorage::render_target_is_sdf_enabled(RID p_render_target) const { const RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, false); + ERR_FAIL_NULL_V(rt, false); return rt->sdf_enabled; } RID TextureStorage::render_target_get_sdf_texture(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); if (rt->sdf_buffer_read.is_null()) { // no texture, create a dummy one for the 2D uniform set RD::TextureFormat tformat; @@ -3684,7 +3684,7 @@ void TextureStorage::_render_target_clear_sdf(RenderTarget *rt) { RID TextureStorage::render_target_get_sdf_framebuffer(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); if (rt->sdf_buffer_write_fb.is_null()) { _render_target_allocate_sdf(rt); @@ -3694,7 +3694,7 @@ RID TextureStorage::render_target_get_sdf_framebuffer(RID p_render_target) { } void TextureStorage::render_target_sdf_process(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); ERR_FAIL_COND(rt->sdf_buffer_write_fb.is_null()); RenderTargetSDF::PushConstant push_constant; @@ -3772,7 +3772,7 @@ void TextureStorage::render_target_copy_to_back_buffer(RID p_render_target, cons ERR_FAIL_NULL(copy_effects); RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); if (!rt->backbuffer.is_valid()) { _create_render_target_backbuffer(rt); } @@ -3825,7 +3825,7 @@ void TextureStorage::render_target_copy_to_back_buffer(RID p_render_target, cons void TextureStorage::render_target_clear_back_buffer(RID p_render_target, const Rect2i &p_region, const Color &p_color) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); CopyEffects *copy_effects = CopyEffects::get_singleton(); ERR_FAIL_NULL(copy_effects); @@ -3854,7 +3854,7 @@ void TextureStorage::render_target_clear_back_buffer(RID p_render_target, const void TextureStorage::render_target_gen_back_buffer_mipmaps(RID p_render_target, const Rect2i &p_region) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); CopyEffects *copy_effects = CopyEffects::get_singleton(); ERR_FAIL_NULL(copy_effects); @@ -3899,51 +3899,51 @@ void TextureStorage::render_target_gen_back_buffer_mipmaps(RID p_render_target, RID TextureStorage::render_target_get_framebuffer_uniform_set(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); return rt->framebuffer_uniform_set; } RID TextureStorage::render_target_get_backbuffer_uniform_set(RID p_render_target) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); return rt->backbuffer_uniform_set; } void TextureStorage::render_target_set_framebuffer_uniform_set(RID p_render_target, RID p_uniform_set) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); rt->framebuffer_uniform_set = p_uniform_set; } void TextureStorage::render_target_set_backbuffer_uniform_set(RID p_render_target, RID p_uniform_set) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); rt->backbuffer_uniform_set = p_uniform_set; } void TextureStorage::render_target_set_vrs_mode(RID p_render_target, RS::ViewportVRSMode p_mode) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); rt->vrs_mode = p_mode; } RS::ViewportVRSMode TextureStorage::render_target_get_vrs_mode(RID p_render_target) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RS::VIEWPORT_VRS_DISABLED); + ERR_FAIL_NULL_V(rt, RS::VIEWPORT_VRS_DISABLED); return rt->vrs_mode; } void TextureStorage::render_target_set_vrs_texture(RID p_render_target, RID p_texture) { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND(!rt); + ERR_FAIL_NULL(rt); rt->vrs_texture = p_texture; } RID TextureStorage::render_target_get_vrs_texture(RID p_render_target) const { RenderTarget *rt = render_target_owner.get_or_null(p_render_target); - ERR_FAIL_COND_V(!rt, RID()); + ERR_FAIL_NULL_V(rt, RID()); return rt->vrs_texture; } diff --git a/servers/rendering/renderer_rd/storage_rd/utilities.cpp b/servers/rendering/renderer_rd/storage_rd/utilities.cpp index cabac4e9eef..8df14d04dbc 100644 --- a/servers/rendering/renderer_rd/storage_rd/utilities.cpp +++ b/servers/rendering/renderer_rd/storage_rd/utilities.cpp @@ -175,27 +175,27 @@ void Utilities::visibility_notifier_free(RID p_notifier) { void Utilities::visibility_notifier_set_aabb(RID p_notifier, const AABB &p_aabb) { VisibilityNotifier *vn = visibility_notifier_owner.get_or_null(p_notifier); - ERR_FAIL_COND(!vn); + ERR_FAIL_NULL(vn); vn->aabb = p_aabb; vn->dependency.changed_notify(Dependency::DEPENDENCY_CHANGED_AABB); } void Utilities::visibility_notifier_set_callbacks(RID p_notifier, const Callable &p_enter_callbable, const Callable &p_exit_callable) { VisibilityNotifier *vn = visibility_notifier_owner.get_or_null(p_notifier); - ERR_FAIL_COND(!vn); + ERR_FAIL_NULL(vn); vn->enter_callback = p_enter_callbable; vn->exit_callback = p_exit_callable; } AABB Utilities::visibility_notifier_get_aabb(RID p_notifier) const { const VisibilityNotifier *vn = visibility_notifier_owner.get_or_null(p_notifier); - ERR_FAIL_COND_V(!vn, AABB()); + ERR_FAIL_NULL_V(vn, AABB()); return vn->aabb; } void Utilities::visibility_notifier_call(RID p_notifier, bool p_enter, bool p_deferred) { VisibilityNotifier *vn = visibility_notifier_owner.get_or_null(p_notifier); - ERR_FAIL_COND(!vn); + ERR_FAIL_NULL(vn); if (p_enter) { if (!vn->enter_callback.is_null()) { diff --git a/servers/rendering/renderer_scene_cull.cpp b/servers/rendering/renderer_scene_cull.cpp index cf7355945be..807eda0f2ab 100644 --- a/servers/rendering/renderer_scene_cull.cpp +++ b/servers/rendering/renderer_scene_cull.cpp @@ -63,7 +63,7 @@ void RendererSceneCull::camera_initialize(RID p_rid) { void RendererSceneCull::camera_set_perspective(RID p_camera, float p_fovy_degrees, float p_z_near, float p_z_far) { Camera *camera = camera_owner.get_or_null(p_camera); - ERR_FAIL_COND(!camera); + ERR_FAIL_NULL(camera); camera->type = Camera::PERSPECTIVE; camera->fov = p_fovy_degrees; camera->znear = p_z_near; @@ -72,7 +72,7 @@ void RendererSceneCull::camera_set_perspective(RID p_camera, float p_fovy_degree void RendererSceneCull::camera_set_orthogonal(RID p_camera, float p_size, float p_z_near, float p_z_far) { Camera *camera = camera_owner.get_or_null(p_camera); - ERR_FAIL_COND(!camera); + ERR_FAIL_NULL(camera); camera->type = Camera::ORTHOGONAL; camera->size = p_size; camera->znear = p_z_near; @@ -81,7 +81,7 @@ void RendererSceneCull::camera_set_orthogonal(RID p_camera, float p_size, float void RendererSceneCull::camera_set_frustum(RID p_camera, float p_size, Vector2 p_offset, float p_z_near, float p_z_far) { Camera *camera = camera_owner.get_or_null(p_camera); - ERR_FAIL_COND(!camera); + ERR_FAIL_NULL(camera); camera->type = Camera::FRUSTUM; camera->size = p_size; camera->offset = p_offset; @@ -91,32 +91,32 @@ void RendererSceneCull::camera_set_frustum(RID p_camera, float p_size, Vector2 p void RendererSceneCull::camera_set_transform(RID p_camera, const Transform3D &p_transform) { Camera *camera = camera_owner.get_or_null(p_camera); - ERR_FAIL_COND(!camera); + ERR_FAIL_NULL(camera); camera->transform = p_transform.orthonormalized(); } void RendererSceneCull::camera_set_cull_mask(RID p_camera, uint32_t p_layers) { Camera *camera = camera_owner.get_or_null(p_camera); - ERR_FAIL_COND(!camera); + ERR_FAIL_NULL(camera); camera->visible_layers = p_layers; } void RendererSceneCull::camera_set_environment(RID p_camera, RID p_env) { Camera *camera = camera_owner.get_or_null(p_camera); - ERR_FAIL_COND(!camera); + ERR_FAIL_NULL(camera); camera->env = p_env; } void RendererSceneCull::camera_set_camera_attributes(RID p_camera, RID p_attributes) { Camera *camera = camera_owner.get_or_null(p_camera); - ERR_FAIL_COND(!camera); + ERR_FAIL_NULL(camera); camera->attributes = p_attributes; } void RendererSceneCull::camera_set_use_vertical_aspect(RID p_camera, bool p_enable) { Camera *camera = camera_owner.get_or_null(p_camera); - ERR_FAIL_COND(!camera); + ERR_FAIL_NULL(camera); camera->vaspect = p_enable; } @@ -390,25 +390,25 @@ void RendererSceneCull::scenario_initialize(RID p_rid) { void RendererSceneCull::scenario_set_environment(RID p_scenario, RID p_environment) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); - ERR_FAIL_COND(!scenario); + ERR_FAIL_NULL(scenario); scenario->environment = p_environment; } void RendererSceneCull::scenario_set_camera_attributes(RID p_scenario, RID p_camera_attributes) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); - ERR_FAIL_COND(!scenario); + ERR_FAIL_NULL(scenario); scenario->camera_attributes = p_camera_attributes; } void RendererSceneCull::scenario_set_fallback_environment(RID p_scenario, RID p_environment) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); - ERR_FAIL_COND(!scenario); + ERR_FAIL_NULL(scenario); scenario->fallback_environment = p_environment; } void RendererSceneCull::scenario_set_reflection_atlas_size(RID p_scenario, int p_reflection_size, int p_reflection_count) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); - ERR_FAIL_COND(!scenario); + ERR_FAIL_NULL(scenario); RSG::light_storage->reflection_atlas_set_size(scenario->reflection_atlas, p_reflection_size, p_reflection_count); } @@ -418,13 +418,13 @@ bool RendererSceneCull::is_scenario(RID p_scenario) const { RID RendererSceneCull::scenario_get_environment(RID p_scenario) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); - ERR_FAIL_COND_V(!scenario, RID()); + ERR_FAIL_NULL_V(scenario, RID()); return scenario->environment; } void RendererSceneCull::scenario_remove_viewport_visibility_mask(RID p_scenario, RID p_viewport) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); - ERR_FAIL_COND(!scenario); + ERR_FAIL_NULL(scenario); if (!scenario->viewport_visibility_masks.has(p_viewport)) { return; } @@ -436,7 +436,7 @@ void RendererSceneCull::scenario_remove_viewport_visibility_mask(RID p_scenario, void RendererSceneCull::scenario_add_viewport_visibility_mask(RID p_scenario, RID p_viewport) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); - ERR_FAIL_COND(!scenario); + ERR_FAIL_NULL(scenario); ERR_FAIL_COND(scenario->viewport_visibility_masks.has(p_viewport)); uint64_t new_mask = 1; @@ -510,7 +510,7 @@ void RendererSceneCull::_instance_update_mesh_instance(Instance *p_instance) { void RendererSceneCull::instance_set_base(RID p_instance, RID p_base) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); Scenario *scenario = instance->scenario; @@ -753,7 +753,7 @@ void RendererSceneCull::instance_set_base(RID p_instance, RID p_base) { void RendererSceneCull::instance_set_scenario(RID p_instance, RID p_scenario) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); if (instance->scenario) { instance->scenario->instances.remove(&instance->scenario_item); @@ -819,7 +819,7 @@ void RendererSceneCull::instance_set_scenario(RID p_instance, RID p_scenario) { if (p_scenario.is_valid()) { Scenario *scenario = scenario_owner.get_or_null(p_scenario); - ERR_FAIL_COND(!scenario); + ERR_FAIL_NULL(scenario); instance->scenario = scenario; @@ -852,7 +852,7 @@ void RendererSceneCull::instance_set_scenario(RID p_instance, RID p_scenario) { void RendererSceneCull::instance_set_layer_mask(RID p_instance, uint32_t p_mask) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); if (instance->layer_mask == p_mask) { return; @@ -879,7 +879,7 @@ void RendererSceneCull::instance_set_layer_mask(RID p_instance, uint32_t p_mask) void RendererSceneCull::instance_set_pivot_data(RID p_instance, float p_sorting_offset, bool p_use_aabb_center) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); instance->sorting_offset = p_sorting_offset; instance->use_aabb_center = p_use_aabb_center; @@ -896,7 +896,7 @@ void RendererSceneCull::instance_set_pivot_data(RID p_instance, float p_sorting_ void RendererSceneCull::instance_geometry_set_transparency(RID p_instance, float p_transparency) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); instance->transparency = p_transparency; @@ -909,7 +909,7 @@ void RendererSceneCull::instance_geometry_set_transparency(RID p_instance, float void RendererSceneCull::instance_set_transform(RID p_instance, const Transform3D &p_transform) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); if (instance->transform == p_transform) { return; //must be checked to avoid worst evil @@ -929,14 +929,14 @@ void RendererSceneCull::instance_set_transform(RID p_instance, const Transform3D void RendererSceneCull::instance_attach_object_instance_id(RID p_instance, ObjectID p_id) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); instance->object_id = p_id; } void RendererSceneCull::instance_set_blend_shape_weight(RID p_instance, int p_shape, float p_weight) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); if (instance->update_item.in_list()) { _update_dirty_instance(instance); @@ -949,7 +949,7 @@ void RendererSceneCull::instance_set_blend_shape_weight(RID p_instance, int p_sh void RendererSceneCull::instance_set_surface_override_material(RID p_instance, int p_surface, RID p_material) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); if (instance->base_type == RS::INSTANCE_MESH) { //may not have been updated yet, may also have not been set yet. When updated will be correcte, worst case @@ -965,7 +965,7 @@ void RendererSceneCull::instance_set_surface_override_material(RID p_instance, i void RendererSceneCull::instance_set_visible(RID p_instance, bool p_visible) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); if (instance->visible == p_visible) { return; @@ -1015,7 +1015,7 @@ inline bool is_geometry_instance(RenderingServer::InstanceType p_type) { void RendererSceneCull::instance_set_custom_aabb(RID p_instance, AABB p_aabb) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); ERR_FAIL_COND(!is_geometry_instance(instance->base_type)); if (p_aabb != AABB()) { @@ -1040,7 +1040,7 @@ void RendererSceneCull::instance_set_custom_aabb(RID p_instance, AABB p_aabb) { void RendererSceneCull::instance_attach_skeleton(RID p_instance, RID p_skeleton) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); if (instance->skeleton == p_skeleton) { return; @@ -1066,7 +1066,7 @@ void RendererSceneCull::instance_attach_skeleton(RID p_instance, RID p_skeleton) void RendererSceneCull::instance_set_extra_visibility_margin(RID p_instance, real_t p_margin) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); instance->extra_margin = p_margin; _instance_queue_update(instance, true, false); @@ -1074,7 +1074,7 @@ void RendererSceneCull::instance_set_extra_visibility_margin(RID p_instance, rea void RendererSceneCull::instance_set_ignore_culling(RID p_instance, bool p_enabled) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); instance->ignore_all_culling = p_enabled; if (instance->scenario && instance->array_index >= 0) { @@ -1090,7 +1090,7 @@ void RendererSceneCull::instance_set_ignore_culling(RID p_instance, bool p_enabl Vector RendererSceneCull::instances_cull_aabb(const AABB &p_aabb, RID p_scenario) const { Vector instances; Scenario *scenario = scenario_owner.get_or_null(p_scenario); - ERR_FAIL_COND_V(!scenario, instances); + ERR_FAIL_NULL_V(scenario, instances); const_cast(this)->update_dirty_instances(); // check dirty instances before culling @@ -1114,7 +1114,7 @@ Vector RendererSceneCull::instances_cull_aabb(const AABB &p_aabb, RID Vector RendererSceneCull::instances_cull_ray(const Vector3 &p_from, const Vector3 &p_to, RID p_scenario) const { Vector instances; Scenario *scenario = scenario_owner.get_or_null(p_scenario); - ERR_FAIL_COND_V(!scenario, instances); + ERR_FAIL_NULL_V(scenario, instances); const_cast(this)->update_dirty_instances(); // check dirty instances before culling struct CullRay { @@ -1137,7 +1137,7 @@ Vector RendererSceneCull::instances_cull_ray(const Vector3 &p_from, co Vector RendererSceneCull::instances_cull_convex(const Vector &p_convex, RID p_scenario) const { Vector instances; Scenario *scenario = scenario_owner.get_or_null(p_scenario); - ERR_FAIL_COND_V(!scenario, instances); + ERR_FAIL_NULL_V(scenario, instances); const_cast(this)->update_dirty_instances(); // check dirty instances before culling Vector points = Geometry3D::compute_convex_mesh_points(&p_convex[0], p_convex.size()); @@ -1161,7 +1161,7 @@ Vector RendererSceneCull::instances_cull_convex(const Vector &p void RendererSceneCull::instance_geometry_set_flag(RID p_instance, RS::InstanceFlags p_flags, bool p_enabled) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); //ERR_FAIL_COND(((1 << instance->base_type) & RS::INSTANCE_GEOMETRY_MASK)); @@ -1238,7 +1238,7 @@ void RendererSceneCull::instance_geometry_set_flag(RID p_instance, RS::InstanceF void RendererSceneCull::instance_geometry_set_cast_shadows_setting(RID p_instance, RS::ShadowCastingSetting p_shadow_casting_setting) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); instance->cast_shadows = p_shadow_casting_setting; @@ -1270,7 +1270,7 @@ void RendererSceneCull::instance_geometry_set_cast_shadows_setting(RID p_instanc void RendererSceneCull::instance_geometry_set_material_override(RID p_instance, RID p_material) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); instance->material_override = p_material; _instance_queue_update(instance, false, true); @@ -1284,7 +1284,7 @@ void RendererSceneCull::instance_geometry_set_material_override(RID p_instance, void RendererSceneCull::instance_geometry_set_material_overlay(RID p_instance, RID p_material) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); instance->material_overlay = p_material; _instance_queue_update(instance, false, true); @@ -1298,7 +1298,7 @@ void RendererSceneCull::instance_geometry_set_material_overlay(RID p_instance, R void RendererSceneCull::instance_geometry_set_visibility_range(RID p_instance, float p_min, float p_max, float p_min_margin, float p_max_margin, RS::VisibilityRangeFadeMode p_fade_mode) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); instance->visibility_range_begin = p_min; instance->visibility_range_end = p_max; @@ -1320,7 +1320,7 @@ void RendererSceneCull::instance_geometry_set_visibility_range(RID p_instance, f void RendererSceneCull::instance_set_visibility_parent(RID p_instance, RID p_parent_instance) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); Instance *old_parent = instance->visibility_parent; if (old_parent) { @@ -1440,7 +1440,7 @@ void RendererSceneCull::_update_instance_visibility_dependencies(Instance *p_ins void RendererSceneCull::instance_geometry_set_lightmap(RID p_instance, RID p_lightmap, const Rect2 &p_lightmap_uv_scale, int p_slice_index) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); if (instance->lightmap) { InstanceLightmapData *lightmap_data = static_cast(((Instance *)instance->lightmap)->base_data); @@ -1471,7 +1471,7 @@ void RendererSceneCull::instance_geometry_set_lightmap(RID p_instance, RID p_lig void RendererSceneCull::instance_geometry_set_lod_bias(RID p_instance, float p_lod_bias) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); instance->lod_bias = p_lod_bias; @@ -1484,7 +1484,7 @@ void RendererSceneCull::instance_geometry_set_lod_bias(RID p_instance, float p_l void RendererSceneCull::instance_geometry_set_shader_parameter(RID p_instance, const StringName &p_parameter, const Variant &p_value) { Instance *instance = instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); ERR_FAIL_COND(p_value.get_type() == Variant::OBJECT); @@ -1522,7 +1522,7 @@ void RendererSceneCull::instance_geometry_set_shader_parameter(RID p_instance, c Variant RendererSceneCull::instance_geometry_get_shader_parameter(RID p_instance, const StringName &p_parameter) const { const Instance *instance = const_cast(this)->instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!instance, Variant()); + ERR_FAIL_NULL_V(instance, Variant()); if (instance->instance_shader_uniforms.has(p_parameter)) { return instance->instance_shader_uniforms[p_parameter].value; @@ -1532,7 +1532,7 @@ Variant RendererSceneCull::instance_geometry_get_shader_parameter(RID p_instance Variant RendererSceneCull::instance_geometry_get_shader_parameter_default_value(RID p_instance, const StringName &p_parameter) const { const Instance *instance = const_cast(this)->instance_owner.get_or_null(p_instance); - ERR_FAIL_COND_V(!instance, Variant()); + ERR_FAIL_NULL_V(instance, Variant()); if (instance->instance_shader_uniforms.has(p_parameter)) { return instance->instance_shader_uniforms[p_parameter].default_value; @@ -1542,7 +1542,7 @@ Variant RendererSceneCull::instance_geometry_get_shader_parameter_default_value( void RendererSceneCull::instance_geometry_get_shader_parameter_list(RID p_instance, List *p_parameters) const { const Instance *instance = const_cast(this)->instance_owner.get_or_null(p_instance); - ERR_FAIL_COND(!instance); + ERR_FAIL_NULL(instance); const_cast(this)->update_dirty_instances(); @@ -2517,7 +2517,7 @@ void RendererSceneCull::render_camera(const Ref &p_render_bu #ifndef _3D_DISABLED Camera *camera = camera_owner.get_or_null(p_camera); - ERR_FAIL_COND(!camera); + ERR_FAIL_NULL(camera); Vector2 jitter; if (p_jitter_phase_count > 0) { @@ -3397,7 +3397,7 @@ void RendererSceneCull::render_empty_scene(const Ref &p_rend bool RendererSceneCull::_render_reflection_probe_step(Instance *p_instance, int p_step) { InstanceReflectionProbeData *reflection_probe = static_cast(p_instance->base_data); Scenario *scenario = p_instance->scenario; - ERR_FAIL_COND_V(!scenario, true); + ERR_FAIL_NULL_V(scenario, true); RenderingServerDefault::redraw_request(); //update, so it updates in editor diff --git a/servers/rendering/renderer_viewport.cpp b/servers/rendering/renderer_viewport.cpp index 09737d03a02..86631ae9d90 100644 --- a/servers/rendering/renderer_viewport.cpp +++ b/servers/rendering/renderer_viewport.cpp @@ -824,7 +824,7 @@ void RendererViewport::viewport_initialize(RID p_rid) { void RendererViewport::viewport_set_use_xr(RID p_viewport, bool p_use_xr) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); if (viewport->use_xr == p_use_xr) { return; @@ -842,7 +842,7 @@ void RendererViewport::viewport_set_use_xr(RID p_viewport, bool p_use_xr) { void RendererViewport::viewport_set_scaling_3d_mode(RID p_viewport, RS::ViewportScaling3DMode p_mode) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); ERR_FAIL_COND_EDMSG(p_mode == RS::VIEWPORT_SCALING_3D_MODE_FSR2 && OS::get_singleton()->get_current_rendering_method() != "forward_plus", "FSR2 is only available when using the Forward+ renderer."); if (viewport->scaling_3d_mode == p_mode) { @@ -862,7 +862,7 @@ void RendererViewport::viewport_set_scaling_3d_mode(RID p_viewport, RS::Viewport void RendererViewport::viewport_set_fsr_sharpness(RID p_viewport, float p_sharpness) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->fsr_sharpness = p_sharpness; if (viewport->render_buffers.is_valid()) { @@ -872,7 +872,7 @@ void RendererViewport::viewport_set_fsr_sharpness(RID p_viewport, float p_sharpn void RendererViewport::viewport_set_texture_mipmap_bias(RID p_viewport, float p_mipmap_bias) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->texture_mipmap_bias = p_mipmap_bias; if (viewport->render_buffers.is_valid()) { @@ -882,7 +882,7 @@ void RendererViewport::viewport_set_texture_mipmap_bias(RID p_viewport, float p_ void RendererViewport::viewport_set_scaling_3d_scale(RID p_viewport, float p_scaling_3d_scale) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); // Clamp to reasonable values that are actually useful. // Values above 2.0 don't serve a practical purpose since the viewport @@ -899,7 +899,7 @@ void RendererViewport::viewport_set_size(RID p_viewport, int p_width, int p_heig ERR_FAIL_COND(p_width < 0 || p_height < 0); Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); ERR_FAIL_COND_MSG(viewport->use_xr, "Cannot set viewport size when using XR"); _viewport_set_size(viewport, p_width, p_height, 1); @@ -924,7 +924,7 @@ bool RendererViewport::_viewport_requires_motion_vectors(Viewport *p_viewport) { void RendererViewport::viewport_set_active(RID p_viewport, bool p_active) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); if (p_active) { ERR_FAIL_COND_MSG(active_viewports.has(viewport), "Can't make active a Viewport that is already active."); @@ -939,21 +939,21 @@ void RendererViewport::viewport_set_active(RID p_viewport, bool p_active) { void RendererViewport::viewport_set_parent_viewport(RID p_viewport, RID p_parent_viewport) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->parent = p_parent_viewport; } void RendererViewport::viewport_set_clear_mode(RID p_viewport, RS::ViewportClearMode p_clear_mode) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->clear_mode = p_clear_mode; } void RendererViewport::viewport_attach_to_screen(RID p_viewport, const Rect2 &p_rect, DisplayServer::WindowID p_screen) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); if (p_screen != DisplayServer::INVALID_WINDOW_ID) { // If using OpenGL we can optimize this operation by rendering directly to system_fbo @@ -979,7 +979,7 @@ void RendererViewport::viewport_attach_to_screen(RID p_viewport, const Rect2 &p_ void RendererViewport::viewport_set_render_direct_to_screen(RID p_viewport, bool p_enable) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); if (p_enable == viewport->viewport_render_direct_to_screen) { return; @@ -1003,28 +1003,28 @@ void RendererViewport::viewport_set_render_direct_to_screen(RID p_viewport, bool void RendererViewport::viewport_set_update_mode(RID p_viewport, RS::ViewportUpdateMode p_mode) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->update_mode = p_mode; } RID RendererViewport::viewport_get_render_target(RID p_viewport) const { const Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND_V(!viewport, RID()); + ERR_FAIL_NULL_V(viewport, RID()); return viewport->render_target; } RID RendererViewport::viewport_get_texture(RID p_viewport) const { const Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND_V(!viewport, RID()); + ERR_FAIL_NULL_V(viewport, RID()); return RSG::texture_storage->render_target_get_texture(viewport->render_target); } RID RendererViewport::viewport_get_occluder_debug_texture(RID p_viewport) const { const Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND_V(!viewport, RID()); + ERR_FAIL_NULL_V(viewport, RID()); if (viewport->use_occlusion_culling && viewport->debug_draw == RenderingServer::VIEWPORT_DEBUG_DRAW_OCCLUDERS) { return RendererSceneOcclusionCull::get_singleton()->buffer_get_debug_texture(p_viewport); @@ -1034,7 +1034,7 @@ RID RendererViewport::viewport_get_occluder_debug_texture(RID p_viewport) const void RendererViewport::viewport_set_prev_camera_data(RID p_viewport, const RendererSceneRender::CameraData *p_camera_data) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); uint64_t frame = RSG::rasterizer->get_frame_number(); if (viewport->prev_camera_data_frame != frame) { viewport->prev_camera_data = *p_camera_data; @@ -1044,26 +1044,26 @@ void RendererViewport::viewport_set_prev_camera_data(RID p_viewport, const Rende const RendererSceneRender::CameraData *RendererViewport::viewport_get_prev_camera_data(RID p_viewport) { const Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND_V(!viewport, nullptr); + ERR_FAIL_NULL_V(viewport, nullptr); return &viewport->prev_camera_data; } void RendererViewport::viewport_set_disable_2d(RID p_viewport, bool p_disable) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->disable_2d = p_disable; } void RendererViewport::viewport_set_environment_mode(RID p_viewport, RS::ViewportEnvironmentMode p_mode) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->disable_environment = p_mode; } bool RendererViewport::viewport_is_environment_disabled(Viewport *viewport) { - ERR_FAIL_COND_V(!viewport, false); + ERR_FAIL_NULL_V(viewport, false); if (viewport->parent.is_valid() && viewport->disable_environment == RS::VIEWPORT_ENVIRONMENT_INHERIT) { Viewport *parent = viewport_owner.get_or_null(viewport->parent); @@ -1074,21 +1074,21 @@ bool RendererViewport::viewport_is_environment_disabled(Viewport *viewport) { void RendererViewport::viewport_set_disable_3d(RID p_viewport, bool p_disable) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->disable_3d = p_disable; } void RendererViewport::viewport_attach_camera(RID p_viewport, RID p_camera) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->camera = p_camera; } void RendererViewport::viewport_set_scenario(RID p_viewport, RID p_scenario) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); if (viewport->scenario.is_valid()) { RSG::scene->scenario_remove_viewport_visibility_mask(viewport->scenario, p_viewport); @@ -1102,11 +1102,11 @@ void RendererViewport::viewport_set_scenario(RID p_viewport, RID p_scenario) { void RendererViewport::viewport_attach_canvas(RID p_viewport, RID p_canvas) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); ERR_FAIL_COND(viewport->canvas_map.has(p_canvas)); RendererCanvasCull::Canvas *canvas = RSG::canvas->canvas_owner.get_or_null(p_canvas); - ERR_FAIL_COND(!canvas); + ERR_FAIL_NULL(canvas); canvas->viewports.insert(p_viewport); viewport->canvas_map[p_canvas] = Viewport::CanvasData(); @@ -1117,10 +1117,10 @@ void RendererViewport::viewport_attach_canvas(RID p_viewport, RID p_canvas) { void RendererViewport::viewport_remove_canvas(RID p_viewport, RID p_canvas) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); RendererCanvasCull::Canvas *canvas = RSG::canvas->canvas_owner.get_or_null(p_canvas); - ERR_FAIL_COND(!canvas); + ERR_FAIL_NULL(canvas); viewport->canvas_map.erase(p_canvas); canvas->viewports.erase(p_viewport); @@ -1128,7 +1128,7 @@ void RendererViewport::viewport_remove_canvas(RID p_viewport, RID p_canvas) { void RendererViewport::viewport_set_canvas_transform(RID p_viewport, RID p_canvas, const Transform2D &p_offset) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); ERR_FAIL_COND(!viewport->canvas_map.has(p_canvas)); viewport->canvas_map[p_canvas].transform = p_offset; @@ -1136,7 +1136,7 @@ void RendererViewport::viewport_set_canvas_transform(RID p_viewport, RID p_canva void RendererViewport::viewport_set_transparent_background(RID p_viewport, bool p_enabled) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); RSG::texture_storage->render_target_set_transparent(viewport->render_target, p_enabled); viewport->transparent_bg = p_enabled; @@ -1144,14 +1144,14 @@ void RendererViewport::viewport_set_transparent_background(RID p_viewport, bool void RendererViewport::viewport_set_global_canvas_transform(RID p_viewport, const Transform2D &p_transform) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->global_transform = p_transform; } void RendererViewport::viewport_set_canvas_stacking(RID p_viewport, RID p_canvas, int p_layer, int p_sublayer) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); ERR_FAIL_COND(!viewport->canvas_map.has(p_canvas)); viewport->canvas_map[p_canvas].layer = p_layer; @@ -1160,7 +1160,7 @@ void RendererViewport::viewport_set_canvas_stacking(RID p_viewport, RID p_canvas void RendererViewport::viewport_set_positional_shadow_atlas_size(RID p_viewport, int p_size, bool p_16_bits) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->shadow_atlas_size = p_size; viewport->shadow_atlas_16_bits = p_16_bits; @@ -1170,14 +1170,14 @@ void RendererViewport::viewport_set_positional_shadow_atlas_size(RID p_viewport, void RendererViewport::viewport_set_positional_shadow_atlas_quadrant_subdivision(RID p_viewport, int p_quadrant, int p_subdiv) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); RSG::light_storage->shadow_atlas_set_quadrant_subdivision(viewport->shadow_atlas, p_quadrant, p_subdiv); } void RendererViewport::viewport_set_msaa_2d(RID p_viewport, RS::ViewportMSAA p_msaa) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); if (viewport->msaa_2d == p_msaa) { return; @@ -1188,7 +1188,7 @@ void RendererViewport::viewport_set_msaa_2d(RID p_viewport, RS::ViewportMSAA p_m void RendererViewport::viewport_set_msaa_3d(RID p_viewport, RS::ViewportMSAA p_msaa) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); if (viewport->msaa_3d == p_msaa) { return; @@ -1199,7 +1199,7 @@ void RendererViewport::viewport_set_msaa_3d(RID p_viewport, RS::ViewportMSAA p_m void RendererViewport::viewport_set_use_hdr_2d(RID p_viewport, bool p_use_hdr_2d) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); if (viewport->use_hdr_2d == p_use_hdr_2d) { return; @@ -1210,7 +1210,7 @@ void RendererViewport::viewport_set_use_hdr_2d(RID p_viewport, bool p_use_hdr_2d void RendererViewport::viewport_set_screen_space_aa(RID p_viewport, RS::ViewportScreenSpaceAA p_mode) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); if (viewport->screen_space_aa == p_mode) { return; @@ -1221,7 +1221,7 @@ void RendererViewport::viewport_set_screen_space_aa(RID p_viewport, RS::Viewport void RendererViewport::viewport_set_use_taa(RID p_viewport, bool p_use_taa) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); ERR_FAIL_COND_EDMSG(OS::get_singleton()->get_current_rendering_method() != "forward_plus", "TAA is only available when using the Forward+ renderer."); if (viewport->use_taa == p_use_taa) { @@ -1241,7 +1241,7 @@ void RendererViewport::viewport_set_use_taa(RID p_viewport, bool p_use_taa) { void RendererViewport::viewport_set_use_debanding(RID p_viewport, bool p_use_debanding) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); if (viewport->use_debanding == p_use_debanding) { return; @@ -1254,7 +1254,7 @@ void RendererViewport::viewport_set_use_debanding(RID p_viewport, bool p_use_deb void RendererViewport::viewport_set_use_occlusion_culling(RID p_viewport, bool p_use_occlusion_culling) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); if (viewport->use_occlusion_culling == p_use_occlusion_culling) { return; @@ -1289,7 +1289,7 @@ void RendererViewport::viewport_set_occlusion_culling_build_quality(RS::Viewport void RendererViewport::viewport_set_mesh_lod_threshold(RID p_viewport, float p_pixels) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->mesh_lod_threshold = p_pixels; } @@ -1308,62 +1308,62 @@ int RendererViewport::viewport_get_render_info(RID p_viewport, RS::ViewportRende void RendererViewport::viewport_set_debug_draw(RID p_viewport, RS::ViewportDebugDraw p_draw) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->debug_draw = p_draw; } void RendererViewport::viewport_set_measure_render_time(RID p_viewport, bool p_enable) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->measure_render_time = p_enable; } float RendererViewport::viewport_get_measured_render_time_cpu(RID p_viewport) const { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND_V(!viewport, 0); + ERR_FAIL_NULL_V(viewport, 0); return double(viewport->time_cpu_end - viewport->time_cpu_begin) / 1000.0; } float RendererViewport::viewport_get_measured_render_time_gpu(RID p_viewport) const { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND_V(!viewport, 0); + ERR_FAIL_NULL_V(viewport, 0); return double((viewport->time_gpu_end - viewport->time_gpu_begin) / 1000) / 1000.0; } void RendererViewport::viewport_set_snap_2d_transforms_to_pixel(RID p_viewport, bool p_enabled) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->snap_2d_transforms_to_pixel = p_enabled; } void RendererViewport::viewport_set_snap_2d_vertices_to_pixel(RID p_viewport, bool p_enabled) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->snap_2d_vertices_to_pixel = p_enabled; } void RendererViewport::viewport_set_default_canvas_item_texture_filter(RID p_viewport, RS::CanvasItemTextureFilter p_filter) { ERR_FAIL_COND_MSG(p_filter == RS::CANVAS_ITEM_TEXTURE_FILTER_DEFAULT, "Viewport does not accept DEFAULT as texture filter (it's the topmost choice already).)"); Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->texture_filter = p_filter; } void RendererViewport::viewport_set_default_canvas_item_texture_repeat(RID p_viewport, RS::CanvasItemTextureRepeat p_repeat) { ERR_FAIL_COND_MSG(p_repeat == RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT, "Viewport does not accept DEFAULT as texture repeat (it's the topmost choice already).)"); Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->texture_repeat = p_repeat; } void RendererViewport::viewport_set_sdf_oversize_and_scale(RID p_viewport, RS::ViewportSDFOversize p_size, RS::ViewportSDFScale p_scale) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); RSG::texture_storage->render_target_set_sdf_size_and_scale(viewport->render_target, p_size, p_scale); } @@ -1384,7 +1384,7 @@ RID RendererViewport::viewport_find_from_screen_attachment(DisplayServer::Window void RendererViewport::viewport_set_vrs_mode(RID p_viewport, RS::ViewportVRSMode p_mode) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); RSG::texture_storage->render_target_set_vrs_mode(viewport->render_target, p_mode); _configure_3d_render_buffers(viewport); @@ -1392,7 +1392,7 @@ void RendererViewport::viewport_set_vrs_mode(RID p_viewport, RS::ViewportVRSMode void RendererViewport::viewport_set_vrs_texture(RID p_viewport, RID p_texture) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); RSG::texture_storage->render_target_set_vrs_texture(viewport->render_target, p_texture); _configure_3d_render_buffers(viewport); @@ -1460,7 +1460,7 @@ void RendererViewport::set_default_clear_color(const Color &p_color) { void RendererViewport::viewport_set_canvas_cull_mask(RID p_viewport, uint32_t p_canvas_cull_mask) { Viewport *viewport = viewport_owner.get_or_null(p_viewport); - ERR_FAIL_COND(!viewport); + ERR_FAIL_NULL(viewport); viewport->canvas_cull_mask = p_canvas_cull_mask; } diff --git a/servers/rendering/rendering_device.cpp b/servers/rendering/rendering_device.cpp index 2b458a985ff..cb6479847a0 100644 --- a/servers/rendering/rendering_device.cpp +++ b/servers/rendering/rendering_device.cpp @@ -73,7 +73,7 @@ Vector RenderingDevice::shader_compile_spirv_from_source(ShaderStage p_ } } - ERR_FAIL_COND_V(!compile_to_spirv_function, Vector()); + ERR_FAIL_NULL_V(compile_to_spirv_function, Vector()); return compile_to_spirv_function(p_stage, p_source_code, p_language, r_error, this); } diff --git a/servers/rendering/shader_compiler.cpp b/servers/rendering/shader_compiler.cpp index 0e6c0e4bf66..671134fb064 100644 --- a/servers/rendering/shader_compiler.cpp +++ b/servers/rendering/shader_compiler.cpp @@ -335,7 +335,7 @@ void ShaderCompiler::_dump_function_deps(const SL::ShaderNode *p_node, const Str } } - ERR_FAIL_COND(!fnode); + ERR_FAIL_NULL(fnode); r_to_add += "\n"; diff --git a/servers/rendering/shader_language.cpp b/servers/rendering/shader_language.cpp index 1460a918260..56ebc262217 100644 --- a/servers/rendering/shader_language.cpp +++ b/servers/rendering/shader_language.cpp @@ -5297,7 +5297,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons } } - ERR_FAIL_COND_V(!base_function, nullptr); //bug, wtf + ERR_FAIL_NULL_V(base_function, nullptr); // Bug, wtf. for (int i = 0; i < call_function->arguments.size(); i++) { int argidx = i + 1; @@ -5729,7 +5729,7 @@ ShaderLanguage::Node *ShaderLanguage::_parse_expression(BlockNode *p_block, cons } } - ERR_FAIL_COND_V(!expr, nullptr); + ERR_FAIL_NULL_V(expr, nullptr); /* OK now see what's NEXT to the operator.. */ diff --git a/servers/rendering/storage/camera_attributes_storage.cpp b/servers/rendering/storage/camera_attributes_storage.cpp index d7f438a68c5..2fece3ce0f5 100644 --- a/servers/rendering/storage/camera_attributes_storage.cpp +++ b/servers/rendering/storage/camera_attributes_storage.cpp @@ -64,7 +64,7 @@ void RendererCameraAttributes::camera_attributes_set_dof_blur_bokeh_shape(RS::DO void RendererCameraAttributes::camera_attributes_set_dof_blur(RID p_camera_attributes, bool p_far_enable, float p_far_distance, float p_far_transition, bool p_near_enable, float p_near_distance, float p_near_transition, float p_amount) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND(!cam_attributes); + ERR_FAIL_NULL(cam_attributes); #ifdef DEBUG_ENABLED if (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility" && (p_far_enable || p_near_enable)) { WARN_PRINT_ONCE_ED("DoF blur is only available when using the Forward+ or Mobile rendering backends."); @@ -83,63 +83,63 @@ void RendererCameraAttributes::camera_attributes_set_dof_blur(RID p_camera_attri bool RendererCameraAttributes::camera_attributes_get_dof_far_enabled(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, false); + ERR_FAIL_NULL_V(cam_attributes, false); return cam_attributes->dof_blur_far_enabled; } float RendererCameraAttributes::camera_attributes_get_dof_far_distance(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, 0.0); + ERR_FAIL_NULL_V(cam_attributes, 0.0); return cam_attributes->dof_blur_far_distance; } float RendererCameraAttributes::camera_attributes_get_dof_far_transition(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, 0.0); + ERR_FAIL_NULL_V(cam_attributes, 0.0); return cam_attributes->dof_blur_far_transition; } bool RendererCameraAttributes::camera_attributes_get_dof_near_enabled(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, false); + ERR_FAIL_NULL_V(cam_attributes, false); return cam_attributes->dof_blur_near_enabled; } float RendererCameraAttributes::camera_attributes_get_dof_near_distance(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, 0.0); + ERR_FAIL_NULL_V(cam_attributes, 0.0); return cam_attributes->dof_blur_near_distance; } float RendererCameraAttributes::camera_attributes_get_dof_near_transition(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, 0.0); + ERR_FAIL_NULL_V(cam_attributes, 0.0); return cam_attributes->dof_blur_near_transition; } float RendererCameraAttributes::camera_attributes_get_dof_blur_amount(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, 0.0); + ERR_FAIL_NULL_V(cam_attributes, 0.0); return cam_attributes->dof_blur_amount; } void RendererCameraAttributes::camera_attributes_set_exposure(RID p_camera_attributes, float p_multiplier, float p_exposure_normalization) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND(!cam_attributes); + ERR_FAIL_NULL(cam_attributes); cam_attributes->exposure_multiplier = p_multiplier; cam_attributes->exposure_normalization = p_exposure_normalization; } float RendererCameraAttributes::camera_attributes_get_exposure_normalization_factor(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, 1.0); + ERR_FAIL_NULL_V(cam_attributes, 1.0); return cam_attributes->exposure_multiplier * cam_attributes->exposure_normalization; } void RendererCameraAttributes::camera_attributes_set_auto_exposure(RID p_camera_attributes, bool p_enable, float p_min_sensitivity, float p_max_sensitivity, float p_speed, float p_scale) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND(!cam_attributes); + ERR_FAIL_NULL(cam_attributes); if (!cam_attributes->use_auto_exposure && p_enable) { cam_attributes->auto_exposure_version = ++auto_exposure_counter; } @@ -157,30 +157,30 @@ void RendererCameraAttributes::camera_attributes_set_auto_exposure(RID p_camera_ float RendererCameraAttributes::camera_attributes_get_auto_exposure_min_sensitivity(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, 0.0); + ERR_FAIL_NULL_V(cam_attributes, 0.0); return cam_attributes->auto_exposure_min_sensitivity; } float RendererCameraAttributes::camera_attributes_get_auto_exposure_max_sensitivity(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, 0.0); + ERR_FAIL_NULL_V(cam_attributes, 0.0); return cam_attributes->auto_exposure_max_sensitivity; } float RendererCameraAttributes::camera_attributes_get_auto_exposure_adjust_speed(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, 0.0); + ERR_FAIL_NULL_V(cam_attributes, 0.0); return cam_attributes->auto_exposure_adjust_speed; } float RendererCameraAttributes::camera_attributes_get_auto_exposure_scale(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, 0.0); + ERR_FAIL_NULL_V(cam_attributes, 0.0); return cam_attributes->auto_exposure_scale; } uint64_t RendererCameraAttributes::camera_attributes_get_auto_exposure_version(RID p_camera_attributes) { CameraAttributes *cam_attributes = camera_attributes_owner.get_or_null(p_camera_attributes); - ERR_FAIL_COND_V(!cam_attributes, 0); + ERR_FAIL_NULL_V(cam_attributes, 0); return cam_attributes->auto_exposure_version; } diff --git a/servers/rendering/storage/environment_storage.cpp b/servers/rendering/storage/environment_storage.cpp index c07a5b6584e..0234f52ca1e 100644 --- a/servers/rendering/storage/environment_storage.cpp +++ b/servers/rendering/storage/environment_storage.cpp @@ -46,50 +46,50 @@ void RendererEnvironmentStorage::environment_free(RID p_rid) { void RendererEnvironmentStorage::environment_set_background(RID p_env, RS::EnvironmentBG p_bg) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); env->background = p_bg; } void RendererEnvironmentStorage::environment_set_sky(RID p_env, RID p_sky) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); env->sky = p_sky; } void RendererEnvironmentStorage::environment_set_sky_custom_fov(RID p_env, float p_scale) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); env->sky_custom_fov = p_scale; } void RendererEnvironmentStorage::environment_set_sky_orientation(RID p_env, const Basis &p_orientation) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); env->sky_orientation = p_orientation; } void RendererEnvironmentStorage::environment_set_bg_color(RID p_env, const Color &p_color) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); env->bg_color = p_color; } void RendererEnvironmentStorage::environment_set_bg_energy(RID p_env, float p_multiplier, float p_intensity) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); env->bg_energy_multiplier = p_multiplier; env->bg_intensity = p_intensity; } void RendererEnvironmentStorage::environment_set_canvas_max_layer(RID p_env, int p_max_layer) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); env->canvas_max_layer = p_max_layer; } void RendererEnvironmentStorage::environment_set_ambient_light(RID p_env, const Color &p_color, RS::EnvironmentAmbientSource p_ambient, float p_energy, float p_sky_contribution, RS::EnvironmentReflectionSource p_reflection_source) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); env->ambient_light = p_color; env->ambient_source = p_ambient; env->ambient_light_energy = p_energy; @@ -99,79 +99,79 @@ void RendererEnvironmentStorage::environment_set_ambient_light(RID p_env, const RS::EnvironmentBG RendererEnvironmentStorage::environment_get_background(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, RS::ENV_BG_CLEAR_COLOR); + ERR_FAIL_NULL_V(env, RS::ENV_BG_CLEAR_COLOR); return env->background; } RID RendererEnvironmentStorage::environment_get_sky(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, RID()); + ERR_FAIL_NULL_V(env, RID()); return env->sky; } float RendererEnvironmentStorage::environment_get_sky_custom_fov(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->sky_custom_fov; } Basis RendererEnvironmentStorage::environment_get_sky_orientation(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, Basis()); + ERR_FAIL_NULL_V(env, Basis()); return env->sky_orientation; } Color RendererEnvironmentStorage::environment_get_bg_color(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, Color()); + ERR_FAIL_NULL_V(env, Color()); return env->bg_color; } float RendererEnvironmentStorage::environment_get_bg_energy_multiplier(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->bg_energy_multiplier; } float RendererEnvironmentStorage::environment_get_bg_intensity(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->bg_intensity; } int RendererEnvironmentStorage::environment_get_canvas_max_layer(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0); + ERR_FAIL_NULL_V(env, 0); return env->canvas_max_layer; } RS::EnvironmentAmbientSource RendererEnvironmentStorage::environment_get_ambient_source(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, RS::ENV_AMBIENT_SOURCE_BG); + ERR_FAIL_NULL_V(env, RS::ENV_AMBIENT_SOURCE_BG); return env->ambient_source; } Color RendererEnvironmentStorage::environment_get_ambient_light(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, Color()); + ERR_FAIL_NULL_V(env, Color()); return env->ambient_light; } float RendererEnvironmentStorage::environment_get_ambient_light_energy(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->ambient_light_energy; } float RendererEnvironmentStorage::environment_get_ambient_sky_contribution(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->ambient_sky_contribution; } RS::EnvironmentReflectionSource RendererEnvironmentStorage::environment_get_reflection_source(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, RS::ENV_REFLECTION_SOURCE_BG); + ERR_FAIL_NULL_V(env, RS::ENV_REFLECTION_SOURCE_BG); return env->reflection_source; } @@ -179,7 +179,7 @@ RS::EnvironmentReflectionSource RendererEnvironmentStorage::environment_get_refl void RendererEnvironmentStorage::environment_set_tonemap(RID p_env, RS::EnvironmentToneMapper p_tone_mapper, float p_exposure, float p_white) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); env->exposure = p_exposure; env->tone_mapper = p_tone_mapper; env->white = p_white; @@ -187,19 +187,19 @@ void RendererEnvironmentStorage::environment_set_tonemap(RID p_env, RS::Environm RS::EnvironmentToneMapper RendererEnvironmentStorage::environment_get_tone_mapper(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, RS::ENV_TONE_MAPPER_LINEAR); + ERR_FAIL_NULL_V(env, RS::ENV_TONE_MAPPER_LINEAR); return env->tone_mapper; } float RendererEnvironmentStorage::environment_get_exposure(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->exposure; } float RendererEnvironmentStorage::environment_get_white(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->white; } @@ -207,7 +207,7 @@ float RendererEnvironmentStorage::environment_get_white(RID p_env) const { void RendererEnvironmentStorage::environment_set_fog(RID p_env, bool p_enable, const Color &p_light_color, float p_light_energy, float p_sun_scatter, float p_density, float p_height, float p_height_density, float p_fog_aerial_perspective, float p_sky_affect) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); env->fog_enabled = p_enable; env->fog_light_color = p_light_color; env->fog_light_energy = p_light_energy; @@ -221,55 +221,55 @@ void RendererEnvironmentStorage::environment_set_fog(RID p_env, bool p_enable, c bool RendererEnvironmentStorage::environment_get_fog_enabled(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, false); + ERR_FAIL_NULL_V(env, false); return env->fog_enabled; } Color RendererEnvironmentStorage::environment_get_fog_light_color(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, Color(0.5, 0.6, 0.7)); + ERR_FAIL_NULL_V(env, Color(0.5, 0.6, 0.7)); return env->fog_light_color; } float RendererEnvironmentStorage::environment_get_fog_light_energy(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->fog_light_energy; } float RendererEnvironmentStorage::environment_get_fog_sun_scatter(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->fog_sun_scatter; } float RendererEnvironmentStorage::environment_get_fog_density(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.001); + ERR_FAIL_NULL_V(env, 0.001); return env->fog_density; } float RendererEnvironmentStorage::environment_get_fog_height(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->fog_height; } float RendererEnvironmentStorage::environment_get_fog_height_density(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->fog_height_density; } float RendererEnvironmentStorage::environment_get_fog_aerial_perspective(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->fog_aerial_perspective; } float RendererEnvironmentStorage::environment_get_fog_sky_affect(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->fog_sky_affect; } @@ -277,7 +277,7 @@ float RendererEnvironmentStorage::environment_get_fog_sky_affect(RID p_env) cons void RendererEnvironmentStorage::environment_set_volumetric_fog(RID p_env, bool p_enable, float p_density, const Color &p_albedo, const Color &p_emission, float p_emission_energy, float p_anisotropy, float p_length, float p_detail_spread, float p_gi_inject, bool p_temporal_reprojection, float p_temporal_reprojection_amount, float p_ambient_inject, float p_sky_affect) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); #ifdef DEBUG_ENABLED if (OS::get_singleton()->get_current_rendering_method() != "forward_plus" && p_enable) { WARN_PRINT_ONCE_ED("Volumetric fog can only be enabled when using the Forward+ rendering backend."); @@ -300,79 +300,79 @@ void RendererEnvironmentStorage::environment_set_volumetric_fog(RID p_env, bool bool RendererEnvironmentStorage::environment_get_volumetric_fog_enabled(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, false); + ERR_FAIL_NULL_V(env, false); return env->volumetric_fog_enabled; } float RendererEnvironmentStorage::environment_get_volumetric_fog_density(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.01); + ERR_FAIL_NULL_V(env, 0.01); return env->volumetric_fog_density; } Color RendererEnvironmentStorage::environment_get_volumetric_fog_scattering(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, Color(1, 1, 1)); + ERR_FAIL_NULL_V(env, Color(1, 1, 1)); return env->volumetric_fog_scattering; } Color RendererEnvironmentStorage::environment_get_volumetric_fog_emission(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, Color(0, 0, 0)); + ERR_FAIL_NULL_V(env, Color(0, 0, 0)); return env->volumetric_fog_emission; } float RendererEnvironmentStorage::environment_get_volumetric_fog_emission_energy(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->volumetric_fog_emission_energy; } float RendererEnvironmentStorage::environment_get_volumetric_fog_anisotropy(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.2); + ERR_FAIL_NULL_V(env, 0.2); return env->volumetric_fog_anisotropy; } float RendererEnvironmentStorage::environment_get_volumetric_fog_length(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 64.0); + ERR_FAIL_NULL_V(env, 64.0); return env->volumetric_fog_length; } float RendererEnvironmentStorage::environment_get_volumetric_fog_detail_spread(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 2.0); + ERR_FAIL_NULL_V(env, 2.0); return env->volumetric_fog_detail_spread; } float RendererEnvironmentStorage::environment_get_volumetric_fog_gi_inject(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->volumetric_fog_gi_inject; } float RendererEnvironmentStorage::environment_get_volumetric_fog_sky_affect(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->volumetric_fog_sky_affect; } bool RendererEnvironmentStorage::environment_get_volumetric_fog_temporal_reprojection(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, true); + ERR_FAIL_NULL_V(env, true); return env->volumetric_fog_temporal_reprojection; } float RendererEnvironmentStorage::environment_get_volumetric_fog_temporal_reprojection_amount(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.9); + ERR_FAIL_NULL_V(env, 0.9); return env->volumetric_fog_temporal_reprojection_amount; } float RendererEnvironmentStorage::environment_get_volumetric_fog_ambient_inject(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->volumetric_fog_ambient_inject; } @@ -380,7 +380,7 @@ float RendererEnvironmentStorage::environment_get_volumetric_fog_ambient_inject( void RendererEnvironmentStorage::environment_set_glow(RID p_env, bool p_enable, Vector p_levels, float p_intensity, float p_strength, float p_mix, float p_bloom_threshold, RS::EnvironmentGlowBlendMode p_blend_mode, float p_hdr_bleed_threshold, float p_hdr_bleed_scale, float p_hdr_luminance_cap, float p_glow_map_strength, RID p_glow_map) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); ERR_FAIL_COND_MSG(p_levels.size() != 7, "Size of array of glow levels must be 7"); #ifdef DEBUG_ENABLED if (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility" && p_enable) { @@ -403,73 +403,73 @@ void RendererEnvironmentStorage::environment_set_glow(RID p_env, bool p_enable, bool RendererEnvironmentStorage::environment_get_glow_enabled(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, false); + ERR_FAIL_NULL_V(env, false); return env->glow_enabled; } Vector RendererEnvironmentStorage::environment_get_glow_levels(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, Vector()); + ERR_FAIL_NULL_V(env, Vector()); return env->glow_levels; } float RendererEnvironmentStorage::environment_get_glow_intensity(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.8); + ERR_FAIL_NULL_V(env, 0.8); return env->glow_intensity; } float RendererEnvironmentStorage::environment_get_glow_strength(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->glow_strength; } float RendererEnvironmentStorage::environment_get_glow_bloom(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->glow_bloom; } float RendererEnvironmentStorage::environment_get_glow_mix(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.01); + ERR_FAIL_NULL_V(env, 0.01); return env->glow_mix; } RS::EnvironmentGlowBlendMode RendererEnvironmentStorage::environment_get_glow_blend_mode(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, RS::ENV_GLOW_BLEND_MODE_SOFTLIGHT); + ERR_FAIL_NULL_V(env, RS::ENV_GLOW_BLEND_MODE_SOFTLIGHT); return env->glow_blend_mode; } float RendererEnvironmentStorage::environment_get_glow_hdr_bleed_threshold(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->glow_hdr_bleed_threshold; } float RendererEnvironmentStorage::environment_get_glow_hdr_luminance_cap(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 12.0); + ERR_FAIL_NULL_V(env, 12.0); return env->glow_hdr_luminance_cap; } float RendererEnvironmentStorage::environment_get_glow_hdr_bleed_scale(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 2.0); + ERR_FAIL_NULL_V(env, 2.0); return env->glow_hdr_bleed_scale; } float RendererEnvironmentStorage::environment_get_glow_map_strength(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->glow_map_strength; } RID RendererEnvironmentStorage::environment_get_glow_map(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, RID()); + ERR_FAIL_NULL_V(env, RID()); return env->glow_map; } @@ -477,7 +477,7 @@ RID RendererEnvironmentStorage::environment_get_glow_map(RID p_env) const { void RendererEnvironmentStorage::environment_set_ssr(RID p_env, bool p_enable, int p_max_steps, float p_fade_int, float p_fade_out, float p_depth_tolerance) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); #ifdef DEBUG_ENABLED if (OS::get_singleton()->get_current_rendering_method() != "forward_plus" && p_enable) { WARN_PRINT_ONCE_ED("Screen-space reflections (SSR) can only be enabled when using the Forward+ rendering backend."); @@ -492,31 +492,31 @@ void RendererEnvironmentStorage::environment_set_ssr(RID p_env, bool p_enable, i bool RendererEnvironmentStorage::environment_get_ssr_enabled(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, false); + ERR_FAIL_NULL_V(env, false); return env->ssr_enabled; } int RendererEnvironmentStorage::environment_get_ssr_max_steps(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 64); + ERR_FAIL_NULL_V(env, 64); return env->ssr_max_steps; } float RendererEnvironmentStorage::environment_get_ssr_fade_in(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.15); + ERR_FAIL_NULL_V(env, 0.15); return env->ssr_fade_in; } float RendererEnvironmentStorage::environment_get_ssr_fade_out(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 2.0); + ERR_FAIL_NULL_V(env, 2.0); return env->ssr_fade_out; } float RendererEnvironmentStorage::environment_get_ssr_depth_tolerance(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.2); + ERR_FAIL_NULL_V(env, 0.2); return env->ssr_depth_tolerance; } @@ -524,7 +524,7 @@ float RendererEnvironmentStorage::environment_get_ssr_depth_tolerance(RID p_env) void RendererEnvironmentStorage::environment_set_ssao(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_power, float p_detail, float p_horizon, float p_sharpness, float p_light_affect, float p_ao_channel_affect) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); #ifdef DEBUG_ENABLED if (OS::get_singleton()->get_current_rendering_method() != "forward_plus" && p_enable) { WARN_PRINT_ONCE_ED("Screen-space ambient occlusion (SSAO) can only be enabled when using the Forward+ rendering backend."); @@ -543,55 +543,55 @@ void RendererEnvironmentStorage::environment_set_ssao(RID p_env, bool p_enable, bool RendererEnvironmentStorage::environment_get_ssao_enabled(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, false); + ERR_FAIL_NULL_V(env, false); return env->ssao_enabled; } float RendererEnvironmentStorage::environment_get_ssao_radius(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->ssao_radius; } float RendererEnvironmentStorage::environment_get_ssao_intensity(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 2.0); + ERR_FAIL_NULL_V(env, 2.0); return env->ssao_intensity; } float RendererEnvironmentStorage::environment_get_ssao_power(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.5); + ERR_FAIL_NULL_V(env, 1.5); return env->ssao_power; } float RendererEnvironmentStorage::environment_get_ssao_detail(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.5); + ERR_FAIL_NULL_V(env, 0.5); return env->ssao_detail; } float RendererEnvironmentStorage::environment_get_ssao_horizon(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.06); + ERR_FAIL_NULL_V(env, 0.06); return env->ssao_horizon; } float RendererEnvironmentStorage::environment_get_ssao_sharpness(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.98); + ERR_FAIL_NULL_V(env, 0.98); return env->ssao_sharpness; } float RendererEnvironmentStorage::environment_get_ssao_direct_light_affect(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->ssao_direct_light_affect; } float RendererEnvironmentStorage::environment_get_ssao_ao_channel_affect(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.0); + ERR_FAIL_NULL_V(env, 0.0); return env->ssao_ao_channel_affect; } @@ -599,7 +599,7 @@ float RendererEnvironmentStorage::environment_get_ssao_ao_channel_affect(RID p_e void RendererEnvironmentStorage::environment_set_ssil(RID p_env, bool p_enable, float p_radius, float p_intensity, float p_sharpness, float p_normal_rejection) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); #ifdef DEBUG_ENABLED if (OS::get_singleton()->get_current_rendering_method() != "forward_plus" && p_enable) { WARN_PRINT_ONCE_ED("Screen-space indirect lighting (SSIL) can only be enabled when using the Forward+ rendering backend."); @@ -614,31 +614,31 @@ void RendererEnvironmentStorage::environment_set_ssil(RID p_env, bool p_enable, bool RendererEnvironmentStorage::environment_get_ssil_enabled(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, false); + ERR_FAIL_NULL_V(env, false); return env->ssil_enabled; } float RendererEnvironmentStorage::environment_get_ssil_radius(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 5.0); + ERR_FAIL_NULL_V(env, 5.0); return env->ssil_radius; } float RendererEnvironmentStorage::environment_get_ssil_intensity(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->ssil_intensity; } float RendererEnvironmentStorage::environment_get_ssil_sharpness(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.98); + ERR_FAIL_NULL_V(env, 0.98); return env->ssil_sharpness; } float RendererEnvironmentStorage::environment_get_ssil_normal_rejection(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->ssil_normal_rejection; } @@ -646,7 +646,7 @@ float RendererEnvironmentStorage::environment_get_ssil_normal_rejection(RID p_en void RendererEnvironmentStorage::environment_set_sdfgi(RID p_env, bool p_enable, int p_cascades, float p_min_cell_size, RS::EnvironmentSDFGIYScale p_y_scale, bool p_use_occlusion, float p_bounce_feedback, bool p_read_sky, float p_energy, float p_normal_bias, float p_probe_bias) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); #ifdef DEBUG_ENABLED if (OS::get_singleton()->get_current_rendering_method() != "forward_plus" && p_enable) { WARN_PRINT_ONCE_ED("SDFGI can only be enabled when using the Forward+ rendering backend."); @@ -666,61 +666,61 @@ void RendererEnvironmentStorage::environment_set_sdfgi(RID p_env, bool p_enable, bool RendererEnvironmentStorage::environment_get_sdfgi_enabled(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, false); + ERR_FAIL_NULL_V(env, false); return env->sdfgi_enabled; } int RendererEnvironmentStorage::environment_get_sdfgi_cascades(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 4); + ERR_FAIL_NULL_V(env, 4); return env->sdfgi_cascades; } float RendererEnvironmentStorage::environment_get_sdfgi_min_cell_size(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.2); + ERR_FAIL_NULL_V(env, 0.2); return env->sdfgi_min_cell_size; } bool RendererEnvironmentStorage::environment_get_sdfgi_use_occlusion(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, false); + ERR_FAIL_NULL_V(env, false); return env->sdfgi_use_occlusion; } float RendererEnvironmentStorage::environment_get_sdfgi_bounce_feedback(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 0.5); + ERR_FAIL_NULL_V(env, 0.5); return env->sdfgi_bounce_feedback; } bool RendererEnvironmentStorage::environment_get_sdfgi_read_sky_light(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, true); + ERR_FAIL_NULL_V(env, true); return env->sdfgi_read_sky_light; } float RendererEnvironmentStorage::environment_get_sdfgi_energy(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->sdfgi_energy; } float RendererEnvironmentStorage::environment_get_sdfgi_normal_bias(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.1); + ERR_FAIL_NULL_V(env, 1.1); return env->sdfgi_normal_bias; } float RendererEnvironmentStorage::environment_get_sdfgi_probe_bias(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.1); + ERR_FAIL_NULL_V(env, 1.1); return env->sdfgi_probe_bias; } RS::EnvironmentSDFGIYScale RendererEnvironmentStorage::environment_get_sdfgi_y_scale(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, RS::ENV_SDFGI_Y_SCALE_75_PERCENT); + ERR_FAIL_NULL_V(env, RS::ENV_SDFGI_Y_SCALE_75_PERCENT); return env->sdfgi_y_scale; } @@ -728,7 +728,7 @@ RS::EnvironmentSDFGIYScale RendererEnvironmentStorage::environment_get_sdfgi_y_s void RendererEnvironmentStorage::environment_set_adjustment(RID p_env, bool p_enable, float p_brightness, float p_contrast, float p_saturation, bool p_use_1d_color_correction, RID p_color_correction) { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND(!env); + ERR_FAIL_NULL(env); #ifdef DEBUG_ENABLED if (OS::get_singleton()->get_current_rendering_method() == "gl_compatibility" && p_enable) { WARN_PRINT_ONCE_ED("Adjustments are not supported when using the GL Compatibility backend yet. Support will be added in a future release."); @@ -744,36 +744,36 @@ void RendererEnvironmentStorage::environment_set_adjustment(RID p_env, bool p_en bool RendererEnvironmentStorage::environment_get_adjustments_enabled(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, false); + ERR_FAIL_NULL_V(env, false); return env->adjustments_enabled; } float RendererEnvironmentStorage::environment_get_adjustments_brightness(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->adjustments_brightness; } float RendererEnvironmentStorage::environment_get_adjustments_contrast(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->adjustments_contrast; } float RendererEnvironmentStorage::environment_get_adjustments_saturation(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, 1.0); + ERR_FAIL_NULL_V(env, 1.0); return env->adjustments_saturation; } bool RendererEnvironmentStorage::environment_get_use_1d_color_correction(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, false); + ERR_FAIL_NULL_V(env, false); return env->use_1d_color_correction; } RID RendererEnvironmentStorage::environment_get_color_correction(RID p_env) const { Environment *env = environment_owner.get_or_null(p_env); - ERR_FAIL_COND_V(!env, RID()); + ERR_FAIL_NULL_V(env, RID()); return env->color_correction; }