Spherical area light behaving like point light

[HectorMRC]

Following the pcss example I have been trying to create an eclipse effect between 3 spherical bodies, one of which is the actual spherical area light. I am attaching my code down below. Despite I am adding a radius to the PointLight, it seams to behave like a 0 radius point light anyway. There is no umbra and penumbra casted by one of the opaque bodies, neither seams the shadow resulting from an area light.

I did not find any open issue regarding PointLight radius, so I assume it's a problem with my understanding of lighting. What am I missing here?

Thanks you all in advance!

use core::f32;
use std::f32::consts::FRAC_PI_2;

use bevy::{
    core_pipeline::{experimental::taa::{TemporalAntiAliasPlugin, TemporalAntiAliasing}, prepass::{DepthPrepass, MotionVectorPrepass}}, input::mouse::MouseWheel, pbr::{CascadesVisibleEntities, CubemapVisibleEntities, ShadowFilteringMethod}, prelude::*, render::{camera::TemporalJitter, mesh::{SphereKind, SphereMeshBuilder}, primitives::CubemapFrusta}
};

const MAGNITUDE: f32 = 1_000_000.;
const VIEW_RADIUS: f32 = 500. * MAGNITUDE;

fn main() {
    App::new()
        .add_plugins(DefaultPlugins)
        .add_plugins(TemporalAntiAliasPlugin)
        .add_systems(Startup, setup)
        .add_systems(Update, on_mouse_wheel_event)
        .run();
}

fn setup(
    mut commands: Commands,
    mut meshes: ResMut<Assets<Mesh>>,
    mut materials: ResMut<Assets<StandardMaterial>>,
) {
    commands.spawn((
        Camera3d::default(),    
        Camera {
            hdr: true,
            ..Default::default()
        },
        Projection::Perspective(PerspectiveProjection {
            fov: FRAC_PI_2,
            near: 1.,
            far: 2. * VIEW_RADIUS,
            ..Default::default()
        }),
        Transform::from_xyz(0., 0., VIEW_RADIUS).looking_at(Vec3::ZERO, Dir3::Y),
        
    ))
    .insert(ShadowFilteringMethod::Temporal)
    .insert(TemporalJitter::default())
    .insert(TemporalAntiAliasing::default())
    .insert(Msaa::Off)
    .insert(DepthPrepass)
    .insert(MotionVectorPrepass);

    commands
        .spawn((
            PointLight {    
            radius: 50. * MAGNITUDE,    
            color: Color::WHITE,
            intensity: 1e16 * MAGNITUDE,
            range: f32::MAX,
            shadows_enabled: true,  
            soft_shadows_enabled: true,  
            ..Default::default()
        },
        Transform::from_xyz(-1000. * MAGNITUDE, 0., 0.),
    ))
        .insert(CubemapVisibleEntities::default())
        .insert(CascadesVisibleEntities::default())
        .insert(CubemapFrusta::default());

    commands.spawn((
        Mesh3d(meshes.add(SphereMeshBuilder {
            sphere: Sphere::new(25. * MAGNITUDE),
            kind: SphereKind::Ico { subdivisions: 8 },
        })),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Color::linear_rgb(0.8, 1., 0.5),
            alpha_mode: AlphaMode::Blend,
            ..Default::default()
        })),
        Transform::from_xyz(0. * MAGNITUDE, 0., 0.),
    ));

    commands.spawn((
        Mesh3d(meshes.add(SphereMeshBuilder {
            sphere: Sphere::new(150. * MAGNITUDE),
            kind: SphereKind::Ico { subdivisions: 8 },
        })),
        MeshMaterial3d(materials.add(StandardMaterial {
            base_color: Color::linear_rgb(0.8, 1., 0.5),
            alpha_mode: AlphaMode::Blend,
            ..Default::default()
        })),
        Transform::from_xyz(500. * MAGNITUDE, 0., 0.),
    )); 
}

fn on_mouse_wheel_event(
    mut scroll: EventReader<MouseWheel>,
    mut camera_query: Query<(&mut Transform, &Projection), With<Camera3d>>,
) {
    let (mut transform, projection) = camera_query.single_mut();
    let Projection::Perspective(projection) = projection else {
        panic!("projection must be perspective");
    };

    let scale = projection.fov / FRAC_PI_2 * (VIEW_RADIUS / 50.) as f32;

    scroll.read().for_each(|event| {
        transform.translation.x -= event.x * scale;
        transform.translation.y += event.y * scale;
    });
}